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 (SizeT i = 0; i < Allocas.size(); ++i) {
+      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, BaseVariable, AllocaSize, CombinedAlignment);
+    CombinedAlloca->setKnownFrameOffset();
+    Insts.push_front(CombinedAlloca);
+  } break;
+  case BVT_StackPointer:
+  case BVT_FramePointer: {
+    for (SizeT 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.
+    const AllocaBaseVariableType BasePointerType =
+        (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