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

src/IceTargetLowering.h

 //===- subzero/src/IceTargetLowering.h - Lowering interface -----*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 128 matching lines @@
 };
 
 class TargetLowering {
   TargetLowering() = delete;
   TargetLowering(const TargetLowering &) = delete;
   TargetLowering &operator=(const TargetLowering &) = delete;
 
 public:
   // TODO(jvoung): return a unique_ptr like the other factory functions.
   static TargetLowering *createLowering(TargetArch Target, Cfg *Func);
-  static void staticInit(TargetArch Target);
+  static void staticInit(const ClFlags &Flags);
   // Each target must define a public static method:
-  //   static void staticInit();
+  //   static void staticInit(const ClFlags &Flags);
   static std::unique_ptr<Assembler> createAssembler(TargetArch Target,
                                                     Cfg *Func);
   void translate() {
     switch (Ctx->getFlags().getOptLevel()) {
     case Opt_m1:
       translateOm1();
       break;
     case Opt_0:
       translateO0();
       break;
@@ skipping 65 matching lines @@
   virtual bool shouldSplitToVariable64On32(Type Ty) const = 0;
 
   bool hasComputedFrame() const { return HasComputedFrame; }
   /// Returns true if this function calls a function that has the "returns
   /// twice" attribute.
   bool callsReturnsTwice() const { return CallsReturnsTwice; }
   void setCallsReturnsTwice(bool RetTwice) { CallsReturnsTwice = RetTwice; }
   SizeT makeNextLabelNumber() { return NextLabelNumber++; }
   SizeT makeNextJumpTableNumber() { return NextJumpTableNumber++; }
   LoweringContext &getContext() { return Context; }
+  Cfg *getFunc() const { return Func; }
+  GlobalContext *getGlobalContext() const { return Ctx; }
 
   enum RegSet {
     RegSet_None = 0,
     RegSet_CallerSave = 1 << 0,
     RegSet_CalleeSave = 1 << 1,
     RegSet_StackPointer = 1 << 2,
     RegSet_FramePointer = 1 << 3,
     RegSet_All = ~RegSet_None
   };
   using RegSetMask = uint32_t;
@@ skipping 12 matching lines @@
                                 uint64_t Salt) const = 0;
 
   /// Get the minimum number of clusters required for a jump table to be
   /// considered.
   virtual SizeT getMinJumpTableSize() const = 0;
   virtual void emitJumpTable(const Cfg *Func,
                              const InstJumpTable *JumpTable) const = 0;
 
   virtual void emitVariable(const Variable *Var) const = 0;
 
-  void emitWithoutPrefix(const ConstantRelocatable *CR) const;
-  void emit(const ConstantRelocatable *CR) const;
-  virtual const char *getConstantPrefix() const = 0;
+  void emitWithoutPrefix(const ConstantRelocatable *CR,
+                         const char *Suffix = "") const;
 
-  virtual void emit(const ConstantUndef *C) const = 0;
   virtual void emit(const ConstantInteger32 *C) const = 0;
   virtual void emit(const ConstantInteger64 *C) const = 0;
   virtual void emit(const ConstantFloat *C) const = 0;
   virtual void emit(const ConstantDouble *C) const = 0;
+  virtual void emit(const ConstantUndef *C) const = 0;
+  virtual void emit(const ConstantRelocatable *CR) const = 0;
 
   /// Performs target-specific argument lowering.
   virtual void lowerArguments() = 0;
 
   virtual void initNodeForLowering(CfgNode *) {}
   virtual void addProlog(CfgNode *Node) = 0;
   virtual void addEpilog(CfgNode *Node) = 0;
 
   virtual ~TargetLowering() = default;
 
@@ skipping 120 matching lines @@
   const static constexpr char *H_call_setjmp = "setjmp";
   const static constexpr char *H_fptosi_f32_i64 = "__Sz_fptosi_f32_i64";
   const static constexpr char *H_fptosi_f64_i64 = "__Sz_fptosi_f64_i64";
   const static constexpr char *H_fptoui_4xi32_f32 = "__Sz_fptoui_4xi32_f32";
   const static constexpr char *H_fptoui_f32_i32 = "__Sz_fptoui_f32_i32";
   const static constexpr char *H_fptoui_f32_i64 = "__Sz_fptoui_f32_i64";
   const static constexpr char *H_fptoui_f64_i32 = "__Sz_fptoui_f64_i32";
   const static constexpr char *H_fptoui_f64_i64 = "__Sz_fptoui_f64_i64";
   const static constexpr char *H_frem_f32 = "fmodf";
   const static constexpr char *H_frem_f64 = "fmod";
+  const static constexpr char *H_getIP_prefix = "__Sz_getIP_";
   const static constexpr char *H_sdiv_i32 = "__divsi3";
   const static constexpr char *H_sdiv_i64 = "__divdi3";
   const static constexpr char *H_sitofp_i64_f32 = "__Sz_sitofp_i64_f32";
   const static constexpr char *H_sitofp_i64_f64 = "__Sz_sitofp_i64_f64";
   const static constexpr char *H_srem_i32 = "__modsi3";
   const static constexpr char *H_srem_i64 = "__moddi3";
   const static constexpr char *H_udiv_i32 = "__udivsi3";
   const static constexpr char *H_udiv_i64 = "__udivdi3";
   const static constexpr char *H_uitofp_4xi32_4xf32 = "__Sz_uitofp_4xi32_4xf32";
   const static constexpr char *H_uitofp_i32_f32 = "__Sz_uitofp_i32_f32";
@@ skipping 50 matching lines @@
   virtual void lower() {}
 
 protected:
   explicit TargetHeaderLowering(GlobalContext *Ctx) : Ctx(Ctx) {}
   GlobalContext *Ctx;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETARGETLOWERING_H