Subzero: Update tests and build scripts for sandboxing.

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.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the CfgNode class, including the complexities
@@ skipping 883 matching lines @@
 }
 
 // Helper class for emitIAS().
 namespace {
 class BundleEmitHelper {
   BundleEmitHelper() = delete;
   BundleEmitHelper(const BundleEmitHelper &) = delete;
   BundleEmitHelper &operator=(const BundleEmitHelper &) = delete;
 
 public:
-  BundleEmitHelper(Assembler *Asm, const InstList &Insts)
-      : Asm(Asm), End(Insts.end()), BundleLockStart(End),
+  BundleEmitHelper(Assembler *Asm, TargetLowering *Target,
+                   const InstList &Insts)
+      : Asm(Asm), Target(Target), End(Insts.end()), BundleLockStart(End),
         BundleSize(1 << Asm->getBundleAlignLog2Bytes()),
         BundleMaskLo(BundleSize - 1), BundleMaskHi(~BundleMaskLo),
         SizeSnapshotPre(0), SizeSnapshotPost(0) {}
   // 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() ==
@@ skipping 25 matching lines @@
     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.
@@ skipping 21 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;
@@ skipping 34 matching lines @@
   // Emission is done twice for each 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, Insts);
+  BundleEmitHelper Helper(Asm, Func->getTarget(), 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
@@ skipping 129 matching lines @@
       if (!First)
         Str << ", ";
       First = false;
       Str << "%" << I->getName();
     }
     Str << "\n";
   }
 }
 
 } // end of namespace Ice