[sil] Add basic SIL support for alloc_stack [non_nested].

This means I just added the flag and added support for
cloning/printing/serializing the bit on alloc_stack.

Author: gottesmm

include/swift/SIL/SILCloner.h

@@ -1062,6 +1062,7 @@ SILCloner<ImplClass>::visitAllocStackInst(AllocStackInst *Inst) {
       true
 #endif
   );
+  NewInst->setStackAllocationIsNested(Inst->isStackAllocationNested());
   recordClonedInstruction(Inst, NewInst);
 }
 

include/swift/SIL/SILInstruction.h

@@ -141,6 +141,24 @@ class SILPrintContext;
 
 template <typename ImplClass> class SILClonerWithScopes;
 
+/// An enum that describes whether or not a stack allocation may violate the
+/// stack discipline of swift.
+///
+/// DISCUSSION: In swift, we require that all allocations on the stack be
+/// strictly allocated in a LIFO order... that is the last stack allocation
+/// created must be the first stack allocation destroyed. In some cases, we
+/// cannot guarantee that behavior. In such cases we may need to use other
+/// strategies that do not involve stack memory (e.x.: using heap memory
+/// although we do not require heap memory to be used).
+enum StackAllocationIsNested_t : bool {
+  /// The instruction may not obey the LIFO rule of stack allocation.
+  StackAllocationIsNotNested = false,
+
+  /// The instruction obeys the LIFO rule of stack allocation and can allocate
+  /// memory on the stack normally.
+  StackAllocationIsNested = true,
+};
+
 enum class MemoryBehavior {
   None,
   /// The instruction may read memory.
@@ -858,6 +876,15 @@ class SILInstruction : public llvm::ilist_node<SILInstruction> {
   /// The stack allocation produced by the instruction, if any.
   SILValue getStackAllocation() const;
 
+  /// Returns the kind of stack memory that should be allocated. There are
+  /// certain (unfortunate) situations in which "stack" allocations may become
+  /// unnested and must use alternative allocation strategies. Rather than
+  /// requiring all of these to explicitly use heap allocation, which may be
+  /// to be significantly less efficient (e.g. )
+  StackAllocationIsNested_t isStackAllocationNested() const;
+
+  void setStackAllocationIsNested(StackAllocationIsNested_t isNested);
+
   /// Returns true if this is the deallocation of a stack allocating instruction.
   /// The first operand must be the allocating instruction.
   bool isDeallocatingStack() const;
@@ -2055,6 +2082,24 @@ class AllocStackInst final
     }
   }
 
+  StackAllocationIsNested_t isStackAllocationNested() const {
+    if (sharedUInt8().AllocStackInst.isNested) {
+      return StackAllocationIsNested;
+    }
+    return StackAllocationIsNotNested;
+  }
+
+  void setStackAllocationIsNested(StackAllocationIsNested_t isNested) {
+    switch (isNested) {
+    case StackAllocationIsNotNested:
+      sharedUInt8().AllocStackInst.isNested = false;
+      break;
+    case StackAllocationIsNested:
+      sharedUInt8().AllocStackInst.isNested = true;
+      break;
+    }
+  }
+
   void markUsesMoveableValueDebugInfo() {
     sharedUInt8().AllocStackInst.usesMoveableValueDebugInfo =
         (bool)UsesMoveableValueDebugInfo;

include/swift/SIL/SILNode.h

@@ -229,7 +229,8 @@ class alignas(8) SILNode :
                  lexical : 1,
                  fromVarDecl : 1,
                  usesMoveableValueDebugInfo : 1,
-                 hasInvalidatedVarInfo : 1);
+                 hasInvalidatedVarInfo : 1,
+                 isNested : 1);
 
     SHARED_FIELD(AllocBoxInst, uint8_t
                  dynamicLifetime : 1,

lib/SIL/IR/SILInstruction.cpp

@@ -1339,6 +1339,27 @@ SILValue SILInstruction::getStackAllocation() const {
   return cast<SingleValueInstruction>(this);
 }
 
+StackAllocationIsNested_t SILInstruction::isStackAllocationNested() const {
+  assert(isAllocatingStack());
+  if (auto ASI = dyn_cast<AllocStackInst>(this)) {
+    return ASI->isStackAllocationNested();
+  } else {
+    // TODO: implement for all remaining allocations
+    return StackAllocationIsNested;
+  }
+}
+
+void SILInstruction::setStackAllocationIsNested(
+    StackAllocationIsNested_t nested) {
+  assert(isAllocatingStack());
+  if (auto ASI = dyn_cast<AllocStackInst>(this)) {
+    assert(nested == StackAllocationIsNested);
+    ASI->setStackAllocationIsNested(nested);
+  } else if (!nested) {
+    llvm_unreachable("unimplemented");
+  }
+}
+
 bool SILInstruction::isDeallocatingStack() const {
   // NOTE: If you're adding a new kind of deallocating instruction,
   // there are several places scattered around the SIL optimizer which

lib/SIL/IR/SILInstructions.cpp

@@ -231,6 +231,7 @@ AllocStackInst::AllocStackInst(
   sharedUInt8().AllocStackInst.fromVarDecl = (bool)isFromVarDecl;
   sharedUInt8().AllocStackInst.usesMoveableValueDebugInfo =
       (bool)usesMoveableValueDebugInfo || elementType.isMoveOnly();
+  setStackAllocationIsNested(StackAllocationIsNested);
   sharedUInt32().AllocStackInst.numOperands = TypeDependentOperands.size();
 
   // VarInfo must be initialized after

lib/SIL/IR/SILPrinter.cpp

@@ -1568,7 +1568,17 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
       printDebugInfoExpression(Var->DIExpr);
   }
 
+  template <class T>
+  void printNonNested(T *inst) {
+    static_assert(&T::isStackAllocationNested !=
+                      &SILInstruction::isStackAllocationNested,
+                  "Type doesn't override isStackAllocationNested");
+    if (inst->isStackAllocationNested() == StackAllocationIsNotNested)
+      *this << "[non_nested] ";
+  }
+
   void visitAllocStackInst(AllocStackInst *AVI) {
+    printNonNested(AVI);
     if (AVI->hasDynamicLifetime())
       *this << "[dynamic_lifetime] ";
     if (AVI->isLexical())

lib/SIL/Parser/ParseSIL.cpp

@@ -4994,6 +4994,7 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
     auto isFromVarDecl = IsNotFromVarDecl;
     UsesMoveableValueDebugInfo_t usesMoveableValueDebugInfo =
         DoesNotUseMoveableValueDebugInfo;
+    auto isNested = StackAllocationIsNested;
 
     StringRef attributeName;
     SourceLoc attributeLoc;
@@ -5006,6 +5007,8 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
         isFromVarDecl = IsFromVarDecl;
       else if (attributeName == "moveable_value_debuginfo")
         usesMoveableValueDebugInfo = UsesMoveableValueDebugInfo;
+      else if (attributeName == "non_nested")
+        isNested = StackAllocationIsNotNested;
       else {
         P.diagnose(attributeLoc, diag::sil_invalid_attribute_for_instruction,
                    attributeName, "alloc_stack");
@@ -5025,14 +5028,16 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
       usesMoveableValueDebugInfo = UsesMoveableValueDebugInfo;
 
     // It doesn't make sense to attach a debug var info if the name is empty
+    AllocStackInst *ASI;
     if (VarInfo.Name.size())
-      ResultVal = B.createAllocStack(InstLoc, Ty, VarInfo, hasDynamicLifetime,
-                                     isLexical, isFromVarDecl,
-                                     usesMoveableValueDebugInfo);
+      ASI = B.createAllocStack(InstLoc, Ty, VarInfo, hasDynamicLifetime,
+                               isLexical, isFromVarDecl,
+                               usesMoveableValueDebugInfo);
     else
-      ResultVal =
-          B.createAllocStack(InstLoc, Ty, {}, hasDynamicLifetime, isLexical,
-                             isFromVarDecl, usesMoveableValueDebugInfo);
+      ASI = B.createAllocStack(InstLoc, Ty, {}, hasDynamicLifetime, isLexical,
+                               isFromVarDecl, usesMoveableValueDebugInfo);
+    ASI->setStackAllocationIsNested(isNested);
+    ResultVal = ASI;
     break;
   }
   case SILInstructionKind::MetatypeInst: {

lib/Serialization/DeserializeSIL.cpp

@@ -1818,9 +1818,12 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
     auto isLexical = IsLexical_t((Attr >> 1) & 0x1);
     auto isFromVarDecl = IsFromVarDecl_t((Attr >> 2) & 0x1);
     auto wasMoved = UsesMoveableValueDebugInfo_t((Attr >> 3) & 0x1);
-    ResultInst = Builder.createAllocStack(
+    auto isNested = StackAllocationIsNested_t((Attr >> 4) & 0x1);
+    auto ASI = Builder.createAllocStack(
         Loc, getSILType(MF->getType(TyID), (SILValueCategory)TyCategory, Fn),
         std::nullopt, hasDynamicLifetime, isLexical, isFromVarDecl, wasMoved);
+    ASI->setStackAllocationIsNested(isNested);
+    ResultInst = ASI;
     break;
   }
   case SILInstructionKind::AllocPackInst: {

lib/Serialization/ModuleFormat.h

@@ -58,7 +58,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 974; // remove 'isCallerIsolated' bit from ParamDecl
+const uint16_t SWIFTMODULE_VERSION_MINOR = 975; // Expand one type layout
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///

lib/Serialization/SILFormat.h

@@ -542,7 +542,7 @@ namespace sil_block {
 
   // SIL instructions with one type. (alloc_stack)
   using SILOneTypeLayout = BCRecordLayout<SIL_ONE_TYPE, SILInstOpCodeField,
-                                          BCFixed<4>, // Optional attributes
+                                          BCFixed<5>, // Optional attributes
                                           TypeIDField, SILTypeCategoryField>;
 
   // SIL instructions with one typed valueref. (dealloc_stack, return)