Extracts an TargetX86Base target which will be used as the common X86{32,64} implementation.

src/IceTargetLoweringX86Base.h

-//===- subzero/src/IceTargetLoweringX8632.h - x86-32 lowering ---*- C++ -*-===//
+//===- 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.
 //
 //===----------------------------------------------------------------------===//
 //
-// This file declares the TargetLoweringX8632 class, which
-// implements the TargetLowering interface for the x86-32
+// This file declares the TargetLoweringX86 template class, which
+// implements the TargetLowering base interface for the x86
 // architecture.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SUBZERO_SRC_ICETARGETLOWERINGX8632_H
-#define SUBZERO_SRC_ICETARGETLOWERINGX8632_H
+#ifndef SUBZERO_SRC_ICETARGETLOWERINGX86BASE_H
+#define SUBZERO_SRC_ICETARGETLOWERINGX86BASE_H
 
 #include <unordered_map>
 
-#include "IceAssemblerX8632.h"
 #include "IceDefs.h"
 #include "IceInst.h"
-#include "IceInstX8632.h"
-#include "IceRegistersX8632.h"
 #include "IceTargetLowering.h"
 
 namespace Ice {
+namespace X86Internal {
 
-class BoolFoldingEntry {
-  BoolFoldingEntry(const BoolFoldingEntry &) = delete;
+template <class MachineTraits> class BoolFolding;
+
+template <class Machine> struct MachineTraits {};
+
+template <class Machine> class TargetX86Base : public Machine {
+  TargetX86Base() = delete;
+  TargetX86Base(const TargetX86Base &) = delete;
+  TargetX86Base &operator=(const TargetX86Base &) = delete;
+
+protected:
+  using TargetLowering::H_bitcast_16xi1_i16;
+  using TargetLowering::H_bitcast_8xi1_i8;
+  using TargetLowering::H_bitcast_i16_16xi1;
+  using TargetLowering::H_bitcast_i8_8xi1;
+  using TargetLowering::H_call_ctpop_i32;
+  using TargetLowering::H_call_ctpop_i64;
+  using TargetLowering::H_call_longjmp;
+  using TargetLowering::H_call_memcpy;
+  using TargetLowering::H_call_memmove;
+  using TargetLowering::H_call_memset;
+  using TargetLowering::H_call_read_tp;
+  using TargetLowering::H_call_setjmp;
+  using TargetLowering::H_fptosi_f32_i64;
+  using TargetLowering::H_fptosi_f64_i64;
+  using TargetLowering::H_fptoui_4xi32_f32;
+  using TargetLowering::H_fptoui_f32_i32;
+  using TargetLowering::H_fptoui_f32_i64;
+  using TargetLowering::H_fptoui_f64_i32;
+  using TargetLowering::H_fptoui_f64_i64;
+  using TargetLowering::H_frem_f32;
+  using TargetLowering::H_frem_f64;
+  using TargetLowering::H_sdiv_i64;
+  using TargetLowering::H_sitofp_i64_f32;
+  using TargetLowering::H_sitofp_i64_f64;
+  using TargetLowering::H_srem_i64;
+  using TargetLowering::H_udiv_i64;
+  using TargetLowering::H_uitofp_4xi32_4xf32;
+  using TargetLowering::H_uitofp_i32_f32;
+  using TargetLowering::H_uitofp_i32_f64;
+  using TargetLowering::H_uitofp_i64_f32;
+  using TargetLowering::H_uitofp_i64_f64;
+  using TargetLowering::H_urem_i64;
+
+  using TargetLowering::alignStackSpillAreas;
+  using TargetLowering::assignVarStackSlots;
+  using TargetLowering::inferTwoAddress;
+  using TargetLowering::makeHelperCall;
+  using TargetLowering::getVarStackSlotParams;
 
 public:
-  BoolFoldingEntry() = default;
-  explicit BoolFoldingEntry(Inst *I);
-  BoolFoldingEntry &operator=(const BoolFoldingEntry &) = default;
-  // Instr is the instruction producing the i1-type variable of interest.
-  Inst *Instr = nullptr;
-  // IsComplex is the cached result of BoolFolding::hasComplexLowering(Instr).
-  bool IsComplex = false;
-  // IsLiveOut is initialized conservatively to true, and is set to false when
-  // we encounter an instruction that ends Var's live range.  We disable the
-  // folding optimization when Var is live beyond this basic block.  Note that
-  // if liveness analysis is not performed (e.g. in Om1 mode), IsLiveOut will
-  // always be true and the folding optimization will never be performed.
-  bool IsLiveOut = true;
-  // NumUses counts the number of times Var is used as a source operand in the
-  // basic block.  If IsComplex is true and there is more than one use of Var,
-  // then the folding optimization is disabled for Var.
-  uint32_t NumUses = 0;
-};
+  using Traits = MachineTraits<Machine>;
+  using BoolFolding = ::Ice::X86Internal::BoolFolding<Traits>;
 
-class BoolFolding {
-public:
-  enum BoolFoldingProducerKind {
-    PK_None,
-    PK_Icmp32,
-    PK_Icmp64,
-    PK_Fcmp,
-    PK_Trunc
-  };
+  using TargetLowering::RegSet_All;
+  using TargetLowering::RegSet_CalleeSave;
+  using TargetLowering::RegSet_CallerSave;
+  using TargetLowering::RegSet_FramePointer;
+  using TargetLowering::RegSet_None;
+  using TargetLowering::RegSet_StackPointer;
+  using TargetLowering::Context;
+  using TargetLowering::Ctx;
+  using TargetLowering::Func;
+  using TargetLowering::RegSetMask;
 
-  // Currently the actual enum values are not used (other than CK_None), but we
-  // go
-  // ahead and produce them anyway for symmetry with the
-  // BoolFoldingProducerKind.
-  enum BoolFoldingConsumerKind { CK_None, CK_Br, CK_Select, CK_Sext, CK_Zext };
+  using TargetLowering::_bundle_lock;
+  using TargetLowering::_bundle_unlock;
+  using TargetLowering::getContext;
+  using TargetLowering::getStackAdjustment;
+  using TargetLowering::regAlloc;
+  using TargetLowering::resetStackAdjustment;
 
-private:
-  BoolFolding(const BoolFolding &) = delete;
-  BoolFolding &operator=(const BoolFolding &) = delete;
-
-public:
-  BoolFolding() = default;
-  static BoolFoldingProducerKind getProducerKind(const Inst *Instr);
-  static BoolFoldingConsumerKind getConsumerKind(const Inst *Instr);
-  static bool hasComplexLowering(const Inst *Instr);
-  void init(CfgNode *Node);
-  const Inst *getProducerFor(const Operand *Opnd) const;
-  void dump(const Cfg *Func) const;
-
-private:
-  // Returns true if Producers contains a valid entry for the given VarNum.
-  bool containsValid(SizeT VarNum) const {
-    auto Element = Producers.find(VarNum);
-    return Element != Producers.end() && Element->second.Instr != nullptr;
-  }
-  void setInvalid(SizeT VarNum) { Producers[VarNum].Instr = nullptr; }
-  // Producers maps Variable::Number to a BoolFoldingEntry.
-  std::unordered_map<SizeT, BoolFoldingEntry> Producers;
-};
-
-class TargetX8632 : public TargetLowering {
-  TargetX8632() = delete;
-  TargetX8632(const TargetX8632 &) = delete;
-  TargetX8632 &operator=(const TargetX8632 &) = delete;
-
-public:
-  static TargetX8632 *create(Cfg *Func) { return new TargetX8632(Func); }
+  static TargetX86Base *create(Cfg *Func) { return new TargetX86Base(Func); }
 
   void translateOm1() override;
   void translateO2() override;
   void doLoadOpt();
   bool doBranchOpt(Inst *I, const CfgNode *NextNode) override;
 
   SizeT getNumRegisters() const override { return RegX8632::Reg_NUM; }
   Variable *getPhysicalRegister(SizeT RegNum, Type Ty = IceType_void) override;
   IceString getRegName(SizeT RegNum, Type Ty) const override;
   llvm::SmallBitVector getRegisterSet(RegSetMask Include,
@@ skipping 27 matching lines @@
   // Ensure that a 64-bit Variable has been split into 2 32-bit
   // Variables, creating them if necessary.  This is needed for all
   // I64 operations, and it is needed for pushing F64 arguments for
   // function calls using the 32-bit push instruction (though the
   // latter could be done by directly writing to the stack).
   void split64(Variable *Var);
   Operand *loOperand(Operand *Operand);
   Operand *hiOperand(Operand *Operand);
   void finishArgumentLowering(Variable *Arg, Variable *FramePtr,
                               size_t BasicFrameOffset, size_t &InArgsSizeBytes);
-  X8632::Address stackVarToAsmOperand(const Variable *Var) const;
+  X8632::Address stackVarToAsmOperand(const Variable *Var) const final;
 
-  enum X86InstructionSet {
-    Begin,
-    // SSE2 is the PNaCl baseline instruction set.
-    SSE2 = Begin,
-    SSE4_1,
-    End
-  };
-
-  X86InstructionSet getInstructionSet() const { return InstructionSet; }
+  typename Traits::InstructionSet getInstructionSet() const final {
+    return InstructionSet;
+  }
 
 protected:
-  explicit TargetX8632(Cfg *Func);
+  explicit TargetX86Base(Cfg *Func);
 
   void postLower() override;
 
   void lowerAlloca(const InstAlloca *Inst) override;
   void lowerArithmetic(const InstArithmetic *Inst) override;
   void lowerAssign(const InstAssign *Inst) override;
   void lowerBr(const InstBr *Inst) override;
   void lowerCall(const InstCall *Inst) override;
   void lowerCast(const InstCast *Inst) override;
   void lowerExtractElement(const InstExtractElement *Inst) override;
@@ skipping 21 matching lines @@
   void lowerAtomicCmpxchg(Variable *DestPrev, Operand *Ptr, Operand *Expected,
                           Operand *Desired);
   // Attempt a more optimized lowering of cmpxchg. Returns true if optimized.
   bool tryOptimizedCmpxchgCmpBr(Variable *DestPrev, Operand *Ptr,
                                 Operand *Expected, Operand *Desired);
   void lowerAtomicRMW(Variable *Dest, uint32_t Operation, Operand *Ptr,
                       Operand *Val);
   void lowerCountZeros(bool Cttz, Type Ty, Variable *Dest, Operand *FirstVal,
                        Operand *SecondVal);
 
-  typedef void (TargetX8632::*LowerBinOp)(Variable *, Operand *);
+  typedef void (TargetX86Base::*LowerBinOp)(Variable *, Operand *);
   void expandAtomicRMWAsCmpxchg(LowerBinOp op_lo, LowerBinOp op_hi,
                                 Variable *Dest, Operand *Ptr, Operand *Val);
 
   void eliminateNextVectorSextInstruction(Variable *SignExtendedResult);
 
   void scalarizeArithmetic(InstArithmetic::OpKind K, Variable *Dest,
                            Operand *Src0, Operand *Src1);
 
   // Operand legalization helpers.  To deal with address mode
   // constraints, the helpers will create a new Operand and emit
@@ skipping 365 matching lines @@
   void _xor_rmw(OperandX8632Mem *DestSrc0, Operand *Src1) {
     Context.insert(InstX8632XorRMW::create(Func, DestSrc0, Src1));
   }
   void _set_dest_nonkillable() {
     Context.getLastInserted()->setDestNonKillable();
   }
 
   bool optimizeScalarMul(Variable *Dest, Operand *Src0, int32_t Src1);
   void findRMW();
 
-  X86InstructionSet InstructionSet = X86InstructionSet::Begin;
+  typename Traits::InstructionSet InstructionSet =
+      Traits::InstructionSet::Begin;
   bool IsEbpBasedFrame = false;
   bool NeedsStackAlignment = false;
   size_t SpillAreaSizeBytes = 0;
   llvm::SmallBitVector TypeToRegisterSet[IceType_NUM];
   llvm::SmallBitVector ScratchRegs;
   llvm::SmallBitVector RegsUsed;
   VarList PhysicalRegisters[IceType_NUM];
   static IceString RegNames[];
 
   // Randomize a given immediate operand
   Operand *randomizeOrPoolImmediate(Constant *Immediate,
                                     int32_t RegNum = Variable::NoRegister);
   OperandX8632Mem *
   randomizeOrPoolImmediate(OperandX8632Mem *MemOperand,
                            int32_t RegNum = Variable::NoRegister);
   bool RandomizationPoolingPaused = false;
 
 private:
-  ~TargetX8632() override {}
+  ~TargetX86Base() override {}
   BoolFolding FoldingInfo;
 };
-
-class TargetDataX8632 final : public TargetDataLowering {
-  TargetDataX8632() = delete;
-  TargetDataX8632(const TargetDataX8632 &) = delete;
-  TargetDataX8632 &operator=(const TargetDataX8632 &) = delete;
-
-public:
-  static std::unique_ptr<TargetDataLowering> create(GlobalContext *Ctx) {
-    return std::unique_ptr<TargetDataLowering>(new TargetDataX8632(Ctx));
-  }
-
-  void lowerGlobals(const VariableDeclarationList &Vars,
-                    const IceString &SectionSuffix) override;
-  void lowerConstants() override;
-
-protected:
-  explicit TargetDataX8632(GlobalContext *Ctx);
-
-private:
-  ~TargetDataX8632() override {}
-  template <typename T> static void emitConstantPool(GlobalContext *Ctx);
-};
-
-class TargetHeaderX8632 final : public TargetHeaderLowering {
-  TargetHeaderX8632() = delete;
-  TargetHeaderX8632(const TargetHeaderX8632 &) = delete;
-  TargetHeaderX8632 &operator=(const TargetHeaderX8632 &) = delete;
-
-public:
-  static std::unique_ptr<TargetHeaderLowering> create(GlobalContext *Ctx) {
-    return std::unique_ptr<TargetHeaderLowering>(new TargetHeaderX8632(Ctx));
-  }
-
-protected:
-  explicit TargetHeaderX8632(GlobalContext *Ctx);
-
-private:
-  ~TargetHeaderX8632() = default;
-};
-
+} // end of namespace X86Internal
 } // end of namespace Ice
 
-#endif // SUBZERO_SRC_ICETARGETLOWERINGX8632_H
+#include "IceTargetLoweringX86BaseImpl.h"
+
+#endif // SUBZERO_SRC_ICETARGETLOWERINGX86BASE_H