Suzero. X8664. NaCl Sandboxing.

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 112 matching lines @@
     TargetX86Base<X8632::Traits>::Traits::FK_Abs;
 
 //------------------------------------------------------------------------------
 //     __      ______  __     __  ______  ______  __  __   __  ______
 //    /\ \    /\  __ \/\ \  _ \ \/\  ___\/\  == \/\ \/\ "-.\ \/\  ___\
 //    \ \ \___\ \ \/\ \ \ \/ ".\ \ \  __\\ \  __<\ \ \ \ \-.  \ \ \__ \
 //     \ \_____\ \_____\ \__/".~\_\ \_____\ \_\ \_\ \_\ \_\\"\_\ \_____\
 //      \/_____/\/_____/\/_/   \/_/\/_____/\/_/ /_/\/_/\/_/ \/_/\/_____/
 //
 //------------------------------------------------------------------------------
+void TargetX8632::_add_sp(Operand *Adjustment) {
+  Variable *esp = getPhysicalRegister(Traits::RegisterSet::Reg_esp);
+  _add(esp, Adjustment);
+}
+
+void TargetX8632::_mov_sp(Operand *NewValue) {
+  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) {
+  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.
   //
   // * Other arguments are pushed onto the stack in right-to-left order, such
@@ skipping 102 matching lines @@
     case IceType_v16i8:
     case IceType_v8i16:
     case IceType_v4i32:
     case IceType_v4f32:
       ReturnReg = makeReg(Dest->getType(), Traits::RegisterSet::Reg_xmm0);
       break;
     }
   }
   Operand *CallTarget =
       legalize(Instr->getCallTarget(), Legal_Reg | Legal_Imm | Legal_AddrAbs);
-  const bool NeedSandboxing = Ctx->getFlags().getUseSandboxing();
   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)));
@@ skipping 446 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 (!Ctx->getFlags().getUseSandboxing())
+  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);
@@ skipping 326 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