SILOptimizer: move String concatination optimization from SILCombine/ConstantFolding to StringOptimization.

This simplifies some code and it's not required to try this optimization on every run of SILCombine and ConstantPropagation.

Author: eeckstein

include/swift/SILOptimizer/Utils/ConstantFolding.h

@@ -70,8 +70,6 @@ class ConstantFolder {
   /// Called for each constant folded instruction.
   std::function<void (SILInstruction *)> Callback;
 
-  bool constantFoldStringConcatenation(ApplyInst *AI);
-
 public:
   /// The constructor.
   ///

include/swift/SILOptimizer/Utils/InstOptUtils.h

@@ -299,11 +299,6 @@ TermInst *addArgumentToBranch(SILValue val, SILBasicBlock *dest,
 /// the given linkage.
 SILLinkage getSpecializedLinkage(SILFunction *f, SILLinkage linkage);
 
-/// Tries to optimize a given apply instruction if it is a concatenation of
-/// string literals. Returns a new instruction if optimization was possible.
-SingleValueInstruction *tryToConcatenateStrings(ApplyInst *ai,
-                                                SILBuilder &builder);
-
 /// Tries to perform jump-threading on all checked_cast_br instruction in
 /// function \p Fn.
 bool tryCheckedCastBrJumpThreading(

lib/SILOptimizer/SILCombiner/SILCombinerApplyVisitors.cpp

@@ -654,12 +654,6 @@ bool SILCombiner::eraseApply(FullApplySite FAS, const UserListTy &Users) {
   return true;
 }
 
-SILInstruction *
-SILCombiner::optimizeConcatenationOfStringLiterals(ApplyInst *AI) {
-  // String literals concatenation optimizer.
-  return tryToConcatenateStrings(AI, Builder);
-}
-
 /// This routine replaces the old witness method inst with a new one.
 void SILCombiner::replaceWitnessMethodInst(
     WitnessMethodInst *WMI, SILBuilderContext &BuilderCtx, CanType ConcreteType,
@@ -1464,12 +1458,6 @@ SILInstruction *SILCombiner::visitApplyInst(ApplyInst *AI) {
   }
 
   if (SF) {
-    if (SF->getEffectsKind() < EffectsKind::ReleaseNone) {
-      // Try to optimize string concatenation.
-      if (auto I = optimizeConcatenationOfStringLiterals(AI)) {
-        return I;
-      }
-    }
     if (SF->hasSemanticsAttr(semantics::ARRAY_UNINITIALIZED)) {
       UserListTy Users;
       // If the uninitialized array is only written into then it can be removed.

lib/SILOptimizer/Transforms/StringOptimization.cpp

@@ -90,7 +90,7 @@ class StringOptimization {
 
   bool optimizeStringAppend(ApplyInst *appendCall,
                             llvm::DenseMap<SILValue, SILValue> &storedStrings);
-
+  bool optimizeStringConcat(ApplyInst *concatCall);
   bool optimizeTypeName(ApplyInst *typeNameCall);
 
   static ApplyInst *isSemanticCall(SILInstruction *inst, StringRef attr,
@@ -102,8 +102,8 @@ class StringOptimization {
   static StringInfo getStringFromStaticLet(SILValue value);
 
   static Optional<int> getIntConstant(SILValue value);
-  static void replaceAppendWith(ApplyInst *appendCall, SILValue newValue,
-                                bool copyNewValue);
+  static void replaceAppendWith(ApplyInst *appendCall, SILValue newValue);
+  static SILValue copyValue(SILValue value, SILInstruction *before);
   ApplyInst *createStringInit(StringRef str, SILInstruction *beforeInst);
 };
 
@@ -144,6 +144,12 @@ bool StringOptimization::optimizeBlock(SILBasicBlock &block) {
         continue;
       }
     }
+    if (ApplyInst *append = isSemanticCall(inst, semantics::STRING_CONCAT, 3)) {
+      if (optimizeStringConcat(append)) {
+        changed = true;
+        continue;
+      }
+    }
     if (ApplyInst *typeName = isSemanticCall(inst, semantics::TYPENAME, 2)) {
       if (optimizeTypeName(typeName)) {
         changed = true;
@@ -184,7 +190,7 @@ bool StringOptimization::optimizeStringAppend(ApplyInst *appendCall,
 
   // Replace lhs.append(rhs) with 'lhs = rhs' if lhs is empty.
   if (lhsString.isEmpty()) {
-    replaceAppendWith(appendCall, rhs, /*copyNewValue*/ true);
+    replaceAppendWith(appendCall, copyValue(rhs, appendCall));
     storedStrings[lhsAddr] = rhs;
     return true;
   }
@@ -195,7 +201,7 @@ bool StringOptimization::optimizeStringAppend(ApplyInst *appendCall,
     std::string concat = lhsString.str;
     concat += rhsString.str;
     if (ApplyInst *stringInit = createStringInit(concat, appendCall)) {
-      replaceAppendWith(appendCall, stringInit, /*copyNewValue*/ false);
+      replaceAppendWith(appendCall, stringInit);
       storedStrings[lhsAddr] = stringInit;
       return true;
     }
@@ -204,6 +210,43 @@ bool StringOptimization::optimizeStringAppend(ApplyInst *appendCall,
   return false;
 }
 
+/// Optimize String.+ in case anything is known about the parameters.
+bool StringOptimization::optimizeStringConcat(ApplyInst *concatCall) {
+  SILValue lhs = concatCall->getArgument(0);
+  SILValue rhs = concatCall->getArgument(1);
+  StringInfo rhsString = getStringInfo(rhs);
+  
+  // Replace lhs + "" with lhs
+  if (rhsString.isEmpty()) {
+    lhs = copyValue(lhs, concatCall);
+    concatCall->replaceAllUsesWith(lhs);
+    concatCall->eraseFromParent();
+    return true;
+  }
+  
+  // Replace "" + rhs with rhs
+  StringInfo lhsString = getStringInfo(lhs);
+  if (lhsString.isEmpty()) {
+    rhs = copyValue(rhs, concatCall);
+    concatCall->replaceAllUsesWith(rhs);
+    concatCall->eraseFromParent();
+    return true;
+  }
+
+  // Replace lhs + rhs with "lhs + rhs" if both lhs and rhs are constant.
+  if (lhsString.isConstant() && rhsString.isConstant()) {
+    std::string concat = lhsString.str;
+    concat += rhsString.str;
+    if (ApplyInst *stringInit = createStringInit(concat, concatCall)) {
+      concatCall->replaceAllUsesWith(stringInit);
+      concatCall->eraseFromParent();
+      return true;
+    }
+  }
+  
+  return false;
+}
+
 /// Checks if the demangling tree contains any node which prevents constant
 /// folding of the type name.
 static bool containsProblematicNode(Demangle::Node *node, bool qualified) {
@@ -499,25 +542,33 @@ Optional<int> StringOptimization::getIntConstant(SILValue value) {
 
 /// Replace a String.append() with a store of \p newValue to the destination.
 void StringOptimization::replaceAppendWith(ApplyInst *appendCall,
-                                      SILValue newValue, bool copyNewValue) {
+                                           SILValue newValue) {
   SILBuilder builder(appendCall);
   SILLocation loc = appendCall->getLoc();
   SILValue destAddr = appendCall->getArgument(1);
   if (appendCall->getFunction()->hasOwnership()) {
-    if (copyNewValue)
-      newValue = builder.createCopyValue(loc, newValue);
     builder.createStore(loc, newValue, destAddr,
                         StoreOwnershipQualifier::Assign);
   } else {
-    if (copyNewValue)
-      builder.createRetainValue(loc, newValue, builder.getDefaultAtomicity());
     builder.createDestroyAddr(loc, destAddr);
     builder.createStore(loc, newValue, destAddr,
                         StoreOwnershipQualifier::Unqualified);
   }
   appendCall->eraseFromParent();
 }
 
+/// Returns a copy of \p value. Depending if the function is in OSSA, insert
+/// either a copy_value or retain_value.
+SILValue StringOptimization::copyValue(SILValue value, SILInstruction *before) {
+  SILBuilder builder(before);
+  SILLocation loc = before->getLoc();
+  if (before->getFunction()->hasOwnership())
+    return builder.createCopyValue(loc, value);
+
+  builder.createRetainValue(loc, value, builder.getDefaultAtomicity());
+  return value;
+}
+
 /// Creates a call to a string initializer.
 ApplyInst *StringOptimization::createStringInit(StringRef str,
                                                 SILInstruction *beforeInst) {

lib/SILOptimizer/Utils/ConstantFolding.cpp

@@ -1509,46 +1509,6 @@ static bool isFoldable(SILInstruction *I) {
          isa<StringLiteralInst>(I);
 }
 
-bool ConstantFolder::constantFoldStringConcatenation(ApplyInst *AI) {
-  SILBuilder B(AI);
-  // Try to apply the string literal concatenation optimization.
-  auto *Concatenated = tryToConcatenateStrings(AI, B);
-  // Bail if string literal concatenation could not be performed.
-  if (!Concatenated)
-    return false;
-
-  // Replace all uses of the old instruction by a new instruction.
-  AI->replaceAllUsesWith(Concatenated);
-
-  auto RemoveCallback = [&](SILInstruction *DeadI) { WorkList.remove(DeadI); };
-  // Remove operands that are not used anymore.
-  // Even if they are apply_inst, it is safe to
-  // do so, because they can only be applies
-  // of functions annotated as string.utf16
-  // or string.utf16.
-  for (auto &Op : AI->getAllOperands()) {
-    SILValue Val = Op.get();
-    Op.drop();
-    if (Val->use_empty()) {
-      auto *DeadI = Val->getDefiningInstruction();
-      assert(DeadI);
-      recursivelyDeleteTriviallyDeadInstructions(DeadI, /*force*/ true,
-                                                 RemoveCallback);
-    }
-  }
-  // Schedule users of the new instruction for constant folding.
-  // We only need to schedule the string.concat invocations.
-  for (auto AIUse : Concatenated->getUses()) {
-    if (isApplyOfStringConcat(*AIUse->getUser())) {
-      WorkList.insert(AIUse->getUser());
-    }
-  }
-  // Delete the old apply instruction.
-  recursivelyDeleteTriviallyDeadInstructions(AI, /*force*/ true,
-                                             RemoveCallback);
-  return true;
-}
-
 /// Given a buitin instruction calling globalStringTablePointer, check whether
 /// the string passed to the builtin is constructed from a literal and if so,
 /// replace the uses of the builtin instruction with the string_literal inst.
@@ -1772,16 +1732,6 @@ ConstantFolder::processWorkList() {
         }
       }
 
-    if (auto *AI = dyn_cast<ApplyInst>(I)) {
-      // Apply may only come from a string.concat invocation.
-      if (constantFoldStringConcatenation(AI)) {
-        // Invalidate all analysis that's related to the call graph.
-        InvalidateInstructions = true;
-      }
-
-      continue;
-    }
-
     // If we have a cast instruction, try to optimize it.
     if (isa<CheckedCastBranchInst>(I) || isa<CheckedCastAddrBranchInst>(I) ||
         isa<UnconditionalCheckedCastInst>(I) ||