Complete v1.0 range analysis

Author: SandroMaglione

Hpps.cpp

@@ -6,6 +6,7 @@
 #include "llvm/IR/Instructions.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/IR/InstrTypes.h"
 
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/Transforms/IPO/PassManagerBuilder.h"
@@ -22,51 +23,91 @@ namespace
     // Run over a single function
     bool runOnFunction(Function &Func) override
     {
-      // Reference to unroll
-      std::vector<Value *> from; // Value that depend on
-      std::vector<Value *> to; // Value that depend to
-
-      // Found range
-      std::vector<Value *> ranged; // Reference to the value found
-      std::vector<int> minRange;
-      std::vector<int> maxRange;
+      // Keep reference of value still left to find the ranges
+      // 'from' is unknown, it depends on 'to' and 'toValue'
+      // from = to + toValue
+      std::vector<Value *> from;
+      std::vector<Value *> to;
+      std::vector<int> toValue;
+      std::vector<unsigned> toOps;
+
+      // Reference of variabiles for which range has been found
+      std::vector<Value *> ranged; // Reference to the variable
+      std::vector<int> minRange;   // Min range of variable
+      std::vector<int> maxRange;   // Max range of variable
+
+      // Keep reference of variables in load instructions
+      std::vector<Value *> loadRef;
 
       // Run over all basic blocks in the function
       for (BasicBlock &BB : Func)
       {
         // Run over all instructions in the basic block
         for (Instruction &I : BB)
         {
-          // The next statement works since operator<<(ostream&,...)
-          // is overloaded for Instruction&
+          // Print instruction
           errs() << I << "\n";
 
-          // if (auto *operInst = dyn_cast<BinaryOperator>(&I))
-          // {
-          //   errs() << "Operand" << operInst->getName() << "\n";
-          // }
+          // When instruction is Add or Sub
+          // Save operand0 (variable) and operand1 (int)
+          // 'to' -> Previous load instruction value
+          // 'from' -> Current assigned variable value
+          // 'toValue' -> Operand1 int value
+          if (auto *operInst = dyn_cast<BinaryOperator>(&I))
+          {
+            Value *oper0 = operInst->getOperand(0);
+            Value *oper1 = operInst->getOperand(1);
+
+            if (operInst->getOpcode() == Instruction::Add)
+            {
+              errs() << "   -Stored:" << operInst->getName() << "\n";
+
+              // Store reference of variable still to find range
+              from.push_back(operInst);
+              to.push_back(loadRef.at(0));
+              toOps.push_back(operInst->getOpcode());
+              if (ConstantInt *CI = dyn_cast<ConstantInt>(oper1))
+              {
+                toValue.push_back(CI->getZExtValue());
+              }
 
-          // if (auto *loadInst = dyn_cast<LoadInst>(&I))
-          // {
-          //   errs() << "Load" << loadInst->getPointerOperand()->getName() << "\n";
-          // }
+              // Remove previous used load instruction value
+              loadRef.pop_back();
+            }
+            else if (operInst->getOpcode() == Instruction::Sub)
+            {
+            }
+          }
 
-          // STORE INSTRUCTION (Check all store in first cycle)
+          // When instruction is load, store reference to its variable
+          if (auto *loadInst = dyn_cast<LoadInst>(&I))
+          {
+            for (Use &U : loadInst->operands())
+            {
+              Value *v = U.get();
+              loadRef.push_back(v);
+            }
+          }
+
+          // When instruction is store
           if (auto *strInst = dyn_cast<StoreInst>(&I))
-          { 
+          {
             // Get operand0 (value) and operand1 (assigned)
             Value *oper0 = strInst->getOperand(0);
             Value *oper1 = strInst->getOperand(1);
 
-            // Oper0 is reference
+            // Store reference to variable still to find range
             if (oper0->hasName())
             {
               errs() << "   -Ref:" << oper0->getName() << "\n";
               from.push_back(oper1);
               to.push_back(oper0);
+
+              toValue.push_back(0);
+              toOps.push_back(Instruction::Add);
             }
 
-            // Oper0 is constant
+            // Store constant range value
             else
             {
               if (ConstantInt *CI = dyn_cast<ConstantInt>(oper0))
@@ -77,20 +118,6 @@ namespace
                 maxRange.push_back(CI->getZExtValue());
               }
             }
-
-            // for (User *U : oper1->users())
-            // {
-            //   if (Instruction *Inst = dyn_cast<Instruction>(U))
-            //   {
-            //     errs() << "-USED:" << *Inst << "\n";
-
-            //     for (Use &U : Inst->operands())
-            //     {
-            //       Value *v = U.get();
-            //       errs() << "-DEF:" << v->getName() << "\n";
-            //     }
-            //   }
-            // }
           }
 
           errs() << "\n";
@@ -101,7 +128,20 @@ namespace
       errs() << "\nREFERENCES:\n";
       for (auto i = 0; i < from.size(); ++i)
       {
-        errs() << to.at(i)->getName() << "(" << to.at(i) << ") <-" << from.at(i)->getName() << "\n";
+        errs() << to.at(i)->getName() << "+" << toValue.at(i) << "<-" << from.at(i)->getName() << "\n";
+
+        // Search variable reference inside already found ranges
+        for (int v = 0; v < ranged.size(); ++v)
+        {
+          // When range found, add a new found range
+          if (to.at(i) == ranged.at(v))
+          {
+            errs() << "-FOUND:" << ranged.at(v)->getName() << "\n";
+            minRange.push_back(minRange.at(v) + toValue.at(i));
+            maxRange.push_back(minRange.at(v) + toValue.at(i));
+            ranged.push_back(from.at(i));
+          }
+        }
       }
 
       // Print value range computed

result.txt

@@ -1,3 +1,4 @@
+	discovered a new reachable node %entry
   %retval = alloca i32, align 4
 
   %a = alloca i32, align 4
@@ -6,6 +7,8 @@
 
   %c = alloca i32, align 4
 
+  %d = alloca i32, align 4
+
   store i32 0, i32* %retval, align 4
    -Const:0
 
@@ -18,18 +21,56 @@
   %0 = load i32, i32* %a, align 4
 
   %add = add nsw i32 %0, 3
+   -Reg:add-a
 
   store i32 %add, i32* %c, align 4
    -Ref:add
 
+  %1 = load i32, i32* %b, align 4
+
+  %add1 = add nsw i32 %1, 10
+   -Reg:add1-b
+
+  store i32 %add1, i32* %d, align 4
+   -Ref:add1
+
   ret i32 0
 
 
 REFERENCES:
-add(0x83ef100) <-c
+a+3<-add
+-NOT_FOUND
+-FOUND:a
+-NOT_FOUND
+-NOT_FOUND
+add+0<-c
+-NOT_FOUND
+-NOT_FOUND
+-NOT_FOUND
+-FOUND:add
+-NOT_FOUND
+b+10<-add1
+-NOT_FOUND
+-NOT_FOUND
+-FOUND:b
+-NOT_FOUND
+-NOT_FOUND
+-NOT_FOUND
+add1+0<-d
+-NOT_FOUND
+-NOT_FOUND
+-NOT_FOUND
+-NOT_FOUND
+-NOT_FOUND
+-FOUND:add1
+-NOT_FOUND
 
 VALUE RANGES:
 retval(0, 0)
 a(0, 0)
 b(10, 10)
-
+add(3, 3)
+c(3, 3)
+add1(20, 20)
+d(20, 20)
+	discovered a new reachable node %entry

simple.c

@@ -0,0 +1,9 @@
+#include <stdio.h>
+
+int main() {
+	int a = 0;
+	int b = 10;
+	int c = a + 3;
+	int d = b + 10;
+	return 0;
+}