SILCombine: optimize mark_dependence of a string literal.

This pattern can occur after StringOptimization when a utf8CString of a literal is replace by the string_literal itself.

Author: eeckstein

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;
 }

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 :