Unify alloca, outgoing arg, and prolog construction

src/IceCfgNode.cpp

 //===- subzero/src/IceCfgNode.cpp - Basic block (node) implementation -----===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 1074 matching lines @@
 }
 
 // Helper class for emitIAS().
 namespace {
 class BundleEmitHelper {
   BundleEmitHelper() = delete;
   BundleEmitHelper(const BundleEmitHelper &) = delete;
   BundleEmitHelper &operator=(const BundleEmitHelper &) = delete;
 
 public:
-  BundleEmitHelper(Assembler *Asm, TargetLowering *Target,
-                   const InstList &Insts)
-      : Asm(Asm), Target(Target), End(Insts.end()), BundleLockStart(End),
+  BundleEmitHelper(Assembler *Asm, const InstList &Insts)
+      : Asm(Asm), End(Insts.end()), BundleLockStart(End),
         BundleSize(1 << Asm->getBundleAlignLog2Bytes()),
         BundleMaskLo(BundleSize - 1), BundleMaskHi(~BundleMaskLo) {}
   // Check whether we're currently within a bundle_lock region.
   bool isInBundleLockRegion() const { return BundleLockStart != End; }
   // Check whether the current bundle_lock region has the align_to_end option.
   bool isAlignToEnd() const {
     assert(isInBundleLockRegion());
     return llvm::cast<InstBundleLock>(getBundleLockStart())->getOption() ==
            InstBundleLock::Opt_AlignToEnd;
   }
@@ skipping 21 matching lines @@
   InstList::const_iterator getBundleLockStart() const {
     assert(isInBundleLockRegion());
     return BundleLockStart;
   }
   // Set up bookkeeping when the bundle_lock instruction is first processed.
   void enterBundleLock(InstList::const_iterator I) {
     assert(!isInBundleLockRegion());
     BundleLockStart = I;
     SizeSnapshotPre = Asm->getBufferSize();
     Asm->setPreliminary(true);
-    Target->snapshotEmitState();
     assert(isInBundleLockRegion());
   }
   // Update bookkeeping when the bundle_unlock instruction is processed.
   void enterBundleUnlock() {
     assert(isInBundleLockRegion());
     SizeSnapshotPost = Asm->getBufferSize();
   }
   // Update bookkeeping when we are completely finished with the bundle_lock
   // region.
   void leaveBundleLockRegion() { BundleLockStart = End; }
@@ skipping 19 matching lines @@
         Asm->padWithNop(BundleSize - Offset);
         SizeSnapshotPre = Asm->getBufferSize();
       }
     }
   }
   // Update bookkeeping when rolling back for the second pass.
   void rollback() {
     assert(isInBundleLockRegion());
     Asm->setBufferSize(SizeSnapshotPre);
     Asm->setPreliminary(false);
-    Target->rollbackEmitState();
   }
 
 private:
   Assembler *const Asm;
-  TargetLowering *const Target;
   // End is a sentinel value such that BundleLockStart==End implies that we are
   // not in a bundle_lock region.
   const InstList::const_iterator End;
   InstList::const_iterator BundleLockStart;
   const intptr_t BundleSize;
   // Masking with BundleMaskLo identifies an address's bundle offset.
   const intptr_t BundleMaskLo;
   // Masking with BundleMaskHi identifies an address's bundle.
   const intptr_t BundleMaskHi;
   intptr_t SizeSnapshotPre = 0;
@@ skipping 34 matching lines @@
   // bundle_lock region. The first pass is a preliminary pass, after which we
   // can figure out what nop padding is needed, then roll back, and make the
   // final pass.
   //
   // Ideally, the first pass would be speculative and the second pass would
   // only be done if nop padding were needed, but the structure of the
   // integrated assembler makes it hard to roll back the state of label
   // bindings, label links, and relocation fixups. Instead, the first pass just
   // disables all mutation of that state.
 
-  BundleEmitHelper Helper(Asm, Func->getTarget(), Insts);
+  BundleEmitHelper Helper(Asm, Insts);
   InstList::const_iterator End = Insts.end();
   // Retrying indicates that we had to roll back to the bundle_lock instruction
   // to apply padding before the bundle_lock sequence.
   bool Retrying = false;
   for (InstList::const_iterator I = Insts.begin(); I != End; ++I) {
     if (I->isDeleted() || I->isRedundantAssign())
       continue;
 
     if (llvm::isa<InstBundleLock>(I)) {
       // Set up the initial bundle_lock state. This should not happen while
@@ skipping 161 matching lines @@
   InstIntrinsicCall *Inst = InstIntrinsicCall::create(
       Func, 5, Func->makeVariable(IceType_i64), RMWI64Name, Info->Info);
   Inst->addArg(AtomicRMWOp);
   Inst->addArg(Counter);
   Inst->addArg(One);
   Inst->addArg(OrderAcquireRelease);
   Insts.push_front(Inst);
 }
 
 } // end of namespace Ice