Merge x86 data and header lowering

src/IceTargetLoweringX86Base.h

 //===- subzero/src/IceTargetLoweringX86Base.h - x86 lowering ----*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 280 matching lines @@
   void emitSandboxedReturn() {
     dispatchToConcrete(&Traits::ConcreteTarget::emitSandboxedReturn);
   }
   /// Emit just the call instruction (without argument or return variable
   /// processing), sandboxing if needed.
   virtual Inst *emitCallToTarget(Operand *CallTarget, Variable *ReturnReg) = 0;
   /// Materialize the moves needed to return a value of the specified type.
   virtual Variable *moveReturnValueToRegister(Operand *Value,
                                               Type ReturnType) = 0;
 
+  /// Emit a jump table to the constant pool.
+  void emitJumpTable(const Cfg *Func,
+                     const InstJumpTable *JumpTable) const override;
+
   /// Emit a fake use of esp to make sure esp stays alive for the entire
   /// function. Otherwise some esp adjustments get dead-code eliminated.
   void keepEspLiveAtExit() {
     Variable *esp =
         Func->getTarget()->getPhysicalRegister(getStackReg(), Traits::WordType);
     Context.insert<InstFakeUse>(esp);
   }
 
   /// Operand legalization helpers. To deal with address mode constraints, the
   /// helpers will create a new Operand and emit instructions that guarantee
@@ skipping 702 matching lines @@
   /// x86lowerIcmp64 handles 64-bit icmp lowering.
   template <typename T = Traits>
   typename std::enable_if<!T::Is64Bit, void>::type
   lowerIcmp64(const InstIcmp *Icmp, const Inst *Consumer);
 
   BoolFolding<Traits> FoldingInfo;
 
   static FixupKind PcRelFixup;
   static FixupKind AbsFixup;
 };
+
+template <typename TraitsType>
+class TargetDataX86 final : public TargetDataLowering {
+  using Traits = TraitsType;
+  TargetDataX86() = delete;
+  TargetDataX86(const TargetDataX86 &) = delete;
+  TargetDataX86 &operator=(const TargetDataX86 &) = delete;
+
+public:
+  ~TargetDataX86() override = default;
+
+  static std::unique_ptr<TargetDataLowering> create(GlobalContext *Ctx) {
+    return makeUnique<TargetDataX86>(Ctx);
+  }
+
+  void lowerGlobals(const VariableDeclarationList &Vars,
+                    const IceString &SectionSuffix) override;
+  void lowerConstants() override;
+  void lowerJumpTables() override;
+
+private:
+  ENABLE_MAKE_UNIQUE;
+
+  explicit TargetDataX86(GlobalContext *Ctx) : TargetDataLowering(Ctx){};
+  template <typename T> static void emitConstantPool(GlobalContext *Ctx);
+};
+
+class TargetHeaderX86 : public TargetHeaderLowering {
+  TargetHeaderX86() = delete;
+  TargetHeaderX86(const TargetHeaderX86 &) = delete;
+  TargetHeaderX86 &operator=(const TargetHeaderX86 &) = delete;
+
+public:
+  ~TargetHeaderX86() = default;
+
+  static std::unique_ptr<TargetHeaderLowering> create(GlobalContext *Ctx) {
+    return makeUnique<TargetHeaderX86>(Ctx);
+  }
+
+private:
+  ENABLE_MAKE_UNIQUE;
+
+  explicit TargetHeaderX86(GlobalContext *Ctx) : TargetHeaderLowering(Ctx) {}
+};
+
 } // end of namespace X86NAMESPACE
 } // end of namespace Ice
 
 #include "IceTargetLoweringX86BaseImpl.h"
 
 #endif // SUBZERO_SRC_ICETARGETLOWERINGX86BASE_H