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

src/IceCfg.cpp

 //===- subzero/src/IceCfg.cpp - Control flow graph implementation ---------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 180 matching lines @@
     // TODO(jpp): this is fragile, at best. Figure out a better way of
     // detecting exit functions.
     if (GlobalContext::matchSymbolName(getFunctionName(), "exit")) {
       addCallToProfileSummary();
     }
     dump("Profiled CFG");
   }
 
   // Create the Hi and Lo variables where a split was needed
   for (Variable *Var : Variables)
-    if (auto Var64On32 = llvm::dyn_cast<Variable64On32>(Var))
+    if (auto *Var64On32 = llvm::dyn_cast<Variable64On32>(Var))
       Var64On32->initHiLo(this);
 
   // Figure out which alloca instructions result in storage at known stack frame
   // offsets.  If this is true for all alloca instructions, then a stack pointer
   // can still be used instead of a frame pointer, freeing up the frame pointer
   // for normal register allocation.  Additionally, for each such alloca, its
   // address could be rematerialized at each use in terms of the stack/frame
   // pointer, saving a stack slot and a load from that stack slot.
   //
   // This simple implementation is limited to alloca instructions at the start
@@ skipping 388 matching lines @@
     Inst *FirstInst = nullptr;
     for (Inst &Inst : Node->getInsts()) {
       if (Inst.isDeleted())
         continue;
       if (FirstInst == nullptr)
         FirstInst = &Inst;
       InstNumberT InstNumber = Inst.getNumber();
       if (Variable *Dest = Inst.getDest()) {
         if (!Dest->getIgnoreLiveness()) {
           bool Invalid = false;
-          const bool IsDest = true;
+          constexpr bool IsDest = true;
           if (!Dest->getLiveRange().containsValue(InstNumber, IsDest))
             Invalid = true;
           // Check that this instruction actually *begins* Dest's live range,
           // by checking that Dest is not live in the previous instruction. As
           // a special exception, we don't check this for the first instruction
           // of the block, because a Phi temporary may be live at the end of
           // the previous block, and if it is also assigned in the first
           // instruction of this block, the adjacent live ranges get merged.
           if (static_cast<class Inst *>(&Inst) != FirstInst &&
               !Inst.isDestRedefined() &&
@@ skipping 211 matching lines @@
     }
   }
   // Print each basic block
   for (CfgNode *Node : Nodes)
     Node->dump(this);
   if (isVerbose(IceV_Instructions))
     Str << "}\n";
 }
 
 } // end of namespace Ice