X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Feval.c;h=87874420dc8643f422b78a7adac9039c89198a9a;hb=2dc4b12fcd647b883223efeb308c277e629b369c;hp=9d8eb3476baf226b5ae2d3389c2bb39872933f8c;hpb=582942f4560f1c8d2a60c2557267f9d3ad8dd6aa;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/eval.c b/gdb/eval.c index 9d8eb3476b..87874420dc 100644 --- a/gdb/eval.c +++ b/gdb/eval.c @@ -42,9 +42,6 @@ #include "typeprint.h" #include -/* This is defined in valops.c */ -extern int overload_resolution; - /* Prototypes for local functions. */ static struct value *evaluate_subexp_for_sizeof (struct expression *, int *, @@ -201,11 +198,11 @@ fetch_subexp_value (struct expression *exp, int *pc, struct value **valp, mark = value_mark (); result = NULL; - TRY + try { result = evaluate_subexp (NULL_TYPE, exp, pc, EVAL_NORMAL); } - CATCH (ex, RETURN_MASK_ALL) + catch (const gdb_exception &ex) { /* Ignore memory errors if we want watchpoints pointing at inaccessible memory to still be created; otherwise, throw the @@ -217,11 +214,10 @@ fetch_subexp_value (struct expression *exp, int *pc, struct value **valp, break; /* Fall through. */ default: - throw_exception (ex); + throw; break; } } - END_CATCH new_mark = value_mark (); if (mark == new_mark) @@ -238,15 +234,14 @@ fetch_subexp_value (struct expression *exp, int *pc, struct value **valp, else { - TRY + try { value_fetch_lazy (result); *valp = result; } - CATCH (except, RETURN_MASK_ERROR) + catch (const gdb_exception_error &except) { } - END_CATCH } } @@ -347,7 +342,7 @@ evaluate_struct_tuple (struct value *struct_val, /* Recursive helper function for setting elements of array tuples. The target is ARRAY (which has bounds LOW_BOUND to HIGH_BOUND); the element value is ELEMENT; EXP, POS and NOSIDE are as usual. - Evaluates index expresions and sets the specified element(s) of + Evaluates index expressions and sets the specified element(s) of ARRAY to ELEMENT. Returns last index value. */ static LONGEST @@ -423,7 +418,7 @@ unop_promote (const struct language_defn *language, struct gdbarch *gdbarch, { default: /* Perform integral promotion for ANSI C/C++. - If not appropropriate for any particular language + If not appropriate for any particular language it needs to modify this function. */ { struct type *builtin_int = builtin_type (gdbarch)->builtin_int; @@ -716,19 +711,18 @@ evaluate_var_value (enum noside noside, const block *blk, symbol *var) struct value *ret = NULL; - TRY + try { ret = value_of_variable (var, blk); } - CATCH (except, RETURN_MASK_ERROR) + catch (const gdb_exception_error &except) { if (noside != EVAL_AVOID_SIDE_EFFECTS) - throw_exception (except); + throw; ret = value_zero (SYMBOL_TYPE (var), not_lval); } - END_CATCH return ret; } @@ -957,19 +951,18 @@ evaluate_funcall (type *expect_type, expression *exp, int *pos, while (unop_user_defined_p (op, arg2)) { struct value *value = NULL; - TRY + try { value = value_x_unop (arg2, op, noside); } - CATCH (except, RETURN_MASK_ERROR) + catch (const gdb_exception_error &except) { if (except.error == NOT_FOUND_ERROR) break; else - throw_exception (except); + throw; } - END_CATCH arg2 = value; } @@ -1051,12 +1044,12 @@ evaluate_funcall (type *expect_type, expression *exp, int *pos, if (op == OP_VAR_MSYM_VALUE) { minimal_symbol *msym = exp->elts[*pos + 2].msymbol; - var_func_name = MSYMBOL_PRINT_NAME (msym); + var_func_name = msym->print_name (); } else if (op == OP_VAR_VALUE) { symbol *sym = exp->elts[*pos + 2].symbol; - var_func_name = SYMBOL_PRINT_NAME (sym); + var_func_name = sym->print_name (); } argvec[0] = evaluate_subexp_with_coercion (exp, pos, noside); @@ -1307,7 +1300,7 @@ evaluate_subexp_standard (struct type *expect_type, (*pos) += 3; symbol *var = exp->elts[pc + 2].symbol; if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_ERROR) - error_unknown_type (SYMBOL_PRINT_NAME (var)); + error_unknown_type (var->print_name ()); if (noside != EVAL_SKIP) return evaluate_var_value (noside, exp->elts[pc + 1].block, var); else @@ -1330,7 +1323,7 @@ evaluate_subexp_standard (struct type *expect_type, type = value_type (val); if (TYPE_CODE (type) == TYPE_CODE_ERROR && (noside != EVAL_AVOID_SIDE_EFFECTS || pc != 0)) - error_unknown_type (MSYMBOL_PRINT_NAME (msymbol)); + error_unknown_type (msymbol->print_name ()); return val; } @@ -1349,7 +1342,7 @@ evaluate_subexp_standard (struct type *expect_type, if (SYMBOL_COMPUTED_OPS (sym) == NULL || SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry == NULL) error (_("Symbol \"%s\" does not have any specific entry value"), - SYMBOL_PRINT_NAME (sym)); + sym->print_name ()); frame = get_selected_frame (NULL); return SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry (sym, frame); @@ -1554,7 +1547,7 @@ evaluate_subexp_standard (struct type *expect_type, { int bit_index = (unsigned) range_low % TARGET_CHAR_BIT; - if (gdbarch_bits_big_endian (exp->gdbarch)) + if (gdbarch_byte_order (exp->gdbarch) == BFD_ENDIAN_BIG) bit_index = TARGET_CHAR_BIT - 1 - bit_index; valaddr[(unsigned) range_low / TARGET_CHAR_BIT] |= 1 << bit_index; @@ -1979,6 +1972,7 @@ evaluate_subexp_standard (struct type *expect_type, case TYPE_CODE_PTR: case TYPE_CODE_FUNC: + case TYPE_CODE_INTERNAL_FUNCTION: /* It's a function call. */ /* Allocate arg vector, including space for the function to be called in argvec[0] and a terminating NULL. */ @@ -1996,10 +1990,13 @@ evaluate_subexp_standard (struct type *expect_type, results in malloc being called with a pointer to an integer followed by an attempt to malloc the arguments to malloc in target memory. Infinite recursion ensues. */ - bool is_artificial = - TYPE_FIELD_ARTIFICIAL (value_type (arg1), tem - 1); - argvec[tem] = fortran_argument_convert (argvec[tem], - is_artificial); + if (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC) + { + bool is_artificial + = TYPE_FIELD_ARTIFICIAL (value_type (arg1), tem - 1); + argvec[tem] = fortran_argument_convert (argvec[tem], + is_artificial); + } } argvec[tem] = 0; /* signal end of arglist */ if (noside == EVAL_SKIP) @@ -2043,19 +2040,18 @@ evaluate_subexp_standard (struct type *expect_type, while (unop_user_defined_p (op, arg1)) { struct value *value = NULL; - TRY + try { value = value_x_unop (arg1, op, noside); } - CATCH (except, RETURN_MASK_ERROR) + catch (const gdb_exception_error &except) { if (except.error == NOT_FOUND_ERROR) break; else - throw_exception (except); + throw; } - END_CATCH arg1 = value; } @@ -2155,7 +2151,14 @@ evaluate_subexp_standard (struct type *expect_type, case BINOP_ASSIGN: arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); - arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside); + /* Special-case assignments where the left-hand-side is a + convenience variable -- in these, don't bother setting an + expected type. This avoids a weird case where re-assigning a + string or array to an internal variable could error with "Too + many array elements". */ + arg2 = evaluate_subexp (VALUE_LVAL (arg1) == lval_internalvar + ? NULL_TYPE : value_type (arg1), + exp, pos, noside); if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS) return arg1; @@ -3215,7 +3218,7 @@ evaluate_subexp_for_sizeof (struct expression *exp, int *pos, type = value_type (mval); if (TYPE_CODE (type) == TYPE_CODE_ERROR) - error_unknown_type (MSYMBOL_PRINT_NAME (msymbol)); + error_unknown_type (msymbol->print_name ()); return value_from_longest (size_type, TYPE_LENGTH (type)); } @@ -3223,7 +3226,7 @@ evaluate_subexp_for_sizeof (struct expression *exp, int *pos, /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting type of the subscript is a variable length array type. In this case we - must re-evaluate the right hand side of the subcription to allow + must re-evaluate the right hand side of the subscription to allow side-effects. */ case BINOP_SUBSCRIPT: if (noside == EVAL_NORMAL)