Merge branch 'master' into empty

Author: compnerd

benchmark/single-source/StringBuilder.swift

@@ -13,10 +13,30 @@
 import TestsUtils
 
 public let StringBuilder = [
-  BenchmarkInfo(name: "StringAdder", runFunction: run_StringAdder, tags: [.validation, .api, .String]),
-  BenchmarkInfo(name: "StringBuilder", runFunction: run_StringBuilder, tags: [.validation, .api, .String]),
-  BenchmarkInfo(name: "StringBuilderLong", runFunction: run_StringBuilderLong, tags: [.validation, .api, .String]),
-  BenchmarkInfo(name: "StringUTF16Builder", runFunction: run_StringUTF16Builder, tags: [.validation, .api, .String]),
+  BenchmarkInfo(
+    name: "StringAdder",
+    runFunction: run_StringAdder,
+    tags: [.validation, .api, .String]),
+  BenchmarkInfo(
+    name: "StringBuilder",
+    runFunction: run_StringBuilder,
+    tags: [.validation, .api, .String]),
+  BenchmarkInfo(
+    name: "StringUTF16Builder",
+    runFunction: run_StringUTF16Builder,
+    tags: [.validation, .api, .String]),
+  BenchmarkInfo(
+    name: "StringUTF16SubstringBuilder",
+    runFunction: run_StringUTF16SubstringBuilder,
+    tags: [.validation, .api, .String]),
+  BenchmarkInfo(
+    name: "StringBuilderLong",
+    runFunction: run_StringBuilderLong,
+    tags: [.validation, .api, .String]),
+  BenchmarkInfo(
+    name: "StringBuilderWithLongSubstring",
+    runFunction: run_StringBuilderWithLongSubstring,
+    tags: [.validation, .api, .String]),
   BenchmarkInfo(
     name: "StringWordBuilder",
     runFunction: run_StringWordBuilder,
@@ -29,7 +49,7 @@ public let StringBuilder = [
 
 @inline(never)
 func buildString(_ i: String) -> String {
-  var sb = i
+  var sb = getString(i)
   for str in ["b","c","d","pizza"] {
     sb += str
   }
@@ -39,54 +59,95 @@ func buildString(_ i: String) -> String {
 @inline(never)
 public func run_StringBuilder(_ N: Int) {
   for _ in 1...5000*N {
-    _ = buildString(getString("a"))
+    blackHole(buildString("a"))
   }
 }
 
 @inline(never)
 func addString(_ i: String) -> String {
-  let s = i + "b" + "c" + "d" + "pizza"
+  let s = getString(i) + "b" + "c" + "d" + "pizza"
   return s
 }
 
 @inline(never)
 public func run_StringAdder(_ N: Int) {
   for _ in 1...5000*N {
-    _ = addString(getString("a"))
+    blackHole(addString("a"))
   }
 }
 
 @inline(never)
 func buildStringUTF16(_ i: String) -> String {
-  var sb = i
+  var sb = getString(i)
   for str in ["🎉","c","d","pizza"] {
     sb += str
   }
   return sb
 }
 
+@inline(never)
+func buildStringFromSmallSubstrings(_ i: String) -> String {
+  var sb = getString(i)
+  for str in ["_🎉","cd","de","pizza"] {
+    sb += str.dropFirst()
+  }
+  return sb
+}
+
 @inline(never)
 public func run_StringUTF16Builder(_ N: Int) {
   for _ in 1...5000*N {
-    _ = buildStringUTF16("a")
+    blackHole(buildStringUTF16("a"))
+  }
+}
+
+@inline(never)
+public func run_StringUTF16SubstringBuilder(_ N: Int) {
+  for _ in 1...5000*N {
+    blackHole(buildStringFromSmallSubstrings("a"))
   }
 }
 
+func getLongString() -> String {
+  let long = """
+    Swift is a multi-paradigm, compiled programming language created for
+     iOS, OS X, watchOS, tvOS and Linux development by Apple Inc. Swift is
+     designed to work with Apple's Cocoa and Cocoa Touch frameworks and the
+     large body of existing Objective-C code written for Apple products. Swift
+     is intended to be more resilient to erroneous code (\"safer\") than
+     Objective-C and also more concise. It is built with the LLVM compiler
+     framework included in Xcode 6 and later and uses the Objective-C runtime,
+     which allows C, Objective-C, C++ and Swift code to run within a single
+     program.
+    """
+  return getString(long)
+}
 
 @inline(never)
 func buildStringLong(_ i: String) -> String {
-  var sb = i
-  let long = "Swift is a multi-paradigm, compiled programming language created for iOS, OS X, watchOS, tvOS and Linux development by Apple Inc. Swift is designed to work with Apple's Cocoa and Cocoa Touch frameworks and the large body of existing Objective-C code written for Apple products. Swift is intended to be more resilient to erroneous code (\"safer\") than Objective-C and also more concise. It is built with the LLVM compiler framework included in Xcode 6 and later and uses the Objective-C runtime, which allows C, Objective-C, C++ and Swift code to run within a single program."
-  sb += long
+  var sb = getString(i)
+  sb += getLongString()
   return sb
 }
 
-
+@inline(never)
+func buildStringWithLongSubstring(_ i: String) -> String {
+  var sb = getString(i)
+  sb += getLongString().dropFirst()
+  return sb
+}
 
 @inline(never)
 public func run_StringBuilderLong(_ N: Int) {
   for _ in 1...5000*N {
-    _ = buildStringLong("👻")
+    blackHole(buildStringLong("👻"))
+  }
+}
+
+@inline(never)
+public func run_StringBuilderWithLongSubstring(_ N: Int) {
+  for _ in 1...5000*N {
+    blackHole(buildStringWithLongSubstring("👻"))
   }
 }
 
@@ -96,6 +157,7 @@ func buildString(
   count: Int,
   reservingCapacity: Bool
 ) -> String {
+  let word = getString(word)
   var sb = ""
   if reservingCapacity {
     sb.reserveCapacity(count * word.unicodeScalars.count)
@@ -108,10 +170,12 @@ func buildString(
 
 @inline(never)
 public func run_StringWordBuilder(_ N: Int) {
-  _ = buildString(word: "bumfuzzle", count: 50_000 * N, reservingCapacity: false)
+  blackHole(buildString(
+    word: "bumfuzzle", count: 50_000 * N, reservingCapacity: false))
 }
 
 @inline(never)
 public func run_StringWordBuilderReservingCapacity(_ N: Int) {
-  _ = buildString(word: "bumfuzzle", count: 50_000 * N, reservingCapacity: true)
+  blackHole(buildString(
+    word: "bumfuzzle", count: 50_000 * N, reservingCapacity: true))
 }

benchmark/single-source/StringInterpolation.swift

@@ -16,6 +16,14 @@ public let StringInterpolation = BenchmarkInfo(
   name: "StringInterpolation",
   runFunction: run_StringInterpolation,
   tags: [.validation, .api, .String])
+public let StringInterpolationSmall = BenchmarkInfo(
+  name: "StringInterpolationSmall",
+  runFunction: run_StringInterpolationSmall,
+  tags: [.validation, .api, .String])
+public let StringInterpolationManySmallSegments = BenchmarkInfo(
+  name: "StringInterpolationManySmallSegments",
+  runFunction: run_StringInterpolationManySmallSegments,
+  tags: [.validation, .api, .String])
 
 class RefTypePrintable : CustomStringConvertible {
   var description: String {
@@ -33,15 +41,66 @@ public func run_StringInterpolation(_ N: Int) {
   for _ in 1...100*N {
     var result = 0
     for _ in 1...reps {
-      let s = "\(anInt) abcdefdhijklmn \(aRefCountedObject) abcdefdhijklmn \u{01}"
+      let s: String = getString(
+        "\(anInt) abcdefdhijklmn \(aRefCountedObject) abcdefdhijklmn \u{01}")
       let utf16 = s.utf16
 
       // FIXME: if String is not stored as UTF-16 on this platform, then the
       // following operation has a non-trivial cost and needs to be replaced
       // with an operation on the native storage type.
-      result = result &+ Int(utf16[utf16.index(before: utf16.endIndex)])
+      result = result &+ Int(utf16.last!)
+      blackHole(s)
+    }
+    CheckResults(result == refResult)
+  }
+}
+
+@inline(never)
+public func run_StringInterpolationSmall(_ N: Int) {
+  let reps = 100
+  let refResult = reps
+  let anInt: Int64 = 0x42
+
+  for _ in 1...100*N {
+    var result = 0
+    for _ in 1...reps {
+      let s: String = getString(
+        "\(getString("int")): \(anInt) \(getString("abc")) \u{01}")
+      result = result &+ Int(s.utf8.last!)
+      blackHole(s)
     }
     CheckResults(result == refResult)
   }
 }
 
+@inline(never)
+public func run_StringInterpolationManySmallSegments(_ N: Int) {
+  let numHex = min(UInt64(N), 0x0FFF_FFFF_FFFF_FFFF)
+  let numOct = min(UInt64(N), 0x0000_03FF_FFFF_FFFF)
+  let numBin = min(UInt64(N), 0x7FFF)
+  let segments = [
+    "abc",
+    String(numHex, radix: 16),
+    "0123456789",
+    String(Double.pi/2),
+    "*barely* small!",
+    String(numOct, radix: 8),
+    "",
+    String(numBin, radix: 2),
+  ]
+  assert(segments.count == 8)
+
+  func getSegment(_ i: Int) -> String {
+    return getString(segments[i])
+  }
+
+  let reps = 100
+  for _ in 1...100*N {
+    for _ in 1...reps {
+      blackHole("""
+        \(getSegment(0)) \(getSegment(1))/\(getSegment(2))_\(getSegment(3))
+        \(getSegment(4)) \(getSegment(5)), \(getSegment(6))~~\(getSegment(7))
+        """)
+    }
+  }
+}

benchmark/utils/main.swift

@@ -280,6 +280,8 @@ registerBenchmark(StringComparison)
 registerBenchmark(StringEdits)
 registerBenchmark(StringEnum)
 registerBenchmark(StringInterpolation)
+registerBenchmark(StringInterpolationSmall)
+registerBenchmark(StringInterpolationManySmallSegments)
 registerBenchmark(StringMatch)
 registerBenchmark(StringRemoveDupes)
 registerBenchmark(StringTests)

docs/ABI/Mangling.rst

@@ -53,6 +53,7 @@ Globals
   global ::= type 'MP'                   // type metadata pattern
   global ::= type 'Ma'                   // type metadata access function
   global ::= type 'ML'                   // type metadata lazy cache variable
+  global ::= nominal-type 'Mr'           // generic type completion function
   global ::= nominal-type 'Mi'           // generic type instantiation function
   global ::= nominal-type 'MI'           // generic type instantiation cache
   global ::= nominal-type 'Mm'           // class metaclass

include/swift/ABI/MetadataValues.h

@@ -33,6 +33,9 @@ enum {
   /// The number of words (pointers) in a value buffer.
   NumWords_ValueBuffer = 3,
 
+  /// The number of words in a metadata completion context.
+  NumWords_MetadataCompletionContext = 4,
+
   /// The number of words in a yield-once coroutine buffer.
   NumWords_YieldOnceBuffer = 4,
 
@@ -1177,6 +1180,47 @@ enum class GenericRequirementLayoutKind : uint32_t {
   Class = 0,
 };
 
+/// Flags used by generic metadata patterns.
+class GenericMetadataPatternFlags : public FlagSet<uint32_t> {
+  enum {
+    // All of these values are bit offsets or widths.
+    // General flags build up from 0.
+    // Kind-specific flags build down from 31.
+
+    /// Does this pattern have an extra-data pattern?
+    HasExtraDataPattern = 0,
+
+    // Class-specific flags.
+
+    /// Does this pattern have an immediate-members pattern?
+    Class_HasImmediateMembersPattern = 31,
+
+    // Value-specific flags.
+
+    /// For value metadata: the metadata kind of the type.
+    Value_MetadataKind = 21,
+    Value_MetadataKind_width = 11,
+  };
+
+public:
+  explicit GenericMetadataPatternFlags(uint32_t bits) : FlagSet(bits) {}
+  constexpr GenericMetadataPatternFlags() {}
+
+  FLAGSET_DEFINE_FLAG_ACCESSORS(Class_HasImmediateMembersPattern,
+                                class_hasImmediateMembersPattern,
+                                class_setHasImmediateMembersPattern)
+
+  FLAGSET_DEFINE_FLAG_ACCESSORS(HasExtraDataPattern,
+                                hasExtraDataPattern,
+                                setHasExtraDataPattern)
+
+  FLAGSET_DEFINE_FIELD_ACCESSORS(Value_MetadataKind,
+                                 Value_MetadataKind_width,
+                                 MetadataKind,
+                                 value_getMetadataKind,
+                                 value_setMetadataKind)
+};
+
 } // end namespace swift
 
 #endif /* SWIFT_ABI_METADATAVALUES_H */

include/swift/AST/DiagnosticsFrontend.def

@@ -209,6 +209,10 @@ ERROR(symbol_in_ir_not_in_tbd,none,
       "symbol '%0' (%1) is in generated IR file, but not in TBD file",
       (StringRef, StringRef))
 
+ERROR(redundant_prefix_compilation_flag,none,
+      "invalid argument '-D%0'; did you provide a redundant '-D' in your build settings?", 
+      (StringRef))    
+
 ERROR(invalid_conditional_compilation_flag,none,
       "conditional compilation flags must be valid Swift identifiers (rather than '%0')",
       (StringRef))

include/swift/Demangling/DemangleNodes.def

@@ -173,6 +173,7 @@ NODE(TypeList)
 NODE(TypeMangling)
 NODE(TypeMetadata)
 NODE(TypeMetadataAccessFunction)
+NODE(TypeMetadataCompletionFunction)
 NODE(TypeMetadataInstantiationCache)
 NODE(TypeMetadataInstantiationFunction)
 NODE(TypeMetadataLazyCache)

include/swift/Driver/Compilation.h

@@ -51,6 +51,9 @@ namespace driver {
 enum class OutputLevel {
   /// Indicates that normal output should be produced.
   Normal,
+  
+  /// Indicates that only jobs should be printed and not run. (-###)
+  PrintJobs,
 
   /// Indicates that verbose output should be produced. (-v)
   Verbose,

include/swift/Driver/Driver.h

@@ -357,9 +357,6 @@ class Driver {
   /// Print the list of Actions in a Compilation.
   void printActions(const Compilation &C) const;
 
-  /// Print the list of Jobs in a Compilation.
-  void printJobs(const Compilation &C) const;
-
   /// Print the driver version.
   void printVersion(const ToolChain &TC, raw_ostream &OS) const;
 

include/swift/IRGen/Linking.h

@@ -159,6 +159,10 @@ class LinkEntity {
     /// The pointer is a NominalTypeDecl*.
     TypeMetadataInstantiationFunction,
 
+    /// The completion function for a generic or resilient nominal type.
+    /// The pointer is a NominalTypeDecl*.
+    TypeMetadataCompletionFunction,
+
     /// The module descriptor for a module.
     /// The pointer is a ModuleDecl*.
     ModuleDescriptor,
@@ -488,6 +492,12 @@ class LinkEntity {
     return entity;
   }
 
+  static LinkEntity forTypeMetadataCompletionFunction(NominalTypeDecl *decl) {
+    LinkEntity entity;
+    entity.setForDecl(Kind::TypeMetadataCompletionFunction, decl);
+    return entity;
+  }
+
   static LinkEntity forTypeMetadataLazyCacheVariable(CanType type) {
     LinkEntity entity;
     entity.setForType(Kind::TypeMetadataLazyCacheVariable, type);