From fed7014be999f6437ebfd8a6465a76f459be0e1b Mon Sep 17 00:00:00 2001 From: Viktor Malik 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(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(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(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(*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 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 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<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; isize(); 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(val1->getType()); + auto *val2p = dyn_cast(val2->getType()); #ifndef NDEBUG - PointerType *val1p = cast(val1->getType()); - PointerType *val2p = cast(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(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