Subzero: Add Non-SFI support for x86-32.

src/IceInstX86BaseImpl.h

 //===- subzero/src/IceInstX86BaseImpl.h - Generic X86 instructions -*- C++ -*=//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief Implements the InstX86Base class and its descendants.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEINSTX86BASEIMPL_H
 #define SUBZERO_SRC_ICEINSTX86BASEIMPL_H
 
 #include "IceInstX86Base.h"
 
 #include "IceAssemblerX86Base.h"
 #include "IceCfg.h"
 #include "IceCfgNode.h"
 #include "IceDefs.h"
 #include "IceInst.h"
 #include "IceOperand.h"
 #include "IceTargetLowering.h"
+#include "IceTargetLoweringX86Base.h"
 
 namespace Ice {
 
 namespace X86NAMESPACE {
 
 template <typename TraitsType>
 const char *InstImpl<TraitsType>::InstX86Base::getWidthString(Type Ty) {
   return Traits::TypeAttributes[Ty].WidthString;
 }
 
@@ skipping 13 matching lines @@
                                                      Operand *Addr,
                                                      InstArithmetic::OpKind Op,
                                                      Variable *Beacon)
     : InstX86Base(Func, InstX86Base::FakeRMW, 3, nullptr), Op(Op) {
   this->addSource(Data);
   this->addSource(Addr);
   this->addSource(Beacon);
 }
 
 template <typename TraitsType>
+InstImpl<TraitsType>::InstX86GetIP::InstX86GetIP(Cfg *Func, Variable *Dest)
+    : InstX86Base(Func, InstX86Base::GetIP, 0, Dest) {}
+
+template <typename TraitsType>
 InstImpl<TraitsType>::InstX86Mul::InstX86Mul(Cfg *Func, Variable *Dest,
                                              Variable *Source1,
                                              Operand *Source2)
     : InstX86Base(Func, InstX86Base::Mul, 2, Dest) {
   this->addSource(Source1);
   this->addSource(Source2);
 }
 
 template <typename TraitsType>
 InstImpl<TraitsType>::InstX86Shld::InstX86Shld(Cfg *Func, Variable *Dest,
@@ skipping 314 matching lines @@
   Type Ty = getData()->getType();
   Str << "rmw " << InstArithmetic::getOpName(getOp()) << " " << Ty << " *";
   getAddr()->dump(Func);
   Str << ", ";
   getData()->dump(Func);
   Str << ", beacon=";
   getBeacon()->dump(Func);
 }
 
 template <typename TraitsType>
+void InstImpl<TraitsType>::InstX86GetIP::emit(const Cfg *Func) const {
+  if (!BuildDefs::dump())
+    return;
+  Ostream &Str = Func->getContext()->getStrEmit();
+  assert(this->getDest()->hasReg());
+  Str << "\t"
+         "addl\t$_GLOBAL_OFFSET_TABLE_, ";
+  this->getDest()->emit(Func);
+}
+
+template <typename TraitsType>
+void InstImpl<TraitsType>::InstX86GetIP::emitIAS(const Cfg *Func) const {
+  if (Func->getContext()->getFlags().getOutFileType() == FT_Iasm) {
+    // TODO(stichnot): Find a workaround for llvm-mc's inability to handle
+    // something like ".long _GLOBAL_OFFSET_TABLE_ + ." .  One possibility is to
+    // just use hybrid iasm output for this add instruction.
+    llvm::report_fatal_error(
+        "Iasm support for _GLOBAL_OFFSET_TABLE_ not implemented");
+  }
+  Assembler *Asm = Func->getAssembler<Assembler>();
+  assert(this->getDest()->hasReg());
+  GPRRegister Reg = Traits::getEncodedGPR(this->getDest()->getRegNum());
+  Constant *GlobalOffsetTable =
+      Func->getContext()->getConstantExternSym("_GLOBAL_OFFSET_TABLE_");
+  AssemblerFixup *Fixup = Asm->createFixup(Traits::FK_GotPC, GlobalOffsetTable);
+  intptr_t OrigPos = Asm->getBufferSize();
+  constexpr int32_t TempDisp = 0;
+  constexpr int32_t ImmediateWidth = 4;
+  // Emit the add instruction once, in a preliminary fashion, to find its total
+  // size.  TODO(stichnot): IceType_i32 should really be something that
+  // represents the target's pointer type.
+  Asm->add(IceType_i32, Reg, AssemblerImmediate(TempDisp, Fixup));
+  const int32_t Disp = Asm->getBufferSize() - OrigPos - ImmediateWidth;
+  // Now roll back and emit the add instruction again, this time with the
+  // correct displacement.
+  Asm->setBufferSize(OrigPos);
+  Asm->add(IceType_i32, Reg, AssemblerImmediate(Disp, Fixup));
+}
+
+template <typename TraitsType>
+void InstImpl<TraitsType>::InstX86GetIP::dump(const Cfg *Func) const {
+  if (!BuildDefs::dump())
+    return;
+  Ostream &Str = Func->getContext()->getStrDump();
+  this->getDest()->dump(Func);
+  Str << " = call getIP";
+}
+
+template <typename TraitsType>
 void InstImpl<TraitsType>::InstX86Label::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   Str << getName(Func) << ":";
 }
 
 template <typename TraitsType>
 void InstImpl<TraitsType>::InstX86Label::emitIAS(const Cfg *Func) const {
   Assembler *Asm = Func->getAssembler<Assembler>();
@@ skipping 268 matching lines @@
     } else {
       Address SrcStackAddr = Target->stackVarToAsmOperand(SrcVar);
       (Asm->*(Emitter.GPRAddr))(Ty, VarReg, SrcStackAddr);
     }
   } else if (const auto *Mem = llvm::dyn_cast<X86OperandMem>(Src)) {
     Mem->emitSegmentOverride(Asm);
     (Asm->*(Emitter.GPRAddr))(Ty, VarReg, Mem->toAsmAddress(Asm, Target));
   } else if (const auto *Imm = llvm::dyn_cast<ConstantInteger32>(Src)) {
     (Asm->*(Emitter.GPRImm))(Ty, VarReg, AssemblerImmediate(Imm->getValue()));
   } else if (const auto *Reloc = llvm::dyn_cast<ConstantRelocatable>(Src)) {
-    AssemblerFixup *Fixup = Asm->createFixup(Traits::RelFixup, Reloc);
+    AssemblerFixup *Fixup =
+        Asm->createFixup(Traits::TargetLowering::getAbsFixup(), Reloc);
     (Asm->*(Emitter.GPRImm))(Ty, VarReg,
                              AssemblerImmediate(Reloc->getOffset(), Fixup));
   } else if (const auto *Split = llvm::dyn_cast<VariableSplit>(Src)) {
     (Asm->*(Emitter.GPRAddr))(Ty, VarReg, Split->toAsmAddress(Func));
   } else {
     llvm_unreachable("Unexpected operand type");
   }
 }
 
 template <typename TraitsType>
 void InstImpl<TraitsType>::emitIASAddrOpTyGPR(const Cfg *Func, Type Ty,
                                               const Address &Addr,
                                               const Operand *Src,
                                               const GPREmitterAddrOp &Emitter) {
   Assembler *Asm = Func->getAssembler<Assembler>();
   // Src can only be Reg or AssemblerImmediate.
   if (const auto *SrcVar = llvm::dyn_cast<Variable>(Src)) {
     assert(SrcVar->hasReg());
     GPRRegister SrcReg = Traits::getEncodedGPR(SrcVar->getRegNum());
     (Asm->*(Emitter.AddrGPR))(Ty, Addr, SrcReg);
   } else if (const auto *Imm = llvm::dyn_cast<ConstantInteger32>(Src)) {
     (Asm->*(Emitter.AddrImm))(Ty, Addr, AssemblerImmediate(Imm->getValue()));
   } else if (const auto *Reloc = llvm::dyn_cast<ConstantRelocatable>(Src)) {
-    AssemblerFixup *Fixup = Asm->createFixup(Traits::RelFixup, Reloc);
+    AssemblerFixup *Fixup =
+        Asm->createFixup(Traits::TargetLowering::getAbsFixup(), Reloc);
     (Asm->*(Emitter.AddrImm))(Ty, Addr,
                               AssemblerImmediate(Reloc->getOffset(), Fixup));
   } else {
     llvm_unreachable("Unexpected operand type");
   }
 }
 
 template <typename TraitsType>
 void InstImpl<TraitsType>::emitIASAsAddrOpTyGPR(
     const Cfg *Func, Type Ty, const Operand *Op0, const Operand *Op1,
@@ skipping 2071 matching lines @@
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "IACA_END";
 }
 
 } // end of namespace X86NAMESPACE
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTX86BASEIMPL_H