about summary refs log tree commit diff homepage
path: root/lib/Core/ExecutorUtil.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'lib/Core/ExecutorUtil.cpp')
-rw-r--r--lib/Core/ExecutorUtil.cpp136
1 files changed, 65 insertions, 71 deletions
diff --git a/lib/Core/ExecutorUtil.cpp b/lib/Core/ExecutorUtil.cpp
index a1e030a5..3bb8a0b0 100644
--- a/lib/Core/ExecutorUtil.cpp
+++ b/lib/Core/ExecutorUtil.cpp
@@ -33,103 +33,97 @@ using namespace llvm;
 
 namespace klee {
 
-ref<Expr> 
-Executor::evalConstantExpr(llvm::ConstantExpr *ce) {
-  const llvm::Type *type = ce->getType();
-
-  ref<Expr> op1(0), op2(0), op3(0);
-  int numOperands = ce->getNumOperands();
-
-  if (numOperands > 0) op1 = evalConstant(ce->getOperand(0));
-  if (numOperands > 1) op2 = evalConstant(ce->getOperand(1));
-  if (numOperands > 2) op3 = evalConstant(ce->getOperand(2));
-  
-  switch (ce->getOpcode()) {
+  ref<ConstantExpr> Executor::evalConstantExpr(llvm::ConstantExpr *ce) {
+    const llvm::Type *type = ce->getType();
+
+    ref<ConstantExpr> op1(0), op2(0), op3(0);
+    int numOperands = ce->getNumOperands();
+
+    if (numOperands > 0) op1 = evalConstant(ce->getOperand(0));
+    if (numOperands > 1) op2 = evalConstant(ce->getOperand(1));
+    if (numOperands > 2) op3 = evalConstant(ce->getOperand(2));
+
+    switch (ce->getOpcode()) {
     default :
       ce->dump();
       llvm::cerr << "error: unknown ConstantExpr type\n"
                  << "opcode: " << ce->getOpcode() << "\n";
       abort();
 
-    case Instruction::Trunc: return ExtractExpr::createByteOff(op1, 
-							       0,
-							       Expr::getWidthForLLVMType(type));
-    case Instruction::ZExt:  return  ZExtExpr::create(op1, 
-                                                      Expr::getWidthForLLVMType(type));
-    case Instruction::SExt:  return  SExtExpr::create(op1, 
-                                                      Expr::getWidthForLLVMType(type));
-    case Instruction::Add:   return   AddExpr::create(op1, op2);
-    case Instruction::Sub:   return   SubExpr::create(op1, op2);
-    case Instruction::Mul:   return   MulExpr::create(op1, op2);
-    case Instruction::SDiv:  return  SDivExpr::create(op1, op2);
-    case Instruction::UDiv:  return  UDivExpr::create(op1, op2);
-    case Instruction::SRem:  return  SRemExpr::create(op1, op2);
-    case Instruction::URem:  return  URemExpr::create(op1, op2);
-    case Instruction::And:   return   AndExpr::create(op1, op2);
-    case Instruction::Or:    return    OrExpr::create(op1, op2);
-    case Instruction::Xor:   return   XorExpr::create(op1, op2);
-    case Instruction::Shl:   return   ShlExpr::create(op1, op2);
-    case Instruction::LShr:  return  LShrExpr::create(op1, op2);
-    case Instruction::AShr:  return  AShrExpr::create(op1, op2);
+    case Instruction::Trunc: 
+      return op1->Extract(0, Expr::getWidthForLLVMType(type));
+    case Instruction::ZExt:  return op1->ZExt(Expr::getWidthForLLVMType(type));
+    case Instruction::SExt:  return op1->SExt(Expr::getWidthForLLVMType(type));
+    case Instruction::Add:   return op1->Add(op2);
+    case Instruction::Sub:   return op1->Sub(op2);
+    case Instruction::Mul:   return op1->Mul(op2);
+    case Instruction::SDiv:  return op1->SDiv(op2);
+    case Instruction::UDiv:  return op1->UDiv(op2);
+    case Instruction::SRem:  return op1->SRem(op2);
+    case Instruction::URem:  return op1->URem(op2);
+    case Instruction::And:   return op1->And(op2);
+    case Instruction::Or:    return op1->Or(op2);
+    case Instruction::Xor:   return op1->Xor(op2);
+    case Instruction::Shl:   return op1->Shl(op2);
+    case Instruction::LShr:  return op1->LShr(op2);
+    case Instruction::AShr:  return op1->AShr(op2);
     case Instruction::BitCast:  return op1;
 
-    case Instruction::IntToPtr: {
-      return ZExtExpr::create(op1, Expr::getWidthForLLVMType(type));
-    } 
+    case Instruction::IntToPtr:
+      return op1->ZExt(Expr::getWidthForLLVMType(type));
+
+    case Instruction::PtrToInt:
+      return op1->ZExt(Expr::getWidthForLLVMType(type));
 
-    case Instruction::PtrToInt: {
-      return ZExtExpr::create(op1, Expr::getWidthForLLVMType(type));
-    }
-      
     case Instruction::GetElementPtr: {
-      ref<Expr> base = op1;
+      ref<ConstantExpr> base = op1;
 
       for (gep_type_iterator ii = gep_type_begin(ce), ie = gep_type_end(ce);
            ii != ie; ++ii) {
-        ref<Expr> addend = ConstantExpr::alloc(0, kMachinePointerType);
-        
+        ref<ConstantExpr> addend = ConstantExpr::alloc(0, Expr::Int32);
+
         if (const StructType *st = dyn_cast<StructType>(*ii)) {
           const StructLayout *sl = kmodule->targetData->getStructLayout(st);
           const ConstantInt *ci = cast<ConstantInt>(ii.getOperand());
-          
-          addend = Expr::createPointer(sl->getElementOffset((unsigned)
-                                                            ci->getZExtValue()));
+
+          addend = ConstantExpr::alloc(sl->getElementOffset((unsigned)
+                                                            ci->getZExtValue()),
+                                       Expr::Int32);
         } else {
           const SequentialType *st = cast<SequentialType>(*ii);
-          ref<Expr> index = evalConstant(cast<Constant>(ii.getOperand()));
-          unsigned elementSize = kmodule->targetData->getTypeStoreSize(st->getElementType());
-          
-          index = Expr::createCoerceToPointerType(index);
-          addend = MulExpr::create(index,
-                                   Expr::createPointer(elementSize));
+          ref<ConstantExpr> index = 
+            evalConstant(cast<Constant>(ii.getOperand()));
+          unsigned elementSize = 
+            kmodule->targetData->getTypeStoreSize(st->getElementType());
+
+          index = index->ZExt(Expr::Int32);
+          addend = index->Mul(ConstantExpr::alloc(elementSize, Expr::Int32));
         }
-        
-        base = AddExpr::create(base, addend);
+
+        base = base->Add(addend);
       }
-      
+
       return base;
     }
       
     case Instruction::ICmp: {
       switch(ce->getPredicate()) {
-        case ICmpInst::ICMP_EQ:  return  EqExpr::create(op1, op2);
-        case ICmpInst::ICMP_NE:  return  NeExpr::create(op1, op2);
-        case ICmpInst::ICMP_UGT: return UgtExpr::create(op1, op2);
-        case ICmpInst::ICMP_UGE: return UgeExpr::create(op1, op2);
-        case ICmpInst::ICMP_ULT: return UltExpr::create(op1, op2);
-        case ICmpInst::ICMP_ULE: return UleExpr::create(op1, op2);
-        case ICmpInst::ICMP_SGT: return SgtExpr::create(op1, op2);
-        case ICmpInst::ICMP_SGE: return SgeExpr::create(op1, op2);
-        case ICmpInst::ICMP_SLT: return SltExpr::create(op1, op2);
-        case ICmpInst::ICMP_SLE: return SleExpr::create(op1, op2);
-        default:
-          assert(0 && "unhandled ICmp predicate");
+      default: assert(0 && "unhandled ICmp predicate");
+      case ICmpInst::ICMP_EQ:  return op1->Eq(op2);
+      case ICmpInst::ICMP_NE:  return op1->Ne(op2);
+      case ICmpInst::ICMP_UGT: return op1->Ugt(op2);
+      case ICmpInst::ICMP_UGE: return op1->Uge(op2);
+      case ICmpInst::ICMP_ULT: return op1->Ult(op2);
+      case ICmpInst::ICMP_ULE: return op1->Ule(op2);
+      case ICmpInst::ICMP_SGT: return op1->Sgt(op2);
+      case ICmpInst::ICMP_SGE: return op1->Sge(op2);
+      case ICmpInst::ICMP_SLT: return op1->Slt(op2);
+      case ICmpInst::ICMP_SLE: return op1->Sle(op2);
       }
     }
-      
-    case Instruction::Select: {
-      return SelectExpr::create(op1, op2, op3);
-    }
+
+    case Instruction::Select:
+      return op1->isTrue() ? op2 : op3;
 
     case Instruction::FAdd:
     case Instruction::FSub:
@@ -144,7 +138,7 @@ Executor::evalConstantExpr(llvm::ConstantExpr *ce) {
     case Instruction::FPToSI:
     case Instruction::FCmp:
       assert(0 && "floating point ConstantExprs unsupported");
+    }
   }
-}
 
 }
generated by cgit-pink 1.4.1 (git 2.36.1) at 2024-11-26 02:33:36 +0000