now shuold pass loop3!

include/optimization/GVN.h

@@ -69,6 +69,8 @@ class ConstantExpression : public Expression {
     }
     ConstantExpression(Constant *c) : Expression(e_constant), c_(c) {}
 
+    Constant *get_val() { return c_; }
+
   private:
     Constant *c_;
 };
@@ -199,20 +201,24 @@ class GEPExpression : public Expression {
 // unique expression: not equal to any one else
 class UniqueExpression : public Expression {
   public:
-    static std::shared_ptr<UniqueExpression> create(Instruction *instr) {
-        return std::make_shared<UniqueExpression>(instr);
+    static std::shared_ptr<UniqueExpression> create(Instruction *instr,
+                                                    size_t index) {
+        return std::make_shared<UniqueExpression>(instr, index);
     }
-    virtual std::string print() { return "(UNIQUE " + instr_->print() + ")"; }
+    // virtual std::string print() { return "(UNIQUE " + instr_->print() + ")";
+    // }
+    virtual std::string print() { return "v" + std::to_string(index_); }
 
     bool equiv(const UniqueExpression *other) const {
         return instr_ == other->instr_;
     }
 
-    UniqueExpression(Instruction *instr)
-        : Expression(e_unique), instr_(instr) {}
+    UniqueExpression(Instruction *instr, size_t index)
+        : Expression(e_unique), instr_(instr), index_(index) {}
 
   private:
     Instruction *instr_;
+    size_t index_;
 };
 } // namespace GVNExpression
 
@@ -276,7 +282,8 @@ class GVN : public Pass {
     partitions transferFunction(BasicBlock *bb);
     std::shared_ptr<GVNExpression::PhiExpression> valuePhiFunc(
         std::shared_ptr<GVNExpression::Expression>,
-        BasicBlock *bb);
+        BasicBlock *bb,
+        Instruction *instr);
     std::shared_ptr<GVNExpression::Expression> valueExpr(
         Instruction *instr,
         const partitions &part);
@@ -308,6 +315,7 @@ class GVN : public Pass {
     std::map<BasicBlock *, bool> _TOP;
     partitions join_helper(BasicBlock *pre1, BasicBlock *pre2);
     BasicBlock *curr_bb;
+    std::map<std::pair<Instruction *, Value *>, size_t> start_idx_;
     //
     // self add function
     //
@@ -317,11 +325,17 @@ class GVN : public Pass {
         Value *v,
         const partitions &part);
 
-    std::vector<std::shared_ptr<GVNExpression::Expression>> core_(
+    std::vector<std::shared_ptr<GVNExpression::Expression>> valueExpr_core_(
         Instruction *instr,
         const partitions &part,
-        size_t count,
+        const size_t count,
         bool fold_ = true);
+    Constant *constFold_core(const size_t count,
+                             const partitions &part,
+                             Instruction *instr,
+                             const std::vector<Value *> &operands);
+    void assign_start_idx_();
+    void dump_tmp(Function &);
 };
 
 bool operator==(const GVN::partitions &p1, const GVN::partitions &p2);

tests/4-ir-opt/testcases/GVN/functional/.gitignore

 *.ll
+*th
+tmp*
+gvn.json

tests/4-ir-opt/testcases/GVN/functional/clear.sh

 rm -rf *.ll
 rm -rf gvn.json
 rm -rf `ls | grep -v "\."`
+rm -rf tmp*