---

yaml
---
r: 341433
b: refs/heads/rxwei-patch-1
c: 0a22ab7
h: refs/heads/master
i:
  341431: 2724e76

Author: compnerd

[refs]

@@ -1015,7 +1015,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-08-18-a: b10b1fce14385faa6d44f6b933e95
 refs/heads/rdar-43033749-fix-batch-mode-no-diags-swift-5.0-branch: a14e64eaad30de89f0f5f0b2a782eed7ecdcb255
 refs/heads/revert-19006-error-bridging-integer-type: 8a9065a3696535305ea53fe9b71f91cbe6702019
 refs/heads/revert-19050-revert-19006-error-bridging-integer-type: ecf752d54b05dd0a20f510f0bfa54a3fec3bcaca
-refs/heads/rxwei-patch-1: 50fd6eae97a19bb5c72e176facdff841475fb301
+refs/heads/rxwei-patch-1: 0a22ab7099a6e0df62f6c44fddbbffaa93b2c5cd
 refs/heads/shahmishal-patch-1: e58ec0f7488258d42bef51bc3e6d7b3dc74d7b2a
 refs/heads/typelist-existential: 4046359efd541fb5c72d69a92eefc0a784df8f5e
 refs/tags/swift-4.2-DEVELOPMENT-SNAPSHOT-2018-08-20-a: 4319ba09e4fb8650ee86061075c74a016b6baab9

branches/rxwei-patch-1/benchmark/single-source/AngryPhonebook.swift

@@ -14,11 +14,59 @@
 // to test uppercase and lowercase ASCII string fast paths.
 import TestsUtils
 
-public let AngryPhonebook = BenchmarkInfo(
-  name: "AngryPhonebook",
-  runFunction: run_AngryPhonebook,
-  tags: [.validation, .api, .String],
-  legacyFactor: 7)
+let t: [BenchmarkCategory] = [.validation, .api, .String]
+
+public let AngryPhonebook = [
+  BenchmarkInfo(
+    name: "AngryPhonebook",
+    runFunction: run_AngryPhonebook,
+    tags: t,
+    legacyFactor: 7),
+
+  // Small String Workloads
+  BenchmarkInfo(
+    name: "AngryPhonebook.ASCII.Small",
+    runFunction: { angryPhonebook($0, ascii) },
+    tags: t,
+    setUpFunction: { blackHole(ascii) }),
+  BenchmarkInfo(
+    name: "AngryPhonebook.Strasse.Small",
+    runFunction: { angryPhonebook($0, strasse) },
+    tags: t,
+    setUpFunction: { blackHole(strasse) }),
+  BenchmarkInfo(
+    name: "AngryPhonebook.Armenian.Small",
+    runFunction: { angryPhonebook($0, armenian) },
+    tags: t,
+    setUpFunction: { blackHole(armenian) }),
+  BenchmarkInfo(
+    name: "AngryPhonebook.Cyrillic.Small",
+    runFunction: { angryPhonebook($0, cyrillic) },
+    tags: t,
+    setUpFunction: { blackHole(cyrillic) }),
+
+  // Regular String Workloads
+  BenchmarkInfo(
+    name: "AngryPhonebook.ASCII",
+    runFunction: { angryPhonebook($0, precomposed: longASCII) },
+    tags: t,
+    setUpFunction: { blackHole(longASCII) }),
+  BenchmarkInfo(
+    name: "AngryPhonebook.Strasse",
+    runFunction: { angryPhonebook($0, precomposed: longStrasse) },
+    tags: t,
+    setUpFunction: { blackHole(longStrasse) }),
+  BenchmarkInfo(
+    name: "AngryPhonebook.Armenian",
+    runFunction: { angryPhonebook($0, precomposed: longArmenian) },
+    tags: t,
+    setUpFunction: { blackHole(longArmenian) }),
+  BenchmarkInfo(
+    name: "AngryPhonebook.Cyrillic",
+    runFunction: { angryPhonebook($0, precomposed: longCyrillic) },
+    tags: t,
+    setUpFunction: { blackHole(longCyrillic) })
+]
 
 let words = [
   "James", "John", "Robert", "Michael", "William", "David", "Richard", "Joseph",
@@ -38,3 +86,67 @@ public func run_AngryPhonebook(_ N: Int) {
     }
   }
 }
+
+// Workloads for various scripts. Always 20 names for 400 pairings.
+// To keep the performance of various scripts roughly comparable, aim for
+// a total length of approximately 120 characters.
+// E.g.: `ascii.joined(separator: "").count == 124`
+// Every name should fit in 15-bytes UTF-8 encoded, to excercise the small
+// string optimization.
+// E.g.: `armenian.allSatisfy { $0._guts.isSmall } == true`
+
+// Workload Size Statistics
+//   SMALL  | UTF-8 | UTF-16 |    REGULAR   |  UTF-8  | UTF-16
+// ---------|-------|--------|--------------|---------|--------
+//    ascii | 124 B |  248 B |    longASCII |  6158 B | 12316 B
+//  strasse | 140 B |  240 B |  longStrasse |  6798 B | 11996 B
+// armenian | 232 B |  232 B | longArmenian | 10478 B | 11676 B
+// cyrillic | 238 B |  238 B | longCyrillic | 10718 B | 11916 B
+
+let ascii = Array(words.prefix(20))
+// Pathological case, uppercase: ß -> SS
+let strasse = Array(repeating: "Straße", count: 20)
+
+let armenian = [
+  "Արմեն", "Աննա", "Հարութ", "Միքայել", "Մարիա", "Դավիթ", "Վարդան",
+  "Նարինե", "Տիգրան", "Տաթևիկ", "Թագուհի", "Թամարա", "Ազնաուր", "Գրիգոր",
+  "Կոմիտաս", "Հայկ", "Գառնիկ", "Վահրամ", "Վահագն", "Գևորգ"]
+
+let cyrillic = [
+  "Ульяна", "Аркадий", "Аня", "Даниил", "Дмитрий", "Эдуард", "Юрій", "Давид",
+  "Анна", "Дмитрий", "Евгений", "Борис", "Ксения", "Артур", "Аполлон",
+  "Соломон", "Николай", "Кристи", "Надежда", "Спартак"]
+
+/// Precompose the phonebook into one large string of comma separated names.
+func phonebook(_ names: [String]) -> String {
+  names.map { firstName in
+    names.map { lastName in
+      firstName + " " + lastName
+    }.joined(separator: ", ")
+  }.joined(separator: ", ")
+}
+
+let longASCII = phonebook(ascii)
+let longStrasse = phonebook(strasse)
+let longArmenian = phonebook(armenian)
+let longCyrillic = phonebook(cyrillic)
+
+@inline(never)
+public func angryPhonebook(_ N: Int, _ names: [String]) {
+  assert(names.count == 20)
+  // Permute the names.
+  for _ in 1...N {
+    for firstname in names {
+      for lastname in names {
+        blackHole((firstname.uppercased(), lastname.lowercased()))
+      }
+    }
+  }
+}
+
+@inline(never)
+public func angryPhonebook(_ N: Int, precomposed names: String) {
+  for _ in 1...N {
+    blackHole((names.uppercased(), names.lowercased()))
+  }
+}

branches/rxwei-patch-1/cmake/modules/AddSwift.cmake

@@ -1905,7 +1905,7 @@ function(add_swift_target_library name)
     if(SWIFTLIB_SHARED)
       if(sdk IN_LIST SWIFT_APPLE_PLATFORMS)
         list(APPEND swiftlib_link_flags_all "-dynamiclib -Wl,-headerpad_max_install_names")
-      elseif(sdk STREQUAL ANDROID)
+      elseif(${sdk} STREQUAL ANDROID)
         list(APPEND swiftlib_link_flags_all "-shared")
         # TODO: Instead of `lib${name}.so` find variable or target property which already have this value.
         list(APPEND swiftlib_link_flags_all "-Wl,-soname,lib${name}.so")

branches/rxwei-patch-1/include/swift/AST/Builtins.def

@@ -551,6 +551,20 @@ BUILTIN_MISC_OPERATION(WillThrow, "willThrow", "", Special)
 /// poundAssert has type (Builtin.Int1, Builtin.RawPointer) -> ().
 BUILTIN_MISC_OPERATION(PoundAssert, "poundAssert", "", Special)
 
+// BUILTIN_MISC_OPERATION_WITH_SILGEN - Miscellaneous operations that are
+// specially emitted during SIL generation.
+#ifndef BUILTIN_MISC_OPERATION_WITH_SILGEN
+#define BUILTIN_MISC_OPERATION_WITH_SILGEN(Id, Name, Attrs, Overload) \
+  BUILTIN_MISC_OPERATION(Id, Name, Attrs, Overload)
+#endif
+
+/// globalStringTablePointer has type String -> Builtin.RawPointer.
+/// It returns an immortal, global string table pointer for strings constructed
+/// from string literals.
+BUILTIN_MISC_OPERATION_WITH_SILGEN(GlobalStringTablePointer, "globalStringTablePointer", "", Special)
+
+#undef BUILTIN_MISC_OPERATION_WITH_SILGEN
+
 #undef BUILTIN_MISC_OPERATION
 
 /// Builtins for instrumentation added by sanitizers during SILGen.

branches/rxwei-patch-1/include/swift/AST/DiagnosticsSIL.def

@@ -484,7 +484,7 @@ NOTE(switch_value_case_doesnt_yield, none, "missing yield in the %0 case",
 NOTE(try_branch_doesnt_yield, none, "missing yield when error is "
      "%select{not |}0thrown", (bool))
 
-// OS log optimization dianostics.
+// OS log optimization diagnostics.
 
 ERROR(oslog_message_argument_not_found, none, "no argument of type %0 in "
   " the os log call", (Identifier))
@@ -505,6 +505,9 @@ ERROR(oslog_non_constant_interpolation, none, "'OSLogInterpolation' struct is "
 ERROR(oslog_property_not_constant, none, "'OSLogInterpolation.%0' is not a "
       "constant: formatting and privacy options must be literals", (StringRef))
 
+ERROR(global_string_pointer_on_non_constant, none, "globalStringTablePointer "
+      "builtin must used only on string literals", ())
+
 #ifndef DIAG_NO_UNDEF
 # if defined(DIAG)
 #  undef DIAG

branches/rxwei-patch-1/include/swift/AST/Identifier.h

@@ -264,6 +264,8 @@ class DeclBaseName {
 
   bool isSpecial() const { return getKind() != Kind::Normal; }
 
+  bool isSubscript() const { return getKind() == Kind::Subscript; }
+
   /// Return the identifier backing the name. Assumes that the name is not
   /// special.
   Identifier getIdentifier() const {

branches/rxwei-patch-1/lib/AST/Builtins.cpp

@@ -951,6 +951,13 @@ static ValueDecl *getGetObjCTypeEncodingOperation(ASTContext &Context,
   return builder.build(Id);
 }
 
+static ValueDecl *getGlobalStringTablePointer(ASTContext &Context,
+                                              Identifier Id) {
+  // String -> Builtin.RawPointer
+  auto stringType = NominalType::get(Context.getStringDecl(), Type(), Context);
+  return getBuiltinFunction(Id, {stringType}, Context.TheRawPointerType);
+}
+
 static ValueDecl *getPoundAssert(ASTContext &Context, Identifier Id) {
   auto int1Type = BuiltinIntegerType::get(1, Context);
   auto optionalRawPointerType = BoundGenericEnumType::get(
@@ -1960,6 +1967,9 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
   case BuiltinValueKind::GetObjCTypeEncoding:
     return getGetObjCTypeEncodingOperation(Context, Id);
 
+  case BuiltinValueKind::GlobalStringTablePointer:
+    return getGlobalStringTablePointer(Context, Id);
+
   case BuiltinValueKind::PoundAssert:
     return getPoundAssert(Context, Id);
 

branches/rxwei-patch-1/lib/IRGen/GenBuiltin.cpp

@@ -354,6 +354,18 @@ if (Builtin.ID == BuiltinValueKind::id) { \
 #define BUILTIN(ID, Name, Attrs)  // Ignore the rest.
 #include "swift/AST/Builtins.def"
 
+  if (Builtin.ID == BuiltinValueKind::GlobalStringTablePointer) {
+    // This builtin should be used only on strings constructed from a
+    // string literal. If we ever get to the point of executing this builtin
+    // at run time, it implies an incorrect use of the builtin and must result
+    // in a trap.
+    IGF.emitTrap(/*Unreachable=*/false);
+    auto returnValue = llvm::UndefValue::get(IGF.IGM.Int8PtrTy);
+    // Consume the arguments of the builtin.
+    (void)args.claimAll();
+    return out.add(returnValue);
+  }
+
   if (Builtin.ID == BuiltinValueKind::WillThrow) {
     // willThrow is emitted like a Swift function call with the error in
     // the error return register. We also have to pass a fake context

branches/rxwei-patch-1/lib/SIL/OperandOwnership.cpp

@@ -1057,6 +1057,16 @@ CONSTANT_OWNERSHIP_BUILTIN(Any, MustBeLive, Swift3ImplicitObjCEntrypoint)
 CONSTANT_OWNERSHIP_BUILTIN(Any, MustBeLive, PoundAssert)
 #undef CONSTANT_OWNERSHIP_BUILTIN
 
+// CONSTANT_OWNERSHIP_BUILTIN(Owned, MustBeLive, GlobalStringTablePointer)
+
+OperandOwnershipKindMap
+OperandOwnershipKindBuiltinClassifier::visitGlobalStringTablePointer(
+    BuiltinInst *bi, StringRef attr) {
+  return Map::compatibilityMap(
+      {{ValueOwnershipKind::Guaranteed, UseLifetimeConstraint::MustBeLive},
+       {ValueOwnershipKind::Owned, UseLifetimeConstraint::MustBeLive}});
+}
+
 // Builtins that should be lowered to SIL instructions so we should never see
 // them.
 #define BUILTIN_SIL_OPERATION(ID, NAME, CATEGORY)                              \

branches/rxwei-patch-1/lib/SIL/ValueOwnership.cpp

@@ -491,6 +491,7 @@ CONSTANT_OWNERSHIP_BUILTIN(Any, OnceWithContext)
 CONSTANT_OWNERSHIP_BUILTIN(Any, TSanInoutAccess)
 CONSTANT_OWNERSHIP_BUILTIN(Any, Swift3ImplicitObjCEntrypoint)
 CONSTANT_OWNERSHIP_BUILTIN(Any, PoundAssert)
+CONSTANT_OWNERSHIP_BUILTIN(Any, GlobalStringTablePointer)
 
 #undef CONSTANT_OWNERSHIP_BUILTIN
 

branches/rxwei-patch-1/lib/SILGen/SILGenApply.cpp

@@ -4057,12 +4057,14 @@ CallEmission::applySpecializedEmitter(SpecializedEmitter &specializedEmitter,
     return firstLevelResult;
   }
 
-  // Builtins.
+  // Named Builtins.
   assert(specializedEmitter.isNamedBuiltin());
   auto builtinName = specializedEmitter.getBuiltinName();
   SmallVector<SILValue, 4> consumedArgs;
   for (auto arg : uncurriedArgs) {
-    // Builtins have a special convention that takes everything at +1.
+    // Named builtins are by default assumed to take all arguments at +1 i.e.,
+    // as Owned or Trivial. Named builtins that don't follow this convention
+    // must use a specialized emitter.
     auto maybePlusOne = arg.ensurePlusOne(SGF, uncurriedLoc.getValue());
     consumedArgs.push_back(maybePlusOne.forward(SGF));
   }

branches/rxwei-patch-1/lib/SILGen/SILGenBuiltin.cpp

@@ -1028,6 +1028,28 @@ static ManagedValue emitBuiltinTypeTrait(SILGenFunction &SGF,
   return ManagedValue::forUnmanaged(val);
 }
 
+/// Emit SIL for the named builtin: globalStringTablePointer. Unlike the default
+/// ownership convention for named builtins, which is to take (non-trivial)
+/// arguments as Owned, this builtin accepts owned as well as guaranteed
+/// arguments, and hence doesn't require the arguments to be at +1. Therefore,
+/// this builtin is emitted specially.
+static ManagedValue
+emitBuiltinGlobalStringTablePointer(SILGenFunction &SGF, SILLocation loc,
+                                    SubstitutionMap subs,
+                                    ArrayRef<ManagedValue> args, SGFContext C) {
+  assert(args.size() == 1);
+
+  SILValue argValue = args[0].getValue();
+  auto &astContext = SGF.getASTContext();
+  Identifier builtinId = astContext.getIdentifier(
+      getBuiltinName(BuiltinValueKind::GlobalStringTablePointer));
+
+  auto resultVal = SGF.B.createBuiltin(loc, builtinId,
+                                       SILType::getRawPointerType(astContext),
+                                       subs, ArrayRef<SILValue>(argValue));
+  return SGF.emitManagedRValueWithCleanup(resultVal);
+}
+
 Optional<SpecializedEmitter>
 SpecializedEmitter::forDecl(SILGenModule &SGM, SILDeclRef function) {
   // Only consider standalone declarations in the Builtin module.
@@ -1052,6 +1074,7 @@ SpecializedEmitter::forDecl(SILGenModule &SGM, SILDeclRef function) {
 #define BUILTIN(Id, Name, Attrs)                                            \
   case BuiltinValueKind::Id:
 #define BUILTIN_SIL_OPERATION(Id, Name, Overload)
+#define BUILTIN_MISC_OPERATION_WITH_SILGEN(Id, Name, Attrs, Overload)
 #define BUILTIN_SANITIZER_OPERATION(Id, Name, Attrs)
 #define BUILTIN_TYPE_CHECKER_OPERATION(Id, Name)
 #define BUILTIN_TYPE_TRAIT_OPERATION(Id, Name)
@@ -1068,8 +1091,12 @@ SpecializedEmitter::forDecl(SILGenModule &SGM, SILDeclRef function) {
   case BuiltinValueKind::Id:                                                \
     return SpecializedEmitter(&emitBuiltin##Id);
 
-  // Sanitizer builtins should never directly be called; they should only
-  // be inserted as instrumentation by SILGen.
+#define BUILTIN_MISC_OPERATION_WITH_SILGEN(Id, Name, Attrs, Overload)          \
+  case BuiltinValueKind::Id:                                                   \
+    return SpecializedEmitter(&emitBuiltin##Id);
+
+    // Sanitizer builtins should never directly be called; they should only
+    // be inserted as instrumentation by SILGen.
 #define BUILTIN_SANITIZER_OPERATION(Id, Name, Attrs)                        \
   case BuiltinValueKind::Id:                                                \
     llvm_unreachable("Sanitizer builtin called directly?");

branches/rxwei-patch-1/lib/SILOptimizer/Mandatory/OSLogOptimization.cpp

@@ -22,8 +22,10 @@
 /// arguments are packed. This pass is closely tied to the implementation of
 /// the log APIs.
 ///
-/// Pass Dependencies: MandatoryInlining. This pass also uses
-/// `ConstExprStepEvaluator` defined in `Utils/ConstExpr.cpp`.
+/// Pass Dependencies:  This pass depends on MandatoryInlining and Mandatory
+/// Linking happening before this pass and ConstantPropagation happening after
+/// this pass. This pass also uses `ConstExprStepEvaluator` defined in
+/// `Utils/ConstExpr.cpp`.
 ///
 /// Algorithm Overview:
 ///

branches/rxwei-patch-1/lib/SILOptimizer/PassManager/PassPipeline.cpp

@@ -114,6 +114,13 @@ static void addMandatoryOptPipeline(SILPassPipelinePlan &P) {
   // SSA based diagnostics.
   P.addPredictableMemoryAccessOptimizations();
 
+  // This phase performs optimizations necessary for correct interoperation of
+  // Swift os log APIs with C os_log ABIs.
+  // Pass dependencies: this pass depends on MandatoryInlining and Mandatory
+  // Linking happening before this pass and ConstantPropagation happening after
+  // this pass.
+  P.addOSLogOptimization();
+
   // Diagnostic ConstantPropagation must be rerun on deserialized functions
   // because it is sensitive to the assert configuration.
   // Consequently, certain optimization passes beyond this point will also rerun.
@@ -129,10 +136,6 @@ static void addMandatoryOptPipeline(SILPassPipelinePlan &P) {
   P.addYieldOnceCheck();
   P.addEmitDFDiagnostics();
 
-  // This phase performs optimizations necessary for correct interoperation of
-  // Swift os log APIs with C os_log ABIs.
-  P.addOSLogOptimization();
-
   // Canonical swift requires all non cond_br critical edges to be split.
   P.addSplitNonCondBrCriticalEdges();
 }

branches/rxwei-patch-1/lib/SILOptimizer/Transforms/AccessEnforcementReleaseSinking.cpp

@@ -130,6 +130,7 @@ static bool isBarrier(SILInstruction *inst) {
     case BuiltinValueKind::Swift3ImplicitObjCEntrypoint:
     case BuiltinValueKind::WillThrow:
     case BuiltinValueKind::PoundAssert:
+    case BuiltinValueKind::GlobalStringTablePointer:
       return false;
 
     // Handle some rare builtins that may be sensitive to object lifetime