Convert Constant->emit() definitions to allow multiple targets to define them.

src/IceOperand.h

 //===- subzero/src/IceOperand.h - High-level operands -----------*- 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 Operand class and its target-independent
@@ skipping 88 matching lines @@
 // constants are allocated from a global arena and are pooled.
 class Constant : public Operand {
   Constant() = delete;
   Constant(const Constant &) = delete;
   Constant &operator=(const Constant &) = delete;
 
 public:
   void emitPoolLabel(Ostream &Str) const {
     Str << ".L$" << getType() << "$" << PoolEntryID;
   }
-  void emit(const Cfg *Func) const override { emit(Func->getContext()); }
-  virtual void emit(GlobalContext *Ctx) const = 0;
-  virtual void emitWithoutDollar(GlobalContext *Ctx) const = 0;
+  void emit(const Cfg *Func) const override { emit(Func->getTarget()); }
+  virtual void emit(TargetLowering *Target) const = 0;
 
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
     return Kind >= kConst_Base && Kind <= kConst_Num;
   }
 
 protected:
   Constant(OperandKind Kind, Type Ty, uint32_t PoolEntryID)
       : Operand(Kind, Ty), PoolEntryID(PoolEntryID) {
     Vars = nullptr;
@@ skipping 18 matching lines @@
 
   static ConstantPrimitive *create(GlobalContext *Ctx, Type Ty, PrimType Value,
                                    uint32_t PoolEntryID) {
     assert(!Ctx->isIRGenerationDisabled() &&
            "Attempt to build primitive constant when IR generation disabled");
     return new (Ctx->allocate<ConstantPrimitive>())
         ConstantPrimitive(Ty, Value, PoolEntryID);
   }
   PrimType getValue() const { return Value; }
   using Constant::emit;
-  // The target needs to implement this for each ConstantPrimitive
-  // specialization.
-  void emit(GlobalContext *Ctx) const override;
-  void emitWithoutDollar(GlobalContext *Ctx) const override;
+  void emit(TargetLowering *Ctx) const final;
   using Constant::dump;
   void dump(const Cfg *, Ostream &Str) const override {
     if (ALLOW_DUMP)
       Str << getValue();
   }
 
   static bool classof(const Operand *Operand) {
     return Operand->getKind() == K;
   }
 
@@ skipping 63 matching lines @@
            "Attempt to build relocatable constant when IR generation disabled");
     return new (Ctx->allocate<ConstantRelocatable>()) ConstantRelocatable(
         Ty, Tuple.Offset, Tuple.Name, Tuple.SuppressMangling, PoolEntryID);
   }
 
   RelocOffsetT getOffset() const { return Offset; }
   const IceString &getName() const { return Name; }
   void setSuppressMangling(bool Value) { SuppressMangling = Value; }
   bool getSuppressMangling() const { return SuppressMangling; }
   using Constant::emit;
+  void emit(TargetLowering *Target) const final;
+  void emitWithoutPrefix(TargetLowering *Ctx) const;
   using Constant::dump;
-  void emit(GlobalContext *Ctx) const override;
-  void emitWithoutDollar(GlobalContext *Ctx) const override;
   void dump(const Cfg *Func, Ostream &Str) const override;
 
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
     return Kind == kConstRelocatable;
   }
 
 private:
   ConstantRelocatable(Type Ty, RelocOffsetT Offset, const IceString &Name,
                       bool SuppressMangling, uint32_t PoolEntryID)
@@ skipping 15 matching lines @@
 
 public:
   static ConstantUndef *create(GlobalContext *Ctx, Type Ty,
                                uint32_t PoolEntryID) {
     assert(!Ctx->isIRGenerationDisabled() &&
            "Attempt to build undefined constant when IR generation disabled");
     return new (Ctx->allocate<ConstantUndef>()) ConstantUndef(Ty, PoolEntryID);
   }
 
   using Constant::emit;
+  void emit(TargetLowering *Target) const final;
   using Constant::dump;
-  // The target needs to implement this.
-  void emit(GlobalContext *Ctx) const override;
-  void emitWithoutDollar(GlobalContext *Ctx) const override;
   void dump(const Cfg *, Ostream &Str) const override {
     if (ALLOW_DUMP)
       Str << "undef";
   }
 
   static bool classof(const Operand *Operand) {
     return Operand->getKind() == kConstUndef;
   }
 
 private:
@@ skipping 345 matching lines @@
 private:
   const Cfg *Func;
   MetadataKind Kind;
   std::vector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H