[AddressLowering] Place projections below types.

Projections may involve opened archetypes.  They must be dominated by
the instructions which open those archetypes.

When determining the earliest storage point for a value and the point at
which to insert its projections, look for such obstructions in the
projection chain.  The first one found is the earliest storage point.

Author: nate-chandler

lib/SILOptimizer/Mandatory/AddressLowering.cpp

@@ -565,6 +565,13 @@ struct AddressLoweringState {
   /// @returns nullable value
   SILValue getEarliestStoragePoint(SILValue userValue, bool allowsInit) const;
 
+  /// Finds and caches the latest opening instruction of the type of the value
+  /// in \p pair.
+  ///
+  /// @returns nullable instruction
+  SILInstruction *
+  getLatestOpeningInst(const ValueStorageMap::ValueStoragePair *) const;
+
   /// The latest instruction which opens an archetype involved in the indicated
   /// type.
   ///
@@ -1256,6 +1263,15 @@ void OpaqueStorageAllocation::allocateValue(SILValue value) {
   createStackAllocationStorage(value);
 }
 
+SILInstruction *AddressLoweringState::getLatestOpeningInst(
+    const ValueStorageMap::ValueStoragePair *pair) const {
+  if (!pair->storage.latestOpeningInst.has_value()) {
+    auto *loi = getLatestOpeningInst(pair->value->getType());
+    pair->storage.latestOpeningInst = {loi};
+  }
+  return pair->storage.latestOpeningInst.value();
+}
+
 SILValue AddressLoweringState::getEarliestStoragePoint(SILValue userValue,
                                                        bool allowsInit) const {
   for (auto *pair : valueStorageMap.getProjections(userValue)) {
@@ -1265,6 +1281,9 @@ SILValue AddressLoweringState::getEarliestStoragePoint(SILValue userValue,
       // not allowed.  The projection will be inserted here.
       return pair->value;
     }
+    if (auto *loi = getLatestOpeningInst(pair)) {
+      return cast<SingleValueInstruction>(loi);
+    }
     assert(!(storage.isProjection() && storage.storageAddress));
     // Reached the bottom of the projection tower.  There must be storage.
     if (!storage.isProjection()) {
@@ -1781,6 +1800,7 @@ AddressLoweringState::getProjectionInsertionPoint(SILValue userValue) const {
   if (!valueStorageMap.getStorage(userValue).isProjection()) {
     return userValue->getDefiningInsertionPoint();
   }
+  SILInstruction *obstruction = nullptr;
   SILInstruction *retval = nullptr;
   for (auto *pair : valueStorageMap.getProjections(userValue)) {
     auto const &storage = pair->storage;
@@ -1789,8 +1809,18 @@ AddressLoweringState::getProjectionInsertionPoint(SILValue userValue) const {
       retval = storage.storageAddress->getNextInstruction();
       break;
     }
+    if (!obstruction) {
+      // It's only necessary to consider the obstruction to the earliest
+      // projection because obstructions to any others must dominate it.
+      if (auto *loi = getLatestOpeningInst(pair))
+        obstruction = loi->getNextInstruction();
+    }
   }
   assert(retval);
+  if (obstruction) {
+    if (domInfo->dominates(retval, obstruction))
+      retval = obstruction;
+  }
   return retval;
 }
 

lib/SILOptimizer/Mandatory/AddressLowering.h

@@ -81,6 +81,10 @@ struct ValueStorage {
   /// after materialization (during instruction rewriting).
   SILValue storageAddress;
 
+  /// The latest instruction which opens an archetype involved in the value's
+  /// type.  Just a cache of getLatestOpeningInst(value).
+  mutable Optional<SILInstruction *> latestOpeningInst = llvm::None;
+
   /// When either isDefProjection or isUseProjection is set, this refers to the
   /// storage whose "def" this value projects out of or whose operand this
   /// storage projects into via its "use.
@@ -152,11 +156,14 @@ struct ValueStorage {
 /// Mapped values are expected to be created in a single RPO pass. "erase" is
 /// unsupported. Values must be replaced using 'replaceValue()'.
 class ValueStorageMap {
+public:
   struct ValueStoragePair {
     SILValue value;
     ValueStorage storage;
     ValueStoragePair(SILValue v, ValueStorage s) : value(v), storage(s) {}
   };
+
+private:
   typedef std::vector<ValueStoragePair> ValueVector;
   // Hash of values to ValueVector indices.
   typedef llvm::DenseMap<SILValue, unsigned> ValueHashMap;

test/SILOptimizer/address_lowering.sil

@@ -1040,6 +1040,32 @@ bb7:
   return %23 : $()
 }
 
+// CHECK-LABEL: sil [ossa] @f163_testOpenedArchetype : {{.*}} {
+// CHECK:       {{bb[0-9]+}}([[INSTANCE:%[^,]+]] :
+// CHECK:         [[ADDR:%[^,]+]] = alloc_stack $Optional<Any>
+// CHECK:         [[BORROW:%[^,]+]] = begin_borrow [lexical] [[INSTANCE]]
+// CHECK:         [[AN_ERROR:%[^,]+]] = open_existential_box [[BORROW]]
+// CHECK:         [[ANY_ADDR:%[^,]+]] = init_enum_data_addr [[ADDR]]
+// CHECK:         [[OPENED_ADDR:%[^,]+]] = init_existential_addr [[ANY_ADDR]]
+// CHECK:         copy_addr [[AN_ERROR]] to [init] [[OPENED_ADDR]]
+// CHECK:         inject_enum_addr [[ADDR]] : $*Optional<Any>, #Optional.some!enumelt
+// CHECK:         apply undef<Any>([[ADDR]])
+// CHECK-LABEL: } // end sil function 'f163_testOpenedArchetype'
+sil [ossa] @f163_testOpenedArchetype : $@convention(c) (@owned any Error) -> () {
+block(%instance : @owned $any Error):
+  %borrow = begin_borrow [lexical] %instance : $any Error
+  %an_error = open_existential_box_value %borrow : $any Error to $@opened("55625EBA-9384-11ED-A0B0-32F16C24A34F", any Error) Self
+  %an_owned_error = copy_value %an_error : $@opened("55625EBA-9384-11ED-A0B0-32F16C24A34F", any Error) Self
+  %any = init_existential_value %an_owned_error : $@opened("55625EBA-9384-11ED-A0B0-32F16C24A34F", any Error) Self, $@opened("55625EBA-9384-11ED-A0B0-32F16C24A34F", any Error) Self, $Any
+  %some_any = enum $Optional<Any>, #Optional.some!enumelt, %any : $Any
+  apply undef<Any>(%some_any) : $@convention(thin) <T> (@in Optional<T>) -> ()
+  end_borrow %borrow : $any Error
+  destroy_value %instance : $any Error
+  %retval = tuple ()
+  return %retval : $()
+} // end sil function 'main'
+
+
 // CHECK-LABEL: sil [ossa] @f170_compare : $@convention(thin) <T where T : Comparable> (@in_guaranteed T, @in_guaranteed T) -> @out T {
 // CHECK: bb0(%0 : $*T, %1 : $*T, %2 : $*T):
 // CHECK:   [[WT:%.*]] = witness_method $T, #Comparable."<" : <Self where Self : Comparable> (Self.Type) -> (Self, Self) -> Builtin.Int1 : $@convention(witness_method: Comparable) <τ_0_0 where τ_0_0 : Comparable> (@in_guaranteed τ_0_0, @in_guaranteed τ_0_0, @thick τ_0_0.Type) -> Builtin.Int1