2008-05-03 Pedro Alves * expression.h (parse_exp_1): Take a context PC instead of a context block. * parse.c (parse_exp_1): Adjust. (parse_exp_in_context): Take a context PC instead of a context block. If valid PC is passed, get the context block from it. (parse_expression): Adjust to the new signature of parse_exp_1. * ada-lang.c (ada_parse_catchpoint_condition): Likewise. * breakpoint.c (condition_command, update_watchpoint): Likewise. * eval.c (parse_and_eval_address_1, parse_to_comma_and_eval): Likewise. * tracepoint.c (validate_actionline, encode_actions): Likewise. * varobj.c (varobj_create, varobj_set_value): Likewise. * wrapper.h (gdb_parse_exp_1): Take a context PC instead of a context block. * wrapper.c (gdb_parse_exp_1): Adjust to the new signature of parse_exp_1. --- gdb/ada-lang.c | 2 +- gdb/breakpoint.c | 24 +++++++++++++++--------- gdb/eval.c | 4 ++-- gdb/expression.h | 2 +- gdb/parse.c | 49 +++++++++++++++++++++++++------------------------ gdb/tracepoint.c | 5 ++--- gdb/varobj.c | 11 ++++++----- gdb/wrapper.c | 4 ++-- gdb/wrapper.h | 2 +- 9 files changed, 55 insertions(+), 48 deletions(-) Index: src/gdb/expression.h =================================================================== --- src.orig/gdb/expression.h 2008-05-03 23:17:27.000000000 +0100 +++ src/gdb/expression.h 2008-05-03 23:23:41.000000000 +0100 @@ -389,7 +389,7 @@ struct expression extern struct expression *parse_expression (char *); -extern struct expression *parse_exp_1 (char **, struct block *, int); +extern struct expression *parse_exp_1 (char **, CORE_ADDR, int); /* The innermost context required by the stack and register variables we've encountered so far. To use this, set it to NULL, then call Index: src/gdb/parse.c =================================================================== --- src.orig/gdb/parse.c 2008-05-03 23:23:39.000000000 +0100 +++ src/gdb/parse.c 2008-05-03 23:23:41.000000000 +0100 @@ -105,8 +105,7 @@ static void prefixify_expression (struct static void prefixify_subexp (struct expression *, struct expression *, int, int); -static struct expression *parse_exp_in_context (char **, struct block *, int, - int); +static struct expression *parse_exp_in_context (char **, CORE_ADDR, int, int); void _initialize_parse (void); @@ -924,8 +923,8 @@ prefixify_subexp (struct expression *ine /* Read an expression from the string *STRINGPTR points to, parse it, and return a pointer to a struct expression that we malloc. - Use block BLOCK as the lexical context for variable names; - if BLOCK is zero, use the block of the selected stack frame. + Use CONTEXT_PC to get the lexical context for variable names; + if CONTEXT_PC is -1, use the block of the selected stack frame. Meanwhile, advance *STRINGPTR to point after the expression, at the first nonwhite character that is not part of the expression (possibly a null character). @@ -933,16 +932,16 @@ prefixify_subexp (struct expression *ine If COMMA is nonzero, stop if a comma is reached. */ struct expression * -parse_exp_1 (char **stringptr, struct block *block, int comma) +parse_exp_1 (char **stringptr, CORE_ADDR context_pc, int comma) { - return parse_exp_in_context (stringptr, block, comma, 0); + return parse_exp_in_context (stringptr, context_pc, comma, 0); } /* As for parse_exp_1, except that if VOID_CONTEXT_P, then no value is expected from the expression. */ static struct expression * -parse_exp_in_context (char **stringptr, struct block *block, int comma, +parse_exp_in_context (char **stringptr, CORE_ADDR context_pc, int comma, int void_context_p) { struct cleanup *old_chain; @@ -961,24 +960,26 @@ parse_exp_in_context (char **stringptr, old_chain = make_cleanup (free_funcalls, 0 /*ignore*/); funcall_chain = 0; - expression_context_block = block; - - /* If no context specified, try using the current frame, if any. */ - if (!expression_context_block) - expression_context_block = get_selected_block (&expression_context_pc); + if (context_pc != ~(CORE_ADDR) 0) + { + expression_context_block = block_for_pc (context_pc); + expression_context_pc = context_pc; + } else - expression_context_pc = BLOCK_START (expression_context_block); - - /* Fall back to using the current source static context, if any. */ - - if (!expression_context_block) { - struct symtab_and_line cursal = get_current_source_symtab_and_line (); - if (cursal.symtab) - expression_context_block - = BLOCKVECTOR_BLOCK (BLOCKVECTOR (cursal.symtab), STATIC_BLOCK); - if (expression_context_block) - expression_context_pc = BLOCK_START (expression_context_block); + /* If no context specified, try using the current frame, if any. */ + expression_context_block = get_selected_block (&expression_context_pc); + + /* Fall back to using the current source static context, if any. */ + if (!expression_context_block) + { + struct symtab_and_line cursal = get_current_source_symtab_and_line (); + if (cursal.symtab) + expression_context_block + = BLOCKVECTOR_BLOCK (BLOCKVECTOR (cursal.symtab), STATIC_BLOCK); + if (expression_context_block) + expression_context_pc = BLOCK_START (expression_context_block); + } } expout_size = 10; @@ -1027,7 +1028,7 @@ struct expression * parse_expression (char *string) { struct expression *exp; - exp = parse_exp_1 (&string, 0, 0); + exp = parse_exp_1 (&string, ~(CORE_ADDR) 0, 0); if (*string) error (_("Junk after end of expression.")); return exp; Index: src/gdb/ada-lang.c =================================================================== --- src.orig/gdb/ada-lang.c 2008-05-03 23:17:27.000000000 +0100 +++ src/gdb/ada-lang.c 2008-05-03 23:23:41.000000000 +0100 @@ -10402,7 +10402,7 @@ static struct expression * ada_parse_catchpoint_condition (char *cond_string, struct symtab_and_line sal) { - return (parse_exp_1 (&cond_string, block_for_pc (sal.pc), 0)); + return (parse_exp_1 (&cond_string, sal.pc, 0)); } /* Return the symtab_and_line that should be used to insert an exception Index: src/gdb/breakpoint.c =================================================================== --- src.orig/gdb/breakpoint.c 2008-05-03 23:23:15.000000000 +0100 +++ src/gdb/breakpoint.c 2008-05-03 23:23:41.000000000 +0100 @@ -617,7 +617,7 @@ condition_command (char *arg, int from_t { arg = p; loc->cond = - parse_exp_1 (&arg, block_for_pc (loc->address), 0); + parse_exp_1 (&arg, loc->address, 0); if (*arg) error (_("Junk at end of expression")); } @@ -910,13 +910,17 @@ update_watchpoint (struct breakpoint *b, if (within_current_scope && reparse) { char *s; + CORE_ADDR context_pc = ~(CORE_ADDR) 0; + if (b->exp) { xfree (b->exp); b->exp = NULL; } s = b->exp_string; - b->exp = parse_exp_1 (&s, b->exp_valid_block, 0); + if (b->exp_valid_block) + context_pc = BLOCK_START (b->exp_valid_block); + b->exp = parse_exp_1 (&s, context_pc, 0); /* If the meaning of expression itself changed, the old value is no longer relevant. We don't want to report a watchpoint hit to the user when the old value and the new value may actually @@ -1001,7 +1005,10 @@ update_watchpoint (struct breakpoint *b, if (b->cond_string != NULL) { char *s = b->cond_string; - b->loc->cond = parse_exp_1 (&s, b->exp_valid_block, 0); + CORE_ADDR context_pc = ~(CORE_ADDR) 0; + if (b->exp_valid_block) + context_pc = BLOCK_START (b->exp_valid_block); + b->loc->cond = parse_exp_1 (&s, context_pc, 0); } } else if (!within_current_scope) @@ -5111,7 +5118,7 @@ create_breakpoint (struct symtabs_and_li if (b->cond_string) { char *arg = b->cond_string; - loc->cond = parse_exp_1 (&arg, block_for_pc (loc->address), 0); + loc->cond = parse_exp_1 (&arg, loc->address, 0); if (*arg) error (_("Garbage %s follows condition"), arg); } @@ -5410,7 +5417,7 @@ find_condition_and_thread (char *tok, CO if (toklen >= 1 && strncmp (tok, "if", toklen) == 0) { tok = cond_start = end_tok + 1; - parse_exp_1 (&tok, block_for_pc (pc), 0); + parse_exp_1 (&tok, pc, 0); cond_end = tok; *cond_string = savestring (cond_start, cond_end - cond_start); @@ -5916,7 +5923,7 @@ watch_command_1 (char *arg, int accessfl /* Parse the rest of the arguments. */ innermost_block = NULL; exp_start = arg; - exp = parse_exp_1 (&arg, 0, 0); + exp = parse_exp_1 (&arg, ~(CORE_ADDR) 0, 0); exp_end = arg; exp_valid_block = innermost_block; mark = value_mark (); @@ -5936,7 +5943,7 @@ watch_command_1 (char *arg, int accessfl if (toklen >= 1 && strncmp (tok, "if", toklen) == 0) { tok = cond_start = end_tok + 1; - cond = parse_exp_1 (&tok, 0, 0); + cond = parse_exp_1 (&tok, ~(CORE_ADDR) 0, 0); cond_end = tok; } if (*tok) @@ -7326,8 +7333,7 @@ update_breakpoint_locations (struct brea s = b->cond_string; TRY_CATCH (e, RETURN_MASK_ERROR) { - new_loc->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc), - 0); + new_loc->cond = parse_exp_1 (&s, sals.sals[i].pc, 0); } if (e.reason < 0) { Index: src/gdb/eval.c =================================================================== --- src.orig/gdb/eval.c 2008-05-03 23:17:27.000000000 +0100 +++ src/gdb/eval.c 2008-05-03 23:23:41.000000000 +0100 @@ -98,7 +98,7 @@ parse_and_eval_address (char *exp) CORE_ADDR parse_and_eval_address_1 (char **expptr) { - struct expression *expr = parse_exp_1 (expptr, (struct block *) 0, 0); + struct expression *expr = parse_exp_1 (expptr, ~(CORE_ADDR) 0, 0); CORE_ADDR addr; struct cleanup *old_chain = make_cleanup (free_current_contents, &expr); @@ -143,7 +143,7 @@ parse_and_eval (char *exp) struct value * parse_to_comma_and_eval (char **expp) { - struct expression *expr = parse_exp_1 (expp, (struct block *) 0, 1); + struct expression *expr = parse_exp_1 (expp, ~(CORE_ADDR) 0, 1); struct value *val; struct cleanup *old_chain = make_cleanup (free_current_contents, &expr); Index: src/gdb/tracepoint.c =================================================================== --- src.orig/gdb/tracepoint.c 2008-05-03 23:17:27.000000000 +0100 +++ src/gdb/tracepoint.c 2008-05-03 23:23:41.000000000 +0100 @@ -973,7 +973,7 @@ validate_actionline (char **line, struct } /* else fall thru, treat p as an expression and parse it! */ } - exp = parse_exp_1 (&p, block_for_pc (t->address), 1); + exp = parse_exp_1 (&p, t->address, 1); old_chain = make_cleanup (free_current_contents, &exp); if (exp->elts[0].opcode == OP_VAR_VALUE) @@ -1600,8 +1600,7 @@ encode_actions (struct tracepoint *t, ch struct cleanup *old_chain1 = NULL; struct agent_reqs areqs; - exp = parse_exp_1 (&action_exp, - block_for_pc (t->address), 1); + exp = parse_exp_1 (&action_exp, t->address, 1); old_chain = make_cleanup (free_current_contents, &exp); switch (exp->elts[0].opcode) Index: src/gdb/varobj.c =================================================================== --- src.orig/gdb/varobj.c 2008-05-03 23:17:27.000000000 +0100 +++ src/gdb/varobj.c 2008-05-03 23:23:41.000000000 +0100 @@ -447,7 +447,6 @@ varobj_create (char *objname, struct varobj *var; struct frame_info *fi; struct frame_info *old_fi = NULL; - struct block *block; struct cleanup *old_chain; /* Fill out a varobj structure for the (root) variable being constructed. */ @@ -460,6 +459,7 @@ varobj_create (char *objname, enum varobj_languages lang; struct value *value = NULL; int expr_len; + CORE_ADDR context_pc; /* Parse and evaluate the expression, filling in as much of the variable's data as possible */ @@ -480,15 +480,16 @@ varobj_create (char *objname, if (type == USE_SELECTED_FRAME) var->root->floating = 1; - block = NULL; if (fi != NULL) - block = get_frame_block (fi, 0); + context_pc = get_frame_pc (fi); + else + context_pc = ~(CORE_ADDR) 0; p = expression; innermost_block = NULL; /* Wrap the call to parse expression, so we can return a sensible error. */ - if (!gdb_parse_exp_1 (&p, block, 0, &var->root->exp)) + if (!gdb_parse_exp_1 (&p, context_pc, 0, &var->root->exp)) { return NULL; } @@ -898,7 +899,7 @@ varobj_set_value (struct varobj *var, ch gdb_assert (varobj_editable_p (var)); input_radix = 10; /* ALWAYS reset to decimal temporarily */ - exp = parse_exp_1 (&s, 0, 0); + exp = parse_exp_1 (&s, ~(CORE_ADDR) 0, 0); if (!gdb_evaluate_expression (exp, &value)) { /* We cannot proceed without a valid expression. */ Index: src/gdb/wrapper.h =================================================================== --- src.orig/gdb/wrapper.h 2008-05-03 23:17:27.000000000 +0100 +++ src/gdb/wrapper.h 2008-05-03 23:23:41.000000000 +0100 @@ -24,7 +24,7 @@ struct value; struct expression; struct block; -extern int gdb_parse_exp_1 (char **, struct block *, +extern int gdb_parse_exp_1 (char **, CORE_ADDR, int, struct expression **); extern int gdb_evaluate_expression (struct expression *, struct value **); Index: src/gdb/wrapper.c =================================================================== --- src.orig/gdb/wrapper.c 2008-05-03 23:17:27.000000000 +0100 +++ src/gdb/wrapper.c 2008-05-03 23:23:41.000000000 +0100 @@ -22,14 +22,14 @@ #include "ui-out.h" int -gdb_parse_exp_1 (char **stringptr, struct block *block, int comma, +gdb_parse_exp_1 (char **stringptr, CORE_ADDR context_pc, int comma, struct expression **expression) { volatile struct gdb_exception except; TRY_CATCH (except, RETURN_MASK_ERROR) { - *expression = parse_exp_1 (stringptr, block, comma); + *expression = parse_exp_1 (stringptr, context_pc, comma); } if (except.reason < 0)