From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 22301 invoked by alias); 11 Mar 2013 19:27:19 -0000 Received: (qmail 22281 invoked by uid 22791); 11 Mar 2013 19:27:17 -0000 X-SWARE-Spam-Status: No, hits=-7.5 required=5.0 tests=AWL,BAYES_00,KHOP_RCVD_UNTRUST,KHOP_SPAMHAUS_DROP,RCVD_IN_DNSWL_HI,RCVD_IN_HOSTKARMA_W,RP_MATCHES_RCVD,SPF_HELO_PASS,TW_XS X-Spam-Check-By: sourceware.org Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Mon, 11 Mar 2013 19:26:55 +0000 Received: from int-mx11.intmail.prod.int.phx2.redhat.com (int-mx11.intmail.prod.int.phx2.redhat.com [10.5.11.24]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id r2BJQt81022894 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK) for ; Mon, 11 Mar 2013 15:26:55 -0400 Received: from barimba (ovpn01.gateway.prod.ext.phx2.redhat.com [10.5.9.1]) by int-mx11.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id r2BJQp6v013555 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES128-SHA bits=128 verify=NO); Mon, 11 Mar 2013 15:26:52 -0400 From: Tom Tromey To: gdb-patches@sourceware.org Subject: RFC: remove trace_kludge global Date: Mon, 11 Mar 2013 19:27:00 -0000 Message-ID: <87k3pdn3es.fsf@fleche.redhat.com> MIME-Version: 1.0 Content-Type: text/plain Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2013-03/txt/msg00488.txt.bz2 This patch removes the trace_kludge and trace_string_kludge globals, turning them into fields of the agent expression being compiled. If you read the comment by trace_kludge, you can see the original plan. I think it was an ok plan -- but I don't think trace_string_kludge can be handled that way. Given that it seems cleanest to just turn these both into fields and remove the globals. Built and regtested on x86-64 Fedora 16. I also regtested using the native-extended-gdbserver.exp board file. Let me know what you think. In the absence of comments I'll put this in next week sometime. Tom 2013-03-11 Tom Tromey * tracepoint.h (decode_agent_options): Add 'trace_string' argument. * tracepoint.c (decode_agent_options): Add 'trace_string' argument. (validate_actionline): Update. (collect_symbol): Add 'trace_string' argument. (struct add_local_symbols_data) : New field. (do_collect_symbol): Update. (add_local_symbols): Add 'trace_string' argument. (encode_actions_1): Update. (trace_dump_actions): Update. * remote.c (remote_download_tracepoint): Update. * dwarf2loc.c (access_memory): Update. * breakpoint.c (parse_cond_to_aexpr): Update. * ax.h (struct agent_expr) : New fields. * ax-general.c (new_agent_expr): Update. * ax-gdb.h (gen_trace_for_expr, gen_trace_for_var) (gen_trace_for_return_address, gen_eval_for_expr): Add argument. (trace_kludge, trace_string_kludge): Remove. * ax-gdb.c (trace_kludge, trace_string_kludge): Remove. (gen_traced_pop, gen_fetch, gen_bitfield_ref, gen_expr): Update. (gen_trace_for_var): Add 'trace_string' argument. (gen_trace_for_expr, gen_eval_for_expr) (gen_trace_for_return_address): Likewise. (gen_printf, agent_eval_command_one): Update. diff --git a/gdb/ax-gdb.c b/gdb/ax-gdb.c index 066826e..34eb82a 100644 --- a/gdb/ax-gdb.c +++ b/gdb/ax-gdb.c @@ -312,36 +312,6 @@ maybe_const_expr (union exp_element **pc) sizes), and this is simpler.) */ -/* Generating bytecode from GDB expressions: the `trace' kludge */ - -/* The compiler in this file is a general-purpose mechanism for - translating GDB expressions into bytecode. One ought to be able to - find a million and one uses for it. - - However, at the moment it is HOPELESSLY BRAIN-DAMAGED for the sake - of expediency. Let he who is without sin cast the first stone. - - For the data tracing facility, we need to insert `trace' bytecodes - before each data fetch; this records all the memory that the - expression touches in the course of evaluation, so that memory will - be available when the user later tries to evaluate the expression - in GDB. - - This should be done (I think) in a post-processing pass, that walks - an arbitrary agent expression and inserts `trace' operations at the - appropriate points. But it's much faster to just hack them - directly into the code. And since we're in a crunch, that's what - I've done. - - Setting the flag trace_kludge to non-zero enables the code that - emits the trace bytecodes at the appropriate points. */ -int trace_kludge; - -/* Inspired by trace_kludge, this indicates that pointers to chars - should get an added tracenz bytecode to record nonzero bytes, up to - a length that is the value of trace_string_kludge. */ -int trace_string_kludge; - /* Scan for all static fields in the given class, including any base classes, and generate tracing bytecodes for each. */ @@ -401,19 +371,19 @@ gen_traced_pop (struct gdbarch *gdbarch, struct agent_expr *ax, struct axs_value *value) { int string_trace = 0; - if (trace_string_kludge + if (ax->trace_string && TYPE_CODE (value->type) == TYPE_CODE_PTR && c_textual_element_type (check_typedef (TYPE_TARGET_TYPE (value->type)), 's')) string_trace = 1; - if (trace_kludge) + if (ax->tracing) switch (value->kind) { case axs_rvalue: if (string_trace) { - ax_const_l (ax, trace_string_kludge); + ax_const_l (ax, ax->trace_string); ax_simple (ax, aop_tracenz); } else @@ -441,7 +411,7 @@ gen_traced_pop (struct gdbarch *gdbarch, if (string_trace) { ax_simple (ax, aop_ref32); - ax_const_l (ax, trace_string_kludge); + ax_const_l (ax, ax->trace_string); ax_simple (ax, aop_tracenz); } } @@ -459,7 +429,7 @@ gen_traced_pop (struct gdbarch *gdbarch, if (string_trace) { ax_reg (ax, value->u.reg); - ax_const_l (ax, trace_string_kludge); + ax_const_l (ax, ax->trace_string); ax_simple (ax, aop_tracenz); } break; @@ -469,7 +439,7 @@ gen_traced_pop (struct gdbarch *gdbarch, ax_simple (ax, aop_pop); /* To trace C++ classes with static fields stored elsewhere. */ - if (trace_kludge + if (ax->tracing && (TYPE_CODE (value->type) == TYPE_CODE_STRUCT || TYPE_CODE (value->type) == TYPE_CODE_UNION)) gen_trace_static_fields (gdbarch, ax, value->type); @@ -509,7 +479,7 @@ gen_extend (struct agent_expr *ax, struct type *type) static void gen_fetch (struct agent_expr *ax, struct type *type) { - if (trace_kludge) + if (ax->tracing) { /* Record the area of memory we're about to fetch. */ ax_trace_quick (ax, TYPE_LENGTH (type)); @@ -1361,7 +1331,7 @@ gen_bitfield_ref (struct expression *exp, struct agent_expr *ax, /* Add the offset. */ gen_offset (ax, offset / TARGET_CHAR_BIT); - if (trace_kludge) + if (ax->tracing) { /* Record the area of memory we're about to fetch. */ ax_trace_quick (ax, op_size / TARGET_CHAR_BIT); @@ -1930,7 +1900,7 @@ gen_expr (struct expression *exp, union exp_element **pc, if (tsv) { ax_tsv (ax, aop_setv, tsv->number); - if (trace_kludge) + if (ax->tracing) ax_tsv (ax, aop_tracev, tsv->number); } else @@ -1957,7 +1927,7 @@ gen_expr (struct expression *exp, union exp_element **pc, { /* The tsv will be the left half of the binary operation. */ ax_tsv (ax, aop_getv, tsv->number); - if (trace_kludge) + if (ax->tracing) ax_tsv (ax, aop_tracev, tsv->number); /* Trace state variables are always 64-bit integers. */ value1.kind = axs_rvalue; @@ -1966,7 +1936,7 @@ gen_expr (struct expression *exp, union exp_element **pc, gen_expr_binop_rest (exp, op2, pc, ax, value, &value1, &value2); /* We have a result of the binary op, set the tsv. */ ax_tsv (ax, aop_setv, tsv->number); - if (trace_kludge) + if (ax->tracing) ax_tsv (ax, aop_tracev, tsv->number); } else @@ -2047,7 +2017,7 @@ gen_expr (struct expression *exp, union exp_element **pc, if (tsv) { ax_tsv (ax, aop_getv, tsv->number); - if (trace_kludge) + if (ax->tracing) ax_tsv (ax, aop_tracev, tsv->number); /* Trace state variables are always 64-bit integers. */ value->kind = axs_rvalue; @@ -2424,7 +2394,7 @@ gen_expr_binop_rest (struct expression *exp, struct agent_expr * gen_trace_for_var (CORE_ADDR scope, struct gdbarch *gdbarch, - struct symbol *var) + struct symbol *var, int trace_string) { struct cleanup *old_chain = 0; struct agent_expr *ax = new_agent_expr (gdbarch, scope); @@ -2432,7 +2402,8 @@ gen_trace_for_var (CORE_ADDR scope, struct gdbarch *gdbarch, old_chain = make_cleanup_free_agent_expr (ax); - trace_kludge = 1; + ax->tracing = 1; + ax->trace_string = trace_string; gen_var_ref (gdbarch, ax, &value, var); /* If there is no actual variable to trace, flag it by returning @@ -2464,7 +2435,8 @@ gen_trace_for_var (CORE_ADDR scope, struct gdbarch *gdbarch, caller can then use the ax_reqs function to discover which registers it relies upon. */ struct agent_expr * -gen_trace_for_expr (CORE_ADDR scope, struct expression *expr) +gen_trace_for_expr (CORE_ADDR scope, struct expression *expr, + int trace_string) { struct cleanup *old_chain = 0; struct agent_expr *ax = new_agent_expr (expr->gdbarch, scope); @@ -2474,7 +2446,8 @@ gen_trace_for_expr (CORE_ADDR scope, struct expression *expr) old_chain = make_cleanup_free_agent_expr (ax); pc = expr->elts; - trace_kludge = 1; + ax->tracing = 1; + ax->trace_string = trace_string; value.optimized_out = 0; gen_expr (expr, &pc, ax, &value); @@ -2499,7 +2472,7 @@ gen_trace_for_expr (CORE_ADDR scope, struct expression *expr) the result of expression evaluation on the top of the stack. */ struct agent_expr * -gen_eval_for_expr (CORE_ADDR scope, struct expression *expr) +gen_eval_for_expr (CORE_ADDR scope, struct expression *expr, int trace_string) { struct cleanup *old_chain = 0; struct agent_expr *ax = new_agent_expr (expr->gdbarch, scope); @@ -2509,7 +2482,8 @@ gen_eval_for_expr (CORE_ADDR scope, struct expression *expr) old_chain = make_cleanup_free_agent_expr (ax); pc = expr->elts; - trace_kludge = 0; + ax->tracing = 0; + ax->trace_string = trace_string; value.optimized_out = 0; gen_expr (expr, &pc, ax, &value); @@ -2526,7 +2500,8 @@ gen_eval_for_expr (CORE_ADDR scope, struct expression *expr) } struct agent_expr * -gen_trace_for_return_address (CORE_ADDR scope, struct gdbarch *gdbarch) +gen_trace_for_return_address (CORE_ADDR scope, struct gdbarch *gdbarch, + int trace_string) { struct cleanup *old_chain = 0; struct agent_expr *ax = new_agent_expr (gdbarch, scope); @@ -2534,7 +2509,8 @@ gen_trace_for_return_address (CORE_ADDR scope, struct gdbarch *gdbarch) old_chain = make_cleanup_free_agent_expr (ax); - trace_kludge = 1; + ax->tracing = 1; + ax->trace_string = trace_string; gdbarch_gen_return_address (gdbarch, ax, &value, scope); @@ -2570,13 +2546,14 @@ gen_printf (CORE_ADDR scope, struct gdbarch *gdbarch, old_chain = make_cleanup_free_agent_expr (ax); + /* We're computing values, not doing side effects. */ + ax->tracing = 0; + /* Evaluate and push the args on the stack in reverse order, for simplicity of collecting them on the target side. */ for (tem = nargs - 1; tem >= 0; --tem) { pc = exprs[tem]->elts; - /* We're computing values, not doing side effects. */ - trace_kludge = 0; value.optimized_out = 0; gen_expr (exprs[tem], &pc, ax, &value); require_rvalue (ax, &value); @@ -2608,17 +2585,18 @@ agent_eval_command_one (char *exp, int eval, CORE_ADDR pc) struct cleanup *old_chain = 0; struct expression *expr; struct agent_expr *agent; + int trace_string = 0; if (!eval) { - trace_string_kludge = 0; if (*exp == '/') - exp = decode_agent_options (exp); + exp = decode_agent_options (exp, &trace_string); } if (!eval && strcmp (exp, "$_ret") == 0) { - agent = gen_trace_for_return_address (pc, get_current_arch ()); + agent = gen_trace_for_return_address (pc, get_current_arch (), + trace_string); old_chain = make_cleanup_free_agent_expr (agent); } else @@ -2626,9 +2604,9 @@ agent_eval_command_one (char *exp, int eval, CORE_ADDR pc) expr = parse_exp_1 (&exp, pc, block_for_pc (pc), 0); old_chain = make_cleanup (free_current_contents, &expr); if (eval) - agent = gen_eval_for_expr (pc, expr); + agent = gen_eval_for_expr (pc, expr, trace_string); else - agent = gen_trace_for_expr (pc, expr); + agent = gen_trace_for_expr (pc, expr, trace_string); make_cleanup_free_agent_expr (agent); } diff --git a/gdb/ax-gdb.h b/gdb/ax-gdb.h index 04772b7..73eb4ab 100644 --- a/gdb/ax-gdb.h +++ b/gdb/ax-gdb.h @@ -100,15 +100,18 @@ struct axs_value record the value of all memory touched by the expression, and leave no values on the stack. The caller can then use the ax_reqs function to discover which registers the expression uses. */ -extern struct agent_expr *gen_trace_for_expr (CORE_ADDR, struct expression *); +extern struct agent_expr *gen_trace_for_expr (CORE_ADDR, struct expression *, + int); extern struct agent_expr *gen_trace_for_var (CORE_ADDR, struct gdbarch *, - struct symbol *); + struct symbol *, int); extern struct agent_expr *gen_trace_for_return_address (CORE_ADDR, - struct gdbarch *); + struct gdbarch *, + int); -extern struct agent_expr *gen_eval_for_expr (CORE_ADDR, struct expression *); +extern struct agent_expr *gen_eval_for_expr (CORE_ADDR, struct expression *, + int); extern void gen_expr (struct expression *exp, union exp_element **pc, struct agent_expr *ax, struct axs_value *value); @@ -121,7 +124,4 @@ extern struct agent_expr *gen_printf (CORE_ADDR, struct gdbarch *, struct format_piece *, int, struct expression **); -extern int trace_kludge; -extern int trace_string_kludge; - #endif /* AX_GDB_H */ diff --git a/gdb/ax-general.c b/gdb/ax-general.c index 8bd4df6..78d7f7e 100644 --- a/gdb/ax-general.c +++ b/gdb/ax-general.c @@ -58,6 +58,9 @@ new_agent_expr (struct gdbarch *gdbarch, CORE_ADDR scope) x->reg_mask = xmalloc (x->reg_mask_len * sizeof (x->reg_mask[0])); memset (x->reg_mask, 0, x->reg_mask_len * sizeof (x->reg_mask[0])); + x->tracing = 0; + x->trace_string = 0; + return x; } diff --git a/gdb/ax.h b/gdb/ax.h index 32887ef..3bb2d5b 100644 --- a/gdb/ax.h +++ b/gdb/ax.h @@ -143,6 +143,23 @@ struct agent_expr */ int reg_mask_len; unsigned char *reg_mask; + + /* For the data tracing facility, we need to insert `trace' bytecodes + before each data fetch; this records all the memory that the + expression touches in the course of evaluation, so that memory will + be available when the user later tries to evaluate the expression + in GDB. + + Setting the flag 'tracing' to non-zero enables the code that + emits the trace bytecodes at the appropriate points. */ + + unsigned int tracing : 1; + + /* This indicates that pointers to chars should get an added + tracenz bytecode to record nonzero bytes, up to a length that + is the value of trace_string. */ + + int trace_string; }; /* Pointer to an agent_expr structure. */ diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c index d6f8bc5..848b1d2 100644 --- a/gdb/breakpoint.c +++ b/gdb/breakpoint.c @@ -2056,7 +2056,7 @@ parse_cond_to_aexpr (CORE_ADDR scope, struct expression *cond) that may show up. */ TRY_CATCH (ex, RETURN_MASK_ERROR) { - aexpr = gen_eval_for_expr (scope, cond); + aexpr = gen_eval_for_expr (scope, cond, 0); } if (ex.reason < 0) diff --git a/gdb/dwarf2loc.c b/gdb/dwarf2loc.c index f300df2..21bacd0 100644 --- a/gdb/dwarf2loc.c +++ b/gdb/dwarf2loc.c @@ -2541,7 +2541,7 @@ access_memory (struct gdbarch *arch, struct agent_expr *expr, ULONGEST nbits) gdb_assert (nbits > 0 && nbits <= sizeof (LONGEST)); - if (trace_kludge) + if (expr->tracing) ax_trace_quick (expr, nbytes); if (nbits <= 8) diff --git a/gdb/remote.c b/gdb/remote.c index 8fc6b85..cd02308 100644 --- a/gdb/remote.c +++ b/gdb/remote.c @@ -10449,7 +10449,7 @@ remote_download_tracepoint (struct bp_location *loc) capabilities at definition time. */ if (remote_supports_cond_tracepoints ()) { - aexpr = gen_eval_for_expr (tpaddr, loc->cond); + aexpr = gen_eval_for_expr (tpaddr, loc->cond, 0); aexpr_chain = make_cleanup_free_agent_expr (aexpr); xsnprintf (buf + strlen (buf), BUF_SIZE - strlen (buf), ":X%x,", aexpr->len); diff --git a/gdb/tracepoint.c b/gdb/tracepoint.c index 9eff137..2119155 100644 --- a/gdb/tracepoint.c +++ b/gdb/tracepoint.c @@ -611,10 +611,12 @@ teval_pseudocommand (char *args, int from_tty) /* Parse any collection options, such as /s for strings. */ char * -decode_agent_options (char *exp) +decode_agent_options (char *exp, int *trace_string) { struct value_print_options opts; + *trace_string = 0; + if (*exp != '/') return exp; @@ -630,10 +632,10 @@ decode_agent_options (char *exp) /* Allow an optional decimal number giving an explicit maximum string length, defaulting it to the "print elements" value; so "collect/s80 mystr" gets at most 80 bytes of string. */ - trace_string_kludge = opts.print_max; + *trace_string = opts.print_max; exp++; if (*exp >= '0' && *exp <= '9') - trace_string_kludge = atoi (exp); + *trace_string = atoi (exp); while (*exp >= '0' && *exp <= '9') exp++; } @@ -709,6 +711,7 @@ validate_actionline (char **line, struct breakpoint *b) struct bp_location *loc; struct agent_expr *aexpr; struct tracepoint *t = (struct tracepoint *) b; + int trace_string = 0; /* If EOF is typed, *line is NULL. */ if (*line == NULL) @@ -729,9 +732,8 @@ validate_actionline (char **line, struct breakpoint *b) if (cmd_cfunc_eq (c, collect_pseudocommand)) { - trace_string_kludge = 0; if (*p == '/') - p = decode_agent_options (p); + p = decode_agent_options (p, &trace_string); do { /* Repeat over a comma-separated list. */ @@ -780,7 +782,7 @@ validate_actionline (char **line, struct breakpoint *b) /* We have something to collect, make sure that the expr to bytecode translator can handle it and that it's not too long. */ - aexpr = gen_trace_for_expr (loc->address, exp); + aexpr = gen_trace_for_expr (loc->address, exp, trace_string); make_cleanup_free_agent_expr (aexpr); if (aexpr->len > MAX_AGENT_EXPR_LEN) @@ -815,7 +817,7 @@ validate_actionline (char **line, struct breakpoint *b) /* We have something to evaluate, make sure that the expr to bytecode translator can handle it and that it's not too long. */ - aexpr = gen_eval_for_expr (loc->address, exp); + aexpr = gen_eval_for_expr (loc->address, exp, 0); make_cleanup_free_agent_expr (aexpr); if (aexpr->len > MAX_AGENT_EXPR_LEN) @@ -986,7 +988,8 @@ collect_symbol (struct collection_list *collect, struct symbol *sym, struct gdbarch *gdbarch, long frame_regno, long frame_offset, - CORE_ADDR scope) + CORE_ADDR scope, + int trace_string) { unsigned long len; unsigned int reg; @@ -1097,7 +1100,7 @@ collect_symbol (struct collection_list *collect, struct agent_expr *aexpr; struct cleanup *old_chain1 = NULL; - aexpr = gen_trace_for_var (scope, gdbarch, sym); + aexpr = gen_trace_for_var (scope, gdbarch, sym, trace_string); /* It can happen that the symbol is recorded as a computed location, but it's been optimized away and doesn't actually @@ -1150,6 +1153,7 @@ struct add_local_symbols_data long frame_regno; long frame_offset; int count; + int trace_string; }; /* The callback for the locals and args iterators. */ @@ -1162,7 +1166,7 @@ do_collect_symbol (const char *print_name, struct add_local_symbols_data *p = cb_data; collect_symbol (p->collect, sym, p->gdbarch, p->frame_regno, - p->frame_offset, p->pc); + p->frame_offset, p->pc, p->trace_string); p->count++; } @@ -1170,7 +1174,8 @@ do_collect_symbol (const char *print_name, static void add_local_symbols (struct collection_list *collect, struct gdbarch *gdbarch, CORE_ADDR pc, - long frame_regno, long frame_offset, int type) + long frame_regno, long frame_offset, int type, + int trace_string) { struct block *block; struct add_local_symbols_data cb_data; @@ -1181,6 +1186,7 @@ add_local_symbols (struct collection_list *collect, cb_data.frame_regno = frame_regno; cb_data.frame_offset = frame_offset; cb_data.count = 0; + cb_data.trace_string = trace_string; if (type == 'L') { @@ -1388,9 +1394,10 @@ encode_actions_1 (struct command_line *action, if (cmd_cfunc_eq (cmd, collect_pseudocommand)) { - trace_string_kludge = 0; + int trace_string = 0; + if (*action_exp == '/') - action_exp = decode_agent_options (action_exp); + action_exp = decode_agent_options (action_exp, &trace_string); do { /* Repeat over a comma-separated list. */ @@ -1410,7 +1417,8 @@ encode_actions_1 (struct command_line *action, tloc->address, frame_reg, frame_offset, - 'A'); + 'A', + trace_string); action_exp = strchr (action_exp, ','); /* more? */ } else if (0 == strncasecmp ("$loc", action_exp, 4)) @@ -1420,7 +1428,8 @@ encode_actions_1 (struct command_line *action, tloc->address, frame_reg, frame_offset, - 'L'); + 'L', + trace_string); action_exp = strchr (action_exp, ','); /* more? */ } else if (0 == strncasecmp ("$_ret", action_exp, 5)) @@ -1428,7 +1437,8 @@ encode_actions_1 (struct command_line *action, struct cleanup *old_chain1 = NULL; aexpr = gen_trace_for_return_address (tloc->address, - tloc->gdbarch); + tloc->gdbarch, + trace_string); old_chain1 = make_cleanup_free_agent_expr (aexpr); @@ -1509,11 +1519,13 @@ encode_actions_1 (struct command_line *action, tloc->gdbarch, frame_reg, frame_offset, - tloc->address); + tloc->address, + trace_string); break; default: /* Full-fledged expression. */ - aexpr = gen_trace_for_expr (tloc->address, exp); + aexpr = gen_trace_for_expr (tloc->address, exp, + trace_string); old_chain1 = make_cleanup_free_agent_expr (aexpr); @@ -1566,7 +1578,7 @@ encode_actions_1 (struct command_line *action, block_for_pc (tloc->address), 1); old_chain = make_cleanup (free_current_contents, &exp); - aexpr = gen_eval_for_expr (tloc->address, exp); + aexpr = gen_eval_for_expr (tloc->address, exp, 0); old_chain1 = make_cleanup_free_agent_expr (aexpr); ax_reqs (aexpr); @@ -2846,8 +2858,10 @@ trace_dump_actions (struct command_line *action, STEPPING_ACTIONS should be equal. */ if (stepping_frame == stepping_actions) { + int trace_string = 0; + if (*action_exp == '/') - action_exp = decode_agent_options (action_exp); + action_exp = decode_agent_options (action_exp, &trace_string); do { /* Repeat over a comma-separated list. */ diff --git a/gdb/tracepoint.h b/gdb/tracepoint.h index b2b9d7c..369aaa5 100644 --- a/gdb/tracepoint.h +++ b/gdb/tracepoint.h @@ -237,7 +237,7 @@ struct cleanup *make_cleanup_restore_traceframe_number (void); void free_actions (struct breakpoint *); -extern char *decode_agent_options (char *exp); +extern char *decode_agent_options (char *exp, int *trace_string); extern void encode_actions (struct breakpoint *t, struct bp_location *tloc, char ***tdp_actions, char ***stepping_actions);