add offset for allign

Author: ladisgin

lib/Core/MockBuilder.cpp

@@ -161,59 +161,107 @@ void MockBuilder::buildCallKleeMakeSymbolic(
        gep});
 }
 
-inline bool isPointer(const std::vector<Annotation::StatementPtr> &statements) {
+inline llvm::Value *
+MockBuilder::goByOffset(llvm::Value *value,
+                        const std::vector<std::string> &offset) {
+  llvm::Value *current = value;
+  for (const auto &inst : offset) {
+    if (inst == "*") {
+      if (!current->getType()->isPointerTy()) {
+        klee_error("Incorrect annotation offset.");
+      }
+      current = builder->CreateLoad(current);
+    } else if (inst == "&") {
+      auto addr = builder->CreateAlloca(current->getType());
+      current = builder->CreateStore(current, addr);
+    } else {
+      const size_t index = std::stol(inst);
+      if (!(current->getType()->isPointerTy() ||
+            current->getType()->isArrayTy())) {
+        klee_error("Incorrect annotation offset.");
+      }
+      current = builder->CreateConstInBoundsGEP1_64(current, index);
+    }
+  }
+  return current;
+}
+
+inline llvm::Type *getTypeByOffset(llvm::Type *value,
+                                   const std::vector<std::string> &offset) {
+  llvm::Type *current = value;
+  for (const auto &inst : offset) {
+    if (inst == "*") {
+      if (!current->isPointerTy()) {
+        return nullptr;
+      }
+      current = current->getPointerElementType();
+    } else if (inst == "&") {
+      // no needed
+    } else {
+      const size_t index = std::stol(inst);
+      if (current->isArrayTy() || current->isPointerTy()) {
+        current = current->getContainedType(index);
+      } else {
+        return nullptr;
+      }
+    }
+  }
+  return current;
+}
+
+inline bool
+isCorrectStatements(const std::vector<Annotation::StatementPtr> &statements,
+                    const llvm::Argument *arg) {
   return std::any_of(statements.begin(), statements.end(),
-                     [](const Annotation::StatementPtr &statement) {
+                     [arg](const Annotation::StatementPtr &statement) {
+                       auto argType =
+                           getTypeByOffset(arg->getType(), statement->offset);
                        switch (statement->getStatementKind()) {
                        case Annotation::StatementKind::Deref:
                        case Annotation::StatementKind::InitNull:
-                         return true;
+                         return argType->isPointerTy();
                        case Annotation::StatementKind::Unknown:
                        default:
-                         return false;
+                         return true;
                        }
                      });
 }
 
 bool tryAllign(
     llvm::Function *func,
-    const std::vector<std::vector<Annotation::StatementPtr>> statements,
+    const std::vector<std::vector<Annotation::StatementPtr>> &statements,
     std::vector<std::vector<Annotation::StatementPtr>> &res) {
   if (func->arg_size() == statements.size()) {
     return true;
   }
 
   for (size_t i = 0, j = 0; j < func->arg_size() && i < statements.size();) {
-    if (isPointer(statements[i])) {
-      while (j < func->arg_size() &&
-             !func->getArg(j)->getType()->isPointerTy()) { // TODO: add check
-        res.emplace_back();
-        j++;
-      }
+    while (isCorrectStatements(statements[i], func->getArg(j))) {
+      res.emplace_back();
+      j++;
       if (j >= func->arg_size()) {
         break;
       }
-      res.push_back(statements[i]);
-    } else {
-      res.push_back(statements[i]);
     }
+    res.push_back(statements[i]);
     j++;
     i++;
   }
   if (func->arg_size() == statements.size()) {
     return true;
   }
-
   return false;
 }
 
 void MockBuilder::buildAnnotationForExternalFunctionParams(
     llvm::Function *func,
-    const std::vector<std::vector<Annotation::StatementPtr>> &statements) {
-  std::vector<std::vector<Annotation::StatementPtr>> res;
-  bool flag = tryAllign(func, statements, res);
+    const std::vector<std::vector<Annotation::StatementPtr>>
+        &statementsNotAllign) {
+  std::vector<std::vector<Annotation::StatementPtr>> statements;
+  bool flag = tryAllign(func, statementsNotAllign, statements);
   if (!flag) {
-    klee_warning("Can't use annotation incorrect arguments count");
+    klee_warning("Annotation: incorrect arguments count function %s ",
+                 func->getName().str().c_str());
     return;
   }
   for (size_t i = 0; i < statements.size(); i++) {
@@ -223,7 +271,7 @@ void MockBuilder::buildAnnotationForExternalFunctionParams(
       switch (statement->getStatementKind()) {
       case Annotation::StatementKind::Deref: {
         if (!elem->getType()->isPointerTy()) {
-          klee_error("Incorrect annotation deref: arg not pointer");
+          klee_error("Annotation: deref arg not pointer");
         }
 
         std::string derefCondName = "condition_deref_arg_" + std::to_string(i) +
@@ -245,8 +293,6 @@ void MockBuilder::buildAnnotationForExternalFunctionParams(
         builder->CreateCondBr(brValue, derefBB, contBB);
 
         builder->SetInsertPoint(derefBB);
-        // deref
-
         builder->CreateBr(contBB);
 
         newFunc->getBasicBlockList().push_back(contBB); // emit merge block
@@ -335,28 +381,4 @@ void MockBuilder::buildAnnotationForExternalFunctionProperties(
   }
 }
 
-llvm::Value *MockBuilder::goByOffset(llvm::Value *value,
-                                     const std::vector<std::string> &offset) {
-  llvm::Value *current = value;
-  for (const auto &inst : offset) {
-    if (inst == "*") {
-      if (!current->getType()->isPointerTy()) {
-        klee_error("Incorrect annotation offset.");
-      }
-      current = builder->CreateLoad(current);
-    } else if (inst == "&") {
-      auto addr = builder->CreateAlloca(current->getType());
-      current = builder->CreateStore(current, addr);
-    } else {
-      const size_t index = std::stol(inst);
-      if (!(current->getType()->isPointerTy() ||
-            current->getType()->isArrayTy())) {
-        klee_error("Incorrect annotation offset.");
-      }
-      current = builder->CreateConstInBoundsGEP1_64(current, index);
-    }
-  }
-  return current;
-}
-
 } // namespace klee