Merge fixed alloca stack adjustments into the prolog

src/IceCfg.cpp

 //===- subzero/src/IceCfg.cpp - Control flow graph implementation ---------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 476 matching lines @@
       // upwards from the stack pointer.
       Offsets.push_back(CurrentOffset);
     }
     // Update the running offset of the fused alloca region.
     CurrentOffset += Size;
   }
   // Round the offset up to the alignment granularity to use as the size.
   uint32_t TotalSize = Utils::applyAlignment(CurrentOffset, CombinedAlignment);
   // Ensure every alloca was assigned an offset.
   assert(Allocas.size() == Offsets.size());
-  Variable *BaseVariable = makeVariable(IceType_i32);
-  Variable *AllocaDest = BaseVariable;
-  // Emit one addition for each alloca after the first.
-  for (size_t i = 0; i < Allocas.size(); ++i) {
-    auto *Alloca = llvm::cast<InstAlloca>(Allocas[i]);
-    switch (BaseVariableType) {
-    case BVT_FramePointer:
-    case BVT_UserPointer: {
+
+
+  switch (BaseVariableType) {
+  case BVT_UserPointer: {
+    Variable *BaseVariable = makeVariable(IceType_i32);
+    for (size_t i = 0; i < Allocas.size(); ++i) {

[Jim Stichnoth, 2015/11/16 14:47:57]

For better or worse, most of the Subzero code that iterates directly over vector
indices uses SizeT.

[sehr, 2015/11/16 18:42:24]

Done.

+      auto *Alloca = llvm::cast<InstAlloca>(Allocas[i]);
       // Emit a new addition operation to replace the alloca.
       Operand *AllocaOffset = Ctx->getConstantInt32(Offsets[i]);
       InstArithmetic *Add =
           InstArithmetic::create(this, InstArithmetic::Add, Alloca->getDest(),
                                  BaseVariable, AllocaOffset);
       Insts.push_front(Add);
-    } break;
-    case BVT_StackPointer: {
+      Alloca->setDeleted();
+    }
+    Operand *AllocaSize = Ctx->getConstantInt32(TotalSize);
+    InstAlloca *CombinedAlloca =
+        InstAlloca::create(this, AllocaSize, CombinedAlignment, BaseVariable);

[Jim Stichnoth, 2015/11/16 14:47:57]

Wow, I just realized that InstAlloca is unique among Inst subclasses, in that
its Dest argument is at the end of the ctor and create() arg lists, instead of
in the first position after the Cfg* arg.  Do you think it's reasonable to fix
that in this CL?

[sehr, 2015/11/16 18:42:24]

Done.

+    CombinedAlloca->setKnownFrameOffset();
+    Insts.push_front(CombinedAlloca);
+  } break;
+  case BVT_StackPointer:
+  case BVT_FramePointer: {
+    for (size_t i = 0; i < Allocas.size(); ++i) {
+      auto *Alloca = llvm::cast<InstAlloca>(Allocas[i]);
       // Emit a fake definition of the rematerializable variable.
       Variable *Dest = Alloca->getDest();
       InstFakeDef *Def = InstFakeDef::create(this, Dest);
-      Dest->setRematerializable(getTarget()->getStackReg(), Offsets[i]);
+      if (BaseVariableType == BVT_StackPointer)
+        Dest->setRematerializable(getTarget()->getStackReg(), Offsets[i]);
+      else
+        Dest->setRematerializable(getTarget()->getFrameReg(), Offsets[i]);
       Insts.push_front(Def);
-    } break;
+      Alloca->setDeleted();
     }
-    Alloca->setDeleted();
+    // Allocate the fixed area in the function prolog.
+    getTarget()->reserveFixedAllocaArea(TotalSize, CombinedAlignment);
+  } break;
   }
-  Operand *AllocaSize = Ctx->getConstantInt32(TotalSize);
-  switch (BaseVariableType) {
-  case BVT_FramePointer: {
-    // Adjust the return of the alloca to the top of the returned region.
-    AllocaDest = makeVariable(IceType_i32);
-    InstArithmetic *Add = InstArithmetic::create(
-        this, InstArithmetic::Add, BaseVariable, AllocaDest, AllocaSize);
-    Insts.push_front(Add);
-  } break;
-  case BVT_StackPointer: {
-    // Emit a fake use to keep the Alloca live.
-    InstFakeUse *Use = InstFakeUse::create(this, AllocaDest);
-    Insts.push_front(Use);
-  } break;
-  case BVT_UserPointer:
-    break;
-  }
-  // And insert the fused alloca.
-  InstAlloca *CombinedAlloca =
-      InstAlloca::create(this, AllocaSize, CombinedAlignment, AllocaDest);
-  CombinedAlloca->setKnownFrameOffset();
-  Insts.push_front(CombinedAlloca);
 }
 
 void Cfg::processAllocas(bool SortAndCombine) {
   const uint32_t StackAlignment = getTarget()->getStackAlignment();
   CfgNode *EntryNode = getEntryNode();
   // LLVM enforces power of 2 alignment.
   assert(llvm::isPowerOf2_32(StackAlignment));
   // Determine if there are large alignment allocations in the entry block or
   // dynamic allocations (variable size in the entry block).
   bool HasLargeAlignment = false;
@@ skipping 34 matching lines @@
   // Mark the target as requiring a frame pointer.
   if (HasLargeAlignment || HasDynamicAllocation)
     getTarget()->setHasFramePointer();
   // Collect the Allocas into the two vectors.
   // Allocas in the entry block that have constant size and alignment less
   // than or equal to the function's stack alignment.
   CfgVector<Inst *> FixedAllocas;
   // Allocas in the entry block that have constant size and alignment greater
   // than the function's stack alignment.
   CfgVector<Inst *> AlignedAllocas;
-  // Maximum alignment used for the dynamic/aligned allocas.
+  // Maximum alignment used by any alloca.
   uint32_t MaxAlignment = StackAlignment;
   for (Inst &Instr : EntryNode->getInsts()) {
     if (auto *Alloca = llvm::dyn_cast<InstAlloca>(&Instr)) {
       if (!llvm::isa<Constant>(Alloca->getSizeInBytes()))
         continue;
       uint32_t AlignmentParam = Alloca->getAlignInBytes();
       // For default align=0, set it to the real value 1, to avoid any
       // bit-manipulation problems below.
       AlignmentParam = std::max(AlignmentParam, 1u);
       assert(llvm::isPowerOf2_32(AlignmentParam));
       if (HasDynamicAllocation && AlignmentParam > StackAlignment) {
         // If we have both dynamic allocations and large stack alignments,
         // high-alignment allocations are pulled out with their own base.
         AlignedAllocas.push_back(Alloca);
       } else {
         FixedAllocas.push_back(Alloca);
       }
       MaxAlignment = std::max(AlignmentParam, MaxAlignment);
     }
   }
   // Add instructions to the head of the entry block in reverse order.
   InstList &Insts = getEntryNode()->getInsts();
   if (HasDynamicAllocation && HasLargeAlignment) {
     // We are using a frame pointer, but fixed large-alignment alloca addresses,
     // do not have a known offset from either the stack or frame pointer.
     // They grow up from a user pointer from an alloca.
     sortAndCombineAllocas(AlignedAllocas, MaxAlignment, Insts, BVT_UserPointer);
+    // Fixed size allocas are addressed relative to the frame pointer.
+    sortAndCombineAllocas(FixedAllocas, StackAlignment, Insts,
+                          BVT_FramePointer);
+  } else {
+    // Otherwise, fixed size allocas are addressed relative to the stack unless
+    // there are dynamic allocas.
+    AllocaBaseVariableType BasePointerType =

[John, 2015/11/16 14:00:02]

const AllocaBaseVariableType

[sehr, 2015/11/16 18:42:24]

Done.

+        (HasDynamicAllocation ? BVT_FramePointer : BVT_StackPointer);
+    sortAndCombineAllocas(FixedAllocas, MaxAlignment, Insts, BasePointerType);
   }
-  // Otherwise, fixed size allocas are always addressed relative to the stack
-  // unless there are dynamic allocas.
-  // TODO(sehr): re-enable frame pointer and decrementing addressing.
-  AllocaBaseVariableType BasePointerType =
-      (HasDynamicAllocation ? BVT_UserPointer : BVT_StackPointer);
-  sortAndCombineAllocas(FixedAllocas, MaxAlignment, Insts, BasePointerType);
-
   if (!FixedAllocas.empty() || !AlignedAllocas.empty())
     // No use calling findRematerializable() unless there is some
     // rematerializable alloca instruction to seed it.
     findRematerializable();
 }
 
 namespace {
 
 // Helpers for findRematerializable().  For each of them, if a suitable
 // rematerialization is found, the instruction's Dest variable is set to be
@@ skipping 452 matching lines @@
     }
   }
   // Print each basic block
   for (CfgNode *Node : Nodes)
     Node->dump(this);
   if (isVerbose(IceV_Instructions))
     Str << "}\n";
 }
 
 } // end of namespace Ice