Merge pull request #2657 from swiftwasm/release/5.4

[pull] swiftwasm-release/5.4 from release/5.4

Author: pull[bot]

include/swift/SIL/SILConstants.h

@@ -604,6 +604,11 @@ class SymbolicValue {
   /// version. This only works for valid constants.
   SymbolicValue cloneInto(SymbolicValueAllocator &allocator) const;
 
+  /// Check that all nested SymbolicValues are constant. Symbolic values such as arrays,
+  /// aggregates and pointers can contain non-constant symbolic values, when instructions
+  /// are skipped during evaluation.
+  bool containsOnlyConstants() const;
+
   void print(llvm::raw_ostream &os, unsigned indent = 0) const;
   void dump() const;
 };

include/swift/Sema/ConstraintSystem.h

@@ -2784,7 +2784,7 @@ class ConstraintSystem {
   void
   filterSolutions(SmallVectorImpl<Solution> &solutions,
                   bool minimize = false) {
-    if (solutions.size() < 2)
+    if (solutions.size() < 2 || isForCodeCompletion())
       return;
 
     if (auto best = findBestSolution(solutions, minimize)) {

lib/Frontend/ModuleInterfaceLoader.cpp

@@ -1292,18 +1292,28 @@ InterfaceSubContextDelegateImpl::InterfaceSubContextDelegateImpl(
   // required by sourcekitd.
   subClangImporterOpts.DetailedPreprocessingRecord =
     clangImporterOpts.DetailedPreprocessingRecord;
+
   // We need to add these extra clang flags because explict module building
   // related flags are all there: -fno-implicit-modules, -fmodule-map-file=,
   // and -fmodule-file=.
   // If we don't add these flags, the interface will be built with implicit
   // PCMs.
-  subClangImporterOpts.ExtraArgs = clangImporterOpts.ExtraArgs;
-  for (auto arg: subClangImporterOpts.ExtraArgs) {
-    GenericArgs.push_back("-Xcc");
-    GenericArgs.push_back(ArgSaver.save(arg));
+  // FIXME: With Implicit Module Builds, if sub-invocations inherit `-fmodule-map-file=` options,
+  // those modulemaps become File dependencies of all downstream PCMs and their depending Swift
+  // modules, triggering unnecessary re-builds. We work around this by only inheriting these options
+  // when building with explicit modules. While this problem will not manifest with Explicit Modules
+  // (which do not use the ClangImporter to build PCMs), we may still need a better way to
+  // decide which options must be inherited here.
+  if (LoaderOpts.disableImplicitSwiftModule) {
+    subClangImporterOpts.ExtraArgs = clangImporterOpts.ExtraArgs;
+    for (auto arg : subClangImporterOpts.ExtraArgs) {
+      GenericArgs.push_back("-Xcc");
+      GenericArgs.push_back(ArgSaver.save(arg));
+    }
   }
 
-  // Tell the genericSubInvocation to serialize dependency hashes if asked to do so.
+  // Tell the genericSubInvocation to serialize dependency hashes if asked to do
+  // so.
   auto &frontendOpts = genericSubInvocation.getFrontendOptions();
   frontendOpts.SerializeModuleInterfaceDependencyHashes =
     serializeDependencyHashes;

lib/IRGen/GenBuiltin.cpp

@@ -120,6 +120,7 @@ getLoweredTypeAndTypeInfo(IRGenModule &IGM, Type unloweredType) {
 /// emitBuiltinCall - Emit a call to a builtin function.
 void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
                             Identifier FnId, SILType resultType,
+                            ArrayRef<SILType> argTypes,
                             Explosion &args, Explosion &out,
                             SubstitutionMap substitutions) {
   if (Builtin.ID == BuiltinValueKind::COWBufferForReading) {
@@ -1074,7 +1075,18 @@ if (Builtin.ID == BuiltinValueKind::id) { \
 
   if (Builtin.ID == BuiltinValueKind::TSanInoutAccess) {
     auto address = args.claimNext();
-    IGF.emitTSanInoutAccessCall(address);
+
+    // The tsanInoutAccess builtin takes a single argument, the address
+    // of the accessed storage
+    SILType accessedType = argTypes[0];
+
+    // Empty types (such as structs without stored properties) have a
+    // meaningless value for their address. We not should call into the
+    // TSan runtime to check for data races on accesses on such addresses.
+    if (!IGF.IGM.getTypeInfo(accessedType)
+        .isKnownEmpty(ResilienceExpansion::Maximal)) {
+      IGF.emitTSanInoutAccessCall(address);
+    }
     return;
   }
 

lib/IRGen/GenBuiltin.h

@@ -33,6 +33,7 @@ namespace irgen {
   /// Emit a call to a builtin function.
   void emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &builtin,
                        Identifier fnId, SILType resultType,
+                       ArrayRef<SILType> argTypes,
                        Explosion &args, Explosion &result,
                        SubstitutionMap substitutions);
 

lib/IRGen/GenClangDecl.cpp

@@ -11,6 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "IRGenModule.h"
+#include "swift/AST/IRGenOptions.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclGroup.h"
 #include "clang/AST/GlobalDecl.h"
@@ -118,14 +119,20 @@ IRGenModule::getAddrOfClangGlobalDecl(clang::GlobalDecl global,
 }
 
 void IRGenModule::finalizeClangCodeGen() {
-  // Ensure that code is emitted for any `PragmaCommentDecl`s. (These are
-  // always guaranteed to be directly below the TranslationUnitDecl.)
-  // In Clang, this happens automatically during the Sema phase, but here we
-  // need to take care of it manually because our Clang CodeGenerator is not
-  // attached to Clang Sema as an ASTConsumer.
-  for (const auto *D : ClangASTContext->getTranslationUnitDecl()->decls()) {
-    if (const auto *PCD = dyn_cast<clang::PragmaCommentDecl>(D)) {
-      emitClangDecl(PCD);
+  // FIXME: We try to avoid looking for PragmaCommentDecls unless we need to,
+  // since clang::DeclContext::decls_begin() can trigger expensive
+  // de-serialization.
+  if (Triple.isWindowsMSVCEnvironment() || Triple.isWindowsItaniumEnvironment() ||
+      IRGen.Opts.LLVMLTOKind != IRGenLLVMLTOKind::None) {
+    // Ensure that code is emitted for any `PragmaCommentDecl`s. (These are
+    // always guaranteed to be directly below the TranslationUnitDecl.)
+    // In Clang, this happens automatically during the Sema phase, but here we
+    // need to take care of it manually because our Clang CodeGenerator is not
+    // attached to Clang Sema as an ASTConsumer.
+    for (const auto *D : ClangASTContext->getTranslationUnitDecl()->decls()) {
+      if (const auto *PCD = dyn_cast<clang::PragmaCommentDecl>(D)) {
+        emitClangDecl(PCD);
+      }
     }
   }
 

lib/IRGen/IRGenSIL.cpp

@@ -2680,18 +2680,21 @@ void IRGenSILFunction::visitBuiltinInst(swift::BuiltinInst *i) {
 
   auto argValues = i->getArguments();
   Explosion args;
+  SmallVector<SILType, 4> argTypes;
 
   for (auto idx : indices(argValues)) {
     auto argValue = argValues[idx];
 
     // Builtin arguments should never be substituted, so use the value's type
     // as the parameter type.
     emitApplyArgument(*this, argValue, argValue->getType(), args);
+
+    argTypes.push_back(argValue->getType());
   }
 
   Explosion result;
   emitBuiltinCall(*this, builtin, i->getName(), i->getType(),
-                  args, result, i->getSubstitutions());
+                  argTypes, args, result, i->getSubstitutions());
 
   setLoweredExplosion(i, result);
 }

lib/SIL/IR/SILConstants.cpp

@@ -260,6 +260,52 @@ SymbolicValue::cloneInto(SymbolicValueAllocator &allocator) const {
   llvm_unreachable("covered switch");
 }
 
+bool SymbolicValue::containsOnlyConstants() const {
+  if (!isConstant())
+    return false;
+
+  auto thisRK = representationKind;
+  switch (thisRK) {
+  case RK_UninitMemory:
+  case RK_Unknown:
+  case RK_Metatype:
+  case RK_Function:
+  case RK_Enum:
+  case RK_IntegerInline:
+  case RK_Integer:
+  case RK_String:
+  case RK_Closure:
+    return true;
+  case RK_Aggregate: {
+    auto elts = getAggregateMembers();
+    for (auto elt : elts)
+      if (!elt.containsOnlyConstants())
+        return false;
+    return true;
+  }
+  case RK_EnumWithPayload: {
+    return getEnumPayloadValue().containsOnlyConstants();
+  }
+  case RK_DirectAddress:
+  case RK_DerivedAddress: {
+    auto *memObject = getAddressValueMemoryObject();
+    return memObject->getValue().containsOnlyConstants();
+  }
+  case RK_ArrayStorage: {
+    CanType elementType;
+    ArrayRef<SymbolicValue> elts = getStoredElements(elementType);
+    for (auto elt : elts)
+      if (!elt.containsOnlyConstants())
+        return false;
+    return true;
+  }
+  case RK_Array: {
+    return getStorageOfArray().containsOnlyConstants();
+  }
+  }
+  llvm_unreachable("covered switch");
+}
+
 //===----------------------------------------------------------------------===//
 // SymbolicValueMemoryObject implementation
 //===----------------------------------------------------------------------===//

lib/SILOptimizer/Mandatory/OSLogOptimization.cpp

@@ -322,8 +322,9 @@ static bool isFoldableArray(SILValue value, ASTContext &astContext) {
     return true;
   SILFunction *callee = cast<ApplyInst>(constructorInst)->getCalleeFunction();
   return !callee ||
-         (!callee->hasSemanticsAttr("array.init.empty") &&
-          !callee->hasSemanticsAttr("array.uninitialized_intrinsic"));
+         (!callee->hasSemanticsAttr(semantics::ARRAY_INIT_EMPTY) &&
+          !callee->hasSemanticsAttr(semantics::ARRAY_UNINITIALIZED_INTRINSIC) &&
+          !callee->hasSemanticsAttr(semantics::ARRAY_FINALIZE_INTRINSIC));
 }
 
 /// Return true iff the given value is a closure but is not a creation of a
@@ -997,6 +998,14 @@ static void substituteConstants(FoldState &foldState) {
   for (SILValue constantSILValue : foldState.getConstantSILValues()) {
     SymbolicValue constantSymbolicVal =
         evaluator.lookupConstValue(constantSILValue).getValue();
+    // Make sure that the symbolic value tracked in the foldState is a constant.
+    // In the case of ArraySymbolicValue, the array storage could be a non-constant
+    // if some instruction in the array initialization sequence was not evaluated
+    // and skipped.
+    if (!constantSymbolicVal.containsOnlyConstants()) {
+      assert(constantSymbolicVal.getKind() != SymbolicValue::String && "encountered non-constant string symbolic value");
+      continue;
+    }
 
     SILInstruction *definingInst = constantSILValue->getDefiningInstruction();
     assert(definingInst);

lib/Sema/TypeCheckStorage.cpp

@@ -2921,7 +2921,7 @@ static void finishPropertyWrapperImplInfo(VarDecl *var,
     return;
   }
 
-  if (var->hasObservers()) {
+  if (var->hasObservers() || var->getDeclContext()->isLocalContext()) {
     info = StorageImplInfo::getMutableComputed();
   } else {
     info = StorageImplInfo(ReadImplKind::Get, WriteImplKind::Set,