Subzero: Automatically infer regalloc preferences and overlap.

src/IceInst.h

 //===- subzero/src/IceInst.h - High-level instructions ----------*- 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 Inst class and its target-independent
@@ skipping 74 matching lines @@
   // instruction, which is the last instruction of the block.
   virtual NodeList getTerminatorEdges() const {
     // All valid terminator instructions override this method.  For
     // the default implementation, we assert in case some CfgNode
     // is constructed without a terminator instruction at the end.
     llvm_unreachable(
         "getTerminatorEdges() called on a non-terminator instruction");
     return NodeList();
   }
 
+  virtual bool isSimpleAssign() const { return false; }
+
   void livenessLightweight(Cfg *Func, llvm::BitVector &Live);
   void liveness(InstNumberT InstNumber, llvm::BitVector &Live,
                 Liveness *Liveness, const CfgNode *Node);
 
   // Get the number of native instructions that this instruction
   // ultimately emits.  By default, high-level instructions don't
   // result in any native instructions, and a target-specific
   // instruction results in a single native instruction.
   virtual uint32_t getEmitInstCount() const { return 0; }
   virtual void emit(const Cfg *Func) const;
@@ skipping 121 matching lines @@
 // abstraction for some of the lowering.  E.g., if Phi instruction
 // lowering happens before target lowering, or for representing an
 // Inttoptr instruction, or as an intermediate step for lowering a
 // Load instruction.
 class InstAssign : public Inst {
 public:
   static InstAssign *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocateInst<InstAssign>())
         InstAssign(Func, Dest, Source);
   }
+  virtual bool isSimpleAssign() const { return true; }
   virtual void dump(const Cfg *Func) const;
   static bool classof(const Inst *Inst) { return Inst->getKind() == Assign; }
 
 private:
   InstAssign(Cfg *Func, Variable *Dest, Operand *Source);
   InstAssign(const InstAssign &) LLVM_DELETED_FUNCTION;
   InstAssign &operator=(const InstAssign &) LLVM_DELETED_FUNCTION;
   virtual ~InstAssign() {}
 };
 
@@ skipping 515 matching lines @@
     assert(Kind >= Target);
   }
   InstTarget(const InstTarget &) LLVM_DELETED_FUNCTION;
   InstTarget &operator=(const InstTarget &) LLVM_DELETED_FUNCTION;
   virtual ~InstTarget() {}
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINST_H