Subzero: Refactor x86 register definitions to use the alias mechanism.

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.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 331 matching lines @@
 
 /// RegWeight is a wrapper for a uint32_t weight value, with a special value
 /// that represents infinite weight, and an addWeight() method that ensures that
 /// W+infinity=infinity.
 class RegWeight {
 public:
   RegWeight() = default;
   explicit RegWeight(uint32_t Weight) : Weight(Weight) {}
   RegWeight(const RegWeight &) = default;
   RegWeight &operator=(const RegWeight &) = default;
-  const static uint32_t Inf = ~0;      /// Force regalloc to give a register
-  const static uint32_t Zero = 0;      /// Force regalloc NOT to give a register
-  const static uint32_t Max = Inf - 1; /// Max natural weight.
+  constexpr static uint32_t Inf = ~0; /// Force regalloc to give a register
+  constexpr static uint32_t Zero = 0; /// Force regalloc NOT to give a register
+  constexpr static uint32_t Max = Inf - 1; /// Max natural weight.
   void addWeight(uint32_t Delta) {
     if (Delta == Inf)
       Weight = Inf;
     else if (Weight != Inf)
       if (Utils::add_overflow(Weight, Delta, &Weight) || Weight == Inf)
         Weight = Max;
   }
   void addWeight(const RegWeight &Other) { addWeight(Other.Weight); }
   void setWeight(uint32_t Val) { Weight = Val; }
   uint32_t getWeight() const { return Weight; }
@@ skipping 100 matching lines @@
   bool getIgnoreLiveness() const { return IgnoreLiveness; }
 
   int32_t getStackOffset() const { return StackOffset; }
   void setStackOffset(int32_t Offset) { StackOffset = Offset; }
   /// Returns the variable's stack offset in symbolic form, to improve
   /// readability in DecorateAsm mode.
   IceString getSymbolicStackOffset(const Cfg *Func) const {
     return "lv$" + getName(Func);
   }
 
-  static const int32_t NoRegister = -1;
+  static constexpr int32_t NoRegister = -1;
   bool hasReg() const { return getRegNum() != NoRegister; }
   int32_t getRegNum() const { return RegNum; }
   void setRegNum(int32_t NewRegNum) {
     // Regnum shouldn't be set more than once.
     assert(!hasReg() || RegNum == NewRegNum);
     RegNum = NewRegNum;
   }
   bool hasRegTmp() const { return getRegNumTmp() != NoRegister; }
   int32_t getRegNumTmp() const { return RegNumTmp; }
   void setRegNumTmp(int32_t NewRegNum) { RegNumTmp = NewRegNum; }
@@ skipping 14 matching lines @@
   void addLiveRange(InstNumberT Start, InstNumberT End) {
     assert(!getIgnoreLiveness());
     Live.addSegment(Start, End);
   }
   void trimLiveRange(InstNumberT Start) { Live.trim(Start); }
   void untrimLiveRange() { Live.untrim(); }
   bool rangeEndsBefore(const Variable *Other) const {
     return Live.endsBefore(Other->Live);
   }
   bool rangeOverlaps(const Variable *Other) const {
-    const bool UseTrimmed = true;
+    constexpr bool UseTrimmed = true;
     return Live.overlaps(Other->Live, UseTrimmed);
   }
   bool rangeOverlapsStart(const Variable *Other) const {
-    const bool UseTrimmed = true;
+    constexpr bool UseTrimmed = true;
     return Live.overlapsInst(Other->Live.getStart(), UseTrimmed);
   }
 
   /// Creates a temporary copy of the variable with a different type. Used
   /// primarily for syntactic correctness of textual assembly emission. Note
   /// that only basic information is copied, in particular not IsArgument,
   /// IsImplicitArgument, IgnoreLiveness, RegNumTmp, Live, LoVar, HiVar,
-  /// VarsReal.
-  Variable *asType(Type Ty);
+  /// VarsReal.  If NewRegNum!=NoRegister, then that register assignment is made
+  /// instead of copying the existing assignment.
+  const Variable *asType(Type Ty, int32_t NewRegNum) const;
 
   void emit(const Cfg *Func) const override;
   using Operand::dump;
   void dump(const Cfg *Func, Ostream &Str) const override;
 
   /// Return reg num of base register, if different from stack/frame register.
   virtual int32_t getBaseRegNum() const { return NoRegister; }
 
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
@@ skipping 200 matching lines @@
 private:
   const Cfg *Func;
   MetadataKind Kind;
   CfgVector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H