Refactoring: extract some code of the inliner to the projection classes.

Michael, thanks for your comments!

This also adds support for tuples and enums in Projection::getOperandForAggregate().



Swift SVN r24112

Author: eeckstein

include/swift/SIL/Projection.h

@@ -223,6 +223,11 @@ class Projection {
     }
   }
 
+  /// Returns the operand of a struct, tuple or enum instruction which is
+  /// associated with this projection. Returns an invalid SILValue if \p I is
+  /// not a matching aggregate instruction.
+  SILValue getOperandForAggregate(SILInstruction *I) const;
+
 private:
   Projection(ProjectionKind Kind, SILType Type, ValueDecl *Decl,
              unsigned Index)
@@ -274,13 +279,11 @@ class ProjectionPath {
 private:
   PathTy Path;
 
-  /// This is private since in all cases where we construct a projection path we
-  /// can fail. That implies that we only want to allow ProjectionPaths to be
-  /// created from static factory methods that can return an rvalue of a
-  /// projection path.
+public:
+  /// Create an empty path which serves as a stack. Use push_back() to populate
+  /// the stack with members.
   ProjectionPath() : Path() {}
 
-public:
   ~ProjectionPath() = default;
 
   /// Do not allow copy construction. The only way to get one of these is from
@@ -317,6 +320,15 @@ class ProjectionPath {
   findMatchingValueProjectionPaths(SILInstruction *I,
                                    SmallVectorImpl<SILInstruction *> &T) const;
 
+  /// Pushes an element to the path.
+  void push_back(const Projection &Proj) { Path.push_back(Proj); }
+
+  /// Removes the last element from the path.
+  void pop_back() { Path.pop_back(); }
+
+  /// Returns the last element of the path.
+  const Projection &back() const { return Path.back(); }
+
   /// Returns true if LHS and RHS have all the same projections in the same
   /// order.
   bool operator==(const ProjectionPath &RHS) const {

lib/SIL/Projection.cpp

@@ -239,6 +239,31 @@ createAddrProjection(SILBuilder &B, SILLocation Loc, SILValue Base) const {
   }
 }
 
+SILValue Projection::getOperandForAggregate(SILInstruction *I) const {
+  switch (getKind()) {
+    case ProjectionKind::Struct:
+      if (isa<StructInst>(I))
+        return I->getOperand(getDeclIndex());
+      break;
+    case ProjectionKind::Tuple:
+      if (isa<TupleInst>(I))
+        return I->getOperand(getIndex());
+      break;
+    case ProjectionKind::Enum:
+      if (EnumInst *EI = dyn_cast<EnumInst>(I)) {
+        if (EI->getElement() == Decl) {
+          assert(EI->hasOperand() && "expected data operand");
+          return EI->getOperand();
+        }
+      }
+      break;
+    case ProjectionKind::Class:
+      // There is no SIL instruction to create a class by aggregating values.
+      break;
+  }
+  return SILValue();
+}
+
 //===----------------------------------------------------------------------===//
 //                              Projection Path
 //===----------------------------------------------------------------------===//

lib/SILPasses/PerformanceInliner.cpp

@@ -42,8 +42,6 @@ namespace {
     // Links between loaded and stored values.
     llvm::DenseMap<SILValue, SILValue> links;
 
-    typedef llvm::SmallVector<Projection, 8> ProjectionStack;
-
     // The constant tracker of the caller function (null if this is the
     // tracker of the callee).
     ConstantTracker *callerTracker;
@@ -53,10 +51,7 @@ namespace {
     ApplyInst *AI;
 
     // Gets the estimated constant of a value.
-    SILInstruction *getConst(SILValue val, ProjectionStack &projStack);
-
-    // Get's the struct/tuple member based on the top of the projection stack.
-    static SILValue getMember(SILInstruction *inst, ProjectionStack &projStack);
+    SILInstruction *getConst(SILValue val, ProjectionPath &projStack);
 
   public:
 
@@ -73,7 +68,7 @@ namespace {
 
     // Gets the estimated constant of a value.
     SILInstruction *getConst(SILValue val) {
-      ProjectionStack projStack;
+      ProjectionPath projStack;
       return getConst(val, projStack);
     }
   };
@@ -132,26 +127,17 @@ void ConstantTracker::trackInst(SILInstruction *inst) {
   }
 }
 
-SILValue ConstantTracker::getMember(SILInstruction *inst,
-                                    ProjectionStack &projStack) {
+// Get the aggregate member based on the top of the projection stack.
+static SILValue getMember(SILInstruction *inst, ProjectionPath &projStack) {
   if (!projStack.empty()) {
     const Projection &proj = projStack.back();
-    switch (proj.getKind()) {
-      case ProjectionKind::Struct:
-        if (StructInst *SI = dyn_cast<StructInst>(inst)) {
-          return SI->getOperand(proj.getDeclIndex());
-        }
-        break;
-      default:
-        // TODO: not yet supported
-        break;
-    }
+    return proj.getOperandForAggregate(inst);
   }
   return SILValue();
 }
 
 SILInstruction *ConstantTracker::getConst(SILValue val,
-                                          ProjectionStack &projStack) {
+                                          ProjectionPath &projStack) {
 
   // Track the value up the dominator tree.
   // The val can also be an address value. In this case it refers to the
@@ -173,22 +159,11 @@ SILInstruction *ConstantTracker::getConst(SILValue val,
       default:
         break;
       }
-      if (Projection::isValueProjection(inst)) {
-        // Extract a member from a struct/tuple.
-        auto proj = Projection::valueProjectionForInstruction(inst);
-        if (proj) {
-          projStack.push_back(proj.getValue());
-          val = inst->getOperand(0);
-          continue;
-        }
-      } else if (Projection::isAddrProjection(inst)) {
-        // Extract a member address from a struct/tuple address.
-        auto proj = Projection::addressProjectionForInstruction(inst);
-        if (proj) {
-          projStack.push_back(proj.getValue());
-          val = inst->getOperand(0);
-          continue;
-        }
+      if (auto proj = Projection::projectionForInstruction(inst)) {
+        // Extract a member from a struct/tuple/enum.
+        projStack.push_back(proj.getValue());
+        val = inst->getOperand(0);
+        continue;
       } else if (SILValue member = getMember(inst, projStack)) {
         // The opposite of a projection instruction: composing a struct/tuple.
         projStack.pop_back();

test/SILPasses/inline_heuristics.sil

@@ -18,6 +18,16 @@ struct Cont {
 	var cl: (Int) -> Int
 }
 
+struct Cont2 {
+	var tp: (Int, (Int) -> Int)
+}
+
+enum E {
+	case A
+	case B((Int) -> Int)
+}
+
+
 // CHECK-LABEL: sil @testDirectClosure
 // CHECK: [[C:%[0-9]+]] = thin_to_thick_function
 // CHECK: apply [[C]](
@@ -30,7 +40,7 @@ struct Cont {
 sil @testDirectClosure : $@thin () -> Int {
 bb0:
   %0 = function_ref @takeDirectClosure : $@thin (@owned @callee_owned (Int) -> Int) -> Int
-  %1 = function_ref @directClosure : $@thin (Int) -> Int
+  %1 = function_ref @closure : $@thin (Int) -> Int
   %2 = thin_to_thick_function %1 : $@thin (Int) -> Int to $@callee_owned (Int) -> Int
   %3 = apply %0(%2) : $@thin (@owned @callee_owned (Int) -> Int) -> Int
   return %3 : $Int
@@ -44,18 +54,6 @@ bb0(%0 : $@callee_owned (Int) -> Int):
   return %3 : $Int
 }
 
-sil shared @directClosure : $@thin (Int) -> Int {
-bb0(%0 : $Int):
-  %1 = integer_literal $Builtin.Word, 1
-  %2 = struct_extract %0 : $Int, #Int.value
-  %3 = integer_literal $Builtin.Int1, -1
-  %4 = builtin "sadd_with_overflow_Word"(%2 : $Builtin.Word, %1 : $Builtin.Word, %3 : $Builtin.Int1) : $(Builtin.Word, Builtin.Int1)
-  %5 = tuple_extract %4 : $(Builtin.Word, Builtin.Int1), 0
-  %6 = tuple_extract %4 : $(Builtin.Word, Builtin.Int1), 1
-  cond_fail %6 : $Builtin.Int1
-  %8 = struct $Int (%5 : $Builtin.Word)
-  return %8 : $Int
-}
 
 // CHECK-LABEL: sil @testStructClosure
 // CHECK: [[C:%[0-9]+]] = struct_extract
@@ -69,7 +67,7 @@ bb0(%0 : $Int):
 sil @testStructClosure : $@thin () -> Int {
 bb0:
   %0 = function_ref @takeStructClosure : $@thin (@owned Cont) -> Int
-  %1 = function_ref @structClosure : $@thin (Int) -> Int
+  %1 = function_ref @closure : $@thin (Int) -> Int
   %2 = thin_to_thick_function %1 : $@thin (Int) -> Int to $@callee_owned (Int) -> Int
   %3 = struct $Cont (%2 : $@callee_owned (Int) -> Int)
   %4 = apply %0(%3) : $@thin (@owned Cont) -> Int
@@ -85,18 +83,6 @@ bb0(%0 : $Cont):
   return %4 : $Int
 }
 
-sil shared @structClosure : $@thin (Int) -> Int {
-bb0(%0 : $Int):
-  %1 = integer_literal $Builtin.Word, 1
-  %2 = struct_extract %0 : $Int, #Int.value
-  %3 = integer_literal $Builtin.Int1, -1
-  %4 = builtin "sadd_with_overflow_Word"(%2 : $Builtin.Word, %1 : $Builtin.Word, %3 : $Builtin.Int1) : $(Builtin.Word, Builtin.Int1)
-  %5 = tuple_extract %4 : $(Builtin.Word, Builtin.Int1), 0
-  %6 = tuple_extract %4 : $(Builtin.Word, Builtin.Int1), 1
-  cond_fail %6 : $Builtin.Int1
-  %8 = struct $Int (%5 : $Builtin.Word)
-  return %8 : $Int
-}
 
 // CHECK-LABEL: sil @testStructAddrClosure
 // CHECK: [[C:%[0-9]+]] = load
@@ -110,7 +96,7 @@ bb0(%0 : $Int):
 sil @testStructAddrClosure : $@thin () -> Int {
 bb0:
   %0 = alloc_stack $Cont
-  %1 = function_ref @structAddrClosure : $@thin (Int) -> Int
+  %1 = function_ref @closure : $@thin (Int) -> Int
   %2 = thin_to_thick_function %1 : $@thin (Int) -> Int to $@callee_owned (Int) -> Int
   %3 = struct $Cont (%2 : $@callee_owned (Int) -> Int)
   store %3 to %0#1 : $*Cont
@@ -134,7 +120,70 @@ bb0(%0 : $*Cont):
   return %6 : $Int
 }
 
-sil shared @structAddrClosure : $@thin (Int) -> Int {
+
+// CHECK-LABEL: sil @testTupleClosure
+// CHECK: [[C:%[0-9]+]] = tuple_extract
+// CHECK: apply [[C]](
+// CHECK: return
+
+// LOG-LABEL: Visiting Function: testTupleClosure
+// LOG: Eligible callee: takeTupleClosure
+// LOG: Boost: apply const function
+
+sil @takeTupleClosure : $@thin (@owned Cont2) -> Int {
+bb0(%0 : $Cont2):
+  %1 = struct_extract %0 : $Cont2, #Cont2.tp
+  %2 = tuple_extract %1 : $(Int, @callee_owned (Int) -> Int), 1
+  %3 = integer_literal $Builtin.Word, 27
+  %4 = struct $Int (%3 : $Builtin.Word)
+  %5 = apply %2(%4) : $@callee_owned (Int) -> Int
+  return %5 : $Int
+}
+
+sil @testTupleClosure : $@thin () -> Int {
+bb0:
+  %0 = function_ref @takeTupleClosure : $@thin (@owned Cont2) -> Int
+  %1 = integer_literal $Builtin.Word, 27
+  %2 = struct $Int (%1 : $Builtin.Word)
+  %3 = function_ref @closure : $@thin (Int) -> Int
+  %4 = thin_to_thick_function %3 : $@thin (Int) -> Int to $@callee_owned (Int) -> Int
+  %5 = tuple (%2 : $Int, %4 : $@callee_owned (Int) -> Int)
+  %6 = struct $Cont2 (%5 : $(Int, @callee_owned (Int) -> Int))
+  %7 = apply %0(%6) : $@thin (@owned Cont2) -> Int
+  return %7 : $Int
+}
+
+
+// CHECK-LABEL: sil @testEnumClosure
+// CHECK: [[C:%[0-9]+]] = unchecked_enum_data
+// CHECK: apply [[C]](
+// CHECK: return
+
+// LOG-LABEL: Visiting Function: testEnumClosure
+// LOG: Eligible callee: takeEnumClosure
+// LOG: Boost: apply const function
+
+sil @takeEnumClosure : $@thin (@owned E) -> Int {
+bb0(%0 : $E):
+  %1 = unchecked_enum_data %0 : $E, #E.B!enumelt.1
+  %2 = integer_literal $Builtin.Word, 27
+  %3 = struct $Int (%2 : $Builtin.Word)
+  %4 = apply %1(%3) : $@callee_owned (Int) -> Int
+  return %4 : $Int
+}
+
+sil @testEnumClosure : $@thin () -> Int {
+bb0:
+  %0 = function_ref @takeEnumClosure : $@thin (@owned E) -> Int
+  %1 = function_ref @closure : $@thin (Int) -> Int
+  %2 = thin_to_thick_function %1 : $@thin (Int) -> Int to $@callee_owned (Int) -> Int
+  %3 = enum $E, #E.B!enumelt.1, %2 : $@callee_owned (Int) -> Int
+  %4 = apply %0(%3) : $@thin (@owned E) -> Int
+  return %4 : $Int
+}
+
+
+sil shared @closure : $@thin (Int) -> Int {
 bb0(%0 : $Int):
   %1 = integer_literal $Builtin.Word, 1
   %2 = struct_extract %0 : $Int, #Int.value