Subzero: Add sandboxing for x86-32.

src/assembler_ia32.cpp

 //===- subzero/src/assembler_ia32.cpp - Assembler for x86-32  -------------===//
 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 //
 // Modified by the Subzero authors.
 //
 //===----------------------------------------------------------------------===//
 //
 //                        The Subzero Code Generator
@@ skipping 61 matching lines @@
 
 Label *AssemblerX86::GetOrCreateCfgNodeLabel(SizeT NodeNumber) {
   return GetOrCreateLabel(NodeNumber, CfgNodeLabels);
 }
 
 Label *AssemblerX86::GetOrCreateLocalLabel(SizeT Number) {
   return GetOrCreateLabel(Number, LocalLabels);
 }
 
 void AssemblerX86::BindCfgNodeLabel(SizeT NodeNumber) {
+  assert(!getPreliminary());
   Label *L = GetOrCreateCfgNodeLabel(NodeNumber);
   this->Bind(L);
 }
 
 void AssemblerX86::BindLocalLabel(SizeT Number) {
   Label *L = GetOrCreateLocalLabel(Number);
-  this->Bind(L);
+  if (!getPreliminary())
+    this->Bind(L);
 }
 
 void AssemblerX86::call(GPRRegister reg) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   EmitUint8(0xFF);
   EmitRegisterOperand(2, reg);
 }
 
 void AssemblerX86::call(const Address &address) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
@@ skipping 2123 matching lines @@
 }
 
 void AssemblerX86::j(CondX86::BrCond condition, Label *label, bool near) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   if (label->IsBound()) {
     static const int kShortSize = 2;
     static const int kLongSize = 6;
     intptr_t offset = label->Position() - buffer_.Size();
     assert(offset <= 0);
     if (Utils::IsInt(8, offset - kShortSize)) {
+      // TODO(stichnot): Here and in jmp(), we may need to be more
+      // conservative about the backward branch distance if the branch
+      // instruction is within a bundle_lock sequence, because the
+      // distance may increase when padding is added.  This isn't an
+      // issue for branches outside a bundle_lock, because if padding
+      // is added, the retry may change it to a long backward branch
+      // without affecting any of the bookkeeping.
       EmitUint8(0x70 + condition);
       EmitUint8((offset - kShortSize) & 0xFF);
     } else {
       EmitUint8(0x0F);
       EmitUint8(0x80 + condition);
       EmitInt32(offset - kLongSize);
     }
   } else if (near) {
     EmitUint8(0x70 + condition);
     EmitNearLabelLink(label);
@@ skipping 214 matching lines @@
     EmitInt32(offset - instruction_size);
   } else {
     EmitLabelLink(label);
   }
 }
 
 void AssemblerX86::EmitLabelLink(Label *label) {
   assert(!label->IsBound());
   intptr_t position = buffer_.Size();
   EmitInt32(label->position_);
-  label->LinkTo(position);
+  if (!getPreliminary())
+    label->LinkTo(position);
 }
 
 void AssemblerX86::EmitNearLabelLink(Label *label) {
   assert(!label->IsBound());
   intptr_t position = buffer_.Size();
   EmitUint8(0);
-  label->NearLinkTo(position);
+  if (!getPreliminary())
+    label->NearLinkTo(position);
 }
 
 void AssemblerX86::EmitGenericShift(int rm, Type Ty, GPRRegister reg,
                                     const Immediate &imm) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   assert(imm.is_int8());
   if (Ty == IceType_i16)
     EmitOperandSizeOverride();
   if (imm.value() == 1) {
     EmitUint8(isByteSizedArithType(Ty) ? 0xD0 : 0xD1);
@@ skipping 11 matching lines @@
   assert(shifter == RegX8632::Encoded_Reg_ecx);
   (void)shifter;
   if (Ty == IceType_i16)
     EmitOperandSizeOverride();
   EmitUint8(isByteSizedArithType(Ty) ? 0xD2 : 0xD3);
   EmitOperand(rm, operand);
 }
 
 } // end of namespace x86
 } // end of namespace Ice