X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Feval.c;h=1dbf6fa50876d04745463b663bce245a5532e403;hb=d7f9d729727b2b85ae3228785762f4d2e6a8742f;hp=8a0cd87d93fc7a856546e6555846ce3330b38a87;hpb=9eec4d1e39028b54f54638c90b2c628b958162fe;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/eval.c b/gdb/eval.c index 8a0cd87d93..1dbf6fa508 100644 --- a/gdb/eval.c +++ b/gdb/eval.c @@ -1,8 +1,8 @@ /* Evaluate expressions for GDB. Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, - 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008 - Free Software Foundation, Inc. + 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008, + 2009, 2010 Free Software Foundation, Inc. This file is part of GDB. @@ -38,16 +38,19 @@ #include "ui-out.h" #include "exceptions.h" #include "regcache.h" +#include "user-regs.h" +#include "valprint.h" +#include "gdb_obstack.h" +#include "objfiles.h" +#include "python/python.h" #include "gdb_assert.h" +#include + /* This is defined in valops.c */ extern int overload_resolution; -/* JYG: lookup rtti type of STRUCTOP_PTR when this is set to continue - on with successful lookup for member/method of the rtti type. */ -extern int objectprint; - /* Prototypes for local functions. */ static struct value *evaluate_subexp_for_sizeof (struct expression *, int *); @@ -55,9 +58,6 @@ static struct value *evaluate_subexp_for_sizeof (struct expression *, int *); static struct value *evaluate_subexp_for_address (struct expression *, int *, enum noside); -static struct value *evaluate_subexp (struct type *, struct expression *, - int *, enum noside); - static char *get_label (struct expression *, int *); static struct value *evaluate_struct_tuple (struct value *, @@ -68,7 +68,7 @@ static LONGEST init_array_element (struct value *, struct value *, struct expression *, int *, enum noside, LONGEST, LONGEST); -static struct value * +struct value * evaluate_subexp (struct type *expect_type, struct expression *exp, int *pos, enum noside noside) { @@ -162,6 +162,7 @@ struct value * evaluate_expression (struct expression *exp) { int pc = 0; + return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_NORMAL); } @@ -172,9 +173,41 @@ struct value * evaluate_type (struct expression *exp) { int pc = 0; + return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS); } +/* Evaluate a subexpression, avoiding all memory references and + getting a value whose type alone is correct. */ + +struct value * +evaluate_subexpression_type (struct expression *exp, int subexp) +{ + return evaluate_subexp (NULL_TYPE, exp, &subexp, EVAL_AVOID_SIDE_EFFECTS); +} + +/* Extract a field operation from an expression. If the subexpression + of EXP starting at *SUBEXP is not a structure dereference + operation, return NULL. Otherwise, return the name of the + dereferenced field, and advance *SUBEXP to point to the + subexpression of the left-hand-side of the dereference. This is + used when completing field names. */ + +char * +extract_field_op (struct expression *exp, int *subexp) +{ + int tem; + char *result; + + if (exp->elts[*subexp].opcode != STRUCTOP_STRUCT + && exp->elts[*subexp].opcode != STRUCTOP_PTR) + return NULL; + tem = longest_to_int (exp->elts[*subexp + 1].longconst); + result = &exp->elts[*subexp + 2].string; + (*subexp) += 1 + 3 + BYTES_TO_EXP_ELEM (tem + 1); + return result; +} + /* If the next expression is an OP_LABELED, skips past it, returning the label. Otherwise, does nothing and returns NULL. */ @@ -186,6 +219,7 @@ get_label (struct expression *exp, int *pos) int pc = (*pos)++; char *name = &exp->elts[pc + 2].string; int tem = longest_to_int (exp->elts[pc + 1].longconst); + (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1); return name; } @@ -207,6 +241,7 @@ evaluate_struct_tuple (struct value *struct_val, int fieldno = -1; int variantno = -1; int subfieldno = -1; + while (--nargs >= 0) { int pc = *pos; @@ -222,12 +257,14 @@ evaluate_struct_tuple (struct value *struct_val, do { char *label = get_label (exp, &pc); + if (label) { for (fieldno = 0; fieldno < TYPE_NFIELDS (struct_type); fieldno++) { char *field_name = TYPE_FIELD_NAME (struct_type, fieldno); + if (field_name != NULL && strcmp (field_name, label) == 0) { variantno = -1; @@ -240,6 +277,7 @@ evaluate_struct_tuple (struct value *struct_val, fieldno++) { char *field_name = TYPE_FIELD_NAME (struct_type, fieldno); + field_type = TYPE_FIELD_TYPE (struct_type, fieldno); if ((field_name == 0 || *field_name == '\0') && TYPE_CODE (field_type) == TYPE_CODE_UNION) @@ -288,7 +326,8 @@ evaluate_struct_tuple (struct value *struct_val, fieldno++; /* Skip static fields. */ while (fieldno < TYPE_NFIELDS (struct_type) - && TYPE_FIELD_STATIC_KIND (struct_type, fieldno)) + && field_is_static (&TYPE_FIELD (struct_type, + fieldno))) fieldno++; subfieldno = fieldno; if (fieldno >= TYPE_NFIELDS (struct_type)) @@ -325,8 +364,8 @@ evaluate_struct_tuple (struct value *struct_val, bitpos += TYPE_FIELD_BITPOS (substruct_type, subfieldno); addr = value_contents_writeable (struct_val) + bitpos / 8; if (bitsize) - modify_field (addr, value_as_long (val), - bitpos % 8, bitsize); + modify_field (struct_type, addr, + value_as_long (val), bitpos % 8, bitsize); else memcpy (addr, value_contents (val), TYPE_LENGTH (value_type (val))); @@ -350,6 +389,7 @@ init_array_element (struct value *array, struct value *element, { LONGEST index; int element_size = TYPE_LENGTH (value_type (element)); + if (exp->elts[*pos].opcode == BINOP_COMMA) { (*pos)++; @@ -361,6 +401,7 @@ init_array_element (struct value *array, struct value *element, else if (exp->elts[*pos].opcode == BINOP_RANGE) { LONGEST low, high; + (*pos)++; low = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside)); high = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside)); @@ -384,7 +425,7 @@ init_array_element (struct value *array, struct value *element, return index; } -struct value * +static struct value * value_f90_subarray (struct value *array, struct expression *exp, int *pos, enum noside noside) { @@ -408,6 +449,244 @@ value_f90_subarray (struct value *array, return value_slice (array, low_bound, high_bound - low_bound + 1); } + +/* Promote value ARG1 as appropriate before performing a unary operation + on this argument. + If the result is not appropriate for any particular language then it + needs to patch this function. */ + +void +unop_promote (const struct language_defn *language, struct gdbarch *gdbarch, + struct value **arg1) +{ + struct type *type1; + + *arg1 = coerce_ref (*arg1); + type1 = check_typedef (value_type (*arg1)); + + if (is_integral_type (type1)) + { + switch (language->la_language) + { + default: + /* Perform integral promotion for ANSI C/C++. + If not appropropriate for any particular language + it needs to modify this function. */ + { + struct type *builtin_int = builtin_type (gdbarch)->builtin_int; + + if (TYPE_LENGTH (type1) < TYPE_LENGTH (builtin_int)) + *arg1 = value_cast (builtin_int, *arg1); + } + break; + } + } +} + +/* Promote values ARG1 and ARG2 as appropriate before performing a binary + operation on those two operands. + If the result is not appropriate for any particular language then it + needs to patch this function. */ + +void +binop_promote (const struct language_defn *language, struct gdbarch *gdbarch, + struct value **arg1, struct value **arg2) +{ + struct type *promoted_type = NULL; + struct type *type1; + struct type *type2; + + *arg1 = coerce_ref (*arg1); + *arg2 = coerce_ref (*arg2); + + type1 = check_typedef (value_type (*arg1)); + type2 = check_typedef (value_type (*arg2)); + + if ((TYPE_CODE (type1) != TYPE_CODE_FLT + && TYPE_CODE (type1) != TYPE_CODE_DECFLOAT + && !is_integral_type (type1)) + || (TYPE_CODE (type2) != TYPE_CODE_FLT + && TYPE_CODE (type2) != TYPE_CODE_DECFLOAT + && !is_integral_type (type2))) + return; + + if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT + || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT) + { + /* No promotion required. */ + } + else if (TYPE_CODE (type1) == TYPE_CODE_FLT + || TYPE_CODE (type2) == TYPE_CODE_FLT) + { + switch (language->la_language) + { + case language_c: + case language_cplus: + case language_asm: + case language_objc: + /* No promotion required. */ + break; + + default: + /* For other languages the result type is unchanged from gdb + version 6.7 for backward compatibility. + If either arg was long double, make sure that value is also long + double. Otherwise use double. */ + if (TYPE_LENGTH (type1) * 8 > gdbarch_double_bit (gdbarch) + || TYPE_LENGTH (type2) * 8 > gdbarch_double_bit (gdbarch)) + promoted_type = builtin_type (gdbarch)->builtin_long_double; + else + promoted_type = builtin_type (gdbarch)->builtin_double; + break; + } + } + else if (TYPE_CODE (type1) == TYPE_CODE_BOOL + && TYPE_CODE (type2) == TYPE_CODE_BOOL) + { + /* No promotion required. */ + } + else + /* Integral operations here. */ + /* FIXME: Also mixed integral/booleans, with result an integer. */ + { + const struct builtin_type *builtin = builtin_type (gdbarch); + unsigned int promoted_len1 = TYPE_LENGTH (type1); + unsigned int promoted_len2 = TYPE_LENGTH (type2); + int is_unsigned1 = TYPE_UNSIGNED (type1); + int is_unsigned2 = TYPE_UNSIGNED (type2); + unsigned int result_len; + int unsigned_operation; + + /* Determine type length and signedness after promotion for + both operands. */ + if (promoted_len1 < TYPE_LENGTH (builtin->builtin_int)) + { + is_unsigned1 = 0; + promoted_len1 = TYPE_LENGTH (builtin->builtin_int); + } + if (promoted_len2 < TYPE_LENGTH (builtin->builtin_int)) + { + is_unsigned2 = 0; + promoted_len2 = TYPE_LENGTH (builtin->builtin_int); + } + + if (promoted_len1 > promoted_len2) + { + unsigned_operation = is_unsigned1; + result_len = promoted_len1; + } + else if (promoted_len2 > promoted_len1) + { + unsigned_operation = is_unsigned2; + result_len = promoted_len2; + } + else + { + unsigned_operation = is_unsigned1 || is_unsigned2; + result_len = promoted_len1; + } + + switch (language->la_language) + { + case language_c: + case language_cplus: + case language_asm: + case language_objc: + if (result_len <= TYPE_LENGTH (builtin->builtin_int)) + { + promoted_type = (unsigned_operation + ? builtin->builtin_unsigned_int + : builtin->builtin_int); + } + else if (result_len <= TYPE_LENGTH (builtin->builtin_long)) + { + promoted_type = (unsigned_operation + ? builtin->builtin_unsigned_long + : builtin->builtin_long); + } + else + { + promoted_type = (unsigned_operation + ? builtin->builtin_unsigned_long_long + : builtin->builtin_long_long); + } + break; + + default: + /* For other languages the result type is unchanged from gdb + version 6.7 for backward compatibility. + If either arg was long long, make sure that value is also long + long. Otherwise use long. */ + if (unsigned_operation) + { + if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT) + promoted_type = builtin->builtin_unsigned_long_long; + else + promoted_type = builtin->builtin_unsigned_long; + } + else + { + if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT) + promoted_type = builtin->builtin_long_long; + else + promoted_type = builtin->builtin_long; + } + break; + } + } + + if (promoted_type) + { + /* Promote both operands to common type. */ + *arg1 = value_cast (promoted_type, *arg1); + *arg2 = value_cast (promoted_type, *arg2); + } +} + +static int +ptrmath_type_p (const struct language_defn *lang, struct type *type) +{ + type = check_typedef (type); + if (TYPE_CODE (type) == TYPE_CODE_REF) + type = TYPE_TARGET_TYPE (type); + + switch (TYPE_CODE (type)) + { + case TYPE_CODE_PTR: + case TYPE_CODE_FUNC: + return 1; + + case TYPE_CODE_ARRAY: + return lang->c_style_arrays; + + default: + return 0; + } +} + +/* Constructs a fake method with the given parameter types. + This function is used by the parser to construct an "expected" + type for method overload resolution. */ + +static struct type * +make_params (int num_types, struct type **param_types) +{ + struct type *type = XZALLOC (struct type); + TYPE_MAIN_TYPE (type) = XZALLOC (struct main_type); + TYPE_LENGTH (type) = 1; + TYPE_CODE (type) = TYPE_CODE_METHOD; + TYPE_VPTR_FIELDNO (type) = -1; + TYPE_CHAIN (type) = type; + TYPE_NFIELDS (type) = num_types; + TYPE_FIELDS (type) = (struct field *) + TYPE_ZALLOC (type, sizeof (struct field) * num_types); + + while (num_types-- > 0) + TYPE_FIELD_TYPE (type, num_types) = param_types[num_types]; + + return type; +} + struct value * evaluate_subexp_standard (struct type *expect_type, struct expression *exp, int *pos, @@ -422,12 +701,14 @@ evaluate_subexp_standard (struct type *expect_type, struct type *type; int nargs; struct value **argvec; - int upper, lower, retcode; + int upper, lower; int code; int ix; long mem_offset; struct type **arg_types; int save_pos1; + struct symbol *function = NULL; + char *function_name = NULL; pc = (*pos)++; op = exp->elts[pc].opcode; @@ -441,7 +722,7 @@ evaluate_subexp_standard (struct type *expect_type, goto nosideret; arg1 = value_aggregate_elt (exp->elts[pc + 1].type, &exp->elts[pc + 3].string, - 0, noside); + expect_type, 0, noside); if (arg1 == NULL) error (_("There is no field named %s"), &exp->elts[pc + 3].string); return arg1; @@ -461,6 +742,7 @@ evaluate_subexp_standard (struct type *expect_type, return value_from_decfloat (exp->elts[pc + 1].type, exp->elts[pc + 2].decfloatconst); + case OP_ADL_FUNC: case OP_VAR_VALUE: (*pos) += 3; if (noside == EVAL_SKIP) @@ -508,8 +790,8 @@ evaluate_subexp_standard (struct type *expect_type, struct value *val; (*pos) += 3 + BYTES_TO_EXP_ELEM (exp->elts[pc + 1].longconst + 1); - regno = frame_map_name_to_regnum (deprecated_safe_get_selected_frame (), - name, strlen (name)); + regno = user_reg_map_name_to_regnum (exp->gdbarch, + name, strlen (name)); if (regno == -1) error (_("Register $%s not available."), name); @@ -519,9 +801,9 @@ evaluate_subexp_standard (struct type *expect_type, So for these registers, we fetch the register value regardless of the evaluation mode. */ if (noside == EVAL_AVOID_SIDE_EFFECTS - && regno < gdbarch_num_regs (current_gdbarch) - + gdbarch_num_pseudo_regs (current_gdbarch)) - val = value_zero (register_type (current_gdbarch, regno), not_lval); + && regno < gdbarch_num_regs (exp->gdbarch) + + gdbarch_num_pseudo_regs (exp->gdbarch)) + val = value_zero (register_type (exp->gdbarch, regno), not_lval); else val = value_of_register (regno, get_selected_frame (NULL)); if (val == NULL) @@ -531,19 +813,21 @@ evaluate_subexp_standard (struct type *expect_type, } case OP_BOOL: (*pos) += 2; - return value_from_longest (LA_BOOL_TYPE, - exp->elts[pc + 1].longconst); + type = language_bool_type (exp->language_defn, exp->gdbarch); + return value_from_longest (type, exp->elts[pc + 1].longconst); case OP_INTERNALVAR: (*pos) += 2; - return value_of_internalvar (exp->elts[pc + 1].internalvar); + return value_of_internalvar (exp->gdbarch, + exp->elts[pc + 1].internalvar); case OP_STRING: tem = longest_to_int (exp->elts[pc + 1].longconst); (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1); if (noside == EVAL_SKIP) goto nosideret; - return value_string (&exp->elts[pc + 2].string, tem); + type = language_string_char_type (exp->language_defn, exp->gdbarch); + return value_string (&exp->elts[pc + 2].string, tem, type); case OP_OBJC_NSSTRING: /* Objective C Foundation Class NSString constant. */ tem = longest_to_int (exp->elts[pc + 1].longconst); @@ -552,7 +836,7 @@ evaluate_subexp_standard (struct type *expect_type, { goto nosideret; } - return (struct value *) value_nsstring (&exp->elts[pc + 2].string, tem + 1); + return value_nsstring (exp->gdbarch, &exp->elts[pc + 2].string, tem + 1); case OP_BITSTRING: tem = longest_to_int (exp->elts[pc + 1].longconst); @@ -560,7 +844,8 @@ evaluate_subexp_standard (struct type *expect_type, += 3 + BYTES_TO_EXP_ELEM ((tem + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT); if (noside == EVAL_SKIP) goto nosideret; - return value_bitstring (&exp->elts[pc + 2].string, tem); + return value_bitstring (&exp->elts[pc + 2].string, tem, + builtin_type (exp->gdbarch)->builtin_int); break; case OP_ARRAY: @@ -574,6 +859,7 @@ evaluate_subexp_standard (struct type *expect_type, && TYPE_CODE (type) == TYPE_CODE_STRUCT) { struct value *rec = allocate_value (expect_type); + memset (value_contents_raw (rec), '\0', TYPE_LENGTH (type)); return evaluate_struct_tuple (rec, exp, pos, noside, nargs); } @@ -581,11 +867,12 @@ evaluate_subexp_standard (struct type *expect_type, if (expect_type != NULL_TYPE && noside != EVAL_SKIP && TYPE_CODE (type) == TYPE_CODE_ARRAY) { - struct type *range_type = TYPE_FIELD_TYPE (type, 0); + struct type *range_type = TYPE_INDEX_TYPE (type); struct type *element_type = TYPE_TARGET_TYPE (type); struct value *array = allocate_value (expect_type); int element_size = TYPE_LENGTH (check_typedef (element_type)); LONGEST low_bound, high_bound, index; + if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0) { low_bound = 0; @@ -597,6 +884,7 @@ evaluate_subexp_standard (struct type *expect_type, { struct value *element; int index_pc = 0; + if (exp->elts[*pos].opcode == BINOP_RANGE) { index_pc = ++(*pos); @@ -608,6 +896,7 @@ evaluate_subexp_standard (struct type *expect_type, if (index_pc) { int continue_pc = *pos; + *pos = index_pc; index = init_array_element (array, element, exp, pos, noside, low_bound, high_bound); @@ -638,8 +927,8 @@ evaluate_subexp_standard (struct type *expect_type, LONGEST low_bound, high_bound; /* get targettype of elementtype */ - while (TYPE_CODE (check_type) == TYPE_CODE_RANGE || - TYPE_CODE (check_type) == TYPE_CODE_TYPEDEF) + while (TYPE_CODE (check_type) == TYPE_CODE_RANGE + || TYPE_CODE (check_type) == TYPE_CODE_TYPEDEF) check_type = TYPE_TARGET_TYPE (check_type); if (get_discrete_bounds (element_type, &low_bound, &high_bound) < 0) @@ -650,6 +939,7 @@ evaluate_subexp_standard (struct type *expect_type, LONGEST range_low, range_high; struct type *range_low_type, *range_high_type; struct value *elem_val; + if (exp->elts[*pos].opcode == BINOP_RANGE) { (*pos)++; @@ -673,14 +963,14 @@ evaluate_subexp_standard (struct type *expect_type, range_low_type = TYPE_TARGET_TYPE (range_low_type); if (TYPE_CODE (range_high_type) == TYPE_CODE_RANGE) range_high_type = TYPE_TARGET_TYPE (range_high_type); - if ((TYPE_CODE (range_low_type) != TYPE_CODE (range_high_type)) || - (TYPE_CODE (range_low_type) == TYPE_CODE_ENUM && - (range_low_type != range_high_type))) + if ((TYPE_CODE (range_low_type) != TYPE_CODE (range_high_type)) + || (TYPE_CODE (range_low_type) == TYPE_CODE_ENUM + && (range_low_type != range_high_type))) /* different element modes */ error (_("POWERSET tuple elements of different mode")); - if ((TYPE_CODE (check_type) != TYPE_CODE (range_low_type)) || - (TYPE_CODE (check_type) == TYPE_CODE_ENUM && - range_low_type != check_type)) + if ((TYPE_CODE (check_type) != TYPE_CODE (range_low_type)) + || (TYPE_CODE (check_type) == TYPE_CODE_ENUM + && range_low_type != check_type)) error (_("incompatible POWERSET tuple elements")); if (range_low > range_high) { @@ -694,7 +984,8 @@ evaluate_subexp_standard (struct type *expect_type, for (; range_low <= range_high; range_low++) { int bit_index = (unsigned) range_low % TARGET_CHAR_BIT; - if (gdbarch_bits_big_endian (current_gdbarch)) + + if (gdbarch_bits_big_endian (exp->gdbarch)) bit_index = TARGET_CHAR_BIT - 1 - bit_index; valaddr[(unsigned) range_low / TARGET_CHAR_BIT] |= 1 << bit_index; @@ -717,9 +1008,10 @@ evaluate_subexp_standard (struct type *expect_type, { struct value *array = evaluate_subexp (NULL_TYPE, exp, pos, noside); int lowbound - = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside)); + = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside)); int upper - = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside)); + = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside)); + if (noside == EVAL_SKIP) goto nosideret; return value_slice (array, lowbound, upper - lowbound + 1); @@ -729,9 +1021,10 @@ evaluate_subexp_standard (struct type *expect_type, { struct value *array = evaluate_subexp (NULL_TYPE, exp, pos, noside); int lowbound - = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside)); + = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside)); int length - = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside)); + = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside)); + return value_slice (array, lowbound, length); } @@ -754,6 +1047,7 @@ evaluate_subexp_standard (struct type *expect_type, { /* Objective C @selector operator. */ char *sel = &exp->elts[pc + 2].string; int len = longest_to_int (exp->elts[pc + 1].longconst); + struct type *selector_type; (*pos) += 3 + BYTES_TO_EXP_ELEM (len + 1); if (noside == EVAL_SKIP) @@ -761,30 +1055,33 @@ evaluate_subexp_standard (struct type *expect_type, if (sel[len] != 0) sel[len] = 0; /* Make sure it's terminated. */ - return value_from_longest (lookup_pointer_type (builtin_type_void), - lookup_child_selector (sel)); + + selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr; + return value_from_longest (selector_type, + lookup_child_selector (exp->gdbarch, sel)); } case OP_OBJC_MSGCALL: { /* Objective C message (method) call. */ - static CORE_ADDR responds_selector = 0; - static CORE_ADDR method_selector = 0; + CORE_ADDR responds_selector = 0; + CORE_ADDR method_selector = 0; CORE_ADDR selector = 0; int struct_return = 0; int sub_no_side = 0; - static struct value *msg_send = NULL; - static struct value *msg_send_stret = NULL; - static int gnu_runtime = 0; + struct value *msg_send = NULL; + struct value *msg_send_stret = NULL; + int gnu_runtime = 0; struct value *target = NULL; struct value *method = NULL; struct value *called_method = NULL; struct type *selector_type = NULL; + struct type *long_type; struct value *ret = NULL; CORE_ADDR addr = 0; @@ -796,7 +1093,9 @@ evaluate_subexp_standard (struct type *expect_type, (*pos) += 3; - selector_type = lookup_pointer_type (builtin_type_void); + long_type = builtin_type (exp->gdbarch)->builtin_long; + selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr; + if (noside == EVAL_AVOID_SIDE_EFFECTS) sub_no_side = EVAL_NORMAL; else @@ -805,7 +1104,7 @@ evaluate_subexp_standard (struct type *expect_type, target = evaluate_subexp (selector_type, exp, pos, sub_no_side); if (value_as_long (target) == 0) - return value_from_longest (builtin_type_long, 0); + return value_from_longest (long_type, 0); if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0)) gnu_runtime = 1; @@ -820,15 +1119,16 @@ evaluate_subexp_standard (struct type *expect_type, only). */ if (gnu_runtime) { - struct type *type; - type = lookup_pointer_type (builtin_type_void); + struct type *type = selector_type; + type = lookup_function_type (type); type = lookup_pointer_type (type); type = lookup_function_type (type); type = lookup_pointer_type (type); - msg_send = find_function_in_inferior ("objc_msg_lookup"); - msg_send_stret = find_function_in_inferior ("objc_msg_lookup"); + msg_send = find_function_in_inferior ("objc_msg_lookup", NULL); + msg_send_stret + = find_function_in_inferior ("objc_msg_lookup", NULL); msg_send = value_from_pointer (type, value_as_address (msg_send)); msg_send_stret = value_from_pointer (type, @@ -836,9 +1136,10 @@ evaluate_subexp_standard (struct type *expect_type, } else { - msg_send = find_function_in_inferior ("objc_msgSend"); + msg_send = find_function_in_inferior ("objc_msgSend", NULL); /* Special dispatcher for methods returning structs */ - msg_send_stret = find_function_in_inferior ("objc_msgSend_stret"); + msg_send_stret + = find_function_in_inferior ("objc_msgSend_stret", NULL); } /* Verify the target object responds to this method. The @@ -846,16 +1147,20 @@ evaluate_subexp_standard (struct type *expect_type, the verification method than the non-standard, but more often used, 'NSObject' class. Make sure we check for both. */ - responds_selector = lookup_child_selector ("respondsToSelector:"); + responds_selector + = lookup_child_selector (exp->gdbarch, "respondsToSelector:"); if (responds_selector == 0) - responds_selector = lookup_child_selector ("respondsTo:"); + responds_selector + = lookup_child_selector (exp->gdbarch, "respondsTo:"); if (responds_selector == 0) error (_("no 'respondsTo:' or 'respondsToSelector:' method")); - method_selector = lookup_child_selector ("methodForSelector:"); + method_selector + = lookup_child_selector (exp->gdbarch, "methodForSelector:"); if (method_selector == 0) - method_selector = lookup_child_selector ("methodFor:"); + method_selector + = lookup_child_selector (exp->gdbarch, "methodFor:"); if (method_selector == 0) error (_("no 'methodFor:' or 'methodForSelector:' method")); @@ -865,8 +1170,8 @@ evaluate_subexp_standard (struct type *expect_type, argvec[0] = msg_send; argvec[1] = target; - argvec[2] = value_from_longest (builtin_type_long, responds_selector); - argvec[3] = value_from_longest (builtin_type_long, selector); + argvec[2] = value_from_longest (long_type, responds_selector); + argvec[3] = value_from_longest (long_type, selector); argvec[4] = 0; ret = call_function_by_hand (argvec[0], 3, argvec + 1); @@ -887,8 +1192,8 @@ evaluate_subexp_standard (struct type *expect_type, argvec[0] = msg_send; argvec[1] = target; - argvec[2] = value_from_longest (builtin_type_long, method_selector); - argvec[3] = value_from_longest (builtin_type_long, selector); + argvec[2] = value_from_longest (long_type, method_selector); + argvec[3] = value_from_longest (long_type, selector); argvec[4] = 0; ret = call_function_by_hand (argvec[0], 3, argvec + 1); @@ -904,8 +1209,13 @@ evaluate_subexp_standard (struct type *expect_type, if (addr) { struct symbol *sym = NULL; - /* Is it a high_level symbol? */ + /* The address might point to a function descriptor; + resolve it to the actual code address instead. */ + addr = gdbarch_convert_from_func_ptr_addr (exp->gdbarch, addr, + ¤t_target); + + /* Is it a high_level symbol? */ sym = find_pc_function (addr); if (sym != NULL) method = value_of_variable (sym, 0); @@ -918,26 +1228,28 @@ evaluate_subexp_standard (struct type *expect_type, { struct block *b; CORE_ADDR funaddr; - struct type *value_type; + struct type *val_type; - funaddr = find_function_addr (method, &value_type); + funaddr = find_function_addr (method, &val_type); b = block_for_pc (funaddr); - CHECK_TYPEDEF (value_type); + CHECK_TYPEDEF (val_type); - if ((value_type == NULL) - || (TYPE_CODE(value_type) == TYPE_CODE_ERROR)) + if ((val_type == NULL) + || (TYPE_CODE(val_type) == TYPE_CODE_ERROR)) { if (expect_type != NULL) - value_type = expect_type; + val_type = expect_type; } - struct_return = using_struct_return (value_type); + struct_return = using_struct_return (exp->gdbarch, + value_type (method), val_type); } else if (expect_type != NULL) { - struct_return = using_struct_return (check_typedef (expect_type)); + struct_return = using_struct_return (exp->gdbarch, NULL, + check_typedef (expect_type)); } /* Found a function symbol. Now we will substitute its @@ -957,11 +1269,20 @@ evaluate_subexp_standard (struct type *expect_type, { if (TYPE_CODE (value_type (method)) != TYPE_CODE_FUNC) error (_("method address has symbol information with non-function type; skipping")); + + /* Create a function pointer of the appropriate type, and replace + its value with the value of msg_send or msg_send_stret. We must + use a pointer here, as msg_send and msg_send_stret are of pointer + type, and the representation may be different on systems that use + function descriptors. */ if (struct_return) - VALUE_ADDRESS (method) = value_as_address (msg_send_stret); + called_method + = value_from_pointer (lookup_pointer_type (value_type (method)), + value_as_address (msg_send_stret)); else - VALUE_ADDRESS (method) = value_as_address (msg_send); - called_method = method; + called_method + = value_from_pointer (lookup_pointer_type (value_type (method)), + value_as_address (msg_send)); } else { @@ -985,6 +1306,7 @@ evaluate_subexp_standard (struct type *expect_type, it. */ struct type *type = value_type (called_method); + if (type && TYPE_CODE (type) == TYPE_CODE_PTR) type = TYPE_TARGET_TYPE (type); type = TYPE_TARGET_TYPE (type); @@ -1006,7 +1328,7 @@ evaluate_subexp_standard (struct type *expect_type, argvec[0] = called_method; argvec[1] = target; - argvec[2] = value_from_longest (builtin_type_long, selector); + argvec[2] = value_from_longest (long_type, selector); /* User-supplied arguments. */ for (tem = 0; tem < nargs; tem++) argvec[tem + 3] = evaluate_subexp_with_coercion (exp, pos, noside); @@ -1016,7 +1338,7 @@ evaluate_subexp_standard (struct type *expect_type, { /* Function objc_msg_lookup returns a pointer. */ deprecated_set_value_type (argvec[0], - lookup_function_type (lookup_pointer_type (value_type (argvec[0])))); + lookup_pointer_type (lookup_function_type (value_type (argvec[0])))); argvec[0] = call_function_by_hand (argvec[0], nargs + 2, argvec + 1); } @@ -1066,6 +1388,7 @@ evaluate_subexp_standard (struct type *expect_type, if (noside == EVAL_AVOID_SIDE_EFFECTS) { struct type *method_type = check_typedef (value_type (arg1)); + arg1 = value_zero (method_type, not_lval); } else @@ -1112,6 +1435,58 @@ evaluate_subexp_standard (struct type *expect_type, /* Now, say which argument to start evaluating from */ tem = 2; } + else if (op == OP_SCOPE + && overload_resolution + && (exp->language_defn->la_language == language_cplus)) + { + /* Unpack it locally so we can properly handle overload + resolution. */ + char *name; + int local_tem; + + pc2 = (*pos)++; + local_tem = longest_to_int (exp->elts[pc2 + 2].longconst); + (*pos) += 4 + BYTES_TO_EXP_ELEM (local_tem + 1); + type = exp->elts[pc2 + 1].type; + name = &exp->elts[pc2 + 3].string; + + function = NULL; + function_name = NULL; + if (TYPE_CODE (type) == TYPE_CODE_NAMESPACE) + { + function = cp_lookup_symbol_namespace (TYPE_TAG_NAME (type), + name, + get_selected_block (0), + VAR_DOMAIN); + if (function == NULL) + error (_("No symbol \"%s\" in namespace \"%s\"."), + name, TYPE_TAG_NAME (type)); + + tem = 1; + } + else + { + gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT + || TYPE_CODE (type) == TYPE_CODE_UNION); + function_name = name; + + arg2 = value_zero (type, lval_memory); + ++nargs; + tem = 2; + } + } + else if (op == OP_ADL_FUNC) + { + /* Save the function position and move pos so that the arguments + can be evaluated. */ + int func_name_len; + + save_pos1 = *pos; + tem = 1; + + func_name_len = longest_to_int (exp->elts[save_pos1 + 3].longconst); + (*pos) += 6 + BYTES_TO_EXP_ELEM (func_name_len + 1); + } else { /* Non-method function call */ @@ -1142,16 +1517,49 @@ evaluate_subexp_standard (struct type *expect_type, /* signal end of arglist */ argvec[tem] = 0; - - if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR) + if (op == OP_ADL_FUNC) + { + struct symbol *symp; + char *func_name; + int name_len; + int string_pc = save_pos1 + 3; + + /* Extract the function name. */ + name_len = longest_to_int (exp->elts[string_pc].longconst); + func_name = (char *) alloca (name_len + 1); + strcpy (func_name, &exp->elts[string_pc + 1].string); + + /* Prepare list of argument types for overload resolution */ + arg_types = (struct type **) alloca (nargs * (sizeof (struct type *))); + for (ix = 1; ix <= nargs; ix++) + arg_types[ix - 1] = value_type (argvec[ix]); + + find_overload_match (arg_types, nargs, func_name, + 0 /* not method */ , 0 /* strict match */ , + NULL, NULL /* pass NULL symbol since symbol is unknown */ , + NULL, &symp, NULL, 0); + + /* Now fix the expression being evaluated. */ + exp->elts[save_pos1 + 2].symbol = symp; + argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1, noside); + } + + if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR + || (op == OP_SCOPE && function_name != NULL)) { int static_memfuncp; - char tstr[256]; + char *tstr; /* Method invocation : stuff "this" as first parameter */ argvec[1] = arg2; - /* Name of method from expression */ - strcpy (tstr, &exp->elts[pc2 + 2].string); + + if (op != OP_SCOPE) + { + /* Name of method from expression */ + tstr = &exp->elts[pc2 + 2].string; + } + else + tstr = function_name; if (overload_resolution && (exp->language_defn->la_language == language_cplus)) { @@ -1166,9 +1574,15 @@ evaluate_subexp_standard (struct type *expect_type, (void) find_overload_match (arg_types, nargs, tstr, 1 /* method */ , 0 /* strict match */ , &arg2 /* the object */ , NULL, - &valp, NULL, &static_memfuncp); - + &valp, NULL, &static_memfuncp, 0); + if (op == OP_SCOPE && !static_memfuncp) + { + /* For the time being, we don't handle this. */ + error (_("Call to overloaded function %s requires " + "`this' pointer"), + function_name); + } argvec[1] = arg2; /* the ``this'' pointer */ argvec[0] = valp; /* use the method found after overload resolution */ } @@ -1176,6 +1590,7 @@ evaluate_subexp_standard (struct type *expect_type, /* Non-C++ case -- or no overload resolution */ { struct value *temp = arg2; + argvec[0] = value_struct_elt (&temp, argvec + 1, tstr, &static_memfuncp, op == STRUCTOP_STRUCT @@ -1184,7 +1599,7 @@ evaluate_subexp_standard (struct type *expect_type, of the ``this'' pointer if necessary, so modify argvec[1] to reflect any ``this'' changes. */ arg2 = value_from_longest (lookup_pointer_type(value_type (temp)), - VALUE_ADDRESS (temp) + value_offset (temp) + value_address (temp) + value_embedded_offset (temp)); argvec[1] = arg2; /* the ``this'' pointer */ } @@ -1201,7 +1616,7 @@ evaluate_subexp_standard (struct type *expect_type, argvec[1] = arg2; argvec[0] = arg1; } - else if (op == OP_VAR_VALUE) + else if (op == OP_VAR_VALUE || (op == OP_SCOPE && function != NULL)) { /* Non-member function being called */ /* fn: This can only be done for C++ functions. A C-style function @@ -1212,6 +1627,14 @@ evaluate_subexp_standard (struct type *expect_type, { /* Language is C++, do some overload resolution before evaluation */ struct symbol *symp; + int no_adl = 0; + + /* If a scope has been specified disable ADL. */ + if (op == OP_SCOPE) + no_adl = 1; + + if (op == OP_VAR_VALUE) + function = exp->elts[save_pos1+2].symbol; /* Prepare list of argument types for overload resolution */ arg_types = (struct type **) alloca (nargs * (sizeof (struct type *))); @@ -1220,12 +1643,18 @@ evaluate_subexp_standard (struct type *expect_type, (void) find_overload_match (arg_types, nargs, NULL /* no need for name */ , 0 /* not method */ , 0 /* strict match */ , - NULL, exp->elts[save_pos1+2].symbol /* the function */ , - NULL, &symp, NULL); + NULL, function /* the function */ , + NULL, &symp, NULL, no_adl); - /* Now fix the expression being evaluated */ - exp->elts[save_pos1+2].symbol = symp; - argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1, noside); + if (op == OP_VAR_VALUE) + { + /* Now fix the expression being evaluated */ + exp->elts[save_pos1+2].symbol = symp; + argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1, + noside); + } + else + argvec[0] = value_of_variable (symp, get_selected_block (0)); } else { @@ -1254,14 +1683,25 @@ evaluate_subexp_standard (struct type *expect_type, gdb isn't asked for it's opinion (ie. through "whatis"), it won't offer it. */ - struct type *ftype = - TYPE_TARGET_TYPE (value_type (argvec[0])); + struct type *ftype = value_type (argvec[0]); - if (ftype) - return allocate_value (TYPE_TARGET_TYPE (value_type (argvec[0]))); + if (TYPE_CODE (ftype) == TYPE_CODE_INTERNAL_FUNCTION) + { + /* We don't know anything about what the internal + function might return, but we have to return + something. */ + return value_zero (builtin_type (exp->gdbarch)->builtin_int, + not_lval); + } + else if (TYPE_TARGET_TYPE (ftype)) + return allocate_value (TYPE_TARGET_TYPE (ftype)); else error (_("Expression of type other than \"Function returning ...\" used as function")); } + if (TYPE_CODE (value_type (argvec[0])) == TYPE_CODE_INTERNAL_FUNCTION) + return call_internal_function (exp->gdbarch, exp->language_defn, + argvec[0], nargs, argvec + 1); + return call_function_by_hand (argvec[0], nargs, argvec + 1); /* pai: FIXME save value from call_function_by_hand, then adjust pc by adjust_fn_pc if +ve */ @@ -1314,7 +1754,7 @@ evaluate_subexp_standard (struct type *expect_type, else { arg2 = evaluate_subexp_with_coercion (exp, pos, noside); - return value_subscript (arg1, arg2); + return value_subscript (arg1, value_as_long (arg2)); } case TYPE_CODE_PTR: @@ -1337,10 +1777,11 @@ evaluate_subexp_standard (struct type *expect_type, case OP_COMPLEX: /* We have a complex number, There should be 2 floating point numbers that compose it */ + (*pos) += 2; arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside); - return value_literal_complex (arg1, arg2, builtin_type_f_complex_s16); + return value_literal_complex (arg1, arg2, exp->elts[pc + 1].type); case STRUCTOP_STRUCT: tem = longest_to_int (exp->elts[pc + 1].longconst); @@ -1356,6 +1797,7 @@ evaluate_subexp_standard (struct type *expect_type, else { struct value *temp = arg1; + return value_struct_elt (&temp, NULL, &exp->elts[pc + 2].string, NULL, "structure"); } @@ -1374,9 +1816,11 @@ evaluate_subexp_standard (struct type *expect_type, struct type *type = value_type (arg1); struct type *real_type; int full, top, using_enc; - - if (objectprint && TYPE_TARGET_TYPE(type) && - (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS)) + struct value_print_options opts; + + get_user_print_options (&opts); + if (opts.objectprint && TYPE_TARGET_TYPE(type) + && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS)) { real_type = value_rtti_target_type (arg1, &full, &top, &using_enc); if (real_type) @@ -1399,6 +1843,7 @@ evaluate_subexp_standard (struct type *expect_type, else { struct value *temp = arg1; + return value_struct_elt (&temp, NULL, &exp->elts[pc + 2].string, NULL, "structure pointer"); } @@ -1443,6 +1888,20 @@ evaluate_subexp_standard (struct type *expect_type, error (_("non-pointer-to-member value used in pointer-to-member construct")); } + case TYPE_INSTANCE: + nargs = longest_to_int (exp->elts[pc + 1].longconst); + arg_types = (struct type **) alloca (nargs * sizeof (struct type *)); + for (ix = 0; ix < nargs; ++ix) + arg_types[ix] = exp->elts[pc + 1 + ix + 1].type; + + expect_type = make_params (nargs, arg_types); + *(pos) += 3 + nargs; + arg1 = evaluate_subexp_standard (expect_type, exp, pos, noside); + xfree (TYPE_FIELDS (expect_type)); + xfree (TYPE_MAIN_TYPE (expect_type)); + xfree (expect_type); + return arg1; + case BINOP_CONCAT: arg1 = evaluate_subexp_with_coercion (exp, pos, noside); arg2 = evaluate_subexp_with_coercion (exp, pos, noside); @@ -1473,12 +1932,28 @@ evaluate_subexp_standard (struct type *expect_type, op = exp->elts[pc + 1].opcode; if (binop_user_defined_p (op, arg1, arg2)) return value_x_binop (arg1, arg2, BINOP_ASSIGN_MODIFY, op, noside); - else if (op == BINOP_ADD) - arg2 = value_add (arg1, arg2); - else if (op == BINOP_SUB) - arg2 = value_sub (arg1, arg2); + else if (op == BINOP_ADD && ptrmath_type_p (exp->language_defn, + value_type (arg1)) + && is_integral_type (value_type (arg2))) + arg2 = value_ptradd (arg1, value_as_long (arg2)); + else if (op == BINOP_SUB && ptrmath_type_p (exp->language_defn, + value_type (arg1)) + && is_integral_type (value_type (arg2))) + arg2 = value_ptradd (arg1, - value_as_long (arg2)); else - arg2 = value_binop (arg1, arg2, op); + { + struct value *tmp = arg1; + + /* For shift and integer exponentiation operations, + only promote the first argument. */ + if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP) + && is_integral_type (value_type (arg2))) + unop_promote (exp->language_defn, exp->gdbarch, &tmp); + else + binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2); + + arg2 = value_binop (tmp, arg2, op); + } return value_assign (arg1, arg2); case BINOP_ADD: @@ -1488,8 +1963,17 @@ evaluate_subexp_standard (struct type *expect_type, goto nosideret; if (binop_user_defined_p (op, arg1, arg2)) return value_x_binop (arg1, arg2, op, OP_NULL, noside); + else if (ptrmath_type_p (exp->language_defn, value_type (arg1)) + && is_integral_type (value_type (arg2))) + return value_ptradd (arg1, value_as_long (arg2)); + else if (ptrmath_type_p (exp->language_defn, value_type (arg2)) + && is_integral_type (value_type (arg1))) + return value_ptradd (arg2, value_as_long (arg1)); else - return value_add (arg1, arg2); + { + binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2); + return value_binop (arg1, arg2, BINOP_ADD); + } case BINOP_SUB: arg1 = evaluate_subexp_with_coercion (exp, pos, noside); @@ -1498,8 +1982,21 @@ evaluate_subexp_standard (struct type *expect_type, goto nosideret; if (binop_user_defined_p (op, arg1, arg2)) return value_x_binop (arg1, arg2, op, OP_NULL, noside); + else if (ptrmath_type_p (exp->language_defn, value_type (arg1)) + && ptrmath_type_p (exp->language_defn, value_type (arg2))) + { + /* FIXME -- should be ptrdiff_t */ + type = builtin_type (exp->gdbarch)->builtin_long; + return value_from_longest (type, value_ptrdiff (arg1, arg2)); + } + else if (ptrmath_type_p (exp->language_defn, value_type (arg1)) + && is_integral_type (value_type (arg2))) + return value_ptradd (arg1, - value_as_long (arg2)); else - return value_sub (arg1, arg2); + { + binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2); + return value_binop (arg1, arg2, BINOP_SUB); + } case BINOP_EXP: case BINOP_MUL: @@ -1536,11 +2033,22 @@ evaluate_subexp_standard (struct type *expect_type, struct value *v_one, *retval; v_one = value_one (value_type (arg2), not_lval); + binop_promote (exp->language_defn, exp->gdbarch, &arg1, &v_one); retval = value_binop (arg1, v_one, op); return retval; } else - return value_binop (arg1, arg2, op); + { + /* For shift and integer exponentiation operations, + only promote the first argument. */ + if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP) + && is_integral_type (value_type (arg2))) + unop_promote (exp->language_defn, exp->gdbarch, &arg1); + else + binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2); + + return value_binop (arg1, arg2, op); + } } case BINOP_RANGE: @@ -1578,7 +2086,7 @@ evaluate_subexp_standard (struct type *expect_type, if (noside == EVAL_AVOID_SIDE_EFFECTS) return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1)); else - return value_subscript (arg1, arg2); + return value_subscript (arg1, value_as_long (arg2)); } case BINOP_IN: @@ -1586,7 +2094,8 @@ evaluate_subexp_standard (struct type *expect_type, arg2 = evaluate_subexp_with_coercion (exp, pos, noside); if (noside == EVAL_SKIP) goto nosideret; - return value_in (arg1, arg2); + type = language_bool_type (exp->language_defn, exp->gdbarch); + return value_from_longest (type, (LONGEST) value_in (arg1, arg2)); case MULTI_SUBSCRIPT: (*pos) += 2; @@ -1634,7 +2143,30 @@ evaluate_subexp_standard (struct type *expect_type, } else { - arg1 = value_subscript (arg1, arg2); + arg1 = coerce_ref (arg1); + type = check_typedef (value_type (arg1)); + + switch (TYPE_CODE (type)) + { + case TYPE_CODE_PTR: + case TYPE_CODE_ARRAY: + case TYPE_CODE_STRING: + arg1 = value_subscript (arg1, value_as_long (arg2)); + break; + + case TYPE_CODE_BITSTRING: + type = language_bool_type (exp->language_defn, exp->gdbarch); + arg1 = value_bitstring_subscript (type, arg1, + value_as_long (arg2)); + break; + + default: + if (TYPE_NAME (type)) + error (_("cannot subscript something of type `%s'"), + TYPE_NAME (type)); + else + error (_("cannot subscript requested type")); + } } } return (arg1); @@ -1656,6 +2188,8 @@ evaluate_subexp_standard (struct type *expect_type, if (nargs != ndimensions) error (_("Wrong number of subscripts")); + gdb_assert (nargs > 0); + /* Now that we know we have a legal array subscript expression let us actually find out where this element exists in the array. */ @@ -1674,13 +2208,8 @@ evaluate_subexp_standard (struct type *expect_type, /* Internal type of array is arranged right to left */ for (i = 0; i < nargs; i++) { - retcode = f77_get_dynamic_upperbound (tmp_type, &upper); - if (retcode == BOUND_FETCH_ERROR) - error (_("Cannot obtain dynamic upper bound")); - - retcode = f77_get_dynamic_lowerbound (tmp_type, &lower); - if (retcode == BOUND_FETCH_ERROR) - error (_("Cannot obtain dynamic lower bound")); + upper = f77_get_upperbound (tmp_type); + lower = f77_get_lowerbound (tmp_type); array_size_array[nargs - i - 1] = upper - lower + 1; @@ -1708,10 +2237,6 @@ evaluate_subexp_standard (struct type *expect_type, offset_item = array_size_array[i - 1] * offset_item + subscript_array[i - 1]; - /* Construct a value node with the value of the offset */ - - arg2 = value_from_longest (builtin_type_f_integer, offset_item); - /* Let us now play a dirty trick: we will take arg1 which is a value node pointing to the topmost level of the multidimensional array-set and pretend @@ -1720,7 +2245,7 @@ evaluate_subexp_standard (struct type *expect_type, returns the correct type value */ deprecated_set_value_type (arg1, tmp_type); - return value_subscripted_rvalue (arg1, arg2, 0); + return value_subscripted_rvalue (arg1, offset_item, 0); } case BINOP_LOGICAL_AND: @@ -1745,7 +2270,8 @@ evaluate_subexp_standard (struct type *expect_type, tem = value_logical_not (arg1); arg2 = evaluate_subexp (NULL_TYPE, exp, pos, (tem ? EVAL_SKIP : noside)); - return value_from_longest (LA_BOOL_TYPE, + type = language_bool_type (exp->language_defn, exp->gdbarch); + return value_from_longest (type, (LONGEST) (!tem && !value_logical_not (arg2))); } @@ -1771,7 +2297,8 @@ evaluate_subexp_standard (struct type *expect_type, tem = value_logical_not (arg1); arg2 = evaluate_subexp (NULL_TYPE, exp, pos, (!tem ? EVAL_SKIP : noside)); - return value_from_longest (LA_BOOL_TYPE, + type = language_bool_type (exp->language_defn, exp->gdbarch); + return value_from_longest (type, (LONGEST) (!tem || !value_logical_not (arg2))); } @@ -1786,8 +2313,10 @@ evaluate_subexp_standard (struct type *expect_type, } else { + binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2); tem = value_equal (arg1, arg2); - return value_from_longest (LA_BOOL_TYPE, (LONGEST) tem); + type = language_bool_type (exp->language_defn, exp->gdbarch); + return value_from_longest (type, (LONGEST) tem); } case BINOP_NOTEQUAL: @@ -1801,8 +2330,10 @@ evaluate_subexp_standard (struct type *expect_type, } else { + binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2); tem = value_equal (arg1, arg2); - return value_from_longest (LA_BOOL_TYPE, (LONGEST) ! tem); + type = language_bool_type (exp->language_defn, exp->gdbarch); + return value_from_longest (type, (LONGEST) ! tem); } case BINOP_LESS: @@ -1816,8 +2347,10 @@ evaluate_subexp_standard (struct type *expect_type, } else { + binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2); tem = value_less (arg1, arg2); - return value_from_longest (LA_BOOL_TYPE, (LONGEST) tem); + type = language_bool_type (exp->language_defn, exp->gdbarch); + return value_from_longest (type, (LONGEST) tem); } case BINOP_GTR: @@ -1831,8 +2364,10 @@ evaluate_subexp_standard (struct type *expect_type, } else { + binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2); tem = value_less (arg2, arg1); - return value_from_longest (LA_BOOL_TYPE, (LONGEST) tem); + type = language_bool_type (exp->language_defn, exp->gdbarch); + return value_from_longest (type, (LONGEST) tem); } case BINOP_GEQ: @@ -1846,8 +2381,10 @@ evaluate_subexp_standard (struct type *expect_type, } else { + binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2); tem = value_less (arg2, arg1) || value_equal (arg1, arg2); - return value_from_longest (LA_BOOL_TYPE, (LONGEST) tem); + type = language_bool_type (exp->language_defn, exp->gdbarch); + return value_from_longest (type, (LONGEST) tem); } case BINOP_LEQ: @@ -1861,8 +2398,10 @@ evaluate_subexp_standard (struct type *expect_type, } else { + binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2); tem = value_less (arg1, arg2) || value_equal (arg1, arg2); - return value_from_longest (LA_BOOL_TYPE, (LONGEST) tem); + type = language_bool_type (exp->language_defn, exp->gdbarch); + return value_from_longest (type, (LONGEST) tem); } case BINOP_REPEAT: @@ -1892,7 +2431,10 @@ evaluate_subexp_standard (struct type *expect_type, if (unop_user_defined_p (op, arg1)) return value_x_unop (arg1, op, noside); else - return value_pos (arg1); + { + unop_promote (exp->language_defn, exp->gdbarch, &arg1); + return value_pos (arg1); + } case UNOP_NEG: arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); @@ -1901,7 +2443,10 @@ evaluate_subexp_standard (struct type *expect_type, if (unop_user_defined_p (op, arg1)) return value_x_unop (arg1, op, noside); else - return value_neg (arg1); + { + unop_promote (exp->language_defn, exp->gdbarch, &arg1); + return value_neg (arg1); + } case UNOP_COMPLEMENT: /* C++: check for and handle destructor names. */ @@ -1913,7 +2458,10 @@ evaluate_subexp_standard (struct type *expect_type, if (unop_user_defined_p (UNOP_COMPLEMENT, arg1)) return value_x_unop (arg1, UNOP_COMPLEMENT, noside); else - return value_complement (arg1); + { + unop_promote (exp->language_defn, exp->gdbarch, &arg1); + return value_complement (arg1); + } case UNOP_LOGICAL_NOT: arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); @@ -1922,8 +2470,10 @@ evaluate_subexp_standard (struct type *expect_type, if (unop_user_defined_p (op, arg1)) return value_x_unop (arg1, op, noside); else - return value_from_longest (LA_BOOL_TYPE, - (LONGEST) value_logical_not (arg1)); + { + type = language_bool_type (exp->language_defn, exp->gdbarch); + return value_from_longest (type, (LONGEST) value_logical_not (arg1)); + } case UNOP_IND: if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR) @@ -1949,10 +2499,19 @@ evaluate_subexp_standard (struct type *expect_type, lval_memory); else if (TYPE_CODE (type) == TYPE_CODE_INT) /* GDB allows dereferencing an int. */ - return value_zero (builtin_type_int, lval_memory); + return value_zero (builtin_type (exp->gdbarch)->builtin_int, + lval_memory); else error (_("Attempt to take contents of a non-pointer value.")); } + + /* Allow * on an integer so we can cast it to whatever we want. + This returns an int, which seems like the most C-like thing to + do. "long long" variables are rare enough that + BUILTIN_TYPE_LONGEST would seem to be a mistake. */ + if (TYPE_CODE (type) == TYPE_CODE_INT) + return value_at_lazy (builtin_type (exp->gdbarch)->builtin_int, + (CORE_ADDR) value_as_address (arg1)); return value_ind (arg1); case UNOP_ADDR: @@ -1968,6 +2527,7 @@ evaluate_subexp_standard (struct type *expect_type, else { struct value *retvalp = evaluate_subexp_for_address (exp, pos, noside); + return retvalp; } @@ -1989,6 +2549,22 @@ evaluate_subexp_standard (struct type *expect_type, arg1 = value_cast (type, arg1); return arg1; + case UNOP_DYNAMIC_CAST: + (*pos) += 2; + type = exp->elts[pc + 1].type; + arg1 = evaluate_subexp (type, exp, pos, noside); + if (noside == EVAL_SKIP) + goto nosideret; + return value_dynamic_cast (type, arg1); + + case UNOP_REINTERPRET_CAST: + (*pos) += 2; + type = exp->elts[pc + 1].type; + arg1 = evaluate_subexp (type, exp, pos, noside); + if (noside == EVAL_SKIP) + goto nosideret; + return value_reinterpret_cast (type, arg1); + case UNOP_MEMVAL: (*pos) += 2; arg1 = evaluate_subexp (expect_type, exp, pos, noside); @@ -2010,6 +2586,7 @@ evaluate_subexp_standard (struct type *expect_type, else { CORE_ADDR tls_addr; + tls_addr = target_translate_tls_address (exp->elts[pc + 1].objfile, value_as_address (arg1)); return value_at_lazy (exp->elts[pc + 2].type, tls_addr); @@ -2025,8 +2602,17 @@ evaluate_subexp_standard (struct type *expect_type, } else { - arg2 = value_add (arg1, value_from_longest (builtin_type_char, - (LONGEST) 1)); + if (ptrmath_type_p (exp->language_defn, value_type (arg1))) + arg2 = value_ptradd (arg1, 1); + else + { + struct value *tmp = arg1; + + arg2 = value_one (value_type (arg1), not_lval); + binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2); + arg2 = value_binop (tmp, arg2, BINOP_ADD); + } + return value_assign (arg1, arg2); } @@ -2040,8 +2626,17 @@ evaluate_subexp_standard (struct type *expect_type, } else { - arg2 = value_sub (arg1, value_from_longest (builtin_type_char, - (LONGEST) 1)); + if (ptrmath_type_p (exp->language_defn, value_type (arg1))) + arg2 = value_ptradd (arg1, -1); + else + { + struct value *tmp = arg1; + + arg2 = value_one (value_type (arg1), not_lval); + binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2); + arg2 = value_binop (tmp, arg2, BINOP_SUB); + } + return value_assign (arg1, arg2); } @@ -2055,8 +2650,17 @@ evaluate_subexp_standard (struct type *expect_type, } else { - arg2 = value_add (arg1, value_from_longest (builtin_type_char, - (LONGEST) 1)); + if (ptrmath_type_p (exp->language_defn, value_type (arg1))) + arg2 = value_ptradd (arg1, 1); + else + { + struct value *tmp = arg1; + + arg2 = value_one (value_type (arg1), not_lval); + binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2); + arg2 = value_binop (tmp, arg2, BINOP_ADD); + } + value_assign (arg1, arg2); return arg1; } @@ -2071,8 +2675,17 @@ evaluate_subexp_standard (struct type *expect_type, } else { - arg2 = value_sub (arg1, value_from_longest (builtin_type_char, - (LONGEST) 1)); + if (ptrmath_type_p (exp->language_defn, value_type (arg1))) + arg2 = value_ptradd (arg1, -1); + else + { + struct value *tmp = arg1; + + arg2 = value_one (value_type (arg1), not_lval); + binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2); + arg2 = value_binop (tmp, arg2, BINOP_SUB); + } + value_assign (arg1, arg2); return arg1; } @@ -2092,7 +2705,18 @@ evaluate_subexp_standard (struct type *expect_type, if (noside == EVAL_SKIP) goto nosideret; else if (noside == EVAL_AVOID_SIDE_EFFECTS) - return allocate_value (exp->elts[pc + 1].type); + { + struct type *type = exp->elts[pc + 1].type; + + /* If this is a typedef, then find its immediate target. We + use check_typedef to resolve stubs, but we ignore its + result because we do not want to dig past all + typedefs. */ + check_typedef (type); + if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF) + type = TYPE_TARGET_TYPE (type); + return allocate_value (type); + } else error (_("Attempt to use a type name as an expression")); @@ -2111,7 +2735,7 @@ GDB does not (yet) know how to evaluate that kind of expression")); } nosideret: - return value_from_longest (builtin_type_long, (LONGEST) 1); + return value_from_longest (builtin_type (exp->gdbarch)->builtin_int, 1); } /* Evaluate a subexpression of EXP, at index *POS, @@ -2147,7 +2771,7 @@ evaluate_subexp_for_address (struct expression *exp, int *pos, goto default_case_after_eval; } - return x; + return coerce_array (x); case UNOP_MEMVAL: (*pos) += 3; @@ -2166,32 +2790,26 @@ evaluate_subexp_for_address (struct expression *exp, int *pos, if (noside == EVAL_AVOID_SIDE_EFFECTS) { struct type *type = - lookup_pointer_type (SYMBOL_TYPE (var)); + lookup_pointer_type (SYMBOL_TYPE (var)); enum address_class sym_class = SYMBOL_CLASS (var); if (sym_class == LOC_CONST || sym_class == LOC_CONST_BYTES - || sym_class == LOC_REGISTER - || sym_class == LOC_REGPARM) + || sym_class == LOC_REGISTER) error (_("Attempt to take address of register or constant.")); return value_zero (type, not_lval); } - else if (symbol_read_needs_frame (var)) - return - locate_var_value - (var, - block_innermost_frame (exp->elts[pc + 1].block)); else - return locate_var_value (var, NULL); + return address_of_variable (var, exp->elts[pc + 1].block); case OP_SCOPE: tem = longest_to_int (exp->elts[pc + 2].longconst); (*pos) += 5 + BYTES_TO_EXP_ELEM (tem + 1); x = value_aggregate_elt (exp->elts[pc + 1].type, &exp->elts[pc + 3].string, - 1, noside); + NULL, 1, noside); if (x == NULL) error (_("There is no field named %s"), &exp->elts[pc + 3].string); return x; @@ -2238,6 +2856,7 @@ evaluate_subexp_with_coercion (struct expression *exp, int pc; struct value *val; struct symbol *var; + struct type *type; pc = (*pos); op = exp->elts[pc].opcode; @@ -2246,14 +2865,13 @@ evaluate_subexp_with_coercion (struct expression *exp, { case OP_VAR_VALUE: var = exp->elts[pc + 2].symbol; - if (TYPE_CODE (check_typedef (SYMBOL_TYPE (var))) == TYPE_CODE_ARRAY - && CAST_IS_CONVERSION) + type = check_typedef (SYMBOL_TYPE (var)); + if (TYPE_CODE (type) == TYPE_CODE_ARRAY + && CAST_IS_CONVERSION (exp->language_defn)) { (*pos) += 4; - val = - locate_var_value - (var, block_innermost_frame (exp->elts[pc + 1].block)); - return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (check_typedef (SYMBOL_TYPE (var)))), + val = address_of_variable (var, exp->elts[pc + 1].block); + return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type)), val); } /* FALLTHROUGH */ @@ -2270,6 +2888,8 @@ evaluate_subexp_with_coercion (struct expression *exp, static struct value * evaluate_subexp_for_sizeof (struct expression *exp, int *pos) { + /* FIXME: This should be size_t. */ + struct type *size_type = builtin_type (exp->gdbarch)->builtin_int; enum exp_opcode op; int pc; struct type *type; @@ -2293,24 +2913,22 @@ evaluate_subexp_for_sizeof (struct expression *exp, int *pos) && TYPE_CODE (type) != TYPE_CODE_ARRAY) error (_("Attempt to take contents of a non-pointer value.")); type = check_typedef (TYPE_TARGET_TYPE (type)); - return value_from_longest (builtin_type_int, (LONGEST) - TYPE_LENGTH (type)); + return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type)); case UNOP_MEMVAL: (*pos) += 3; type = check_typedef (exp->elts[pc + 1].type); - return value_from_longest (builtin_type_int, - (LONGEST) TYPE_LENGTH (type)); + return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type)); case OP_VAR_VALUE: (*pos) += 4; type = check_typedef (SYMBOL_TYPE (exp->elts[pc + 2].symbol)); return - value_from_longest (builtin_type_int, (LONGEST) TYPE_LENGTH (type)); + value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type)); default: val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS); - return value_from_longest (builtin_type_int, + return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (value_type (val))); } } @@ -2322,6 +2940,7 @@ parse_and_eval_type (char *p, int length) { char *tmp = (char *) alloca (length + 4); struct expression *expr; + tmp[0] = '('; memcpy (tmp + 1, p, length); tmp[length + 1] = ')';