Subzero. RAII NaCl Bundling.

src/IceTargetLoweringX8632.cpp

 //===- subzero/src/IceTargetLoweringX8632.cpp - x86-32 lowering -----------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 128 matching lines @@
   Variable *esp = getPhysicalRegister(Traits::RegisterSet::Reg_esp);
   _redefined(_mov(esp, NewValue));
 }
 
 void TargetX8632::_sub_sp(Operand *Adjustment) {
   Variable *esp = getPhysicalRegister(Traits::RegisterSet::Reg_esp);
   _sub(esp, Adjustment);
 }
 
 void TargetX8632::lowerIndirectJump(Variable *JumpTarget) {
+  AutoBundle _(this);
+
   if (NeedSandboxing) {
-    _bundle_lock();
     const SizeT BundleSize =
         1 << Func->getAssembler<>()->getBundleAlignLog2Bytes();
     _and(JumpTarget, Ctx->getConstantInt32(~(BundleSize - 1)));
   }
+
   _jmp(JumpTarget);
-  if (NeedSandboxing)
-    _bundle_unlock();
 }
 
 void TargetX8632::lowerCall(const InstCall *Instr) {
   // x86-32 calling convention:
   //
   // * At the point before the call, the stack must be aligned to 16 bytes.
   //
   // * The first four arguments of vector type, regardless of their position
   // relative to the other arguments in the argument list, are placed in
   // registers xmm0 - xmm3.
@@ skipping 103 matching lines @@
     case IceType_v8i1:
     case IceType_v16i1:
     case IceType_v16i8:
     case IceType_v8i16:
     case IceType_v4i32:
     case IceType_v4f32:
       ReturnReg = makeReg(DestTy, Traits::RegisterSet::Reg_xmm0);
       break;
     }
   }
+
   Operand *CallTarget =
       legalize(Instr->getCallTarget(), Legal_Reg | Legal_Imm | Legal_AddrAbs);
-  if (NeedSandboxing) {
-    if (llvm::isa<Constant>(CallTarget)) {
-      _bundle_lock(InstBundleLock::Opt_AlignToEnd);
-    } else {
-      Variable *CallTargetVar = nullptr;
-      _mov(CallTargetVar, CallTarget);
-      _bundle_lock(InstBundleLock::Opt_AlignToEnd);
-      const SizeT BundleSize =
-          1 << Func->getAssembler<>()->getBundleAlignLog2Bytes();
-      _and(CallTargetVar, Ctx->getConstantInt32(~(BundleSize - 1)));
-      CallTarget = CallTargetVar;
+
+  Traits::Insts::Call *NewCall;
+  /* AutoBundle scoping */ {
+    std::unique_ptr<AutoBundle> Bundle;
+    if (NeedSandboxing) {
+      if (llvm::isa<Constant>(CallTarget)) {
+        Bundle = makeUnique<AutoBundle>(this, InstBundleLock::Opt_AlignToEnd);
+      } else {
+        Variable *CallTargetVar = nullptr;
+        _mov(CallTargetVar, CallTarget);
+        Bundle = makeUnique<AutoBundle>(this, InstBundleLock::Opt_AlignToEnd);
+        const SizeT BundleSize =
+            1 << Func->getAssembler<>()->getBundleAlignLog2Bytes();
+        _and(CallTargetVar, Ctx->getConstantInt32(~(BundleSize - 1)));
+        CallTarget = CallTargetVar;
+      }
     }
+    NewCall = Context.insert<Traits::Insts::Call>(ReturnReg, CallTarget);
   }
-  auto *NewCall = Context.insert<Traits::Insts::Call>(ReturnReg, CallTarget);
-  if (NeedSandboxing)
-    _bundle_unlock();
+
   if (ReturnRegHi)
     Context.insert<InstFakeDef>(ReturnRegHi);
 
   // Insert a register-kill pseudo instruction.
   Context.insert<InstFakeKill>(NewCall);
 
   if (Dest != nullptr && isScalarFloatingType(Dest->getType())) {
     // Special treatment for an FP function which returns its result in st(0).
     // If Dest ends up being a physical xmm register, the fstp emit code will
     // route st(0) through the space reserved in the function argument area
@@ skipping 433 matching lines @@
   for (SizeT i = 0; i < Popped.size(); ++i) {
     SizeT j = Popped.size() - i - 1;
     SizeT Canonical = Traits::getBaseReg(j);
     if (j == Traits::RegisterSet::Reg_ebp && IsEbpBasedFrame)
       continue;
     if (Popped[j]) {
       _pop(getPhysicalRegister(Canonical));
     }
   }
 
-  if (!NeedSandboxing)
+  if (!NeedSandboxing) {
     return;
+  }
+
   // Change the original ret instruction into a sandboxed return sequence.
   // t:ecx = pop
   // bundle_lock
   // and t, ~31
   // jmp *t
   // bundle_unlock
   // FakeUse <original_ret_operand>
   Variable *T_ecx = makeReg(IceType_i32, Traits::RegisterSet::Reg_ecx);
   _pop(T_ecx);
   lowerIndirectJump(T_ecx);
@@ skipping 325 matching lines @@
 #define X(tag, sizeLog2, align, elts, elty, str)                               \
   static_assert(_table1_##tag == _table2_##tag,                                \
                 "Inconsistency between ICETYPEX8632_TABLE and ICETYPE_TABLE");
 ICETYPE_TABLE
 #undef X
 } // end of namespace dummy3
 } // end of anonymous namespace
 
 } // end of namespace X8632
 } // end of namespace Ice