Blob Blame History Raw
From fed7014be999f6437ebfd8a6465a76f459be0e1b Mon Sep 17 00:00:00 2001
From: Viktor Malik <viktor.malik@gmail.com>
Date: Mon, 10 Jan 2022 16:41:05 +0100
Subject: [PATCH 6/6] Fix LLVM 13 warnings

Since LLVM 13, CreateGEP and CreateLoad require explicit types.
---
 src/ast/codegen_llvm.cpp | 265 ++++++++++++++++++++++++---------------
 src/ast/irbuilderbpf.cpp |  56 +++++----
 2 files changed, 200 insertions(+), 121 deletions(-)

diff --git a/src/ast/codegen_llvm.cpp b/src/ast/codegen_llvm.cpp
index d30327a2..0bd23276 100644
--- a/src/ast/codegen_llvm.cpp
+++ b/src/ast/codegen_llvm.cpp
@@ -224,9 +224,10 @@ void CodegenLLVM::visit(Builtin &builtin)
     // LLVM optimization is possible to transform `(uint64*)ctx` into
     // `(uint8*)ctx`, but sometimes this causes invalid context access.
     // Mark every context acess to supporess any LLVM optimization.
-    expr_ = b_.CreateLoad(b_.getInt64Ty(),
-                          b_.CreateGEP(ctx, b_.getInt64(offset)),
-                          builtin.ident);
+    expr_ = b_.CreateLoad(
+	    b_.getInt64Ty(),
+	    b_.CreateGEP(b_.getInt64Ty(), ctx, b_.getInt64(offset)),
+	    builtin.ident);
     // LLVM 7.0 <= does not have CreateLoad(*Ty, *Ptr, isVolatile, Name),
     // so call setVolatile() manually
     dyn_cast<LoadInst>(expr_)->setVolatile(true);
@@ -249,16 +250,17 @@ void CodegenLLVM::visit(Builtin &builtin)
 
     int arg_num = atoi(builtin.ident.substr(4).c_str());
     Value *ctx = b_.CreatePointerCast(ctx_, b_.getInt64Ty()->getPointerTo());
-    Value *sp = b_.CreateLoad(b_.getInt64Ty(),
-                              b_.CreateGEP(ctx, b_.getInt64(sp_offset)),
-                              "reg_sp");
+    Value *sp = b_.CreateLoad(
+        b_.getInt64Ty(),
+        b_.CreateGEP(b_.getInt64Ty(), ctx, b_.getInt64(sp_offset)),
+        "reg_sp");
     dyn_cast<LoadInst>(sp)->setVolatile(true);
     AllocaInst *dst = b_.CreateAllocaBPF(builtin.type, builtin.ident);
     Value *src = b_.CreateAdd(sp,
                               b_.getInt64((arg_num + arch::arg_stack_offset()) *
                                           sizeof(uintptr_t)));
     b_.CreateProbeRead(ctx_, dst, 8, src, builtin.type.GetAS(), builtin.loc);
-    expr_ = b_.CreateLoad(dst);
+    expr_ = b_.CreateLoad(b_.GetType(builtin.type), dst);
     b_.CreateLifetimeEnd(dst);
   }
   else if (builtin.ident == "probe")
@@ -526,8 +528,12 @@ void CodegenLLVM::visit(Call &call)
     b_.CREATE_MEMSET(buf, b_.getInt8(0), bpftrace_.strlen_, 1);
     auto arg0 = call.vargs->front();
     auto scoped_del = accept(call.vargs->front());
-    b_.CreateProbeReadStr(
-        ctx_, buf, b_.CreateLoad(strlen), expr_, arg0->type.GetAS(), call.loc);
+    b_.CreateProbeReadStr(ctx_,
+                          buf,
+                          b_.CreateLoad(b_.getInt64Ty(), strlen),
+                          expr_,
+                          arg0->type.GetAS(),
+                          call.loc);
     b_.CreateLifetimeEnd(strlen);
 
     expr_ = buf;
@@ -569,12 +575,14 @@ void CodegenLLVM::visit(Call &call)
                                               false);
     AllocaInst *buf = b_.CreateAllocaBPF(buf_struct, "buffer");
 
-    Value *buf_len_offset = b_.CreateGEP(buf,
+    Value *buf_len_offset = b_.CreateGEP(buf_struct,
+                                         buf,
                                          { b_.getInt32(0), b_.getInt32(0) });
     length = b_.CreateIntCast(length, buf_struct->getElementType(0), false);
     b_.CreateStore(length, buf_len_offset);
 
-    Value *buf_data_offset = b_.CreateGEP(buf,
+    Value *buf_data_offset = b_.CreateGEP(buf_struct,
+                                          buf,
                                           { b_.getInt32(0), b_.getInt32(1) });
     b_.CREATE_MEMSET(buf_data_offset,
                      b_.GetIntSameSize(0, elements.at(0)),
@@ -664,14 +672,14 @@ void CodegenLLVM::visit(Call &call)
     b_.SetInsertPoint(notzero);
     b_.CreateStore(b_.getInt64(asyncactionint(AsyncAction::join)), perfdata);
     b_.CreateStore(b_.getInt64(join_id_),
-                   b_.CreateGEP(perfdata, b_.getInt64(8)));
+                   b_.CreateGEP(b_.getInt8Ty(), perfdata, b_.getInt64(8)));
     join_id_++;
     AllocaInst *arr = b_.CreateAllocaBPF(b_.getInt64Ty(), call.func + "_r0");
     b_.CreateProbeRead(ctx_, arr, 8, expr_, addrspace, call.loc);
     b_.CreateProbeReadStr(ctx_,
                           b_.CreateAdd(perfdata, b_.getInt64(8 + 8)),
                           bpftrace_.join_argsize_,
-                          b_.CreateLoad(arr),
+                          b_.CreateLoad(b_.getInt64Ty(), arr),
                           addrspace,
                           call.loc);
 
@@ -679,14 +687,18 @@ void CodegenLLVM::visit(Call &call)
     {
       // argi
       b_.CreateStore(b_.CreateAdd(expr_, b_.getInt64(8 * i)), first);
-      b_.CreateProbeRead(
-          ctx_, second, 8, b_.CreateLoad(first), addrspace, call.loc);
+      b_.CreateProbeRead(ctx_,
+                         second,
+                         8,
+                         b_.CreateLoad(b_.getInt64Ty(), first),
+                         addrspace,
+                         call.loc);
       b_.CreateProbeReadStr(
           ctx_,
           b_.CreateAdd(perfdata,
                        b_.getInt64(8 + 8 + i * bpftrace_.join_argsize_)),
           bpftrace_.join_argsize_,
-          b_.CreateLoad(second),
+          b_.CreateLoad(b_.getInt64Ty(), second),
           addrspace,
           call.loc);
     }
@@ -729,7 +741,9 @@ void CodegenLLVM::visit(Call &call)
 
     AllocaInst *buf = b_.CreateAllocaBPF(inet_struct, "inet");
 
-    Value *af_offset = b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(0) });
+    Value *af_offset = b_.CreateGEP(inet_struct,
+                                    buf,
+                                    { b_.getInt64(0), b_.getInt32(0) });
     Value *af_type;
 
     auto inet = call.vargs->at(0);
@@ -752,7 +766,9 @@ void CodegenLLVM::visit(Call &call)
     }
     b_.CreateStore(af_type, af_offset);
 
-    Value *inet_offset = b_.CreateGEP(buf, {b_.getInt32(0), b_.getInt32(1)});
+    Value *inet_offset = b_.CreateGEP(inet_struct,
+                                      buf,
+                                      { b_.getInt32(0), b_.getInt32(1) });
     b_.CREATE_MEMSET(inet_offset, b_.getInt8(0), 16, 1);
 
     auto scoped_del = accept(inet);
@@ -785,9 +801,10 @@ void CodegenLLVM::visit(Call &call)
     }
 
     Value *ctx = b_.CreatePointerCast(ctx_, b_.getInt64Ty()->getPointerTo());
-    expr_ = b_.CreateLoad(b_.getInt64Ty(),
-                          b_.CreateGEP(ctx, b_.getInt64(offset)),
-                          call.func + "_" + reg_name);
+    expr_ = b_.CreateLoad(
+        b_.getInt64Ty(),
+        b_.CreateGEP(b_.getInt64Ty(), ctx, b_.getInt64(offset)),
+        call.func + "_" + reg_name);
     dyn_cast<LoadInst>(expr_)->setVolatile(true);
   }
   else if (call.func == "printf")
@@ -812,8 +829,10 @@ void CodegenLLVM::visit(Call &call)
         auto scoped_del = accept(&arg);
 
         // and store it to data area
-        Value *offset = b_.CreateGEP(
-            data, { b_.getInt64(0), b_.getInt64((i - 1) * ptr_size) });
+        Value *offset = b_.CreateGEP(b_.GetType(data_type),
+                                     data,
+                                     { b_.getInt64(0),
+                                       b_.getInt64((i - 1) * ptr_size) });
         b_.CreateStore(expr_, offset);
 
         // keep the expression alive, so it's still there
@@ -901,7 +920,9 @@ void CodegenLLVM::visit(Call &call)
     AllocaInst *buf = b_.CreateAllocaBPF(event_struct,
                                          call.func + "_" + map.ident);
 
-    auto aa_ptr = b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(0) });
+    auto aa_ptr = b_.CreateGEP(event_struct,
+                               buf,
+                               { b_.getInt64(0), b_.getInt32(0) });
     if (call.func == "clear")
       b_.CreateStore(b_.GetIntSameSize(asyncactionint(AsyncAction::clear),
                                        elements.at(0)),
@@ -912,7 +933,9 @@ void CodegenLLVM::visit(Call &call)
                      aa_ptr);
 
     auto id = bpftrace_.maps[map.ident].value()->id;
-    auto *ident_ptr = b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(1) });
+    auto *ident_ptr = b_.CreateGEP(event_struct,
+                                   buf,
+                                   { b_.getInt64(0), b_.getInt32(1) });
     b_.CreateStore(b_.GetIntSameSize(id, elements.at(1)), ident_ptr);
 
     b_.CreatePerfEventOutput(ctx_, buf, getStructSize(event_struct));
@@ -928,12 +951,13 @@ void CodegenLLVM::visit(Call &call)
 
     AllocaInst *buf = b_.CreateAllocaBPF(time_struct, call.func + "_t");
 
-    b_.CreateStore(b_.GetIntSameSize(asyncactionint(AsyncAction::time),
-                                     elements.at(0)),
-                   b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(0) }));
+    b_.CreateStore(
+        b_.GetIntSameSize(asyncactionint(AsyncAction::time), elements.at(0)),
+        b_.CreateGEP(time_struct, buf, { b_.getInt64(0), b_.getInt32(0) }));
 
-    b_.CreateStore(b_.GetIntSameSize(time_id_, elements.at(1)),
-                   b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(1) }));
+    b_.CreateStore(
+        b_.GetIntSameSize(time_id_, elements.at(1)),
+        b_.CreateGEP(time_struct, buf, { b_.getInt64(0), b_.getInt32(1) }));
 
     time_id_++;
     b_.CreatePerfEventOutput(ctx_, buf, getStructSize(time_struct));
@@ -948,13 +972,15 @@ void CodegenLLVM::visit(Call &call)
                                                    true);
 
     AllocaInst *buf = b_.CreateAllocaBPF(strftime_struct, call.func + "_args");
-    b_.CreateStore(b_.GetIntSameSize(strftime_id_, elements.at(0)),
-                   b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(0) }));
+    b_.CreateStore(
+        b_.GetIntSameSize(strftime_id_, elements.at(0)),
+        b_.CreateGEP(strftime_struct, buf, { b_.getInt64(0), b_.getInt32(0) }));
     strftime_id_++;
     Expression *arg = call.vargs->at(1);
     auto scoped_del = accept(arg);
-    b_.CreateStore(expr_,
-                   b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(1) }));
+    b_.CreateStore(
+        expr_,
+        b_.CreateGEP(strftime_struct, buf, { b_.getInt64(0), b_.getInt32(1) }));
     expr_ = buf;
   }
   else if (call.func == "kstack" || call.func == "ustack")
@@ -1068,11 +1094,12 @@ void CodegenLLVM::visit(Call &call)
     AllocaInst *buf = b_.CreateAllocaBPF(unwatch_struct, "unwatch");
     size_t struct_size = datalayout().getTypeAllocSize(unwatch_struct);
 
-    b_.CreateStore(b_.getInt64(asyncactionint(AsyncAction::watchpoint_detach)),
-                   b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(0) }));
+    b_.CreateStore(
+        b_.getInt64(asyncactionint(AsyncAction::watchpoint_detach)),
+        b_.CreateGEP(unwatch_struct, buf, { b_.getInt64(0), b_.getInt32(0) }));
     b_.CreateStore(
         b_.CreateIntCast(expr_, b_.getInt64Ty(), false /* unsigned */),
-        b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(1) }));
+        b_.CreateGEP(unwatch_struct, buf, { b_.getInt64(0), b_.getInt32(1) }));
     b_.CreatePerfEventOutput(ctx_, buf, struct_size);
     b_.CreateLifetimeEnd(buf);
     expr_ = nullptr;
@@ -1102,7 +1129,8 @@ void CodegenLLVM::visit(Variable &var)
   }
   else
   {
-    expr_ = b_.CreateLoad(variables_[var.ident]);
+    auto *var_alloca = variables_[var.ident];
+    expr_ = b_.CreateLoad(var_alloca->getType()->getElementType(), var_alloca);
   }
 }
 
@@ -1379,13 +1407,15 @@ void CodegenLLVM::visit(Unop &unop)
           if (unop.is_post_op)
             expr_ = oldval;
           else
-            expr_ = b_.CreateLoad(newval);
+            expr_ = b_.CreateLoad(b_.GetType(map.type), newval);
           b_.CreateLifetimeEnd(newval);
         }
         else if (unop.expr->is_variable)
         {
           Variable &var = static_cast<Variable&>(*unop.expr);
-          Value *oldval = b_.CreateLoad(variables_[var.ident]);
+          Value *oldval = b_.CreateLoad(
+		  variables_[var.ident]->getType()->getElementType(),
+		  variables_[var.ident]);
           Value *newval;
           if (is_increment)
             newval = b_.CreateAdd(oldval, b_.getInt64(1));
@@ -1411,9 +1441,10 @@ void CodegenLLVM::visit(Unop &unop)
                                   : type.GetSize();
         auto as =  type.GetAS();
 
-        AllocaInst *dst = b_.CreateAllocaBPF(SizedType(type.type, size), "deref");
+	auto dst_type = SizedType(type.type, size);
+        AllocaInst *dst = b_.CreateAllocaBPF(dst_type, "deref");
         b_.CreateProbeRead(ctx_, dst, size, expr_, as, unop.loc);
-        expr_ = b_.CreateIntCast(b_.CreateLoad(dst),
+        expr_ = b_.CreateIntCast(b_.CreateLoad(b_.GetType(dst_type), dst),
                                  b_.getInt64Ty(),
                                  type.IsSigned());
         b_.CreateLifetimeEnd(dst);
@@ -1434,7 +1465,7 @@ void CodegenLLVM::visit(Unop &unop)
           int size = unop.type.IsIntegerTy() ? et->GetIntBitWidth() / 8 : 8;
           AllocaInst *dst = b_.CreateAllocaBPF(*et, "deref");
           b_.CreateProbeRead(ctx_, dst, size, expr_, type.GetAS(), unop.loc);
-          expr_ = b_.CreateIntCast(b_.CreateLoad(dst),
+          expr_ = b_.CreateIntCast(b_.CreateLoad(b_.GetType(*et), dst),
                                    b_.getInt64Ty(),
                                    unop.type.IsSigned());
           b_.CreateLifetimeEnd(dst);
@@ -1492,7 +1523,7 @@ void CodegenLLVM::visit(Ternary &ternary)
     b_.CreateBr(done);
 
     b_.SetInsertPoint(done);
-    expr_ = b_.CreateLoad(result);
+    expr_ = b_.CreateLoad(b_.GetType(ternary.type), result);
   }
   else if (ternary.type.IsStringTy())
   {
@@ -1549,7 +1580,8 @@ void CodegenLLVM::visit(FieldAccess &acc)
   }
   else if (type.IsTupleTy())
   {
-    Value *src = b_.CreateGEP(expr_,
+    Value *src = b_.CreateGEP(b_.GetType(type),
+                              expr_,
                               { b_.getInt32(0), b_.getInt32(acc.index) });
     SizedType &elem_type = type.GetFields()[acc.index].type;
 
@@ -1596,10 +1628,12 @@ void CodegenLLVM::visit(FieldAccess &acc)
       if (field.is_bitfield)
       {
         Value *raw;
+        auto field_type = b_.GetType(field.type);
         if (type.IsCtxAccess())
-          raw = b_.CreateLoad(
-              b_.CreateIntToPtr(src, b_.GetType(field.type)->getPointerTo()),
-              true);
+          raw = b_.CreateLoad(field_type,
+                              b_.CreateIntToPtr(src,
+                                                field_type->getPointerTo()),
+                              true);
         else
         {
           AllocaInst *dst = b_.CreateAllocaBPF(field.type,
@@ -1610,7 +1644,7 @@ void CodegenLLVM::visit(FieldAccess &acc)
           b_.CREATE_MEMSET(dst, b_.getInt8(0), field.type.GetSize(), 1);
           b_.CreateProbeRead(
               ctx_, dst, field.bitfield.read_bytes, src, type.GetAS(), acc.loc);
-          raw = b_.CreateLoad(dst);
+          raw = b_.CreateLoad(field_type, dst);
           b_.CreateLifetimeEnd(dst);
         }
         size_t rshiftbits;
@@ -1638,7 +1672,8 @@ void CodegenLLVM::visit(FieldAccess &acc)
         // offset which we add to the start of the tracepoint struct.
         expr_ = b_.CreateLoad(
             b_.getInt32Ty(),
-            b_.CreateGEP(b_.CreatePointerCast(ctx_,
+            b_.CreateGEP(b_.getInt32Ty(),
+                         b_.CreatePointerCast(ctx_,
                                               b_.getInt32Ty()->getPointerTo()),
                          b_.getInt64(field.offset / 4)));
         expr_ = b_.CreateIntCast(expr_, b_.getInt64Ty(), false);
@@ -1757,7 +1792,9 @@ void CodegenLLVM::visit(Tuple &tuple)
     Expression *elem = tuple.elems->at(i);
     auto scoped_del = accept(elem);
 
-    Value *dst = b_.CreateGEP(buf, { b_.getInt32(0), b_.getInt32(i) });
+    Value *dst = b_.CreateGEP(tuple_ty,
+                              buf,
+                              { b_.getInt32(0), b_.getInt32(i) });
 
     if (onStack(elem->type))
       b_.CREATE_MEMCPY(dst, expr_, elem->type.GetSize(), 1);
@@ -2357,6 +2394,7 @@ std::tuple<Value *, CodegenLLVM::ScopedExprDeleter> CodegenLLVM::getMapKey(
         size += expr->type.GetSize();
       }
       key = b_.CreateAllocaBPF(size, map.ident + "_key");
+      auto *key_type = ArrayType::get(b_.getInt8Ty(), size);
 
       int offset = 0;
       // Construct a map key in the stack
@@ -2364,7 +2402,8 @@ std::tuple<Value *, CodegenLLVM::ScopedExprDeleter> CodegenLLVM::getMapKey(
       {
         auto scoped_del = accept(expr);
         Value *offset_val = b_.CreateGEP(
-            key, { b_.getInt64(0), b_.getInt64(offset) });
+		key_type, key,
+		{ b_.getInt64(0), b_.getInt64(offset) });
 
         if (onStack(expr->type))
           b_.CREATE_MEMCPY(offset_val, expr_, expr->type.GetSize(), 1);
@@ -2417,18 +2456,19 @@ AllocaInst *CodegenLLVM::getHistMapKey(Map &map, Value *log2)
       size += expr->type.GetSize();
     }
     key = b_.CreateAllocaBPF(size, map.ident + "_key");
+    auto *key_type = ArrayType::get(b_.getInt8Ty(), size);
 
     int offset = 0;
     for (Expression *expr : *map.vargs) {
       auto scoped_del = accept(expr);
-      Value *offset_val = b_.CreateGEP(key, {b_.getInt64(0), b_.getInt64(offset)});
+      Value *offset_val = b_.CreateGEP(key_type, key, {b_.getInt64(0), b_.getInt64(offset)});
       if (shouldBeOnStackAlready(expr->type))
         b_.CREATE_MEMCPY(offset_val, expr_, expr->type.GetSize(), 1);
       else
         b_.CreateStore(expr_, offset_val);
       offset += expr->type.GetSize();
     }
-    Value *offset_val = b_.CreateGEP(key, {b_.getInt64(0), b_.getInt64(offset)});
+    Value *offset_val = b_.CreateGEP(key_type, key, {b_.getInt64(0), b_.getInt64(offset)});
     b_.CreateStore(log2, offset_val);
   }
   else
@@ -2475,7 +2515,7 @@ Value *CodegenLLVM::createLogicalAnd(Binop &binop)
   b_.CreateBr(merge_block);
 
   b_.SetInsertPoint(merge_block);
-  return b_.CreateLoad(result);
+  return b_.CreateLoad(b_.getInt64Ty(), result);
 }
 
 Value *CodegenLLVM::createLogicalOr(Binop &binop)
@@ -2514,7 +2554,7 @@ Value *CodegenLLVM::createLogicalOr(Binop &binop)
   b_.CreateBr(merge_block);
 
   b_.SetInsertPoint(merge_block);
-  return b_.CreateLoad(result);
+  return b_.CreateLoad(b_.getInt64Ty(), result);
 }
 
 Function *CodegenLLVM::createLog2Function()
@@ -2558,34 +2598,37 @@ Function *CodegenLLVM::createLog2Function()
   // test for less than zero
   BasicBlock *is_less_than_zero = BasicBlock::Create(module_->getContext(), "hist.is_less_than_zero", log2_func);
   BasicBlock *is_not_less_than_zero = BasicBlock::Create(module_->getContext(), "hist.is_not_less_than_zero", log2_func);
-  b_.CreateCondBr(b_.CreateICmpSLT(b_.CreateLoad(n_alloc), b_.getInt64(0)),
+  b_.CreateCondBr(b_.CreateICmpSLT(b_.CreateLoad(b_.getInt64Ty(), n_alloc),
+                                   b_.getInt64(0)),
                   is_less_than_zero,
                   is_not_less_than_zero);
   b_.SetInsertPoint(is_less_than_zero);
-  createRet(b_.CreateLoad(result));
+  createRet(b_.CreateLoad(b_.getInt64Ty(), result));
   b_.SetInsertPoint(is_not_less_than_zero);
 
   // test for equal to zero
   BasicBlock *is_zero = BasicBlock::Create(module_->getContext(), "hist.is_zero", log2_func);
   BasicBlock *is_not_zero = BasicBlock::Create(module_->getContext(), "hist.is_not_zero", log2_func);
-  b_.CreateCondBr(b_.CreateICmpEQ(b_.CreateLoad(n_alloc), b_.getInt64(0)),
+  b_.CreateCondBr(b_.CreateICmpEQ(b_.CreateLoad(b_.getInt64Ty(), n_alloc),
+                                  b_.getInt64(0)),
                   is_zero,
                   is_not_zero);
   b_.SetInsertPoint(is_zero);
   b_.CreateStore(b_.getInt64(1), result);
-  createRet(b_.CreateLoad(result));
+  createRet(b_.CreateLoad(b_.getInt64Ty(), result));
   b_.SetInsertPoint(is_not_zero);
 
   // power-of-2 index, offset by +2
   b_.CreateStore(b_.getInt64(2), result);
   for (int i = 4; i >= 0; i--)
   {
-    Value *n = b_.CreateLoad(n_alloc);
+    Value *n = b_.CreateLoad(b_.getInt64Ty(), n_alloc);
     Value *shift = b_.CreateShl(b_.CreateIntCast(b_.CreateICmpSGE(b_.CreateIntCast(n, b_.getInt64Ty(), false), b_.getInt64(1 << (1<<i))), b_.getInt64Ty(), false), i);
     b_.CreateStore(b_.CreateLShr(n, shift), n_alloc);
-    b_.CreateStore(b_.CreateAdd(b_.CreateLoad(result), shift), result);
+    b_.CreateStore(b_.CreateAdd(b_.CreateLoad(b_.getInt64Ty(), result), shift),
+                   result);
   }
-  createRet(b_.CreateLoad(result));
+  createRet(b_.CreateLoad(b_.getInt64Ty(), result));
   b_.restoreIP(ip);
   return module_->getFunction("log2");
 }
@@ -2635,8 +2678,8 @@ Function *CodegenLLVM::createLinearFunction()
 
   // algorithm
   {
-    Value *min = b_.CreateLoad(min_alloc);
-    Value *val = b_.CreateLoad(value_alloc);
+    Value *min = b_.CreateLoad(b_.getInt64Ty(), min_alloc);
+    Value *val = b_.CreateLoad(b_.getInt64Ty(), value_alloc);
     cmp = b_.CreateICmpSLT(val, min);
   }
   BasicBlock *lt_min = BasicBlock::Create(module_->getContext(), "lhist.lt_min", linear_func);
@@ -2648,8 +2691,8 @@ Function *CodegenLLVM::createLinearFunction()
 
   b_.SetInsertPoint(ge_min);
   {
-    Value *max = b_.CreateLoad(max_alloc);
-    Value *val = b_.CreateLoad(value_alloc);
+    Value *max = b_.CreateLoad(b_.getInt64Ty(), max_alloc);
+    Value *val = b_.CreateLoad(b_.getInt64Ty(), value_alloc);
     cmp = b_.CreateICmpSGT(val, max);
   }
   BasicBlock *le_max = BasicBlock::Create(module_->getContext(), "lhist.le_max", linear_func);
@@ -2658,22 +2701,22 @@ Function *CodegenLLVM::createLinearFunction()
 
   b_.SetInsertPoint(gt_max);
   {
-    Value *step = b_.CreateLoad(step_alloc);
-    Value *min = b_.CreateLoad(min_alloc);
-    Value *max = b_.CreateLoad(max_alloc);
+    Value *step = b_.CreateLoad(b_.getInt64Ty(), step_alloc);
+    Value *min = b_.CreateLoad(b_.getInt64Ty(), min_alloc);
+    Value *max = b_.CreateLoad(b_.getInt64Ty(), max_alloc);
     Value *div = b_.CreateUDiv(b_.CreateSub(max, min), step);
     b_.CreateStore(b_.CreateAdd(div, b_.getInt64(1)), result_alloc);
-    createRet(b_.CreateLoad(result_alloc));
+    createRet(b_.CreateLoad(b_.getInt64Ty(), result_alloc));
   }
 
   b_.SetInsertPoint(le_max);
   {
-    Value *step = b_.CreateLoad(step_alloc);
-    Value *min = b_.CreateLoad(min_alloc);
-    Value *val = b_.CreateLoad(value_alloc);
+    Value *step = b_.CreateLoad(b_.getInt64Ty(), step_alloc);
+    Value *min = b_.CreateLoad(b_.getInt64Ty(), min_alloc);
+    Value *val = b_.CreateLoad(b_.getInt64Ty(), value_alloc);
     Value *div3 = b_.CreateUDiv(b_.CreateSub(val, min), step);
     b_.CreateStore(b_.CreateAdd(div3, b_.getInt64(1)), result_alloc);
-    createRet(b_.CreateLoad(result_alloc));
+    createRet(b_.CreateLoad(b_.getInt64Ty(), result_alloc));
   }
 
   b_.restoreIP(ip);
@@ -2711,14 +2754,18 @@ void CodegenLLVM::createFormatStringCall(Call &call, int &id, CallArgs &call_arg
   // as the struct is not packed we need to memset it.
   b_.CREATE_MEMSET(fmt_args, b_.getInt8(0), struct_size, 1);
 
-  Value *id_offset = b_.CreateGEP(fmt_args, {b_.getInt32(0), b_.getInt32(0)});
+  Value *id_offset = b_.CreateGEP(fmt_struct,
+                                  fmt_args,
+                                  { b_.getInt32(0), b_.getInt32(0) });
   b_.CreateStore(b_.getInt64(id + asyncactionint(async_action)), id_offset);
 
   for (size_t i=1; i<call.vargs->size(); i++)
   {
     Expression &arg = *call.vargs->at(i);
     auto scoped_del = accept(&arg);
-    Value *offset = b_.CreateGEP(fmt_args, {b_.getInt32(0), b_.getInt32(i)});
+    Value *offset = b_.CreateGEP(fmt_struct,
+                                 fmt_args,
+                                 { b_.getInt32(0), b_.getInt32(i) });
     if (needMemcpy(arg.type))
       b_.CREATE_MEMCPY(offset, expr_, arg.type.GetSize(), 1);
     else if (arg.type.IsIntegerTy() && arg.type.GetSize() < 8)
@@ -2758,10 +2805,12 @@ void CodegenLLVM::generateWatchpointSetupProbe(
   // Pull out function argument
   Value *ctx = func->arg_begin();
   int offset = arch::arg_offset(arg_num);
-  Value *addr = b_.CreateLoad(
-      b_.getInt64Ty(),
-      b_.CreateGEP(ctx, b_.getInt64(offset * sizeof(uintptr_t))),
-      "arg" + std::to_string(arg_num));
+  Value *arg = b_.CreateGEP(b_.getInt8Ty(),
+                            ctx,
+                            b_.getInt64(offset * sizeof(uintptr_t)));
+  Value *addr = b_.CreateLoad(b_.getInt64Ty(),
+                              arg,
+                              "arg" + std::to_string(arg_num));
 
   // Tell userspace to setup the real watchpoint
   auto elements = AsyncEvent::Watchpoint().asLLVMType(b_);
@@ -2772,12 +2821,16 @@ void CodegenLLVM::generateWatchpointSetupProbe(
   size_t struct_size = datalayout().getTypeAllocSize(watchpoint_struct);
 
   // Fill in perf event struct
-  b_.CreateStore(b_.getInt64(asyncactionint(AsyncAction::watchpoint_attach)),
-                 b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(0) }));
-  b_.CreateStore(b_.getInt64(watchpoint_id_),
-                 b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(1) }));
+  b_.CreateStore(
+      b_.getInt64(asyncactionint(AsyncAction::watchpoint_attach)),
+      b_.CreateGEP(watchpoint_struct, buf, { b_.getInt64(0), b_.getInt32(0) }));
+  b_.CreateStore(
+      b_.getInt64(watchpoint_id_),
+      b_.CreateGEP(watchpoint_struct, buf, { b_.getInt64(0), b_.getInt32(1) }));
   watchpoint_id_++;
-  b_.CreateStore(addr, b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(2) }));
+  b_.CreateStore(
+      addr,
+      b_.CreateGEP(watchpoint_struct, buf, { b_.getInt64(0), b_.getInt32(2) }));
   b_.CreatePerfEventOutput(ctx, buf, struct_size);
   b_.CreateLifetimeEnd(buf);
 
@@ -2796,11 +2849,14 @@ void CodegenLLVM::createPrintMapCall(Call &call)
                                        call.func + "_" + map.ident);
 
   // store asyncactionid:
-  b_.CreateStore(b_.getInt64(asyncactionint(AsyncAction::print)),
-                 b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(0) }));
+  b_.CreateStore(
+      b_.getInt64(asyncactionint(AsyncAction::print)),
+      b_.CreateGEP(print_struct, buf, { b_.getInt64(0), b_.getInt32(0) }));
 
   auto id = bpftrace_.maps[map.ident].value()->id;
-  auto *ident_ptr = b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(1) });
+  auto *ident_ptr = b_.CreateGEP(print_struct,
+                                 buf,
+                                 { b_.getInt64(0), b_.getInt32(1) });
   b_.CreateStore(b_.GetIntSameSize(id, elements.at(1)), ident_ptr);
 
   // top, div
@@ -2812,14 +2868,16 @@ void CodegenLLVM::createPrintMapCall(Call &call)
     auto scoped_del = accept(call.vargs->at(arg_idx));
 
     b_.CreateStore(b_.CreateIntCast(expr_, elements.at(arg_idx), false),
-                   b_.CreateGEP(buf,
+                   b_.CreateGEP(print_struct,
+                                buf,
                                 { b_.getInt64(0), b_.getInt32(arg_idx + 1) }));
   }
 
   for (; arg_idx < 3; arg_idx++)
   {
     b_.CreateStore(b_.GetIntSameSize(0, elements.at(arg_idx)),
-                   b_.CreateGEP(buf,
+                   b_.CreateGEP(print_struct,
+                                buf,
                                 { b_.getInt64(0), b_.getInt32(arg_idx + 1) }));
   }
 
@@ -2844,15 +2902,19 @@ void CodegenLLVM::createPrintNonMapCall(Call &call, int &id)
   size_t struct_size = datalayout().getTypeAllocSize(print_struct);
 
   // Store asyncactionid:
-  b_.CreateStore(b_.getInt64(asyncactionint(AsyncAction::print_non_map)),
-                 b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(0) }));
+  b_.CreateStore(
+      b_.getInt64(asyncactionint(AsyncAction::print_non_map)),
+      b_.CreateGEP(print_struct, buf, { b_.getInt64(0), b_.getInt32(0) }));
 
   // Store print id
-  b_.CreateStore(b_.getInt64(id),
-                 b_.CreateGEP(buf, { b_.getInt64(0), b_.getInt32(1) }));
+  b_.CreateStore(
+      b_.getInt64(id),
+      b_.CreateGEP(print_struct, buf, { b_.getInt64(0), b_.getInt32(1) }));
 
   // Store content
-  Value *content_offset = b_.CreateGEP(buf, { b_.getInt32(0), b_.getInt32(2) });
+  Value *content_offset = b_.CreateGEP(print_struct,
+                                       buf,
+                                       { b_.getInt32(0), b_.getInt32(2) });
   b_.CREATE_MEMSET(content_offset, b_.getInt8(0), arg.type.GetSize(), 1);
   if (needMemcpy(arg.type))
   {
@@ -3023,7 +3085,9 @@ void CodegenLLVM::readDatastructElemFromStack(Value *src_data,
     src_data = b_.CreateIntToPtr(src_data,
                                  b_.GetType(data_type)->getPointerTo());
 
-  Value *src = b_.CreateGEP(src_data, { b_.getInt32(0), index });
+  Value *src = b_.CreateGEP(b_.GetType(data_type),
+                            src_data,
+                            { b_.getInt32(0), index });
 
   // It may happen that the result pointer type is not correct, in such case
   // do a typecast
@@ -3034,7 +3098,7 @@ void CodegenLLVM::readDatastructElemFromStack(Value *src_data,
   if (elem_type.IsIntegerTy() || elem_type.IsPtrTy())
   {
     // Load the correct type from src
-    expr_ = b_.CreateLoad(src, true);
+    expr_ = b_.CreateLoad(b_.GetType(elem_type), src, true);
   }
   else
   {
@@ -3101,7 +3165,8 @@ void CodegenLLVM::probereadDatastructElem(Value *src_data,
     // Read data onto stack
     if (data_type.IsCtxAccess())
     {
-      expr_ = b_.CreateLoad(b_.CreateIntToPtr(src, dst_type->getPointerTo()),
+      expr_ = b_.CreateLoad(dst_type,
+                            b_.CreateIntToPtr(src, dst_type->getPointerTo()),
                             true);
       expr_ = b_.CreateIntCast(expr_, b_.getInt64Ty(), elem_type.IsSigned());
 
@@ -3132,7 +3197,7 @@ void CodegenLLVM::probereadDatastructElem(Value *src_data,
       AllocaInst *dst = b_.CreateAllocaBPF(elem_type, temp_name);
       b_.CreateProbeRead(
           ctx_, dst, elem_type.GetSize(), src, data_type.GetAS(), loc);
-      expr_ = b_.CreateIntCast(b_.CreateLoad(dst),
+      expr_ = b_.CreateIntCast(b_.CreateLoad(b_.GetType(elem_type), dst),
                                b_.getInt64Ty(),
                                elem_type.IsSigned());
       b_.CreateLifetimeEnd(dst);
diff --git a/src/ast/irbuilderbpf.cpp b/src/ast/irbuilderbpf.cpp
index ab1464d3..59771e91 100644
--- a/src/ast/irbuilderbpf.cpp
+++ b/src/ast/irbuilderbpf.cpp
@@ -94,8 +94,8 @@ AllocaInst *IRBuilderBPF::CreateUSym(llvm::Value *val)
   Value *pid = CreateLShr(CreateGetPidTgid(), 32);
 
   // The extra 0 here ensures the type of addr_offset will be int64
-  Value *addr_offset = CreateGEP(buf, { getInt64(0), getInt32(0) });
-  Value *pid_offset = CreateGEP(buf, { getInt64(0), getInt32(1) });
+  Value *addr_offset = CreateGEP(usym_t, buf, { getInt64(0), getInt32(0) });
+  Value *pid_offset = CreateGEP(usym_t, buf, { getInt64(0), getInt32(1) });
 
   CreateStore(val, addr_offset);
   CreateStore(pid, pid_offset);
@@ -401,7 +401,8 @@ Value *IRBuilderBPF::CreateMapLookupElem(Value *ctx,
   if (needMemcpy(type))
     return value;
 
-  Value *ret = CreateLoad(value);
+  // value is a pointer to i64
+  Value *ret = CreateLoad(getInt64Ty(), value);
   CreateLifetimeEnd(value);
   return ret;
 }
@@ -621,7 +622,10 @@ Value *IRBuilderBPF::CreateUSDTReadArgument(Value *ctx,
     // bpftrace's args are internally represented as 64 bit integers. However,
     // the underlying argument (of the target program) may be less than 64
     // bits. So we must be careful to zero out unused bits.
-    Value* reg = CreateGEP(ctx, getInt64(offset * sizeof(uintptr_t)), "load_register");
+    Value *reg = CreateGEP(getInt8Ty(),
+                           ctx,
+                           getInt64(offset * sizeof(uintptr_t)),
+                           "load_register");
     AllocaInst *dst = CreateAllocaBPF(builtin.type, builtin.ident);
     Value *index_offset = nullptr;
     if (argument->valid & BCC_USDT_ARGUMENT_INDEX_REGISTER_NAME)
@@ -632,7 +636,8 @@ Value *IRBuilderBPF::CreateUSDTReadArgument(Value *ctx,
         LOG(FATAL) << "offset for register " << argument->index_register_name
                    << " not known";
       }
-      index_offset = CreateGEP(ctx,
+      index_offset = CreateGEP(getInt8Ty(),
+                               ctx,
                                getInt64(ioffset * sizeof(uintptr_t)),
                                "load_register");
       index_offset = CreateLoad(getInt64Ty(), index_offset);
@@ -754,7 +759,7 @@ Value *IRBuilderBPF::CreateStrncmp(Value *ctx __attribute__((unused)),
                                                "strcmp.loop",
                                                parent);
 
-      auto *ptr = CreateGEP(val, { getInt32(0), getInt32(i) });
+      auto *ptr = CreateGEP(valp->getElementType(), val, { getInt32(0), getInt32(i) });
       Value *l = CreateLoad(getInt8Ty(), ptr);
       Value *r = getInt8(c_str[i]);
       Value *cmp = CreateICmpNE(l, r, "strcmp.cmp");
@@ -767,7 +772,8 @@ Value *IRBuilderBPF::CreateStrncmp(Value *ctx __attribute__((unused)),
   CreateBr(str_ne);
 
   SetInsertPoint(str_ne);
-  Value *result = CreateLoad(store);
+  // store is a pointer to bool (i1 *)
+  Value *result = CreateLoad(getInt1Ty(), store);
   CreateLifetimeEnd(store);
   result = CreateIntCast(result, getInt64Ty(), false);
   return result;
@@ -817,9 +823,11 @@ Value *IRBuilderBPF::CreateStrncmp(Value *ctx,
      }
   */
 
+  auto *val1p = dyn_cast<PointerType>(val1->getType());
+  auto *val2p = dyn_cast<PointerType>(val2->getType());
 #ifndef NDEBUG
-  PointerType *val1p = cast<PointerType>(val1->getType());
-  PointerType *val2p = cast<PointerType>(val2->getType());
+  assert(val1p);
+  assert(val2p);
 
   assert(val1p->getElementType()->isArrayTy() &&
          val1p->getElementType()->getArrayElementType() == getInt8Ty());
@@ -852,11 +860,11 @@ Value *IRBuilderBPF::CreateStrncmp(Value *ctx,
                                                      "strcmp.loop_null_cmp",
                                                      parent);
 
-    auto *ptr1 = CreateGEP(val1, { getInt32(0), getInt32(i) });
+    auto *ptr1 = CreateGEP(val1p->getElementType(), val1, { getInt32(0), getInt32(i) });
     CreateProbeRead(ctx, val_l, 1, ptr1, as1, loc);
     Value *l = CreateLoad(getInt8Ty(), val_l);
 
-    auto *ptr2 = CreateGEP(val2, { getInt32(0), getInt32(i) });
+    auto *ptr2 = CreateGEP(val2p->getElementType(), val2, { getInt32(0), getInt32(i) });
     CreateProbeRead(ctx, val_r, 1, ptr2, as2, loc);
     Value *r = CreateLoad(getInt8Ty(), val_r);
 
@@ -878,7 +886,8 @@ Value *IRBuilderBPF::CreateStrncmp(Value *ctx,
   CreateBr(str_ne);
   SetInsertPoint(str_ne);
 
-  Value *result = CreateLoad(store);
+  // store is a pointer to bool (i1 *)
+  Value *result = CreateLoad(getInt1Ty(), store);
   CreateLifetimeEnd(store);
   CreateLifetimeEnd(val_l);
   CreateLifetimeEnd(val_r);
@@ -1107,7 +1116,7 @@ Value *IRBuilderBPF::CreatKFuncArg(Value *ctx,
 {
   ctx = CreatePointerCast(ctx, getInt64Ty()->getPointerTo());
   Value *expr = CreateLoad(getInt64Ty(),
-                           CreateGEP(ctx, getInt64(type.kfarg_idx)),
+                           CreateGEP(getInt64Ty(), ctx, getInt64(type.kfarg_idx)),
                            name);
 
   // LLVM 7.0 <= does not have CreateLoad(*Ty, *Ptr, isVolatile, Name),
@@ -1161,12 +1170,15 @@ void IRBuilderBPF::CreateHelperError(Value *ctx,
                                                   elements,
                                                   true);
   AllocaInst *buf = CreateAllocaBPF(helper_error_struct, "helper_error_t");
-  CreateStore(GetIntSameSize(asyncactionint(AsyncAction::helper_error),
-                             elements.at(0)),
-              CreateGEP(buf, { getInt64(0), getInt32(0) }));
-  CreateStore(GetIntSameSize(error_id, elements.at(1)),
-              CreateGEP(buf, { getInt64(0), getInt32(1) }));
-  CreateStore(return_value, CreateGEP(buf, { getInt64(0), getInt32(2) }));
+  CreateStore(
+      GetIntSameSize(asyncactionint(AsyncAction::helper_error), elements.at(0)),
+      CreateGEP(helper_error_struct, buf, { getInt64(0), getInt32(0) }));
+  CreateStore(
+      GetIntSameSize(error_id, elements.at(1)),
+      CreateGEP(helper_error_struct, buf, { getInt64(0), getInt32(1) }));
+  CreateStore(
+      return_value,
+      CreateGEP(helper_error_struct, buf, { getInt64(0), getInt32(2) }));
 
   auto &layout = module_.getDataLayout();
   auto struct_size = layout.getTypeAllocSize(helper_error_struct);
@@ -1256,11 +1268,13 @@ void IRBuilderBPF::CreateSeqPrintf(Value *ctx,
 
   ctx = CreatePointerCast(ctx, getInt8Ty()->getPointerTo());
   Value *meta = CreateLoad(getInt64Ty()->getPointerTo(),
-                           CreateGEP(ctx, getInt64(0)),
+                           CreateGEP(getInt8Ty(), ctx, getInt64(0)),
                            "meta");
   dyn_cast<LoadInst>(meta)->setVolatile(true);
 
-  Value *seq = CreateLoad(getInt64Ty(), CreateGEP(meta, getInt64(0)), "seq");
+  Value *seq = CreateLoad(getInt64Ty(),
+                          CreateGEP(getInt64Ty(), meta, getInt64(0)),
+                          "seq");
 
   CallInst *call = createCall(seq_printf_func,
                               { seq, fmt, fmt_size, data, data_len },
-- 
2.35.3