Suzero. X8664. NaCl Sandboxing.

src/IceInstX8632.cpp

 //===- subzero/src/IceInstX8632.cpp - X86-32 instruction implementation ---===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 58 matching lines @@
 #undef X
 };
 
 void TargetX8632Traits::X86Operand::dump(const Cfg *, Ostream &Str) const {
   if (BuildDefs::dump())
     Str << "<OperandX8632>";
 }
 
 TargetX8632Traits::X86OperandMem::X86OperandMem(
     Cfg *Func, Type Ty, Variable *Base, Constant *Offset, Variable *Index,
-    uint16_t Shift, SegmentRegisters SegmentReg, bool IsPIC)
+    uint16_t Shift, SegmentRegisters SegmentReg, bool IsRebased)
     : X86Operand(kMem, Ty), Base(Base), Offset(Offset), Index(Index),
-      Shift(Shift), SegmentReg(SegmentReg), IsPIC(IsPIC) {
+      Shift(Shift), SegmentReg(SegmentReg), IsRebased(IsRebased) {
   assert(Shift <= 3);
   Vars = nullptr;
   NumVars = 0;
   if (Base)
     ++NumVars;
   if (Index)
     ++NumVars;
   if (NumVars) {
     Vars = Func->allocateArrayOf<Variable *>(NumVars);
     SizeT I = 0;
@@ skipping 19 matching lines @@
   return Disp;
 }
 
 void validateMemOperandPIC(const TargetX8632Traits::X86OperandMem *Mem,
                            bool UseNonsfi) {
   if (!BuildDefs::asserts())
     return;
   const bool HasCR =
       Mem->getOffset() && llvm::isa<ConstantRelocatable>(Mem->getOffset());
   (void)HasCR;
-  const bool IsPIC = Mem->getIsPIC();
-  (void)IsPIC;
+  const bool IsRebased = Mem->getIsRebased();
+  (void)IsRebased;
   if (UseNonsfi)
-    assert(HasCR == IsPIC);
+    assert(HasCR == IsRebased);
   else
-    assert(!IsPIC);
+    assert(!IsRebased);
 }
 
 } // end of anonymous namespace
 
 void TargetX8632Traits::X86OperandMem::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   const bool UseNonsfi = Func->getContext()->getFlags().getUseNonsfi();
   validateMemOperandPIC(this, UseNonsfi);
   const auto *Target =
@@ skipping 116 matching lines @@
 void TargetX8632Traits::X86OperandMem::emitSegmentOverride(
     TargetX8632Traits::Assembler *Asm) const {
   if (SegmentReg != DefaultSegment) {
     assert(SegmentReg >= 0 && SegmentReg < SegReg_NUM);
     Asm->emitSegmentOverride(X8632::Traits::InstSegmentPrefixes[SegmentReg]);
   }
 }
 
 TargetX8632Traits::Address TargetX8632Traits::X86OperandMem::toAsmAddress(
     TargetX8632Traits::Assembler *Asm,
-    const Ice::TargetLowering *TargetLowering) const {
+    const Ice::TargetLowering *TargetLowering, bool /*LeaAddr*/) const {
   const auto *Target =
       static_cast<const ::Ice::X8632::TargetX8632 *>(TargetLowering);
   const bool UseNonsfi = Target->getGlobalContext()->getFlags().getUseNonsfi();
   validateMemOperandPIC(this, UseNonsfi);
   int32_t Disp = 0;
   if (getBase() && getBase()->isRematerializable()) {
     Disp += GetRematerializableOffset(getBase(), Target);
   }
   // The index should never be rematerializable.  But if we ever allow it, then
   // we should make sure the rematerialization offset is shifted by the Shift
@@ skipping 72 matching lines @@
     Var->dump(Func);
   else
     Var->dump(Str);
   Str << ")";
 }
 
 } // namespace X8632
 } // end of namespace Ice
 
 X86INSTS_DEFINE_STATIC_DATA(X8632, X8632::Traits)