StringOptimization: optimize C string literals.

Replace a String initializer followed by String.utf8CString with a (UTF8 encoded) string literal.
This code pattern is generated when calling C functions with string literals, e.g.

  puts("hello!")

rdar://74941849

Author: eeckstein

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.

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/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
+}
+