Suzero. X8664. NaCl 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.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 1089 matching lines @@
         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;
   }
+  bool isPadToEnd() const {
+    assert(isInBundleLockRegion());
+    return llvm::cast<InstBundleLock>(getBundleLockStart())->getOption() ==
+           InstBundleLock::Opt_PadToEnd;
+  }
   // Check whether the entire bundle_lock region falls within the same bundle.
   bool isSameBundle() const {
     assert(isInBundleLockRegion());
     return SizeSnapshotPre == SizeSnapshotPost ||
            (SizeSnapshotPre & BundleMaskHi) ==
                ((SizeSnapshotPost - 1) & BundleMaskHi);
   }
   // Get the bundle alignment of the first instruction of the bundle_lock
   // region.
   intptr_t getPreAlignment() const {
@@ skipping 45 matching lines @@
   // sequences ends precisely at a bundle boundary.
   void padForAlignToEnd() {
     assert(isInBundleLockRegion());
     if (isAlignToEnd()) {
       if (intptr_t Offset = getPostAlignment()) {
         Asm->padWithNop(BundleSize - Offset);
         SizeSnapshotPre = Asm->getBufferSize();
       }
     }
   }
-  // Update bookkeeping when rolling back for the second pass.
+  // If pad_to_end is specified, add padding such that the first instruction
+  // after the instruction sequence starts starts at a bundle boundary.

[Jim Stichnoth, 2016/01/14 00:09:52]

starts starts

[John, 2016/01/14 23:18:25]

Done.

+  void padForPadToEnd() {
+    assert(isInBundleLockRegion());
+    if (isPadToEnd()) {
+      if (intptr_t Offset = getPostAlignment()) {
+        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);
   }
 
 private:
   Assembler *const Asm;
   // End is a sentinel value such that BundleLockStart==End implies that we are
   // not in a bundle_lock region.
@@ skipping 68 matching lines @@
     }
 
     if (llvm::isa<InstBundleUnlock>(I)) {
       Helper.enterBundleUnlock();
       if (Retrying) {
         // Make sure all instructions are in the same bundle.
         assert(Helper.isSameBundle());
         // If align_to_end is specified, make sure the next instruction begins
         // the bundle.
         assert(!Helper.isAlignToEnd() || Helper.getPostAlignment() == 0);
+        Helper.padForPadToEnd();
         Helper.leaveBundleLockRegion();
         Retrying = false;
       } else {
         // This is the first pass, so roll back for the retry pass.
         Helper.rollback();
         // Pad to the next bundle if the instruction sequence crossed a bundle
         // boundary.
         Helper.padToNextBundle();
         // Insert additional padding to make AlignToEnd work.
         Helper.padForAlignToEnd();
@@ skipping 136 matching lines @@
   auto *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