From b5a0dd413a3e4f521df7febca6b88f0ec6b9ff36 Mon Sep 17 00:00:00 2001 From: "Frank Ch. Eigler" Date: Fri, 18 Dec 2009 12:20:52 -0500 Subject: [PATCH] PR10601 part 1: i386 and x86-64 regset for dwarf fetch/store_register()s * runtime/loc2c-runtime.h (fetch_register, store_register): forked into k_ (kernel) and u_ (user) varieties. Implement i386 and x86_64 in terms of regset.h; fall back to k_* for other architectures. * tapsets.cxx: (*::visit_target_symbol): Emit macros to map loc2c's fetch/store_register to loc2c-runtime's k_ or u_ as appopriate. --- runtime/loc2c-runtime.h | 385 +++++++++++++++++++++++++++++++--------- tapsets.cxx | 43 ++++- 2 files changed, 338 insertions(+), 90 deletions(-) diff --git a/runtime/loc2c-runtime.h b/runtime/loc2c-runtime.h index e9e5a0716..d23df7f22 100644 --- a/runtime/loc2c-runtime.h +++ b/runtime/loc2c-runtime.h @@ -1,5 +1,5 @@ /* target operations - * Copyright (C) 2005 Red Hat Inc. + * Copyright (C) 2005-2009 Red Hat Inc. * Copyright (C) 2005, 2006, 2007 Intel Corporation. * Copyright (C) 2007 Quentin Barnes. * @@ -44,10 +44,10 @@ can be pasted into an identifier name. These definitions turn it into a per-register macro, defined below for machines with individually-named registers. */ -#define fetch_register(regno) \ - ((intptr_t) dwarf_register_##regno (c->regs)) -#define store_register(regno, value) \ - (dwarf_register_##regno (c->regs) = (value)) +#define k_fetch_register(regno) \ + ((intptr_t) k_dwarf_register_##regno (c->regs)) +#define k_store_register(regno, value) \ + (k_dwarf_register_##regno (c->regs) = (value)) /* The deref and store_deref macros are called to safely access addresses @@ -82,35 +82,242 @@ }) #endif + +/* PR 10601: user-space (user_regset) register access. Needs porting to each architecture. */ +#include + +struct usr_regset_lut { + char *name; + unsigned rsn; + unsigned pos; +}; + +/* DWARF register number -to- user_regset offset/bank mapping table. */ +static const struct usr_regset_lut url_i386[] = { + { "ax", NT_PRSTATUS, 6*4 }, + { "cx", NT_PRSTATUS, 1*4 }, + { "dx", NT_PRSTATUS, 2*4 }, + { "bx", NT_PRSTATUS, 0*4 }, + { "sp", NT_PRSTATUS, 15*4 }, + { "bp", NT_PRSTATUS, 5*4 }, + { "di", NT_PRSTATUS, 4*4 }, + { "si", NT_PRSTATUS, 3*4 }, +}; + +static const struct usr_regset_lut url_x86_64[] = { + { "rax", NT_PRSTATUS, 10*8 }, + { "rdx", NT_PRSTATUS, 12*8 }, + { "rcx", NT_PRSTATUS, 11*8 }, + { "rbx", NT_PRSTATUS, 5*8 }, + { "rsi", NT_PRSTATUS, 13*8 }, + { "rdi", NT_PRSTATUS, 14*8 }, + { "rbp", NT_PRSTATUS, 4*8 }, + { "rsp", NT_PRSTATUS, 19*8 }, + { "r8", NT_PRSTATUS, 9*8 }, + { "r9", NT_PRSTATUS, 8*8 }, + { "r10", NT_PRSTATUS, 7*8 }, + { "r11", NT_PRSTATUS, 6*8 }, + { "r12", NT_PRSTATUS, 3*8 }, + { "r13", NT_PRSTATUS, 2*8 }, + { "r14", NT_PRSTATUS, 1*8 }, + { "r15", NT_PRSTATUS, 0*8 }, +}; + + + +static u32 ursl_fetch32 (const struct usr_regset_lut* lut, unsigned lutsize, int e_machine, unsigned regno) +{ + u32 value = ~0; + const struct user_regset_view *rsv = task_user_regset_view(current); + unsigned rsi; + int rc; + unsigned rsn; + unsigned pos; + unsigned count; + + WARN_ON (!rsv); + if (!rsv) goto out; + WARN_ON (regno >= lutsize); + if (regno >= lutsize) goto out; + if (rsv->e_machine != e_machine) goto out; + + rsn = lut[regno].rsn; + pos = lut[regno].pos; + count = sizeof(value); + + for (rsi=0; rsin; rsi++) + if (rsv->regsets[rsi].core_note_type == rsn) + { + const struct user_regset *rs = & rsv->regsets[rsi]; + rc = (rs->get)(current, rs, pos, count, & value, NULL); + WARN_ON (rc); + /* success */ + goto out; + } + WARN_ON (1); /* did not find appropriate regset! */ + + out: + return value; +} + + +static void ursl_store32 (const struct usr_regset_lut* lut,unsigned lutsize, int e_machine, unsigned regno, u32 value) +{ + const struct user_regset_view *rsv = task_user_regset_view(current); + unsigned rsi; + int rc; + unsigned rsn; + unsigned pos; + unsigned count; + + WARN_ON (!rsv); + if (!rsv) goto out; + WARN_ON (regno >= lutsize); + if (regno >= lutsize) goto out; + if (rsv->e_machine != e_machine) goto out; + + rsn = lut[regno].rsn; + pos = lut[regno].pos; + count = sizeof(value); + + for (rsi=0; rsin; rsi++) + if (rsv->regsets[rsi].core_note_type == rsn) + { + const struct user_regset *rs = & rsv->regsets[rsi]; + rc = (rs->set)(current, rs, pos, count, & value, NULL); + WARN_ON (rc); + /* success */ + goto out; + } + WARN_ON (1); /* did not find appropriate regset! */ + + out: + return; +} + + +static u64 ursl_fetch64 (const struct usr_regset_lut* lut, unsigned lutsize, int e_machine, unsigned regno) +{ + u64 value = ~0; + const struct user_regset_view *rsv = task_user_regset_view(current); + unsigned rsi; + int rc; + unsigned rsn; + unsigned pos; + unsigned count; + + if (!rsv) goto out; + if (regno >= lutsize) goto out; + if (rsv->e_machine != e_machine) goto out; + + rsn = lut[regno].rsn; + pos = lut[regno].pos; + count = sizeof(value); + + for (rsi=0; rsin; rsi++) + if (rsv->regsets[rsi].core_note_type == rsn) + { + const struct user_regset *rs = & rsv->regsets[rsi]; + rc = (rs->get)(current, rs, pos, count, & value, NULL); + if (rc) + goto out; + /* success */ + return value; + } + out: + printk (KERN_WARNING "process %d mach %d regno %d not available for fetch.\n", current->tgid, e_machine, regno); + return value; +} + + +static void ursl_store64 (const struct usr_regset_lut* lut,unsigned lutsize, int e_machine, unsigned regno, u64 value) +{ + const struct user_regset_view *rsv = task_user_regset_view(current); + unsigned rsi; + int rc; + unsigned rsn; + unsigned pos; + unsigned count; + + WARN_ON (!rsv); + if (!rsv) goto out; + WARN_ON (regno >= lutsize); + if (regno >= lutsize) goto out; + if (rsv->e_machine != e_machine) goto out; + + rsn = lut[regno].rsn; + pos = lut[regno].pos; + count = sizeof(value); + + for (rsi=0; rsin; rsi++) + if (rsv->regsets[rsi].core_note_type == rsn) + { + const struct user_regset *rs = & rsv->regsets[rsi]; + rc = (rs->set)(current, rs, pos, count, & value, NULL); + if (rc) + goto out; + /* success */ + return; + } + + out: + printk (KERN_WARNING "process %d mach %d regno %d not available for store.\n", current->tgid, e_machine, regno); + return; +} + + +#define S(array) sizeof(array)/sizeof(array[0]) +#if defined (__i386__) + +#define u_fetch_register(regno) ursl_fetch32(url_i386, S(url_i386), EM_386, regno) +#define u_store_register(regno,value) ursl_store32(url_i386, S(url_i386), EM_386, regno, value) + +#elif defined (__x86_64__) + +#define u_fetch_register(regno) (_stp_probing_32bit_app(c->regs) ? ursl_fetch32(url_i386, S(url_i386), EM_386, regno) : ursl_fetch64(url_x86_64, S(url_x86_64), EM_X86_64, regno)) +#define u_store_register(regno,value) (_stp_probing_32bit_app(c->regs) ? ursl_store2(url_i386, S(url_i386), EM_386, regno, value) : ursl_store64(url_x86_64, S(url_x86_64), EM_X86_64, regno, value)) + +#else + +#error "no can do" + +/* Some other architecture; downgrade to kernel register access. */ +#define u_fetch_register(regno) k_fetch_register(regno) +#define u_store_register(regno,value) k_store_register(regno,value) + +#endif + + + #if defined (STAPCONF_X86_UNIREGS) && defined (__i386__) -#define dwarf_register_0(regs) regs->ax -#define dwarf_register_1(regs) regs->cx -#define dwarf_register_2(regs) regs->dx -#define dwarf_register_3(regs) regs->bx -#define dwarf_register_4(regs) ((long) ®s->sp) -#define dwarf_register_5(regs) regs->bp -#define dwarf_register_6(regs) regs->si -#define dwarf_register_7(regs) regs->di +#define k_dwarf_register_0(regs) regs->ax +#define k_dwarf_register_1(regs) regs->cx +#define k_dwarf_register_2(regs) regs->dx +#define k_dwarf_register_3(regs) regs->bx +#define k_dwarf_register_4(regs) ((long) ®s->sp) +#define k_dwarf_register_5(regs) regs->bp +#define k_dwarf_register_6(regs) regs->si +#define k_dwarf_register_7(regs) regs->di #elif defined (STAPCONF_X86_UNIREGS) && defined (__x86_64__) -#define dwarf_register_0(regs) regs->ax -#define dwarf_register_1(regs) regs->dx -#define dwarf_register_2(regs) regs->cx -#define dwarf_register_3(regs) regs->bx -#define dwarf_register_4(regs) regs->si -#define dwarf_register_5(regs) regs->di -#define dwarf_register_6(regs) regs->bp -#define dwarf_register_7(regs) regs->sp -#define dwarf_register_8(regs) regs->r8 -#define dwarf_register_9(regs) regs->r9 -#define dwarf_register_10(regs) regs->r10 -#define dwarf_register_11(regs) regs->r11 -#define dwarf_register_12(regs) regs->r12 -#define dwarf_register_13(regs) regs->r13 -#define dwarf_register_14(regs) regs->r14 -#define dwarf_register_15(regs) regs->r15 +#define k_dwarf_register_0(regs) regs->ax +#define k_dwarf_register_1(regs) regs->dx +#define k_dwarf_register_2(regs) regs->cx +#define k_dwarf_register_3(regs) regs->bx +#define k_dwarf_register_4(regs) regs->si +#define k_dwarf_register_5(regs) regs->di +#define k_dwarf_register_6(regs) regs->bp +#define k_dwarf_register_7(regs) regs->sp +#define k_dwarf_register_8(regs) regs->r8 +#define k_dwarf_register_9(regs) regs->r9 +#define k_dwarf_register_10(regs) regs->r10 +#define k_dwarf_register_11(regs) regs->r11 +#define k_dwarf_register_12(regs) regs->r12 +#define k_dwarf_register_13(regs) regs->r13 +#define k_dwarf_register_14(regs) regs->r14 +#define k_dwarf_register_15(regs) regs->r15 #elif defined __i386__ @@ -120,60 +327,60 @@ For a kernel mode trap, the interrupted state's esp is actually an address inside where the `struct pt_regs' on the kernel trap stack points. */ -#define dwarf_register_0(regs) regs->eax -#define dwarf_register_1(regs) regs->ecx -#define dwarf_register_2(regs) regs->edx -#define dwarf_register_3(regs) regs->ebx -#define dwarf_register_4(regs) (user_mode(regs) ? regs->esp : (long)®s->esp) -#define dwarf_register_5(regs) regs->ebp -#define dwarf_register_6(regs) regs->esi -#define dwarf_register_7(regs) regs->edi +#define k_dwarf_register_0(regs) regs->eax +#define k_dwarf_register_1(regs) regs->ecx +#define k_dwarf_register_2(regs) regs->edx +#define k_dwarf_register_3(regs) regs->ebx +#define k_dwarf_register_4(regs) (user_mode(regs) ? regs->esp : (long)®s->esp) +#define k_dwarf_register_5(regs) regs->ebp +#define k_dwarf_register_6(regs) regs->esi +#define k_dwarf_register_7(regs) regs->edi #elif defined __ia64__ -#undef fetch_register -#undef store_register +#undef k_fetch_register +#undef k_store_register -#define fetch_register(regno) ia64_fetch_register(regno, c->regs, &c->unwaddr) -#define store_register(regno,value) ia64_store_register(regno, c->regs, value) +#define k_fetch_register(regno) ia64_fetch_register(regno, c->regs, &c->unwaddr) +#define k_store_register(regno,value) ia64_store_register(regno, c->regs, value) #elif defined __x86_64__ -#define dwarf_register_0(regs) regs->rax -#define dwarf_register_1(regs) regs->rdx -#define dwarf_register_2(regs) regs->rcx -#define dwarf_register_3(regs) regs->rbx -#define dwarf_register_4(regs) regs->rsi -#define dwarf_register_5(regs) regs->rdi -#define dwarf_register_6(regs) regs->rbp -#define dwarf_register_7(regs) regs->rsp -#define dwarf_register_8(regs) regs->r8 -#define dwarf_register_9(regs) regs->r9 -#define dwarf_register_10(regs) regs->r10 -#define dwarf_register_11(regs) regs->r11 -#define dwarf_register_12(regs) regs->r12 -#define dwarf_register_13(regs) regs->r13 -#define dwarf_register_14(regs) regs->r14 -#define dwarf_register_15(regs) regs->r15 +#define k_dwarf_register_0(regs) regs->rax +#define k_dwarf_register_1(regs) regs->rdx +#define k_dwarf_register_2(regs) regs->rcx +#define k_dwarf_register_3(regs) regs->rbx +#define k_dwarf_register_4(regs) regs->rsi +#define k_dwarf_register_5(regs) regs->rdi +#define k_dwarf_register_6(regs) regs->rbp +#define k_dwarf_register_7(regs) regs->rsp +#define k_dwarf_register_8(regs) regs->r8 +#define k_dwarf_register_9(regs) regs->r9 +#define k_dwarf_register_10(regs) regs->r10 +#define k_dwarf_register_11(regs) regs->r11 +#define k_dwarf_register_12(regs) regs->r12 +#define k_dwarf_register_13(regs) regs->r13 +#define k_dwarf_register_14(regs) regs->r14 +#define k_dwarf_register_15(regs) regs->r15 #elif defined __powerpc__ -#undef fetch_register -#undef store_register -#define fetch_register(regno) ((intptr_t) c->regs->gpr[regno]) -#define store_register(regno,value) (c->regs->gpr[regno] = (value)) +#undef k_fetch_register +#undef k_store_register +#define k_fetch_register(regno) ((intptr_t) c->regs->gpr[regno]) +#define k_store_register(regno,value) (c->regs->gpr[regno] = (value)) #elif defined (__arm__) -#undef fetch_register -#undef store_register -#define fetch_register(regno) ((long) c->regs->uregs[regno]) -#define store_register(regno,value) (c->regs->uregs[regno] = (value)) +#undef k_fetch_register +#undef k_store_register +#define k_fetch_register(regno) ((long) c->regs->uregs[regno]) +#define k_store_register(regno,value) (c->regs->uregs[regno] = (value)) #elif defined (__s390__) || defined (__s390x__) -#undef fetch_register -#undef store_register -#define fetch_register(regno) ((intptr_t) c->regs->gprs[regno]) -#define store_register(regno,value) (c->regs->gprs[regno] = (value)) +#undef k_fetch_register +#undef k_store_register +#define k_fetch_register(regno) ((intptr_t) c->regs->gprs[regno]) +#define k_store_register(regno,value) (c->regs->gprs[regno] = (value)) #endif @@ -206,7 +413,7 @@ STORE_DEREF_FAULT(ptr); \ }) -#define deref(size, addr) ({ \ +#define k_deref(size, addr) ({ \ intptr_t _i = 0; \ switch (size) { \ case 1: _i = kread((u8 *)(addr)); break; \ @@ -218,7 +425,7 @@ _i; \ }) -#define store_deref(size, addr, value) ({ \ +#define k_store_deref(size, addr, value) ({ \ switch (size) { \ case 1: kwrite((u8 *)(addr), (value)); break; \ case 2: kwrite((u16 *)(addr), (value)); break; \ @@ -228,6 +435,7 @@ } \ }) + extern void __deref_bad(void); extern void __store_deref_bad(void); @@ -235,7 +443,7 @@ extern void __store_deref_bad(void); #if defined __i386__ -#define deref(size, addr) \ +#define k_deref(size, addr) \ ({ \ int _bad = 0; \ u8 _b; u16 _w; u32 _l; \ @@ -255,7 +463,7 @@ extern void __store_deref_bad(void); _v; \ }) -#define store_deref(size, addr, value) \ +#define k_store_deref(size, addr, value) \ ({ \ int _bad = 0; \ if (lookup_bad_addr((unsigned long)addr, size)) \ @@ -275,7 +483,7 @@ extern void __store_deref_bad(void); #elif defined __x86_64__ -#define deref(size, addr) \ +#define k_deref(size, addr) \ ({ \ int _bad = 0; \ u8 _b; u16 _w; u32 _l; u64 _q; \ @@ -296,7 +504,7 @@ extern void __store_deref_bad(void); _v; \ }) -#define store_deref(size, addr, value) \ +#define k_store_deref(size, addr, value) \ ({ \ int _bad = 0; \ if (lookup_bad_addr((unsigned long)addr, size)) \ @@ -315,7 +523,7 @@ extern void __store_deref_bad(void); }) #elif defined __ia64__ -#define deref(size, addr) \ +#define k_deref(size, addr) \ ({ \ int _bad = 0; \ intptr_t _v=0; \ @@ -334,7 +542,7 @@ extern void __store_deref_bad(void); _v; \ }) -#define store_deref(size, addr, value) \ +#define k_store_deref(size, addr, value) \ ({ \ int _bad=0; \ if (lookup_bad_addr((unsigned long)addr, size)) \ @@ -393,7 +601,7 @@ extern void __store_deref_bad(void); "i"(sizeof(unsigned long))) -#define deref(size, addr) \ +#define k_deref(size, addr) \ ({ \ int _bad = 0; \ intptr_t _v = 0; \ @@ -413,7 +621,7 @@ extern void __store_deref_bad(void); _v; \ }) -#define store_deref(size, addr, value) \ +#define k_store_deref(size, addr, value) \ ({ \ int _bad = 0; \ if (lookup_bad_addr((unsigned long)addr, size)) \ @@ -567,7 +775,7 @@ extern void __store_deref_bad(void); : "r" (x), "i" (-EFAULT) \ : "cc") -#define deref(size, addr) \ +#define k_deref(size, addr) \ ({ \ int _bad = 0; \ intptr_t _v=0; \ @@ -585,7 +793,7 @@ extern void __store_deref_bad(void); _v; \ }) -#define store_deref(size, addr, value) \ +#define k_store_deref(size, addr, value) \ ({ \ int _bad=0; \ if (lookup_bad_addr((unsigned long)addr, size)) \ @@ -655,7 +863,7 @@ extern void __store_deref_bad(void); : "cc"); \ }) -#define deref(size, addr) \ +#define k_deref(size, addr) \ ({ \ u8 _b; u16 _w; u32 _l; u64 _q; \ int _bad = 0; \ @@ -692,7 +900,7 @@ extern void __store_deref_bad(void); _v; \ }) -#define store_deref(size, addr, value) \ +#define k_store_deref(size, addr, value) \ ({ \ int _bad = 0; \ int i; \ @@ -738,14 +946,21 @@ extern void __store_deref_bad(void); #else #define kread(ptr) \ - ( (typeof(*(ptr))) deref(sizeof(*(ptr)), (ptr)) ) + ( (typeof(*(ptr))) k_deref(sizeof(*(ptr)), (ptr)) ) #define kwrite(ptr, value) \ - ( store_deref(sizeof(*(ptr)), (ptr), (long)(typeof(*(ptr)))(value)) ) + ( k_store_deref(sizeof(*(ptr)), (ptr), (long)(typeof(*(ptr)))(value)) ) #endif #endif /* STAPCONF_PROBE_KERNEL */ +/* XXX: PR10601 */ +/* Perhaps this should use something like set_fs(USER_DS); k_deref() ; set_fs(KERNEL_DS) + * But then again, the addr_map protections do that already. */ +#define u_deref(a,b) k_deref(a,b) +#define u_store_deref(a,b,c) k_store_deref(a,b,c) + + #define deref_string(dst, addr, maxbytes) \ ({ \ uintptr_t _addr; \ diff --git a/tapsets.cxx b/tapsets.cxx index a97fa5a2e..cfd21bff4 100644 --- a/tapsets.cxx +++ b/tapsets.cxx @@ -2400,9 +2400,14 @@ dwarf_var_expanding_visitor::visit_target_symbol (target_symbol *e) try { + // PR10601: adapt to kernel-vs-userspace loc2c-runtime + ec->code += "\n#define fetch_register " + string(q.has_process?"u":"k") + "_fetch_register\n"; + ec->code += "#define store_register " + string(q.has_process?"u":"k") + "_store_register\n"; + ec->code += "#define deref " + string(q.has_process?"u":"k") + "_deref\n"; + if (q.has_return && (e->base_name == "$return")) { - ec->code = q.dw.literal_stmt_for_return (scope_die, + ec->code += q.dw.literal_stmt_for_return (scope_die, addr, e, lvalue, @@ -2410,7 +2415,7 @@ dwarf_var_expanding_visitor::visit_target_symbol (target_symbol *e) } else { - ec->code = q.dw.literal_stmt_for_local (getscopes(e), + ec->code += q.dw.literal_stmt_for_local (getscopes(e), addr, e->base_name.substr(1), e, @@ -2422,6 +2427,11 @@ dwarf_var_expanding_visitor::visit_target_symbol (target_symbol *e) ec->code += "/* pure */"; ec->code += "/* unprivileged */"; + + // PR10601 + ec->code += "\n#undef fetch_register\n"; + ec->code += "\n#undef store_register\n"; + ec->code += "\n#undef deref\n"; } catch (const semantic_error& er) { @@ -2687,6 +2697,7 @@ void dwarf_cast_expanding_visitor::visit_cast_op (cast_op* e) // split the module string by ':' for alternatives vector modules; tokenize(e->module, modules, ":"); + bool userspace_p=false; // PR10601 for (unsigned i = 0; code.empty() && i < modules.size(); ++i) { string& module = modules[i]; @@ -2697,7 +2708,8 @@ void dwarf_cast_expanding_visitor::visit_cast_op (cast_op* e) dwflpp* dw; try { - if (! is_user_module (module)) + userspace_p=is_user_module (module); + if (! userspace_p) { // kernel or kernel module target dw = db.get_kern_dw(s, module); @@ -2739,9 +2751,15 @@ void dwarf_cast_expanding_visitor::visit_cast_op (cast_op* e) embeddedcode *ec = new embeddedcode; ec->tok = e->tok; - ec->code = code; fdecl->body = ec; + // PR10601: adapt to kernel-vs-userspace loc2c-runtime + ec->code += "\n#define fetch_register " + string(userspace_p?"u":"k") + "_fetch_register\n"; + ec->code += "#define store_register " + string(userspace_p?"u":"k") + "_store_register\n"; + ec->code += "#define deref " + string(userspace_p?"u":"k") + "_deref\n"; + + ec->code += code; + // Give the fdecl an argument for the pointer we're trying to cast vardecl *v1 = new vardecl; v1->type = pe_long; @@ -2781,6 +2799,11 @@ void dwarf_cast_expanding_visitor::visit_cast_op (cast_op* e) ec->code += "/* unprivileged */"; + // PR10601 + ec->code += "\n#undef fetch_register\n"; + ec->code += "\n#undef store_register\n"; + ec->code += "\n#undef deref\n"; + s.functions[fdecl->name] = fdecl; // Synthesize a functioncall. @@ -5764,9 +5787,14 @@ tracepoint_var_expanding_visitor::visit_target_symbol_arg (target_symbol* e) fdecl->name = fname; fdecl->body = ec; + // PR10601: adapt to kernel-vs-userspace loc2c-runtime + ec->code += "\n#define fetch_register k_fetch_register\n"; + ec->code += "#define store_register k_store_register\n"; + ec->code += "#define deref k_deref\n"; + try { - ec->code = dw.literal_stmt_for_pointer (&arg->type_die, e, + ec->code += dw.literal_stmt_for_pointer (&arg->type_die, e, lvalue, fdecl->type); } catch (const semantic_error& er) @@ -5824,6 +5852,11 @@ tracepoint_var_expanding_visitor::visit_target_symbol_arg (target_symbol* e) ec->code += "/* unprivileged */"; + // PR10601 + ec->code += "\n#undef fetch_register\n"; + ec->code += "\n#undef store_register\n"; + ec->code += "\n#undef deref\n"; + dw.sess.functions[fdecl->name] = fdecl; // Synthesize a functioncall. -- 2.43.5