Support identifying btf type

k(ret)func and iter are btf-based tracing, which can detect whether dereferencing is safe through btf, so dereferencing does not need to call the helper function bpf_probe_read. This patch mainly modifies the semantic and codegen modules

semantic:
- Handle the ctx of iter, mark is_btftype as true
- Handle the retval of kretfunc, mark is_btftype as true
- When dealing with ArrayAccess, Unop, FieldAccess, inherit is_btftype attribute

codegen:
- If it is a string type, use CREATE_MEMCPY directly to load the data
- For other types, load data through CreateDatastructElemLoad instead of CreateProbeRead

Signed-off-by: Shuyi Cheng <chengshuyi@linux.alibaba.com>

src/ast/passes/codegen_llvm.cpp

@@ -1852,6 +1852,7 @@ void CodegenLLVM::visit(FieldAccess &acc)
   bool is_tparg = type.is_tparg;
   bool is_internal = type.is_internal;
   bool is_funcarg = type.is_funcarg;
+  bool is_btftype = type.is_btftype;
   assert(type.IsRecordTy() || type.IsTupleTy());
 
   if (type.is_funcarg)
@@ -1893,6 +1894,7 @@ void CodegenLLVM::visit(FieldAccess &acc)
   type.is_tparg = is_tparg;
   type.is_internal = is_internal;
   type.is_funcarg = is_funcarg;
+  type.is_btftype = is_btftype;
   // Restore the addrspace info
   // struct MyStruct { const int* a; };  $s = (struct MyStruct *)arg0;  $s->a
   type.SetAS(addrspace);
@@ -3530,23 +3532,30 @@ void CodegenLLVM::probereadDatastructElem(Value *src_data,
   {
     // Read data onto stack
     AllocaInst *dst = b_.CreateAllocaBPF(elem_type, temp_name);
-    b_.CreateProbeRead(ctx_, dst, elem_type, src, loc, data_type.GetAS());
+    if (elem_type.IsStringTy() && data_type.is_btftype)
+    {
+      b_.CREATE_MEMCPY(dst, src, elem_type.GetSize(), 1);
+    }
+    else
+    {
+      b_.CreateProbeRead(ctx_, dst, elem_type, src, loc, data_type.GetAS());
+    }
     expr_ = dst;
     expr_deleter_ = [this, dst]() { b_.CreateLifetimeEnd(dst); };
   }
   else
   {
     // Read data onto stack
-    if (data_type.IsCtxAccess())
+    if (data_type.IsCtxAccess() || data_type.is_btftype)
     {
       expr_ = b_.CreateDatastructElemLoad(
           elem_type,
           b_.CreateIntToPtr(src, dst_type->getPointerTo()),
           true,
           data_type.GetAS());
-
       // check context access for iter probes (required by kernel)
-      if (probetype(current_attach_point_->provider) == ProbeType::iter)
+      if (data_type.IsCtxAccess() &&
+          probetype(current_attach_point_->provider) == ProbeType::iter)
       {
         Function *parent = b_.GetInsertBlock()->getParent();
         BasicBlock *pred_false_block = BasicBlock::Create(module_->getContext(),

src/ast/passes/semantic_analyser.cpp

@@ -282,6 +282,7 @@ void SemanticAnalyser::visit(Builtin &builtin)
               CreateRecord(type, bpftrace_.structs.Lookup(type)),
               AddrSpace::kernel);
           builtin.type.MarkCtxAccess();
+          builtin.type.is_btftype = true;
         }
         else
         {
@@ -331,7 +332,10 @@ void SemanticAnalyser::visit(Builtin &builtin)
       auto it = ap_args_.find("$retval");
 
       if (it != ap_args_.end())
+      {
         builtin.type = it->second;
+        builtin.type.is_btftype = true;
+      }
       else
         LOG(ERROR, builtin.loc, err_) << "Can't find a field $retval";
     }
@@ -1622,6 +1626,7 @@ void SemanticAnalyser::visit(ArrayAccess &arr)
   else
     arr.type = CreateNone();
   arr.type.is_internal = type.is_internal;
+  arr.type.is_btftype = type.is_btftype;
   arr.type.SetAS(type.GetAS());
 }
 
@@ -1992,6 +1997,7 @@ void SemanticAnalyser::visit(Unop &unop)
         unop.type.is_funcarg = type.is_funcarg;
         unop.type.is_tparg = type.is_tparg;
       }
+      unop.type.is_btftype = type.is_btftype;
       unop.type.SetAS(type.GetAS());
     }
     else if (type.IsRecordTy())
@@ -2178,6 +2184,12 @@ void SemanticAnalyser::visit(FieldAccess &acc)
       {
         if (acc.type.IsNoneTy())
           LOG(ERROR, acc.loc, err_) << acc.field << " has unsupported type";
+
+        ProbeType probetype = single_provider_type();
+        if (probetype == ProbeType::kfunc || probetype == ProbeType::kretfunc)
+        {
+          acc.type.is_btftype = true;
+        }
       }
     }
     else
@@ -2268,6 +2280,7 @@ void SemanticAnalyser::visit(FieldAccess &acc)
         acc.type.MarkCtxAccess();
       }
       acc.type.is_internal = type.is_internal;
+      acc.type.is_btftype = type.is_btftype;
       acc.type.SetAS(acc.expr->type.GetAS());
 
       // The kernel uses the first 8 bytes to store `struct pt_regs`. Any

src/types.h

@@ -115,6 +115,7 @@ class SizedType
   bool is_internal = false;
   bool is_tparg = false;
   bool is_funcarg = false;
+  bool is_btftype = false;
   int funcarg_idx = -1;
 
 private:
@@ -141,6 +142,7 @@ class SizedType
             is_internal,
             is_tparg,
             is_funcarg,
+            is_btftype,
             funcarg_idx,
             size_,
             is_signed_,