Rebase to bpftrace 0.13.1

- Rebase to bpftrace 0.13.1.
- Rebuild for LLVM14

Resolves: rhbz#2061052
Related: rhbz#2061764

Signed-off-by: Jerome Marchand <jmarchan@redhat.com>

.gitignore

@@ -9,3 +9,4 @@
 /bpftrace-0.10.0.tar.gz
 /bpftrace-0.11.0.tar.gz
 /bpftrace-0.12.1.tar.gz
+/bpftrace-0.13.1.tar.gz

bpftrace-0.12.1-Fix-single-arg-wildcard-listings.patch

@@ -1,72 +0,0 @@
-From b7fd0900b18c4b640926e0bb830464565a527ca1 Mon Sep 17 00:00:00 2001
-From: Daniel Xu <dxu@dxuuu.xyz>
-Date: Mon, 5 Apr 2021 14:35:08 -0700
-Subject: [PATCH] Fix single arg wildcard listings
-
-The docs say we can do stuff like
-
-  # bpftrace -l "*sleep*"
-
-so we should probably implement it. We probably regressed on this during
-the probe matching refactoring.
----
- src/ast/attachpoint_parser.cpp | 10 +++++++---
- tests/runtime/regression       |  6 ++++++
- 2 files changed, 13 insertions(+), 3 deletions(-)
-
-diff --git a/src/ast/attachpoint_parser.cpp b/src/ast/attachpoint_parser.cpp
-index cfac09bc..b62549d7 100644
---- a/src/ast/attachpoint_parser.cpp
-+++ b/src/ast/attachpoint_parser.cpp
-@@ -77,6 +77,9 @@ AttachPointParser::State AttachPointParser::parse_attachpoint(AttachPoint &ap)
-   std::set<std::string> probe_types;
-   if (has_wildcard(parts_.front()))
-   {
-+    // Single argument listing looks at all relevant probe types
-+    std::string probetype_query = (parts_.size() == 1) ? "*" : parts_.front();
-+
-     // Probe type expansion
-     // If PID is specified or the second part of the attach point is a path
-     // (contains '/'), use userspace probe types.
-@@ -85,12 +88,12 @@ AttachPointParser::State AttachPointParser::parse_attachpoint(AttachPoint &ap)
-         (parts_.size() >= 2 && parts_[1].find('/') != std::string::npos))
-     {
-       probe_types = bpftrace_.probe_matcher_->expand_probetype_userspace(
--          parts_.front());
-+          probetype_query);
-     }
-     else
-     {
-       probe_types = bpftrace_.probe_matcher_->expand_probetype_kernel(
--          parts_.front());
-+          probetype_query);
-     }
-   }
-   else
-@@ -111,7 +114,8 @@ AttachPointParser::State AttachPointParser::parse_attachpoint(AttachPoint &ap)
-     for (const auto &probe_type : probe_types)
-     {
-       std::string raw_input = ap.raw_input;
--      erase_prefix(raw_input);
-+      if (parts_.size() > 1)
-+        erase_prefix(raw_input);
-       raw_input = probe_type + ":" + raw_input;
-       // New attach points have ignore_invalid set to true - probe types for
-       // which raw_input has invalid number of parts will be ignored (instead
-diff --git a/tests/runtime/regression b/tests/runtime/regression
-index 7f40ffdb..b7fa4653 100644
---- a/tests/runtime/regression
-+++ b/tests/runtime/regression
-@@ -33,3 +33,9 @@ NAME c_array_indexing
- RUN bpftrace -v -e 'struct Foo { int a; uint8_t b[10]; } uprobe:testprogs/uprobe_test:function2 { $foo = (struct Foo *)arg0; printf("%c %c %c %c %c\n", $foo->b[0], $foo->b[1], $foo->b[2], $foo->b[3], $foo->b[4]) }' -c ./testprogs/uprobe_test
- EXPECT h e l l o
- TIMEOUT 5
-+
-+# https://github.com/iovisor/bpftrace/issues/1773
-+NAME single_arg_wildcard_listing
-+RUN bpftrace -l "*do_nanosleep*"
-+EXPECT kprobe:do_nanosleep
-+TIMEOUT 1
--- 
-2.34.1
-

bpftrace-0.13.1-Fix-LLVM-13-warnings.patch

@@ -0,0 +1,834 @@
+From 291cb44a513049e94b8de80f58fa7f08d3491aea 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 8/8] 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
+

bpftrace-0.13.1-Fix-compile-under-llvm14-trunk.patch

@@ -0,0 +1,42 @@
+From aee721b9b5ed72c287b302df20ea0fffc3cd72bd Mon Sep 17 00:00:00 2001
+From: Yucong Sun <sunyucong@gmail.com>
+Date: Thu, 21 Oct 2021 14:43:38 -0700
+Subject: [PATCH 7/7] Fix compile under llvm14 (trunk)
+
+---
+ CMakeLists.txt | 2 +-
+ src/bpforc.h   | 4 ++++
+ 2 files changed, 5 insertions(+), 1 deletion(-)
+
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 3beeb027..3cfae6cb 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -159,7 +159,7 @@ else()
+     find_package(LLVM REQUIRED)
+   endif()
+ 
+-  if((${LLVM_VERSION_MAJOR} VERSION_LESS 6) OR (${LLVM_VERSION_MAJOR} VERSION_GREATER 12))
++  if((${LLVM_VERSION_MAJOR} VERSION_LESS 6) OR (${LLVM_VERSION_MAJOR} VERSION_GREATER 14))
+     message(SEND_ERROR "Unsupported LLVM version found: ${LLVM_INCLUDE_DIRS}")
+     message(SEND_ERROR "Specify an LLVM major version using LLVM_REQUESTED_VERSION=<major version>")
+   endif()
+diff --git a/src/bpforc.h b/src/bpforc.h
+index cc6a1c97..a0e5c9b8 100644
+--- a/src/bpforc.h
++++ b/src/bpforc.h
+@@ -14,7 +14,11 @@
+ #include <llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h>
+ #include <llvm/ExecutionEngine/SectionMemoryManager.h>
+ #include <llvm/Support/Error.h>
++#if LLVM_VERSION_MAJOR < 14
+ #include <llvm/Support/TargetRegistry.h>
++#else
++#include <llvm/MC/TargetRegistry.h>
++#endif
+ #include <llvm/Target/TargetMachine.h>
+ 
+ #ifdef LLVM_ORC_V2
+-- 
+2.35.3
+

bpftrace-0.13.1-Fix-libbtf-0.6.0-build.patch

@@ -0,0 +1,39 @@
+From d26accaba6f911cf82be7e9791bf6440213c5627 Mon Sep 17 00:00:00 2001
+From: Jerome Marchand <jmarchan@redhat.com>
+Date: Wed, 23 Mar 2022 09:47:25 +0100
+Subject: [PATCH 4/6] Fix libbtf 0.6.0 build
+
+Libbtf 0.6.0 introduced a new version of btf_dump__new(). The new
+version is btf_dump__new_v0_6_0() while the old version was renamed
+btf_dump__new_deprecated(). btf_dump__new() is now overloaded,
+unfortunately the macro doesn't work on cpp, at least with LLVM 12.
+Let's call btf_dump__new_deprecated() explicitely when it's defined.
+
+Signed-off-by: Jerome Marchand <jmarchan@redhat.com>
+---
+ src/btf.cpp | 9 +++++++++
+ 1 file changed, 9 insertions(+)
+
+diff --git a/src/btf.cpp b/src/btf.cpp
+index a5a5e2c0..fccf0a00 100644
+--- a/src/btf.cpp
++++ b/src/btf.cpp
+@@ -24,6 +24,15 @@
+ #pragma GCC diagnostic pop
+ #include <bpf/libbpf.h>
+ 
++/*
++ * Since libbtf 0.6, btf_dump__new() has been overloaded and now can design
++ * either btf_dump__new_v0_6_0() or btf_dump__new_deprecated(), which is the
++ * same as btf_dump__new() for libbtf < 0.6, and the one we still use.
++ */
++#if LIBBPF_MAJOR_VERSION == 0 && LIBBPF_MINOR_VERSION >= 6
++#define btf_dump__new(a1, a2, a3, a4) btf_dump__new_deprecated(a1, a2, a3, a4)
++#endif
++
+ #include "bpftrace.h"
+ 
+ namespace bpftrace {
+-- 
+2.35.3
+

bpftrace-0.13.1-Fix-mdflush.patch

@@ -1,11 +1,13 @@
-From 7453a97005fda29f0b7be8f257736a19d7c13dbe Mon Sep 17 00:00:00 2001
+From 0585b27f6070c0d4016ae9b0d6e1a28261f2e2d2 Mon Sep 17 00:00:00 2001
 From: Jerome Marchand <jmarchan@redhat.com>
 Date: Fri, 15 Oct 2021 14:26:28 +0200
-Subject: [PATCH] Fix mdflush
+Subject: [PATCH 2/6] Fix mdflush
 
 Since kernel commit 309dca309fc ("block: store a block_device pointer
 in struct bio") struct bio points again to a block_device and not to a
 gendisk directly.
+
+Signed-off-by: Jerome Marchand <jmarchan@redhat.com>
 ---
  tools/mdflush.bt | 2 +-
  1 file changed, 1 insertion(+), 1 deletion(-)
@@ -22,5 +24,5 @@ index e767b81d..541abba1 100755
 +	    ((struct bio *)arg1)->bi_bdev->bd_disk->disk_name);
  }
 -- 
-2.31.1
+2.35.3
 

bpftrace-0.13.1-RHEL-9-fixes.patch

@@ -1,10 +1,12 @@
-From 453e1ea9b9d036cc9cfa0ef2e20c53e926e1b3b8 Mon Sep 17 00:00:00 2001
+From 4d7c2c148f7fb788d74e6cd3b6d65c07a815b0c1 Mon Sep 17 00:00:00 2001
 From: Jerome Marchand <jmarchan@redhat.com>
 Date: Tue, 11 Jun 2019 16:41:59 +0200
-Subject: [PATCH] RHEL 9 fixes
+Subject: [PATCH 1/6] RHEL 9 fixes
 
 Fixes the following RHEL 8 specific issues:
  - library path in gethostlatency and threadsnoop
+
+Signed-off-by: Jerome Marchand <jmarchan@redhat.com>
 ---
  tools/gethostlatency.bt | 12 ++++++------
  tools/threadsnoop.bt    |  2 +-
@@ -39,7 +41,7 @@ index 9f4ec31e..dd389c6f 100755
  {
  	$latms = (nsecs - @start[tid]) / 1e6;
 diff --git a/tools/threadsnoop.bt b/tools/threadsnoop.bt
-index 3824bc6d..bdc6e4df 100755
+index 3824bc6d..ab52bc48 100755
 --- a/tools/threadsnoop.bt
 +++ b/tools/threadsnoop.bt
 @@ -18,7 +18,7 @@ BEGIN
@@ -52,5 +54,5 @@ index 3824bc6d..bdc6e4df 100755
  	printf("%-10u %-6d %-16s %s\n", elapsed / 1e6, pid, comm,
  	    usym(arg2));
 -- 
-2.31.1
+2.35.3
 

bpftrace-0.13.1-RHEL-aarch64-fixes-statsnoop-and-opensnoop.patch

@@ -1,7 +1,7 @@
-From 69f6d7ff04f43451eea2fb028a84a76331bbf6ea Mon Sep 17 00:00:00 2001
+From b23980e4f6ed33d98f4f09ef25ae17baca215cce Mon Sep 17 00:00:00 2001
 From: Jerome Marchand <jmarchan@redhat.com>
 Date: Thu, 11 Jun 2020 14:56:36 +0200
-Subject: [PATCH] RHEL-8: aarch64: fixes statsnoop and opensnoop
+Subject: [PATCH 6/6] RHEL: aarch64: fixes statsnoop and opensnoop
 
 On aarch64 the open syscall has been dropped. Only openat remains,
 wich is called by libc open() function.
@@ -12,6 +12,8 @@ instance, new(l)stat are missing from aarch64.
 
 The only way I can think of fixing thess is RHEL-8 only arch specific
 patches.
+
+Signed-off-by: Jerome Marchand <jmarchan@redhat.com>
 ---
  tools/opensnoop.bt | 2 --
  tools/statsnoop.bt | 8 ++------
@@ -60,5 +62,5 @@ index b2d529e2..f612ea94 100755
  {
  	$ret = args->ret;
 -- 
-2.30.2
+2.35.3
 

bpftrace-0.13.1-Update-bio-tools-to-work-on-kernel-5.16.patch

@@ -1,84 +1,78 @@
-From 617bb8501c091be2501b3abe4dad47804d5a4278 Mon Sep 17 00:00:00 2001
+From ff22437ef4310a2ab37d732bdd1496a926315691 Mon Sep 17 00:00:00 2001
 From: Viktor Malik <viktor.malik@gmail.com>
 Date: Mon, 17 Jan 2022 11:15:26 +0100
-Subject: [PATCH] Update bio* tools to work on RHEL9
+Subject: [PATCH 5/6] Update bio* tools to work on kernel 5.16+
 
-Kernel commit:
-    9e6c144e5fee block: inline hot paths of blk_account_io_*()
-renamed some functions used in the tools.
+Kernel 5.16 contains commit:
 
-Kernel commit:
-    5f8d3bf600d2 block: move struct request to blk-mq.h
-moved "struct request" to a different header.
+    https://github.com/torvalds/linux/commit/be6bfe36db1795babe9d92178a47b2e02193cb0f
 
-This fixes both issues.
+which renamed some of the functions that the bio* tools attach to.
 ---
- tools/biolatency.bt | 4 ++--
- tools/biosnoop.bt   | 6 +++---
- tools/biostacks.bt  | 2 +-
- 3 files changed, 6 insertions(+), 6 deletions(-)
+ tools/biolatency.bt | 6 ++++--
+ tools/biosnoop.bt   | 6 ++++--
+ tools/biostacks.bt  | 3 ++-
+ 3 files changed, 10 insertions(+), 5 deletions(-)
 
 diff --git a/tools/biolatency.bt b/tools/biolatency.bt
-index 4ea910b4..8fb0490d 100755
+index 4ea910b4..d5af1f29 100755
 --- a/tools/biolatency.bt
 +++ b/tools/biolatency.bt
-@@ -16,12 +16,12 @@ BEGIN
+@@ -16,12 +16,14 @@ BEGIN
  	printf("Tracing block device I/O... Hit Ctrl-C to end.\n");
  }
  
 -kprobe:blk_account_io_start
++kprobe:blk_account_io_start,
 +kprobe:__blk_account_io_start
  {
  	@start[arg0] = nsecs;
  }
  
 -kprobe:blk_account_io_done
++kprobe:blk_account_io_done,
 +kprobe:__blk_account_io_done
  /@start[arg0]/
  {
  	@usecs = hist((nsecs - @start[arg0]) / 1000);
 diff --git a/tools/biosnoop.bt b/tools/biosnoop.bt
-index 38ffeb52..6519054c 100755
+index 38ffeb52..aa88f4ba 100755
 --- a/tools/biosnoop.bt
 +++ b/tools/biosnoop.bt
-@@ -1,5 +1,5 @@
- #!/usr/bin/env bpftrace
--#include <linux/blkdev.h>
-+#include <linux/blk-mq.h>
- /*
-  * biosnoop.bt   Block I/O tracing tool, showing per I/O latency.
-  *               For Linux, uses bpftrace, eBPF.
-@@ -16,7 +16,7 @@ BEGIN
+@@ -16,7 +16,8 @@ BEGIN
  	printf("%-12s %-7s %-16s %-6s %7s\n", "TIME(ms)", "DISK", "COMM", "PID", "LAT(ms)");
  }
  
 -kprobe:blk_account_io_start
++kprobe:blk_account_io_start,
 +kprobe:__blk_account_io_start
  {
  	@start[arg0] = nsecs;
  	@iopid[arg0] = pid;
-@@ -24,7 +24,7 @@ kprobe:blk_account_io_start
+@@ -24,7 +25,8 @@ kprobe:blk_account_io_start
  	@disk[arg0] = ((struct request *)arg0)->rq_disk->disk_name;
  }
  
 -kprobe:blk_account_io_done
++kprobe:blk_account_io_done,
 +kprobe:__blk_account_io_done
  /@start[arg0] != 0 && @iopid[arg0] != 0 && @iocomm[arg0] != ""/
  
  {
 diff --git a/tools/biostacks.bt b/tools/biostacks.bt
-index 58201cdf..fdd2efed 100755
+index 58201cdf..1bc9f819 100755
 --- a/tools/biostacks.bt
 +++ b/tools/biostacks.bt
-@@ -18,7 +18,7 @@ BEGIN
+@@ -18,7 +18,8 @@ BEGIN
  	printf("Tracing block I/O with init stacks. Hit Ctrl-C to end.\n");
  }
  
 -kprobe:blk_account_io_start
++kprobe:blk_account_io_start,
 +kprobe:__blk_account_io_start
  {
  	@reqstack[arg0] = kstack;
  	@reqts[arg0] = nsecs;
 -- 
-2.34.1
+2.35.3
 

bpftrace-0.13.1-biosnoop.bt-handle-Linux-5.17-block-layer-update.patch

@@ -0,0 +1,98 @@
+From bcb8903067ce7a45b67ad0d5cabf83154b56d5ab Mon Sep 17 00:00:00 2001
+From: Viktor Malik <viktor.malik@gmail.com>
+Date: Mon, 9 May 2022 07:58:46 +0200
+Subject: [PATCH 10/10] biosnoop.bt: handle Linux 5.17 block layer update
+
+The kernel upstream commit:
+
+    https://github.com/torvalds/linux/commit/f3fa33acca9f0058157214800f68b10d8e71ab7a
+
+has removed the `rq_disk` field from `struct request`. Instead,
+`->q->disk` should be used, so this is reflected in biosnoop.bt.
+
+The old version of the tool (suitable for kernel <= 5.16) is backed up
+in tools/old and used in the CI.
+---
+ tools/biosnoop.bt     |  2 +-
+ tools/old/biosnoop.bt | 56 +++++++++++++++++++++++++++++++++++++++++++
+ 2 files changed, 57 insertions(+), 1 deletion(-)
+ create mode 100755 tools/old/biosnoop.bt
+
+diff --git a/tools/biosnoop.bt b/tools/biosnoop.bt
+index 33ad75de..c00ef428 100755
+--- a/tools/biosnoop.bt
++++ b/tools/biosnoop.bt
+@@ -25,7 +25,7 @@ kprobe:__blk_account_io_start
+ 	@start[arg0] = nsecs;
+ 	@iopid[arg0] = pid;
+ 	@iocomm[arg0] = comm;
+-	@disk[arg0] = ((struct request *)arg0)->rq_disk->disk_name;
++	@disk[arg0] = ((struct request *)arg0)->q->disk->disk_name;
+ }
+ 
+ kprobe:blk_account_io_done,
+diff --git a/tools/old/biosnoop.bt b/tools/old/biosnoop.bt
+new file mode 100755
+index 00000000..1a99643a
+--- /dev/null
++++ b/tools/old/biosnoop.bt
+@@ -0,0 +1,56 @@
++#!/usr/bin/env bpftrace
++/*
++ * biosnoop.bt   Block I/O tracing tool, showing per I/O latency.
++ *               For Linux, uses bpftrace, eBPF.
++ *
++ * TODO: switch to block tracepoints. Add offset and size columns.
++ *
++ * This is a bpftrace version of the bcc tool of the same name.
++ *
++ * For Linux <= 5.16.
++ *
++ * 15-Nov-2017	Brendan Gregg	Created this.
++ */
++
++#ifndef BPFTRACE_HAVE_BTF
++#include <linux/blkdev.h>
++#include <linux/blk-mq.h>
++#endif
++
++BEGIN
++{
++	printf("%-12s %-7s %-16s %-6s %7s\n", "TIME(ms)", "DISK", "COMM", "PID", "LAT(ms)");
++}
++
++kprobe:blk_account_io_start,
++kprobe:__blk_account_io_start
++{
++	@start[arg0] = nsecs;
++	@iopid[arg0] = pid;
++	@iocomm[arg0] = comm;
++	@disk[arg0] = ((struct request *)arg0)->rq_disk->disk_name;
++}
++
++kprobe:blk_account_io_done,
++kprobe:__blk_account_io_done
++/@start[arg0] != 0 && @iopid[arg0] != 0 && @iocomm[arg0] != ""/
++
++{
++	$now = nsecs;
++	printf("%-12u %-7s %-16s %-6d %7d\n",
++	    elapsed / 1e6, @disk[arg0], @iocomm[arg0], @iopid[arg0],
++	    ($now - @start[arg0]) / 1e6);
++
++	delete(@start[arg0]);
++	delete(@iopid[arg0]);
++	delete(@iocomm[arg0]);
++	delete(@disk[arg0]);
++}
++
++END
++{
++	clear(@start);
++	clear(@iopid);
++	clear(@iocomm);
++	clear(@disk);
++}
+-- 
+2.35.3
+

bpftrace-0.13.1-orc-Fix-build-with-clang-13.patch

@@ -1,7 +1,7 @@
-From ddbd909505ed0530f0e4dec45c195e0cb315d516 Mon Sep 17 00:00:00 2001
+From f562f8fae4bdb8ac51fc815b725bfaada2371b31 Mon Sep 17 00:00:00 2001
 From: Khem Raj <raj.khem@gmail.com>
 Date: Sat, 4 Sep 2021 17:28:17 -0700
-Subject: [PATCH] orc: Fix build with clang >= 13
+Subject: [PATCH 3/6] orc: Fix build with clang >= 13
 
 Fixes errors like
 src/ast/bpforc/bpforcv2.cpp:3:9: error: constructor for 'bpftrace::BpfOrc' must explicitly initialize the member 'ES' which does not have a default constructor
@@ -17,7 +17,7 @@ Signed-off-by: Khem Raj <raj.khem@gmail.com>
  2 files changed, 37 insertions(+), 9 deletions(-)
 
 diff --git a/src/bpforc.h b/src/bpforc.h
-index 5634c544..1900e497 100644
+index c333a651..cc6a1c97 100644
 --- a/src/bpforc.h
 +++ b/src/bpforc.h
 @@ -20,6 +20,9 @@
@@ -30,7 +30,7 @@ index 5634c544..1900e497 100644
  #endif
  
  #include <optional>
-@@ -66,8 +69,12 @@ class BpfOrc
+@@ -71,8 +74,12 @@ class BpfOrc
    std::unique_ptr<TargetMachine> TM;
    DataLayout DL;
  #if LLVM_VERSION_MAJOR >= 7
@@ -43,7 +43,7 @@ index 5634c544..1900e497 100644
  #if LLVM_VERSION_MAJOR >= 7 && LLVM_VERSION_MAJOR < 12
    std::shared_ptr<SymbolResolver> Resolver;
  #endif
-@@ -92,7 +99,21 @@ class BpfOrc
+@@ -97,7 +104,21 @@ class BpfOrc
  #endif
  
  public:
@@ -65,7 +65,7 @@ index 5634c544..1900e497 100644
    void compile(std::unique_ptr<Module> M);
  
    /* Helper for creating a orc object, responsible for creating internal objects
-@@ -125,7 +146,7 @@ class BpfOrc
+@@ -130,7 +151,7 @@ class BpfOrc
  #ifdef LLVM_ORC_V2
    Expected<JITEvaluatedSymbol> lookup(StringRef Name)
    {
@@ -75,10 +75,10 @@ index 5634c544..1900e497 100644
  #endif
  };
 diff --git a/src/bpforcv2.cpp b/src/bpforcv2.cpp
-index 209e08e5..104213b0 100644
+index 9876625b..3e6684e4 100644
 --- a/src/bpforcv2.cpp
 +++ b/src/bpforcv2.cpp
-@@ -1,24 +1,26 @@
+@@ -1,21 +1,23 @@
  // Included by bpforc.cpp
  
 -BpfOrc::BpfOrc(TargetMachine *TM, DataLayout DL)
@@ -103,15 +103,12 @@ index 209e08e5..104213b0 100644
 -      MainJD(cantFail(ES.createJITDylib("<main>")))
 +      MainJD(cantFail(this->ES->createJITDylib("<main>")))
  {
-   MainJD.addGenerator(
-       cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(
-           DL.getGlobalPrefix())));
  }
 -
  LLVMContext &BpfOrc::getContext()
  {
    return *CTX.getContext();
-@@ -37,8 +39,13 @@ std::unique_ptr<BpfOrc> BpfOrc::Create()
+@@ -34,8 +36,13 @@ std::unique_ptr<BpfOrc> BpfOrc::Create()
    // return unique_ptrs
    auto DL = cantFail(JTMB.getDefaultDataLayoutForTarget());
    auto TM = cantFail(JTMB.createTargetMachine());
@@ -128,5 +125,5 @@ index 209e08e5..104213b0 100644
  
  void BpfOrc::compile(std::unique_ptr<Module> M)
 -- 
-2.31.1
+2.35.3
 

bpftrace-0.13.1-tools-Make-tools-rely-on-BTF-instead-of-header-files.patch

@@ -0,0 +1,285 @@
+From 9c9ac55573ac33abbbbad256eda08dafba18bf9f Mon Sep 17 00:00:00 2001
+From: Jerome Marchand <jmarchan@redhat.com>
+Date: Thu, 29 Apr 2021 12:03:28 +0200
+Subject: [PATCH 9/9] tools: Make tools rely on BTF instead of header files.
+
+Many distribution already ship BTF and this is more robust that
+parsing header files.
+
+Fixes #1820
+---
+ docs/reference_guide.md | 3 ++-
+ src/clang_parser.cpp    | 4 ++++
+ tools/biosnoop.bt       | 5 ++++-
+ tools/dcsnoop.bt        | 2 ++
+ tools/mdflush.bt        | 2 ++
+ tools/naptime.bt        | 2 ++
+ tools/oomkill.bt        | 2 ++
+ tools/runqlen.bt        | 6 ++++--
+ tools/tcpaccept.bt      | 4 ++++
+ tools/tcpconnect.bt     | 4 ++++
+ tools/tcpdrop.bt        | 4 ++++
+ tools/tcplife.bt        | 4 ++++
+ tools/tcpretrans.bt     | 4 ++++
+ tools/tcpsynbl.bt       | 2 ++
+ 14 files changed, 44 insertions(+), 4 deletions(-)
+
+diff --git a/docs/reference_guide.md b/docs/reference_guide.md
+index 69a8ed22..11a685de 100644
+--- a/docs/reference_guide.md
++++ b/docs/reference_guide.md
+@@ -3455,7 +3455,8 @@ Attaching 1 probe...
+ # BTF Support
+ 
+ If kernel has BTF, kernel types are automatically available and there is no need to include additional headers
+-to use them.
++to use them. To allow users to detect this situation in scripts, the preprocessor macro `BPFTRACE_HAVE_BTF` 
++is defined if BTF is detected. See tools/ for examples of its usage.
+ 
+ Requirements for using BTF:
+ 
+diff --git a/src/clang_parser.cpp b/src/clang_parser.cpp
+index 20269a71..7fb39949 100644
+--- a/src/clang_parser.cpp
++++ b/src/clang_parser.cpp
+@@ -747,6 +747,9 @@ bool ClangParser::parse(ast::Program *program, BPFtrace &bpftrace, std::vector<s
+     // Since we're omitting <linux/types.h> there's no reason to
+     // add the wokarounds for it
+     args.push_back("-D__CLANG_WORKAROUNDS_H");
++    // Let script know we have BTF -- this is useful for prewritten tools to
++    // conditionally include headers if BTF isn't available.
++    args.push_back("-DBPFTRACE_HAVE_BTF");
+ 
+     if (handler.parse_file("definitions.h", input, args, input_files, false) &&
+         handler.has_redefinition_error())
+@@ -779,6 +782,7 @@ bool ClangParser::parse(ast::Program *program, BPFtrace &bpftrace, std::vector<s
+     // taken from BTF. We cannot use BTF in such a case.
+     args.pop_back();
+     args.pop_back();
++    args.pop_back();
+     input_files.back() = get_empty_btf_generated_header();
+   }
+ 
+diff --git a/tools/biosnoop.bt b/tools/biosnoop.bt
+index aa88f4ba..33ad75de 100755
+--- a/tools/biosnoop.bt
++++ b/tools/biosnoop.bt
+@@ -1,5 +1,4 @@
+ #!/usr/bin/env bpftrace
+-#include <linux/blkdev.h>
+ /*
+  * biosnoop.bt   Block I/O tracing tool, showing per I/O latency.
+  *               For Linux, uses bpftrace, eBPF.
+@@ -11,6 +10,10 @@
+  * 15-Nov-2017	Brendan Gregg	Created this.
+  */
+ 
++#ifndef BPFTRACE_HAVE_BTF
++#include <linux/blkdev.h>
++#endif
++
+ BEGIN
+ {
+ 	printf("%-12s %-7s %-16s %-6s %7s\n", "TIME(ms)", "DISK", "COMM", "PID", "LAT(ms)");
+diff --git a/tools/dcsnoop.bt b/tools/dcsnoop.bt
+index 183f0fb5..e85ab1aa 100755
+--- a/tools/dcsnoop.bt
++++ b/tools/dcsnoop.bt
+@@ -15,6 +15,7 @@
+  * 08-Sep-2018	Brendan Gregg	Created this.
+  */
+ 
++#ifndef BPFTRACE_HAVE_BTF
+ #include <linux/fs.h>
+ #include <linux/sched.h>
+ 
+@@ -24,6 +25,7 @@ struct nameidata {
+         struct qstr     last;
+         // [...]
+ };
++#endif
+ 
+ BEGIN
+ {
+diff --git a/tools/mdflush.bt b/tools/mdflush.bt
+index 541abba1..1db547f6 100755
+--- a/tools/mdflush.bt
++++ b/tools/mdflush.bt
+@@ -13,8 +13,10 @@
+  * 08-Sep-2018	Brendan Gregg	Created this.
+  */
+ 
++#ifndef BPFTRACE_HAVE_BTF
+ #include <linux/genhd.h>
+ #include <linux/bio.h>
++#endif
+ 
+ BEGIN
+ {
+diff --git a/tools/naptime.bt b/tools/naptime.bt
+index eb96b677..a84652a3 100755
+--- a/tools/naptime.bt
++++ b/tools/naptime.bt
+@@ -13,8 +13,10 @@
+  * 16-Feb-2019  Brendan Gregg   Created this.
+  */
+ 
++#ifndef BPFTRACE_HAVE_BTF
+ #include <linux/time.h>
+ #include <linux/sched.h>
++#endif
+ 
+ BEGIN
+ {
+diff --git a/tools/oomkill.bt b/tools/oomkill.bt
+index 6126682d..1c9b16a3 100755
+--- a/tools/oomkill.bt
++++ b/tools/oomkill.bt
+@@ -20,7 +20,9 @@
+  * 07-Sep-2018	Brendan Gregg	Created this.
+  */
+ 
++#ifndef BPFTRACE_HAVE_BTF
+ #include <linux/oom.h>
++#endif
+ 
+ BEGIN
+ {
+diff --git a/tools/runqlen.bt b/tools/runqlen.bt
+index 02d82d74..1be42adc 100755
+--- a/tools/runqlen.bt
++++ b/tools/runqlen.bt
+@@ -11,17 +11,19 @@
+  * 07-Oct-2018	Brendan Gregg	Created this.
+  */
+ 
++#ifndef BPFTRACE_HAVE_BTF
+ #include <linux/sched.h>
+ 
+ // Until BTF is available, we'll need to declare some of this struct manually,
+ // since it isn't available to be #included. This will need maintenance to match
+ // your kernel version. It is from kernel/sched/sched.h:
+-struct cfs_rq_partial {
++struct cfs_rq {
+ 	struct load_weight load;
+ 	unsigned long runnable_weight;
+ 	unsigned int nr_running;
+ 	unsigned int h_nr_running;
+ };
++#endif
+ 
+ BEGIN
+ {
+@@ -31,7 +33,7 @@ BEGIN
+ profile:hz:99
+ {
+ 	$task = (struct task_struct *)curtask;
+-	$my_q = (struct cfs_rq_partial *)$task->se.cfs_rq;
++	$my_q = (struct cfs_rq *)$task->se.cfs_rq;
+ 	$len = $my_q->nr_running;
+ 	$len = $len > 0 ? $len - 1 : 0;	// subtract currently running task
+ 	@runqlen = lhist($len, 0, 100, 1);
+diff --git a/tools/tcpaccept.bt b/tools/tcpaccept.bt
+index b40a041b..2f4dfe1f 100755
+--- a/tools/tcpaccept.bt
++++ b/tools/tcpaccept.bt
+@@ -16,8 +16,12 @@
+  * 23-Nov-2018	Dale Hamel	created this.
+  */
+ 
++#ifndef BPFTRACE_HAVE_BTF
+ #include <linux/socket.h>
+ #include <net/sock.h>
++#else
++#include <sys/socket.h>
++#endif
+ 
+ BEGIN
+ {
+diff --git a/tools/tcpconnect.bt b/tools/tcpconnect.bt
+index 4ae30d65..05c3ca0e 100755
+--- a/tools/tcpconnect.bt
++++ b/tools/tcpconnect.bt
+@@ -19,8 +19,12 @@
+  * 23-Nov-2018	Dale Hamel	created this.
+  */
+ 
++#ifndef BPFTRACE_HAVE_BTF
+ #include <linux/socket.h>
+ #include <net/sock.h>
++#else
++#include <sys/socket.h>
++#endif
+ 
+ BEGIN
+ {
+diff --git a/tools/tcpdrop.bt b/tools/tcpdrop.bt
+index 79a86b08..2de3e507 100755
+--- a/tools/tcpdrop.bt
++++ b/tools/tcpdrop.bt
+@@ -17,8 +17,12 @@
+  * 23-Nov-2018	Dale Hamel	created this.
+  */
+ 
++#ifndef BPFTRACE_HAVE_BTF
+ #include <linux/socket.h>
+ #include <net/sock.h>
++#else
++#include <sys/socket.h>
++#endif
+ 
+ BEGIN
+ {
+diff --git a/tools/tcplife.bt b/tools/tcplife.bt
+index 9c0d8814..a9a054bf 100755
+--- a/tools/tcplife.bt
++++ b/tools/tcplife.bt
+@@ -13,10 +13,14 @@
+  * 17-Apr-2019  Brendan Gregg   Created this.
+  */
+ 
++#ifndef BPFTRACE_HAVE_BTF
+ #include <net/tcp_states.h>
+ #include <net/sock.h>
+ #include <linux/socket.h>
+ #include <linux/tcp.h>
++#else
++#include <sys/socket.h>
++#endif
+ 
+ BEGIN
+ {
+diff --git a/tools/tcpretrans.bt b/tools/tcpretrans.bt
+index 8b9500c0..777d78fa 100755
+--- a/tools/tcpretrans.bt
++++ b/tools/tcpretrans.bt
+@@ -17,8 +17,12 @@
+  * 23-Nov-2018  Dale Hamel      created this.
+  */
+ 
++#ifndef BPFTRACE_HAVE_BTF
+ #include <linux/socket.h>
+ #include <net/sock.h>
++#else
++#include <sys/socket.h>
++#endif
+ 
+ BEGIN
+ {
+diff --git a/tools/tcpsynbl.bt b/tools/tcpsynbl.bt
+index 4b3c99c3..0570f29c 100755
+--- a/tools/tcpsynbl.bt
++++ b/tools/tcpsynbl.bt
+@@ -13,7 +13,9 @@
+  * 19-Apr-2019  Brendan Gregg   Created this.
+  */
+ 
++#ifndef BPFTRACE_HAVE_BTF
+ #include <net/sock.h>
++#endif
+ 
+ BEGIN
+ {
+-- 
+2.35.3
+

bpftrace.spec

@@ -1,6 +1,6 @@
 Name:           bpftrace
-Version:        0.12.1
-Release:        8%{?dist}
+Version:        0.13.1
+Release:        1%{?dist}
 Summary:        High-level tracing language for Linux eBPF
 License:        ASL 2.0
 
@@ -9,10 +9,14 @@ Source0:        %{url}/archive/v%{version}/%{name}-%{version}.tar.gz
 Patch0:         %{name}-%{version}-RHEL-9-fixes.patch
 Patch1:         %{name}-%{version}-Fix-mdflush.patch
 Patch2:         %{name}-%{version}-orc-Fix-build-with-clang-13.patch
-Patch3:         %{name}-%{version}-Fix-single-arg-wildcard-listings.patch
-Patch4:         %{name}-%{version}-Update-bio-tools-to-work-on-RHEL9.patch
+Patch3:         %{name}-%{version}-Update-bio-tools-to-work-on-kernel-5.16.patch
+Patch4:         %{name}-%{version}-tools-Make-tools-rely-on-BTF-instead-of-header-files.patch
+Patch5:         %{name}-%{version}-Fix-libbtf-0.6.0-build.patch
+Patch6:         %{name}-%{version}-Fix-compile-under-llvm14-trunk.patch
+Patch7:         %{name}-%{version}-Fix-LLVM-13-warnings.patch
+Patch8:         %{name}-%{version}-biosnoop.bt-handle-Linux-5.17-block-layer-update.patch
 
-Patch10:        %{name}-%{version}-aarch64-fixes-statsnoop-and-opensnoop.patch
+Patch10:        %{name}-%{version}-RHEL-aarch64-fixes-statsnoop-and-opensnoop.patch
 
 # Arches will be included as upstream support is added and dependencies are
 # satisfied in the respective arches
@@ -85,6 +89,10 @@ find %{buildroot}%{_datadir}/%{name}/tools -type f -exec \
 %{_datadir}/%{name}/tools/doc/*.txt
 
 %changelog
+* Mon May 16 2022 Jerome Marchand <jmarchan@redhat.com> - 0.13.1-1
+- Rebase to bpftrace 0.13.1
+- Rebuild for LLVM14
+
 * Mon Feb 21 2022 Viktor Malik <vmalik@redhat.com> - 0.12.1-8
 - Fix wildcard listing bug
 - Fix bio* tools

sources

@@ -1 +1 @@
-SHA512 (bpftrace-0.12.1.tar.gz) = a578499668bd2eb7342689b6c0ef3db6ca263a971d8e6f1b9a68c502c27170d24ede212a0fc2a72263e72aff58924f488a5c80d447397503a08512dc47b63345
+SHA512 (bpftrace-0.13.1.tar.gz) = fa810067023ddd6cbf2fd4c7c46138dd756eb9b3e37d00d049017f201f71c6a69ac2eb261619eb7e83356dc43fa1a0ed4d78b40f2ff36d76caa15e5c754ab224