Fix handling of undef integer values.

rellic/AST/ASTBuilder.cpp

@@ -162,7 +162,13 @@ clang::Expr *ASTBuilder::CreateNull() {
   return CreateCStyleCast(ctx.VoidPtrTy, lit);
 };
 
-clang::Expr *ASTBuilder::CreateUndef(clang::QualType type) {
+clang::Expr *ASTBuilder::CreateUndefInteger(clang::QualType type) {
+  auto val{llvm::APInt::getNullValue(ctx.getTypeSize(type))};
+  auto lit{CreateIntLit(val)};
+  return lit;
+};
+
+clang::Expr *ASTBuilder::CreateUndefPointer(clang::QualType type) {
   auto null{CreateNull()};
   auto cast{CreateCStyleCast(ctx.getPointerType(type), null)};
   return CreateDeref(cast);

rellic/AST/ASTBuilder.h

@@ -54,7 +54,8 @@ class ASTBuilder {
   };
   // Special values
   clang::Expr *CreateNull();
-  clang::Expr *CreateUndef(clang::QualType type);
+  clang::Expr *CreateUndefPointer(clang::QualType type);
+  clang::Expr *CreateUndefInteger(clang::QualType type);
   // Identifiers
   clang::IdentifierInfo *CreateIdentifier(std::string name);
   // Variable declaration

rellic/AST/IRToASTVisitor.cpp

@@ -150,19 +150,26 @@ clang::Expr *IRToASTVisitor::CreateLiteralExpr(llvm::Constant *constant) {
     } break;
     // Integers
     case llvm::Type::IntegerTyID: {
-      auto val{llvm::cast<llvm::ConstantInt>(constant)->getValue()};
-      if (val.getBitWidth() == 1U) {
-        result = ast.CreateIntLit(val);
+      if (llvm::isa<llvm::ConstantInt>(constant)) {
+        auto ci = llvm::cast<llvm::ConstantInt>(constant);
+        auto val{ci->getValue()};
+        if (val.getBitWidth() == 1U) {
+          result = ast.CreateIntLit(val);
+        } else {
+          result = ast.CreateAdjustedIntLit(val);
+        }
+      } else if (llvm::isa<llvm::UndefValue>(constant)) {
+        result = ast.CreateUndefInteger(c_type);
       } else {
-        result = ast.CreateAdjustedIntLit(val);
+        LOG(FATAL) << "Unsupported integer constant";
       }
     } break;
 
     case llvm::Type::PointerTyID: {
       if (llvm::isa<llvm::ConstantPointerNull>(constant)) {
         result = ast.CreateNull();
       } else if (llvm::isa<llvm::UndefValue>(constant)) {
-        result = ast.CreateUndef(c_type);
+        result = ast.CreateUndefPointer(c_type);
       } else {
         LOG(FATAL) << "Unsupported pointer constant";
       }

unittests/AST/ASTBuilder.cpp

@@ -267,7 +267,25 @@ TEST_SUITE("ASTBuilder::CreateNull") {
   }
 }
 
-TEST_SUITE("ASTBuilder::CreateUndef") {
+TEST_SUITE("ASTBuilder::CreateUndefInteger") {
+  SCENARIO("Create clang::Expr to stand in for an undefined integer") {
+    GIVEN("Empty clang::ASTContext") {
+      auto unit{GetASTUnit()};
+      auto &ctx{unit->getASTContext()};
+      rellic::ASTBuilder ast(*unit);
+      GIVEN("an unsigned integer type") {
+        auto type{ctx.UnsignedIntTy};
+        THEN("return a value that satisfied LLVM's undef semantics (aka anything)") {
+          auto expr{ast.CreateUndefInteger(type)};
+          REQUIRE(expr != nullptr);
+          CHECK(expr->getType() == ctx.UnsignedIntTy);
+        }
+      }
+    }
+  }
+}
+
+TEST_SUITE("ASTBuilder::CreateUndefPointer") {
   SCENARIO("Create clang::Expr whose value is undefined") {
     GIVEN("Empty clang::ASTContext") {
       auto unit{GetASTUnit()};
@@ -276,7 +294,7 @@ TEST_SUITE("ASTBuilder::CreateUndef") {
       GIVEN("an arbitrary type t") {
         auto type{ctx.DoubleTy};
         THEN("return a null pointer dereference of type t") {
-          auto expr{ast.CreateUndef(type)};
+          auto expr{ast.CreateUndefPointer(type)};
           REQUIRE(expr != nullptr);
           CHECK(expr->getType() == ctx.DoubleTy);
           auto deref{clang::dyn_cast<clang::UnaryOperator>(expr)};