Subzero: Initial implementation of BB Local CSE

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 80 matching lines @@
   void dump(Ostream &Str) const {
     if (BuildDefs::dump())
       dump(nullptr, Str);
   }
   /// @}
 
   virtual ~Operand() = default;
 
   virtual Variable *asBoolean() { return nullptr; }
 
+  virtual SizeT hashValue() const {
+    llvm::report_fatal_error("Tried to hash unsupported operand type : " +
+                             std::to_string(Kind));
+    return 0;
+  }
+
 protected:
   Operand(OperandKind Kind, Type Ty) : Ty(Ty), Kind(Kind) {
     // It is undefined behavior to have a larger value in the enum
     assert(Kind <= kTarget_Max);
   }
 
   const Type Ty;
   const OperandKind Kind;
   /// Vars and NumVars are initialized by the derived class.
   SizeT NumVars = 0;
@@ skipping 35 matching lines @@
   bool getShouldBePooled() const { return ShouldBePooled; }
 
   // This should be thread-safe because the constant pool lock is acquired
   // before the method is invoked.
   void updateLookupCount() {
     if (!BuildDefs::dump())
       return;
     ++LookupCount;
   }
   CounterType getLookupCount() const { return LookupCount; }
+  SizeT hashValue() const override { return 0; }
 
 protected:
   Constant(OperandKind Kind, Type Ty) : Operand(Kind, Ty) {
     Vars = nullptr;
     NumVars = 0;
   }
   /// Set the ShouldBePooled field to the proper value after the object is fully
   /// initialized.
   void initShouldBePooled();
   GlobalString LabelName;
@@ skipping 31 matching lines @@
   using Constant::dump;
   void dump(const Cfg *, Ostream &Str) const override {
     if (BuildDefs::dump())
       Str << getValue();
   }
 
   static bool classof(const Operand *Operand) {
     return Operand->getKind() == K;
   }
 
+  SizeT hashValue() const override {
+    return std::hash<PrimType>()(Value);
+  }
+
   virtual bool shouldBeRandomizedOrPooled() const override { return false; }
 
 private:
   ConstantPrimitive(Type Ty, PrimType Value) : Constant(K, Ty), Value(Value) {}
 
   void initName(GlobalContext *Ctx) {
     std::string Buffer;
     llvm::raw_string_ostream Str(Buffer);
     constexpr bool IsCompact = !BuildDefs::dump();
     if (IsCompact) {
@@ skipping 545 matching lines @@
   void dump(const Cfg *Func, Ostream &Str) const override;
 
   /// Return reg num of base register, if different from stack/frame register.
   virtual RegNumT getBaseRegNum() const { return RegNumT(); }
 
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
     return Kind >= kVariable && Kind <= kVariable_Max;
   }
 
+  SizeT hashValue() const override {
+    return std::hash<SizeT>()(getIndex());
+  }
+
 protected:
   Variable(const Cfg *Func, OperandKind K, Type Ty, SizeT Index)
       : Operand(K, Ty), Number(Index),
         Name(VariableString::createWithoutString(Func)),
         RegisterClass(static_cast<RegClass>(Ty)) {
     Vars = VarsReal;
     Vars[0] = this;
     NumVars = 1;
   }
   /// Number is unique across all variables, and is used as a (bit)vector index
@@ skipping 230 matching lines @@
     return Operand->getKind() == kVariableBoolean;
   }
 
 private:
   Variable *BoolSource = nullptr;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H