---

yaml
---
r: 278523
b: refs/heads/swift-5.1-old-llvm-branch
c: 7d0438b
h: refs/heads/master
i:
  278521: 377eb13
  278519: f854f03

Author: palimondo

[refs]

@@ -1241,7 +1241,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2019-01-24-a: b6f62823aa5010b2ae53f15f72a57
 refs/heads/marcrasi-astverifier-disable: 3fac766a23a77ebd0640296bfd7fc116ea60a4e0
 refs/heads/revert-22227-a-tall-white-fountain-played: adfce60b2eaa54903ea189bed8a783bca609fa53
 refs/heads/revert-22300-revert-22227-a-tall-white-fountain-played: 5f92040224df7dd4e618fdfb367349df64d8acad
-refs/heads/swift-5.1-old-llvm-branch: b2776f33ceb39f4d29e2b6f32a91e7ba0f182c7d
+refs/heads/swift-5.1-old-llvm-branch: 7d0438b4f5a9af67582c0778f1fe5e845bef856a
 refs/heads/swift-5.1-branch: 8060872acb4105d9655e020fe047e1ebcd77d0fb
 refs/tags/swift-4.2.2-RELEASE: e429d1f1aaf59e69d38207a96e56265c7f6fccec
 refs/tags/swift-5.0-DEVELOPMENT-SNAPSHOT-2019-02-02-a: 3e5a03d32ff3b1e9af90d6c1198c14f938379a6e

branches/swift-5.1-old-llvm-branch/include/swift/AST/DiagnosticsSema.def

@@ -586,8 +586,8 @@ ERROR(cannot_return_value_from_void_func,none,
 
 ERROR(sema_no_import,Fatal,
       "no such module '%0'", (StringRef))
-ERROR(sema_no_import_arch,Fatal,
-      "could not find module '%0' for architecture '%1'; "
+ERROR(sema_no_import_target,Fatal,
+      "could not find module '%0' for target '%1'; "
       "found: %2", (StringRef, StringRef, StringRef))
 ERROR(sema_no_import_repl,none,
       "no such module '%0'", (StringRef))

branches/swift-5.1-old-llvm-branch/include/swift/AST/NameLookup.h

@@ -118,20 +118,25 @@ class UnqualifiedLookup {
   /// That is, \c makeArrayRef(Results).take_front(IndexOfFirstOuterResults)
   /// will be Results from the innermost scope that had results, and the
   /// remaining elements of Results will be from parent scopes of this one.
+  ///
+  /// Allows unqualified name lookup to return results from outer scopes.
+  /// This is necessary for disambiguating calls to functions like `min` and
+  /// `max`.
   size_t IndexOfFirstOuterResult;
 
   /// Return true if anything was found by the name lookup.
   bool isSuccess() const { return !Results.empty(); }
 
   /// Get the result as a single type, or a null type if that fails.
-  TypeDecl *getSingleTypeResult();
+  TypeDecl *getSingleTypeResult() const;
 };
 
 inline UnqualifiedLookup::Options operator|(UnqualifiedLookup::Flags flag1,
                                             UnqualifiedLookup::Flags flag2) {
   return UnqualifiedLookup::Options(flag1) | flag2;
 }
 
+
 /// Describes the reason why a certain declaration is visible.
 enum class DeclVisibilityKind {
   /// Declaration is a local variable or type.
@@ -352,6 +357,29 @@ void lookupInModule(ModuleDecl *module, ModuleDecl::AccessPathTy accessPath,
                     const DeclContext *moduleScopeContext,
                     ArrayRef<ModuleDecl::ImportedModule> extraImports = {});
 
+template <typename Fn>
+void forAllVisibleModules(const DeclContext *DC, const Fn &fn) {
+  DeclContext *moduleScope = DC->getModuleScopeContext();
+  if (auto file = dyn_cast<FileUnit>(moduleScope))
+    file->forAllVisibleModules(fn);
+  else
+    cast<ModuleDecl>(moduleScope)
+        ->forAllVisibleModules(ModuleDecl::AccessPathTy(), fn);
+}
+
+/// Only name lookup has gathered a set of results, perform any necessary
+/// steps to prune the result set before returning it to the caller.
+bool finishLookup(const DeclContext *dc, NLOptions options,
+                  SmallVectorImpl<ValueDecl *> &decls);
+
+/// Do nothing if debugClient is null.
+template <typename Result>
+void filterForDiscriminator(SmallVectorImpl<Result> &results,
+                            DebuggerClient *debugClient);
+
+void recordLookupOfTopLevelName(DeclContext *topLevelContext, DeclName name,
+                                bool isCascading);
+
 } // end namespace namelookup
 
 /// Retrieve the set of nominal type declarations that are directly

branches/swift-5.1-old-llvm-branch/include/swift/Basic/Platform.h

@@ -74,6 +74,17 @@ namespace swift {
   ///
   /// This is a stop-gap until full Triple support (ala Clang) exists within swiftc.
   StringRef getMajorArchitectureName(const llvm::Triple &triple);
+
+  /// Computes the normalized target triple used as the most preferred name for
+  /// module loading.
+  ///
+  /// For platforms with fat binaries, this canonicalizes architecture,
+  /// vendor, and OS names, strips OS versions, and makes inferred environments
+  /// explicit. For other platforms, it returns the unmodified triple.
+  ///
+  /// The input triple should already be "normalized" in the sense that
+  /// llvm::Triple::normalize() would not affect it.
+  llvm::Triple getTargetSpecificModuleTriple(const llvm::Triple &triple);
 } // end namespace swift
 
 #endif // SWIFT_BASIC_PLATFORM_H

branches/swift-5.1-old-llvm-branch/include/swift/Demangling/Demangle.h

@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
@@ -35,6 +35,11 @@ namespace Demangle {
 
 enum class SymbolicReferenceKind : uint8_t;
 
+/// A simple default implementation that assigns letters to archetypes in
+/// alphabetic order.
+std::string archetypeName(uint64_t index, uint64_t depth);
+
+/// Display style options for the demangler.
 struct DemangleOptions {
   bool SynthesizeSugarOnTypes = false;
   bool DisplayDebuggerGeneratedModule = true;
@@ -52,6 +57,7 @@ struct DemangleOptions {
   bool ShortenArchetype = false;
   bool ShowPrivateDiscriminators = true;
   bool ShowFunctionArgumentTypes = true;
+  std::function<std::string(uint64_t, uint64_t)> ArchetypeName = archetypeName;
 
   DemangleOptions() {}
 
@@ -346,17 +352,19 @@ class Context {
   /// prefix: _T, _T0, $S, _$S.
   ///
   /// \returns The demangled string.
-  std::string demangleSymbolAsString(llvm::StringRef MangledName,
-                            const DemangleOptions &Options = DemangleOptions());
+  std::string demangleSymbolAsString(
+      llvm::StringRef MangledName,
+      const DemangleOptions &Options = DemangleOptions());
 
   /// Demangle the given type and return the readable name.
   ///
   /// \param MangledName The mangled type string, which does _not_ start with
   /// a mangling prefix.
   ///
   /// \returns The demangled string.
-  std::string demangleTypeAsString(llvm::StringRef MangledName,
-                            const DemangleOptions &Options = DemangleOptions());
+  std::string
+  demangleTypeAsString(llvm::StringRef MangledName,
+                       const DemangleOptions &Options = DemangleOptions());
 
   /// Returns true if the mangledName refers to a thunk function.
   ///
@@ -584,7 +592,6 @@ bool nodeConsumesGenericArgs(Node *node);
 bool isSpecialized(Node *node);
 
 NodePointer getUnspecialized(Node *node, NodeFactory &Factory);
-std::string archetypeName(Node::IndexType index, Node::IndexType depth);
 
 /// Returns true if the node \p kind refers to a context node, e.g. a nominal
 /// type or a function.

branches/swift-5.1-old-llvm-branch/include/swift/Remote/MetadataReader.h

@@ -410,11 +410,15 @@ class MetadataReader {
     StoredPointer InstanceAddress =
         InstanceMetadataAddressAddress + 2 * sizeof(StoredPointer);
 
+    // When built with Objective-C interop, the runtime also stores a conformance
+    // to Hashable and the base type introducing the Hashable conformance.
+    if (isObjC)
+      InstanceAddress += 2 * sizeof(StoredPointer);
+
     // Round up to alignment, and we have the start address of the
     // instance payload.
     auto AlignmentMask = VWT->getAlignmentMask();
-    auto Offset = (sizeof(HeapObject) + AlignmentMask) & ~AlignmentMask;
-    InstanceAddress += Offset;
+    InstanceAddress = (InstanceAddress + AlignmentMask) & ~AlignmentMask;
 
     return RemoteExistential(
         RemoteAddress(*InstanceMetadataAddress),
@@ -2447,6 +2451,12 @@ class MetadataReader {
       tryFindSymbol(_address, symbolName);                   \
       tryReadSymbol(_address, dest);                         \
     } while (0)
+#   define tryFindAndReadSymbolWithDefault(dest, symbolName, default) do { \
+      dest = default;                                                      \
+      auto _address = Reader->getSymbolAddress(symbolName);                \
+      if (_address)                                                        \
+        tryReadSymbol(_address, dest);                                     \
+    } while (0)
 
     tryFindAndReadSymbol(TaggedPointerMask,
                          "objc_debug_taggedpointer_mask");
@@ -2459,30 +2469,34 @@ class MetadataReader {
     if (!TaggedPointerClassesAddr)
       finish(TaggedPointerEncodingKind::Error);
     TaggedPointerClasses = TaggedPointerClassesAddr.getAddressData();
-    tryFindAndReadSymbol(TaggedPointerExtendedMask,
-                         "objc_debug_taggedpointer_ext_mask");
-    tryFindAndReadSymbol(TaggedPointerExtendedSlotShift,
-                         "objc_debug_taggedpointer_ext_slot_shift");
-    tryFindAndReadSymbol(TaggedPointerExtendedSlotMask,
-                         "objc_debug_taggedpointer_ext_slot_mask");
-    tryFindSymbol(TaggedPointerExtendedClassesAddr,
-                  "objc_debug_taggedpointer_ext_classes");
-    if (!TaggedPointerExtendedClassesAddr)
-      finish(TaggedPointerEncodingKind::Error);
-    TaggedPointerExtendedClasses =
-        TaggedPointerExtendedClassesAddr.getAddressData();
+    
+    // Extended tagged pointers don't exist on older OSes. Handle those
+    // by setting the variables to zero.
+    tryFindAndReadSymbolWithDefault(TaggedPointerExtendedMask,
+                                    "objc_debug_taggedpointer_ext_mask",
+                                    0);
+    tryFindAndReadSymbolWithDefault(TaggedPointerExtendedSlotShift,
+                                    "objc_debug_taggedpointer_ext_slot_shift",
+                                    0);
+    tryFindAndReadSymbolWithDefault(TaggedPointerExtendedSlotMask,
+                                    "objc_debug_taggedpointer_ext_slot_mask",
+                                    0);
+    auto TaggedPointerExtendedClassesAddr =
+      Reader->getSymbolAddress("objc_debug_taggedpointer_ext_classes");
+    if (TaggedPointerExtendedClassesAddr)
+      TaggedPointerExtendedClasses =
+          TaggedPointerExtendedClassesAddr.getAddressData();
 
     // The tagged pointer obfuscator is not present on older OSes, in
     // which case we can treat it as zero.
-    TaggedPointerObfuscator = 0;
-    auto TaggedPointerObfuscatorAddr = Reader->getSymbolAddress(
-      "objc_debug_taggedpointer_obfuscator");
-    if (TaggedPointerObfuscatorAddr)
-      tryReadSymbol(TaggedPointerObfuscatorAddr, TaggedPointerObfuscator);
-
+    tryFindAndReadSymbolWithDefault(TaggedPointerObfuscator,
+                                    "objc_debug_taggedpointer_obfuscator",
+                                    0);
+    
 #   undef tryFindSymbol
 #   undef tryReadSymbol
 #   undef tryFindAndReadSymbol
+#   undef tryFindAndReadSymbolWithDefault
 
     return finish(TaggedPointerEncodingKind::Extended);
   }

branches/swift-5.1-old-llvm-branch/include/swift/SIL/OptimizationRemark.h

@@ -50,7 +50,8 @@ struct Argument {
   Argument(StringRef Key, unsigned long long N);
 
   Argument(StringRef Key, SILFunction *F);
-  Argument(StringRef Key, SILType *Ty);
+  Argument(StringRef Key, SILType Ty);
+  Argument(StringRef Key, CanType Ty);
 };
 
 /// Shorthand to insert named-value pairs.

branches/swift-5.1-old-llvm-branch/include/swift/SIL/SILBuilder.h

@@ -918,8 +918,10 @@ class SILBuilder {
   } \
   Copy##Name##ValueInst *createCopy##Name##Value(SILLocation Loc, \
                                                  SILValue operand) { \
+    auto type = getFunction().getLoweredType( \
+      operand->getType().getASTType().getReferenceStorageReferent()); \
     return insert(new (getModule()) \
-      Copy##Name##ValueInst(getSILDebugLocation(Loc), operand, getModule())); \
+      Copy##Name##ValueInst(getSILDebugLocation(Loc), operand, type)); \
   }
 #define SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, ...) \
   NEVER_LOADABLE_CHECKED_REF_STORAGE(Name, "...") \

branches/swift-5.1-old-llvm-branch/include/swift/SIL/SILFunction.h

@@ -38,6 +38,11 @@ class SILModule;
 class SILFunctionBuilder;
 class SILProfiler;
 
+namespace Lowering {
+class TypeLowering;
+class AbstractionPattern;
+}
+
 enum IsBare_t { IsNotBare, IsBare };
 enum IsTransparent_t { IsNotTransparent, IsTransparent };
 enum Inline_t { InlineDefault, NoInline, AlwaysInline };
@@ -464,6 +469,19 @@ class SILFunction
             : ResilienceExpansion::Maximal);
   }
 
+  const Lowering::TypeLowering &
+  getTypeLowering(Lowering::AbstractionPattern orig, Type subst);
+
+  const Lowering::TypeLowering &getTypeLowering(Type t) const;
+
+  SILType getLoweredType(Lowering::AbstractionPattern orig, Type subst) const;
+
+  SILType getLoweredType(Type t) const;
+
+  SILType getLoweredLoadableType(Type t) const;
+
+  const Lowering::TypeLowering &getTypeLowering(SILType type) const;
+
   /// Returns true if this function has a calling convention that has a self
   /// argument.
   bool hasSelfParam() const {

branches/swift-5.1-old-llvm-branch/include/swift/SIL/SILInstruction.h

@@ -3929,30 +3929,26 @@ class StoreReferenceInstBase : public InstructionBase<K, NonValueInstruction> {
 /// \param loc The location of the expression that caused the load.
 /// \param lvalue The SILValue representing the address to
 ///        use for the load.
-#define NEVER_LOADABLE_CHECKED_REF_STORAGE(Name, ...) \
+#define NEVER_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, ...) \
 class Load##Name##Inst \
     : public LoadReferenceInstBase<SILInstructionKind::Load##Name##Inst> { \
   friend SILBuilder; \
   Load##Name##Inst(SILDebugLocation loc, SILValue lvalue, IsTake_t isTake) \
     : LoadReferenceInstBase(loc, lvalue, isTake) {} \
 };
-#define SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, ...) \
-  NEVER_LOADABLE_CHECKED_REF_STORAGE(Name, "...")
 #include "swift/AST/ReferenceStorage.def"
 
 /// Represents a store to a dynamic reference storage memory location.
 /// This is only required for address-only scenarios; for loadable
 /// references, it's better to use a ref_to_##name and a store.
-#define NEVER_LOADABLE_CHECKED_REF_STORAGE(Name, ...) \
+#define NEVER_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, ...) \
 class Store##Name##Inst \
     : public StoreReferenceInstBase<SILInstructionKind::Store##Name##Inst> { \
   friend SILBuilder; \
   Store##Name##Inst(SILDebugLocation loc, SILValue src, SILValue dest, \
                 IsInitialization_t isInit) \
     : StoreReferenceInstBase(loc, src, dest, isInit) {} \
 };
-#define SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, ...) \
-  NEVER_LOADABLE_CHECKED_REF_STORAGE(Name, "...")
 #include "swift/AST/ReferenceStorage.def"
 
 /// CopyAddrInst - Represents a copy from one memory location to another. This
@@ -6332,9 +6328,8 @@ class Copy##Name##ValueInst \
                                   SingleValueInstruction> { \
   friend class SILBuilder; \
   Copy##Name##ValueInst(SILDebugLocation DebugLoc, SILValue operand, \
-                       SILModule &M) \
-      : UnaryInstructionBase(DebugLoc, operand, \
-                             operand->getType().getReferentType(M)) {} \
+                        SILType type) \
+      : UnaryInstructionBase(DebugLoc, operand, type) {} \
 };
 #include "swift/AST/ReferenceStorage.def"
 

branches/swift-5.1-old-llvm-branch/include/swift/SIL/SILModule.h

@@ -598,7 +598,10 @@ class SILModule {
 
   /// Can value operations (copies and destroys) on the given lowered type
   /// be performed in this module?
-  bool isTypeABIAccessible(SILType type);
+  // FIXME: Expansion
+  bool isTypeABIAccessible(SILType type,
+                           ResilienceExpansion forExpansion
+                             = ResilienceExpansion::Minimal);
 
   /// Can type metadata for the given formal type be fetched in
   /// the given module?

branches/swift-5.1-old-llvm-branch/include/swift/SIL/SILType.h

@@ -477,12 +477,6 @@ class SILType {
   /// representation. Class existentials do not always qualify.
   bool isHeapObjectReferenceType() const;
 
-  /// Return the SILType corresponding to the underlying type of the given
-  /// metatype type.
-  ///
-  /// *NOTE* Only call on SILTypes for metatype types.
-  SILType getMetatypeInstanceType(SILModule& M) const;
-
   /// Returns true if this SILType is an aggregate that contains \p Ty
   bool aggregateContainsRecord(SILType Ty, SILModule &SILMod) const;
 
@@ -501,10 +495,6 @@ class SILType {
 
   /// Returns true if this is the AnyObject SILType;
   bool isAnyObject() const { return getASTType()->isAnyObject(); }
-
-  /// Returns the underlying referent SILType of an @sil_unowned or @sil_weak
-  /// Type.
-  SILType getReferentType(SILModule &M) const;
 
   /// Returns a SILType with any archetypes mapped out of context.
   SILType mapTypeOutOfContext() const;

branches/swift-5.1-old-llvm-branch/include/swift/SIL/TypeLowering.h

@@ -769,13 +769,16 @@ class TypeConverter {
                                ResilienceExpansion::Minimal);
 
   // Returns the lowered SIL type for a Swift type.
-  SILType getLoweredType(Type t) {
-    return getTypeLowering(t, ResilienceExpansion::Minimal).getLoweredType();
+  SILType getLoweredType(Type t, ResilienceExpansion forExpansion
+                           = ResilienceExpansion::Minimal) {
+    return getTypeLowering(t, forExpansion).getLoweredType();
   }
 
   // Returns the lowered SIL type for a Swift type.
-  SILType getLoweredType(AbstractionPattern origType, Type substType) {
-    return getTypeLowering(origType, substType, ResilienceExpansion::Minimal)
+  SILType getLoweredType(AbstractionPattern origType, Type substType,
+                         ResilienceExpansion forExpansion =
+                           ResilienceExpansion::Minimal) {
+    return getTypeLowering(origType, substType, forExpansion)
       .getLoweredType();
   }