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

src/IceInstX86Base.h

 //===- subzero/src/IceInstX86Base.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
@@ skipping 83 matching lines @@
       Cmpps,
       Cmpxchg,
       Cmpxchg8b,
       Cvt,
       Div,
       Divps,
       Divss,
       FakeRMW,
       Fld,
       Fstp,
+      GetIP,
       Icmp,
       Idiv,
       Imul,
       ImulImm,
       Insertps,
       Jmp,
       Label,
       Lea,
       Load,
       Mfence,
@@ skipping 144 matching lines @@
     static bool classof(const Inst *Inst) {
       return InstX86Base::isClassof(Inst, InstX86Base::FakeRMW);
     }
 
   private:
     InstArithmetic::OpKind Op;
     InstX86FakeRMW(Cfg *Func, Operand *Data, Operand *Addr,
                    InstArithmetic::OpKind Op, Variable *Beacon);
   };
 
+  class InstX86GetIP final : public InstX86Base {
+    InstX86GetIP() = delete;
+    InstX86GetIP(const InstX86GetIP &) = delete;
+    InstX86GetIP &operator=(const InstX86GetIP &) = delete;
+
+  public:
+    static InstX86GetIP *create(Cfg *Func, Variable *Dest) {
+      return new (Func->allocate<InstX86GetIP>()) InstX86GetIP(Func, Dest);
+    }
+    void emit(const Cfg *Func) const override;
+    void emitIAS(const Cfg *Func) const override;
+    void dump(const Cfg *Func) const override;
+    static bool classof(const Inst *Inst) {
+      return InstX86Base::isClassof(Inst, InstX86Base::GetIP);
+    }
+
+  private:
+    InstX86GetIP(Cfg *Func, Variable *Dest);
+  };
+
   /// InstX86Label represents an intra-block label that is the target of an
   /// intra-block branch. The offset between the label and the branch must be
   /// fit into one byte (considered "near"). These are used for lowering i1
   /// calculations, Select instructions, and 64-bit compares on a 32-bit
   /// architecture, without basic block splitting. Basic block splitting is not
   /// so desirable for several reasons, one of which is the impact on decisions
   /// based on whether a variable's live range spans multiple basic blocks.
   ///
   /// Intra-block control flow must be used with caution. Consider the sequence
   /// for "c = (a >= b ? x : y)".
@@ skipping 2486 matching lines @@
   private:
     InstX86IacaEnd(Cfg *Func);
   };
 }; // struct InstImpl
 
 /// struct Insts is a template that can be used to instantiate all the X86
 /// instructions for a target with a simple
 ///
 /// using Insts = ::Ice::X86NAMESPACE::Insts<TraitsType>;
 template <typename TraitsType> struct Insts {
+  using GetIP = typename InstImpl<TraitsType>::InstX86GetIP;
   using FakeRMW = typename InstImpl<TraitsType>::InstX86FakeRMW;
   using Label = typename InstImpl<TraitsType>::InstX86Label;
 
   using Call = typename InstImpl<TraitsType>::InstX86Call;
 
   using Br = typename InstImpl<TraitsType>::InstX86Br;
   using Jmp = typename InstImpl<TraitsType>::InstX86Jmp;
   using Bswap = typename InstImpl<TraitsType>::InstX86Bswap;
   using Neg = typename InstImpl<TraitsType>::InstX86Neg;
   using Bsf = typename InstImpl<TraitsType>::InstX86Bsf;
@@ skipping 691 matching lines @@
           &InstImpl<TraitsType>::Assembler::psrl};                             \
   }                                                                            \
   }
 
 } // end of namespace X86NAMESPACE
 } // end of namespace Ice
 
 #include "IceInstX86BaseImpl.h"
 
 #endif // SUBZERO_SRC_ICEINSTX86BASE_H