Merge pull request #36349 from eeckstein/c-string-optimization

StringOptimization: optimize C string literals.

Author: eeckstein

include/swift/AST/SemanticAttrs.def

@@ -26,6 +26,7 @@
 
 SEMANTICS_ATTR(STRING_EQUALS, "string.equals")
 SEMANTICS_ATTR(STRING_MAKE_UTF8, "string.makeUTF8")
+SEMANTICS_ATTR(STRING_GET_UTF8_CSTRING, "string.getUTF8CString")
 SEMANTICS_ATTR(STRING_ESCAPE_PERCENT_GET, "string.escapePercent.get")
 SEMANTICS_ATTR(STRING_CONCAT, "string.concat")
 SEMANTICS_ATTR(STRING_APPEND, "string.append")

lib/SILOptimizer/SILCombiner/SILCombinerMiscVisitors.cpp

@@ -2181,6 +2181,18 @@ visitAllocRefDynamicInst(AllocRefDynamicInst *ARDI) {
   return NewInst;
 }
 
+/// Returns true if \p val is a literal instruction or a struct of a literal
+/// instruction.
+/// What we want to catch here is a UnsafePointer<Int8> of a string literal.
+static bool isLiteral(SILValue val) {
+  while (auto *str = dyn_cast<StructInst>(val)) {
+    if (str->getNumOperands() != 1)
+      return false;
+    val = str->getOperand(0);
+  }
+  return isa<LiteralInst>(val);
+}
+
 SILInstruction *SILCombiner::visitMarkDependenceInst(MarkDependenceInst *mdi) {
   auto base = lookThroughOwnershipInsts(mdi->getBase());
 
@@ -2242,6 +2254,14 @@ SILInstruction *SILCombiner::visitMarkDependenceInst(MarkDependenceInst *mdi) {
       }
     }
   }
+  
+  if (isLiteral(mdi->getValue())) {
+    // A literal lives forever, so no mark_dependence is needed.
+    // This pattern can occur after StringOptimization when a utf8CString of
+    // a literal is replace by the string_literal itself.
+    replaceInstUsesWith(*mdi, mdi->getValue());
+    return eraseInstFromFunction(*mdi);
+  }
 
   return nullptr;
 }

lib/SILOptimizer/Transforms/StringOptimization.cpp

@@ -39,6 +39,7 @@ namespace {
 ///   * Replaces x.append(y) with x = x + y if x and y are constant strings.
 ///   * Replaces _typeName(T.self) with a constant string if T is statically
 ///     known.
+///   * Replaces String(literal).utf8CString with the string literal itself.
 ///
 /// This pass must run on high-level SIL, where semantic calls are still in
 /// place.
@@ -92,6 +93,7 @@ class StringOptimization {
                             llvm::DenseMap<SILValue, SILValue> &storedStrings);
   bool optimizeStringConcat(ApplyInst *concatCall);
   bool optimizeTypeName(ApplyInst *typeNameCall);
+  bool optimizeGetCString(ApplyInst *getCStringCall);
 
   static ApplyInst *isSemanticCall(SILInstruction *inst, StringRef attr,
                                    unsigned numArgs);
@@ -156,6 +158,13 @@ bool StringOptimization::optimizeBlock(SILBasicBlock &block) {
         continue;
       }
     }
+    if (ApplyInst *getCString = isSemanticCall(inst,
+                                       semantics::STRING_GET_UTF8_CSTRING, 1)) {
+      if (optimizeGetCString(getCString)) {
+        changed = true;
+        continue;
+      }
+    }
     // Remove items from storedStrings if inst overwrites (or potentially
     // overwrites) a stored String in an identifyable object.
     invalidateModifiedObjects(inst, storedStrings);
@@ -328,6 +337,50 @@ bool StringOptimization::optimizeTypeName(ApplyInst *typeNameCall) {
   return true;
 }
 
+/// Replaces a String initializer followed by String.utf8CString with a
+/// (UTF8 encoded) string literal.
+///
+/// Note that string literals are always generated with a trailing 0-byte.
+bool StringOptimization::optimizeGetCString(ApplyInst *getCStringCall) {
+  // Is this a String.utf8CString of a literal String?
+  StringInfo stringInfo = getStringInfo(getCStringCall->getArgument(0));
+  if (!stringInfo.isConstant())
+    return false;
+
+  StringLiteralInst *literal = nullptr;
+  bool changed = false;
+  SmallVector<SILInstruction *, 16> workList;
+  workList.push_back(getCStringCall);
+
+  /// String.utf8CString returns an array of Int8. Search for ref_tail_addr of
+  /// the array buffer.
+  while (!workList.empty()) {
+    SILInstruction *inst = workList.pop_back_val();
+    // Look through string_extract which extract the buffer from the array.
+    if (isa<StructExtractInst>(inst) || inst == getCStringCall) {
+      for (Operand *use : cast<SingleValueInstruction>(inst)->getUses()) {
+        workList.push_back(use->getUser());
+      }
+      continue;
+    }
+    if (auto *rta = dyn_cast<RefTailAddrInst>(inst)) {
+      // Replace the ref_tail_addr with a pointer_to_address of the string
+      // literal.
+      if (!literal) {
+        // Build the literal if we don't have one, yet.
+        SILBuilder builder(getCStringCall);
+        literal = builder.createStringLiteral(getCStringCall->getLoc(),
+                    stringInfo.str, StringLiteralInst::Encoding::UTF8);
+      }
+      SILBuilder builder(rta);
+      auto *strAddr = builder.createPointerToAddress(rta->getLoc(), literal,
+                        rta->getType(), /*isStrict*/ false);
+      rta->replaceAllUsesWith(strAddr);
+      changed = true;
+    }
+  }
+  return changed;
+}
 
 /// Returns the apply instruction if \p inst is a call of a function which has
 /// a semantic attribute \p attr and exactly \p numArgs arguments.

stdlib/public/core/StringUTF8View.swift

@@ -251,13 +251,16 @@ extension String {
   ///     }
   ///     // Prints "6"
   public var utf8CString: ContiguousArray<CChar> {
-    if _fastPath(_guts.isFastUTF8) {
-      var result = _guts.withFastCChar { ContiguousArray($0) }
-      result.append(0)
-      return result
-    }
+    @_effects(readonly) @_semantics("string.getUTF8CString")
+    get {
+      if _fastPath(_guts.isFastUTF8) {
+        var result = _guts.withFastCChar { ContiguousArray($0) }
+        result.append(0)
+        return result
+      }
 
-    return _slowUTF8CString()
+      return _slowUTF8CString()
+    }
   }
 
   @usableFromInline @inline(never) // slow-path

test/SILOptimizer/c_string_optimization.swift

@@ -0,0 +1,36 @@
+// RUN: %target-build-swift -O %s -module-name=test -emit-sil | %FileCheck %s
+
+// RUN: %empty-directory(%t) 
+// RUN: %target-build-swift -O -module-name=test %s -o %t/a.out
+// RUN: %target-run %t/a.out | %FileCheck %s -check-prefix=CHECK-OUTPUT
+
+// REQUIRES: executable_test,swift_stdlib_no_asserts
+
+#if canImport(Darwin)
+  import Darwin
+#elseif canImport(Glibc)
+  import Glibc
+#elseif os(Windows)
+  import CRT
+#else
+#error("Unsupported platform")
+#endif
+
+// CHECK-LABEL: sil [noinline] @$s4test0A26StringConstantForCFunctionyyF
+// CHECK-NOT: apply
+// CHECK:    [[L:%[0-9]+]] = string_literal utf8 "Hello world!"
+// CHECK-NOT: apply
+// CHECK:    [[P:%[0-9]+]] = struct $UnsafePointer<Int8> ([[L]] : $Builtin.RawPointer)
+// CHECK-NOT: apply
+// CHECK:    [[O:%[0-9]+]] = enum $Optional<UnsafePointer<Int8>>, #Optional.some!enumelt, [[P]]
+// CHECK-NOT: apply
+// CHECK:    [[F:%[0-9]+]] = function_ref @puts
+// CHECK:    apply [[F]]([[O]])
+// CHECK: } // end sil function '$s4test0A26StringConstantForCFunctionyyF'
+@inline(never)
+public func testStringConstantForCFunction() {
+  puts("Hello " + "world!")
+}
+
+// CHECK-OUTPUT: Hello world!
+testStringConstantForCFunction()

test/SILOptimizer/sil_combine_ossa.sil

@@ -4195,6 +4195,19 @@ bb0(%0 : $*Builtin.Int64, %1 : @owned $B):
   return %4 : $Builtin.Int64
 }
 
+// CHECK-LABEL: sil [ossa] @mark_dependence_string_literal
+// CHECK:       %1 = string_literal utf8 "a"
+// CHECK:       %2 = struct $UnsafePointer<Int8> (%1 : $Builtin.RawPointer)
+// CHECK:       return %2
+// CHECK: } // end sil function 'mark_dependence_string_literal'
+sil [ossa] @mark_dependence_string_literal : $@convention(thin) (@guaranteed Builtin.NativeObject) -> UnsafePointer<Int8> {
+bb0(%0 : @guaranteed $Builtin.NativeObject):
+  %1 = string_literal utf8 "a"
+  %2 = struct $UnsafePointer<Int8> (%1 : $Builtin.RawPointer)
+  %3 = mark_dependence %2 : $UnsafePointer<Int8> on %0 : $Builtin.NativeObject
+  return %3 : $UnsafePointer<Int8>
+}
+
 // Test to see if we can constant fold a classify_bridge_object on a Swift class
 // to false.
 // CHECK-LABEL: sil [ossa] @test_classify_fold :

test/SILOptimizer/string_optimization.sil

@@ -11,6 +11,7 @@ sil [readonly] [_semantics "string.init_empty"] @empty_string : $@convention(met
 sil [_semantics "string.init_empty"] @empty_string_with_capacity : $@convention(method) (Int, @thin String.Type) -> @owned String
 sil [_semantics "string.append"] @string_append : $@convention(method) (@guaranteed String, @inout String) -> ()
 sil [_semantics "string.concat"] @string_concat : $@convention(method) (@guaranteed String, @guaranteed String, @thin String.Type) -> @owned String
+sil [readonly] [_semantics "string.getUTF8CString"] @string_getUTF8CString : $@convention(method) (@guaranteed String) -> @owned ContiguousArray<Int8>
 
 // CHECK-LABEL: sil @append_to_empty_string
 // CHECK:       [[S:%[0-9]+]] = alloc_stack $String
@@ -232,3 +233,24 @@ bb0(%0 : $String):
   return %13 : $String
 }
 
+// CHECK-LABEL: sil @test_cstring
+// CHECK:       %0 = string_literal utf8 "a"
+// CHECK:       return %0
+// CHECK:     } // end sil function 'test_cstring'
+sil @test_cstring : $@convention(thin) () -> Builtin.RawPointer {
+bb0:
+  %3 = string_literal utf8 "a"
+  %4 = integer_literal $Builtin.Word, 1
+  %5 = integer_literal $Builtin.Int1, -1
+  %6 = metatype $@thin String.Type
+  %7 = function_ref @$sSS21_builtinStringLiteral17utf8CodeUnitCount7isASCIISSBp_BwBi1_tcfC : $@convention(method) (Builtin.RawPointer, Builtin.Word, Builtin.Int1, @thin String.Type) -> @owned String
+  %8 = apply %7(%3, %4, %5, %6) : $@convention(method) (Builtin.RawPointer, Builtin.Word, Builtin.Int1, @thin String.Type) -> @owned String
+  %9 = function_ref @string_getUTF8CString : $@convention(method) (@guaranteed String) -> @owned ContiguousArray<Int8>
+  %10 = apply %9(%8) : $@convention(method) (@guaranteed String) -> @owned ContiguousArray<Int8>
+  %11 = struct_extract %10 : $ContiguousArray<Int8>, #ContiguousArray._buffer
+  %12 = struct_extract %11 : $_ContiguousArrayBuffer<Int8>, #_ContiguousArrayBuffer._storage
+  %13 = ref_tail_addr %12 : $__ContiguousArrayStorageBase, $Int8
+  %14 = address_to_pointer %13 : $*Int8 to $Builtin.RawPointer
+  return %14 : $Builtin.RawPointer
+}
+