Merge pull request swiftlang#20043 from eeckstein/utf8-string-literals

support static large string literal generation for the new UTF8 String implementation

Author: eeckstein

include/swift/SIL/SILGlobalVariable.h

@@ -158,6 +158,11 @@ class SILGlobalVariable
   static bool isValidStaticInitializerInst(const SILInstruction *I,
                                            SILModule &M);
 
+  /// Returns the usub_with_overflow builtin if \p TE extracts the result of
+  /// such a subtraction, which is required to have an integer_literal as right
+  /// operand.
+  static BuiltinInst *getOffsetSubtract(const TupleExtractInst *TE, SILModule &M);
+
   void dropAllReferences() {
     StaticInitializerBlock.dropAllReferences();
   }

include/swift/SIL/SILValue.h

@@ -280,7 +280,7 @@ class ValueBase : public SILNode, public SILAllocated<ValueBase> {
   inline Operand *getSingleUse() const;
 
   template <class T>
-  inline T *getSingleUserOfType();
+  inline T *getSingleUserOfType() const;
 
   /// Return the instruction that defines this value, or null if it is
   /// not defined by an instruction.
@@ -706,7 +706,7 @@ inline Operand *ValueBase::getSingleUse() const {
 }
 
 template <class T>
-inline T *ValueBase::getSingleUserOfType() {
+inline T *ValueBase::getSingleUserOfType() const {
   T *Result = nullptr;
   for (auto *Op : getUses()) {
     if (auto *Tmp = dyn_cast<T>(Op->getUser())) {

lib/IRGen/GenConstant.cpp

@@ -94,20 +94,30 @@ static llvm::Constant *emitConstantValue(IRGenModule &IGM, SILValue operand) {
         return llvm::ConstantExpr::getZExtOrBitCast(value, IGM.getStorageType(BI->getType()));
       }
       case BuiltinValueKind::StringObjectOr: {
-        llvm::Constant *lhs = emitConstantValue(IGM, BI->getArguments()[0]);
-        llvm::Constant *rhs = emitConstantValue(IGM, BI->getArguments()[1]);
         // It is a requirement that the or'd bits in the left argument are
         // initialized with 0. Therefore the or-operation is equivalent to an
         // addition. We need an addition to generate a valid relocation.
+        llvm::Constant *rhs = emitConstantValue(IGM, BI->getArguments()[1]);
+        if (auto *TE = dyn_cast<TupleExtractInst>(BI->getArguments()[0])) {
+          // Handle StringObjectOr(tuple_extract(usub_with_overflow(x, offset)), bits)
+          // This pattern appears in UTF8 String literal construction.
+          // Generate the equivalent: add(x, sub(bits - offset)
+          BuiltinInst *SubtrBI =
+            SILGlobalVariable::getOffsetSubtract(TE, IGM.getSILModule());
+          assert(SubtrBI && "unsupported argument of StringObjectOr");
+          auto *ptr = emitConstantValue(IGM, SubtrBI->getArguments()[0]);
+          auto *offset = emitConstantValue(IGM, SubtrBI->getArguments()[1]);
+          auto *totalOffset = llvm::ConstantExpr::getSub(rhs, offset);
+          return llvm::ConstantExpr::getAdd(ptr, totalOffset);
+        }
+        llvm::Constant *lhs = emitConstantValue(IGM, BI->getArguments()[0]);
         return llvm::ConstantExpr::getAdd(lhs, rhs);
       }
       default:
         llvm_unreachable("unsupported builtin for constant expression");
     }
   } else if (auto *VTBI = dyn_cast<ValueToBridgeObjectInst>(operand)) {
-    auto *SI = cast<StructInst>(VTBI->getOperand());
-    assert(SI->getElements().size() == 1);
-    auto *val = emitConstantValue(IGM, SI->getElements()[0]);
+    auto *val = emitConstantValue(IGM, VTBI->getOperand());
     auto *sTy = IGM.getTypeInfo(VTBI->getType()).getStorageType();
     return llvm::ConstantExpr::getIntToPtr(val, sTy);
   } else {

lib/SIL/SILGlobalVariable.cpp

@@ -78,6 +78,31 @@ SILInstruction *SILGlobalVariable::getStaticInitializerValue() {
   return &StaticInitializerBlock.back();
 }
 
+BuiltinInst *SILGlobalVariable::getOffsetSubtract(const TupleExtractInst *TE,
+                                                  SILModule &M) {
+
+  // Match the pattern:
+  // tuple_extract(usub_with_overflow(x, integer_literal, integer_literal 0), 0)
+
+  if (TE->getFieldNo() != 0)
+    return nullptr;
+
+  auto *BI = dyn_cast<BuiltinInst>(TE->getOperand());
+  if (!BI)
+    return nullptr;
+  if (M.getBuiltinInfo(BI->getName()).ID != BuiltinValueKind::USubOver)
+    return nullptr;
+
+  if (!isa<IntegerLiteralInst>(BI->getArguments()[1]))
+    return nullptr;
+
+  auto *overflowFlag = dyn_cast<IntegerLiteralInst>(BI->getArguments()[2]);
+  if (!overflowFlag || !overflowFlag->getValue().isNullValue())
+    return nullptr;
+
+  return BI;
+}
+
 bool SILGlobalVariable::isValidStaticInitializerInst(const SILInstruction *I,
                                                      SILModule &M) {
   switch (I->getKind()) {
@@ -99,11 +124,27 @@ bool SILGlobalVariable::isValidStaticInitializerInst(const SILInstruction *I,
           break;
         case BuiltinValueKind::ZExtOrBitCast:
           return true;
+        case BuiltinValueKind::USubOver: {
+          // Handle StringObjectOr(tuple_extract(usub_with_overflow(x, offset)), bits)
+          // This pattern appears in UTF8 String literal construction.
+          auto *TE = bi->getSingleUserOfType<TupleExtractInst>();
+          return TE && getOffsetSubtract(TE, M);
+        }
         default:
           break;
       }
       return false;
     }
+    case SILInstructionKind::TupleExtractInst: {
+      // Handle StringObjectOr(tuple_extract(usub_with_overflow(x, offset)), bits)
+      // This pattern appears in UTF8 String literal construction.
+      auto *TE = cast<TupleExtractInst>(I);
+      if (!getOffsetSubtract(TE, M))
+        return false;
+      auto *BI = TE->getSingleUserOfType<BuiltinInst>();
+      return BI &&
+        M.getBuiltinInfo(BI->getName()).ID == BuiltinValueKind::StringObjectOr;
+    }
     case SILInstructionKind::StringLiteralInst:
       switch (cast<StringLiteralInst>(I)->getEncoding()) {
         case StringLiteralInst::Encoding::Bytes:

lib/SILGen/SILGenBuiltin.cpp

@@ -867,9 +867,15 @@ static ManagedValue emitBuiltinValueToBridgeObject(SILGenFunction &SGF,
   assert(args.size() == 1 && "ValueToBridgeObject should have one argument");
   assert(subs.getReplacementTypes().size() == 1 &&
          "ValueToBridgeObject should have one sub");
-  auto &fromTL = SGF.getTypeLowering(subs.getReplacementTypes()[0]);
-  assert(fromTL.isTrivial() && "Expected a trivial type");
-  (void)fromTL;
+
+  Type argTy = subs.getReplacementTypes()[0];
+  if (!argTy->is<BuiltinIntegerType>()) {
+    SGF.SGM.diagnose(loc, diag::invalid_sil_builtin,
+                     "argument to builtin should be a builtin integer");
+    SILType objPointerType = SILType::getBridgeObjectType(SGF.F.getASTContext());
+    SILValue undef = SILUndef::get(objPointerType, SGF.SGM.M);
+    return ManagedValue::forUnmanaged(undef);
+  }
 
   SILValue result = SGF.B.createValueToBridgeObject(loc, args[0].getValue());
   return SGF.emitManagedRetain(loc, result);

stdlib/public/core/Builtin.swift

@@ -458,7 +458,7 @@ public func _bridgeObject(
 @inlinable
 public func _bridgeObject(fromTagged x: UInt) -> Builtin.BridgeObject {
   _sanityCheck(x & _bridgeObjectTaggedPointerBits != 0)
-  let object: Builtin.BridgeObject = Builtin.valueToBridgeObject(x)
+  let object: Builtin.BridgeObject = Builtin.valueToBridgeObject(x._value)
   _sanityCheck(_isTaggedObject(object))
   return object
 }

test/IRGen/static_initializer.sil

@@ -103,6 +103,25 @@ sil_global @static_array_with_empty_element : $TestArrayStorage = {
 }
 // CHECK: @static_array_with_empty_element = {{( dllexport)?}}{{(protected )?}}global %T18static_initializer16TestArrayStorageC_tailelems3c { [1 x i64] zeroinitializer, %T18static_initializer16TestArrayStorageC_tailelems3 <{ %swift.refcounted zeroinitializer, %Ts5Int32V <{ i32 2 }>, [1 x i8] undef, [1 x i8] undef }> }, align 8
 
+struct MyString {
+  var buffer: Builtin.BridgeObject
+}
+
+sil_global [let] @string_with_offset : $MyString = {
+  %0 = integer_literal $Builtin.Int64, -9223372036854775808
+  %1 = integer_literal $Builtin.Int1, 0
+  %2 = integer_literal $Builtin.Int64, 32
+  %3 = string_literal utf8 "abc123asd3sdj3basfasdf"
+  %4 = builtin "ptrtoint_Word"(%3 : $Builtin.RawPointer) : $Builtin.Word
+  %5 = builtin "zextOrBitCast_Word_Int64"(%4 : $Builtin.Word) : $Builtin.Int64
+  %6 = builtin "usub_with_overflow_Int64"(%5 : $Builtin.Int64, %2 : $Builtin.Int64, %1 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
+  %7 = tuple_extract %6 : $(Builtin.Int64, Builtin.Int1), 0
+  %8 = builtin "stringObjectOr_Int64"(%7 : $Builtin.Int64, %0 : $Builtin.Int64) : $Builtin.Int64
+  %9 = value_to_bridge_object %8 : $Builtin.Int64
+  %initval = struct $MyString (%9 : $Builtin.BridgeObject)
+}
+// CHECK: @string_with_offset = {{.*global .*}} <{ %swift.bridge* inttoptr (i64 add (i64 ptrtoint ([23 x i8]* @0 to i64), i64 9223372036854775776) to %swift.bridge*) }>, align 8
+
 // CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i8* @_TF2cha1xSi() {{.*}} {
 // CHECK-NEXT: entry:
 // CHECK-NEXT: ret i8* bitcast (%Ts5Int32V* @"$s2ch1xSiv" to i8*)

test/SILGen/builtins.swift

@@ -809,12 +809,13 @@ func once(control: Builtin.RawPointer) {
 
 // CHECK-LABEL: sil hidden @$s8builtins19valueToBridgeObjectyBbSuF : $@convention(thin) (UInt) -> @owned Builtin.BridgeObject {
 // CHECK: bb0([[UINT:%.*]] : @trivial $UInt):
-// CHECK:   [[CAST:%.*]] = value_to_bridge_object [[UINT]] : $UInt
+// CHECK:   [[BI:%.*]] = struct_extract [[UINT]] : $UInt, #UInt._value
+// CHECK:   [[CAST:%.*]] = value_to_bridge_object [[BI]]
 // CHECK:   [[RET:%.*]] = copy_value [[CAST]] : $Builtin.BridgeObject
 // CHECK:   return [[RET]] : $Builtin.BridgeObject
 // CHECK: } // end sil function '$s8builtins19valueToBridgeObjectyBbSuF'
 func valueToBridgeObject(_ x: UInt) -> Builtin.BridgeObject {
-  return Builtin.valueToBridgeObject(x)
+  return Builtin.valueToBridgeObject(x._value)
 }
 
 // CHECK-LABEL: sil hidden @$s8builtins10assumeTrueyyBi1_F