add a semantic attribute "optimize.sil.inline.constant.arguments"

This forces inlining the annotated function if its arguments are constant.

Author: eeckstein

include/swift/AST/SemanticAttrs.def

@@ -71,6 +71,8 @@ SEMANTICS_ATTR(TYPENAME, "typeName")
 SEMANTICS_ATTR(OPTIMIZE_SIL_SPECIALIZE_GENERIC_NEVER, "optimize.sil.specialize.generic.never")
 SEMANTICS_ATTR(OPTIMIZE_SIL_SPECIALIZE_GENERIC_PARTIAL_NEVER,
           "optimize.sil.specialize.generic.partial.never")
+SEMANTICS_ATTR(OPTIMIZE_SIL_INLINE_CONSTANT_ARGUMENTS,
+          "optimize.sil.inline.constant.arguments")
 SEMANTICS_ATTR(OPTIMIZE_SIL_SPECIALIZE_GENERIC_SIZE_NEVER,
           "optimize.sil.specialize.generic.size.never")
 SEMANTICS_ATTR(OPTIMIZE_SIL_SPECIALIZE_OWNED2GUARANTEE_NEVER,

lib/SILOptimizer/Transforms/PerformanceInliner.cpp

@@ -456,6 +456,33 @@ bool isProfitableToInlineAutodiffVJP(SILFunction *vjp, SILFunction *caller,
   return true;
 }
 
+static bool isConstantValue(SILValue v, ValueSet &visited) {
+  if (!visited.insert(v))
+    return true;
+
+  if (isa<LiteralInst>(v))
+    return true;
+  if (auto *s = dyn_cast<StructInst>(v)) {
+    for (Operand &op : s->getAllOperands()) {
+      if (!isConstantValue(op.get(), visited))
+        return false;
+    }
+    return true;
+  }
+  return false;
+}
+
+static bool hasConstantArguments(FullApplySite fas) {
+  ValueSet visited(fas.getFunction());
+  for (Operand &op : fas.getArgumentOperands()) {
+    if (!fas.isIndirectResultOperand(op)) {
+      if (!isConstantValue(op.get(), visited))
+        return false;
+    }
+  }
+  return true;
+}
+
 bool SILPerformanceInliner::isProfitableToInline(
     FullApplySite AI, Weight CallerWeight, ConstantTracker &callerTracker,
     int &NumCallerBlocks,
@@ -524,6 +551,11 @@ bool SILPerformanceInliner::isProfitableToInline(
     return true;
   }
 
+  if (Callee->hasSemanticsAttr(semantics::OPTIMIZE_SIL_INLINE_CONSTANT_ARGUMENTS) &&
+      hasConstantArguments(AI)) {
+    return true;
+  }
+
   // Bail out if this generic call can be optimized by means of
   // the generic specialization, because we prefer generic specialization
   // to inlining of generics.