X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Feval.c;h=7e0e9edbf990882b3b9ce2df9e8f943c35689859;hb=f33e9acf1b9d497a366d072caee34548fcfdf1cb;hp=95a2e4a3f8ef42922d8194d9daef623c1ac2c72f;hpb=cb137aa50156c9b105cf393b867c7dbe206ef9c9;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/eval.c b/gdb/eval.c index 95a2e4a3f8..7e0e9edbf9 100644 --- a/gdb/eval.c +++ b/gdb/eval.c @@ -37,9 +37,6 @@ #include "block.h" #include "parser-defs.h" -/* Defined in symtab.c */ -extern int hp_som_som_object_present; - /* This is defined in valops.c */ extern int overload_resolution; @@ -200,7 +197,7 @@ evaluate_struct_tuple (struct value *struct_val, struct expression *exp, int *pos, enum noside noside, int nargs) { - struct type *struct_type = check_typedef (VALUE_TYPE (struct_val)); + struct type *struct_type = check_typedef (value_type (struct_val)); struct type *substruct_type = struct_type; struct type *field_type; int fieldno = -1; @@ -311,7 +308,7 @@ evaluate_struct_tuple (struct value *struct_val, /* Now actually set the field in struct_val. */ /* Assign val to field fieldno. */ - if (VALUE_TYPE (val) != field_type) + if (value_type (val) != field_type) val = value_cast (field_type, val); bitsize = TYPE_FIELD_BITSIZE (substruct_type, subfieldno); @@ -324,7 +321,7 @@ evaluate_struct_tuple (struct value *struct_val, bitpos % 8, bitsize); else memcpy (addr, VALUE_CONTENTS (val), - TYPE_LENGTH (VALUE_TYPE (val))); + TYPE_LENGTH (value_type (val))); } while (--nlabels > 0); } @@ -344,7 +341,7 @@ init_array_element (struct value *array, struct value *element, enum noside noside, LONGEST low_bound, LONGEST high_bound) { LONGEST index; - int element_size = TYPE_LENGTH (VALUE_TYPE (element)); + int element_size = TYPE_LENGTH (value_type (element)); if (exp->elts[*pos].opcode == BINOP_COMMA) { (*pos)++; @@ -450,11 +447,11 @@ evaluate_subexp_standard (struct type *expect_type, case OP_REGISTER: { int regno = longest_to_int (exp->elts[pc + 1].longconst); - struct value *val = value_of_register (regno, get_selected_frame ()); + struct value *val = value_of_register (regno, get_selected_frame (NULL)); (*pos) += 2; if (val == NULL) error ("Value of register %s not available.", - frame_map_regnum_to_name (get_selected_frame (), regno)); + frame_map_regnum_to_name (get_selected_frame (NULL), regno)); else return val; } @@ -532,7 +529,7 @@ evaluate_subexp_standard (struct type *expect_type, evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP); } element = evaluate_subexp (element_type, exp, pos, noside); - if (VALUE_TYPE (element) != element_type) + if (value_type (element) != element_type) element = value_cast (element_type, element); if (index_pc) { @@ -583,16 +580,16 @@ evaluate_subexp_standard (struct type *expect_type, { (*pos)++; elem_val = evaluate_subexp (element_type, exp, pos, noside); - range_low_type = VALUE_TYPE (elem_val); + range_low_type = value_type (elem_val); range_low = value_as_long (elem_val); elem_val = evaluate_subexp (element_type, exp, pos, noside); - range_high_type = VALUE_TYPE (elem_val); + range_high_type = value_type (elem_val); range_high = value_as_long (elem_val); } else { elem_val = evaluate_subexp (element_type, exp, pos, noside); - range_low_type = range_high_type = VALUE_TYPE (elem_val); + range_low_type = range_high_type = value_type (elem_val); range_low = range_high = value_as_long (elem_val); } /* check types of elements to avoid mixture of elements from @@ -697,10 +694,10 @@ evaluate_subexp_standard (struct type *expect_type, case OP_OBJC_MSGCALL: { /* Objective C message (method) call. */ - static unsigned long responds_selector = 0; - static unsigned long method_selector = 0; + static CORE_ADDR responds_selector = 0; + static CORE_ADDR method_selector = 0; - unsigned long selector = 0; + CORE_ADDR selector = 0; int using_gcc = 0; int struct_return = 0; @@ -750,8 +747,19 @@ evaluate_subexp_standard (struct type *expect_type, only). */ if (gnu_runtime) { + struct type *type; + type = lookup_pointer_type (builtin_type_void); + 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 = value_from_pointer (type, value_as_address (msg_send)); + msg_send_stret = value_from_pointer (type, + value_as_address (msg_send_stret)); } else { @@ -877,7 +885,7 @@ evaluate_subexp_standard (struct type *expect_type, if (method) { - if (TYPE_CODE (VALUE_TYPE (method)) != TYPE_CODE_FUNC) + if (TYPE_CODE (value_type (method)) != TYPE_CODE_FUNC) error ("method address has symbol information with non-function type; skipping"); if (struct_return) VALUE_ADDRESS (method) = value_as_address (msg_send_stret); @@ -906,7 +914,7 @@ evaluate_subexp_standard (struct type *expect_type, it's opinion (ie. through "whatis"), it won't offer it. */ - struct type *type = VALUE_TYPE (called_method); + 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); @@ -936,14 +944,13 @@ evaluate_subexp_standard (struct type *expect_type, if (gnu_runtime && (method != NULL)) { - ret = call_function_by_hand (argvec[0], nargs + 2, argvec + 1); /* Function objc_msg_lookup returns a pointer. */ - argvec[0] = ret; - ret = call_function_by_hand (argvec[0], nargs + 2, argvec + 1); + argvec[0]->type + = lookup_function_type (lookup_pointer_type (value_type (argvec[0]))); + argvec[0] = call_function_by_hand (argvec[0], nargs + 2, argvec + 1); } - else - ret = call_function_by_hand (argvec[0], nargs + 2, argvec + 1); + ret = call_function_by_hand (argvec[0], nargs + 2, argvec + 1); return ret; } break; @@ -962,7 +969,7 @@ evaluate_subexp_standard (struct type *expect_type, /* 1997-08-01 Currently we do not support function invocation via pointers-to-methods with HP aCC. Pointer does not point to the function, but possibly to some thunk. */ - if (hp_som_som_object_present) + if (deprecated_hp_som_som_object_present) { error ("Not implemented: function invocation through pointer to method with HP aCC"); } @@ -998,9 +1005,9 @@ evaluate_subexp_standard (struct type *expect_type, int fnoffset = METHOD_PTR_TO_VOFFSET (fnptr); struct type *basetype; struct type *domain_type = - TYPE_DOMAIN_TYPE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))); + TYPE_DOMAIN_TYPE (TYPE_TARGET_TYPE (value_type (arg1))); int i, j; - basetype = TYPE_TARGET_TYPE (VALUE_TYPE (arg2)); + basetype = TYPE_TARGET_TYPE (value_type (arg2)); if (domain_type != basetype) arg2 = value_cast (lookup_pointer_type (domain_type), arg2); basetype = TYPE_VPTR_BASETYPE (domain_type); @@ -1023,7 +1030,7 @@ evaluate_subexp_standard (struct type *expect_type, } else { - VALUE_TYPE (arg1) = lookup_pointer_type (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))); + arg1->type = lookup_pointer_type (TYPE_TARGET_TYPE (value_type (arg1))); } got_it: @@ -1074,7 +1081,7 @@ evaluate_subexp_standard (struct type *expect_type, save_pos1 = *pos; argvec[0] = evaluate_subexp_with_coercion (exp, pos, noside); tem = 1; - type = VALUE_TYPE (argvec[0]); + type = value_type (argvec[0]); if (type && TYPE_CODE (type) == TYPE_CODE_PTR) type = TYPE_TARGET_TYPE (type); if (type && TYPE_CODE (type) == TYPE_CODE_FUNC) @@ -1117,7 +1124,7 @@ evaluate_subexp_standard (struct type *expect_type, /* 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]); + arg_types[ix - 1] = value_type (argvec[ix]); (void) find_overload_match (arg_types, nargs, tstr, 1 /* method */ , 0 /* strict match */ , @@ -1139,9 +1146,9 @@ evaluate_subexp_standard (struct type *expect_type, /* value_struct_elt updates temp with the correct value 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_EMBEDDED_OFFSET (temp)); + arg2 = value_from_longest (lookup_pointer_type(value_type (temp)), + VALUE_ADDRESS (temp) + value_offset (temp) + + VALUE_EMBEDDED_OFFSET (temp)); argvec[1] = arg2; /* the ``this'' pointer */ } @@ -1172,7 +1179,7 @@ evaluate_subexp_standard (struct type *expect_type, /* 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]); + arg_types[ix - 1] = value_type (argvec[ix]); (void) find_overload_match (arg_types, nargs, NULL /* no need for name */ , 0 /* not method */ , 0 /* strict match */ , @@ -1211,10 +1218,10 @@ evaluate_subexp_standard (struct type *expect_type, it won't offer it. */ struct type *ftype = - TYPE_TARGET_TYPE (VALUE_TYPE (argvec[0])); + TYPE_TARGET_TYPE (value_type (argvec[0])); if (ftype) - return allocate_value (TYPE_TARGET_TYPE (VALUE_TYPE (argvec[0]))); + return allocate_value (TYPE_TARGET_TYPE (value_type (argvec[0]))); else error ("Expression of type other than \"Function returning ...\" used as function"); } @@ -1235,7 +1242,7 @@ evaluate_subexp_standard (struct type *expect_type, /* First determine the type code we are dealing with. */ arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); - type = check_typedef (VALUE_TYPE (arg1)); + type = check_typedef (value_type (arg1)); code = TYPE_CODE (type); switch (code) @@ -1299,7 +1306,7 @@ evaluate_subexp_standard (struct type *expect_type, if (noside == EVAL_SKIP) goto nosideret; if (noside == EVAL_AVOID_SIDE_EFFECTS) - return value_zero (lookup_struct_elt_type (VALUE_TYPE (arg1), + return value_zero (lookup_struct_elt_type (value_type (arg1), &exp->elts[pc + 2].string, 0), lval_memory); @@ -1321,7 +1328,7 @@ evaluate_subexp_standard (struct type *expect_type, with rtti type in order to continue on with successful lookup of member / method only available in the rtti type. */ { - struct type *type = VALUE_TYPE (arg1); + struct type *type = value_type (arg1); struct type *real_type; int full, top, using_enc; @@ -1342,7 +1349,7 @@ evaluate_subexp_standard (struct type *expect_type, } if (noside == EVAL_AVOID_SIDE_EFFECTS) - return value_zero (lookup_struct_elt_type (VALUE_TYPE (arg1), + return value_zero (lookup_struct_elt_type (value_type (arg1), &exp->elts[pc + 2].string, 0), lval_memory); @@ -1358,9 +1365,9 @@ evaluate_subexp_standard (struct type *expect_type, arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside); /* With HP aCC, pointers to methods do not point to the function code */ - if (hp_som_som_object_present && - (TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_PTR) && - (TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg2))) == TYPE_CODE_METHOD)) + if (deprecated_hp_som_som_object_present && + (TYPE_CODE (value_type (arg2)) == TYPE_CODE_PTR) && + (TYPE_CODE (TYPE_TARGET_TYPE (value_type (arg2))) == TYPE_CODE_METHOD)) error ("Pointers to methods not supported with HP aCC"); /* 1997-08-19 */ mem_offset = value_as_long (arg2); @@ -1371,9 +1378,9 @@ evaluate_subexp_standard (struct type *expect_type, arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside); /* With HP aCC, pointers to methods do not point to the function code */ - if (hp_som_som_object_present && - (TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_PTR) && - (TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg2))) == TYPE_CODE_METHOD)) + if (deprecated_hp_som_som_object_present && + (TYPE_CODE (value_type (arg2)) == TYPE_CODE_PTR) && + (TYPE_CODE (TYPE_TARGET_TYPE (value_type (arg2))) == TYPE_CODE_METHOD)) error ("Pointers to methods not supported with HP aCC"); /* 1997-08-19 */ mem_offset = value_as_long (arg2); @@ -1381,7 +1388,7 @@ evaluate_subexp_standard (struct type *expect_type, handle_pointer_to_member: /* HP aCC generates offsets that have bit #29 set; turn it off to get a real offset to the member. */ - if (hp_som_som_object_present) + if (deprecated_hp_som_som_object_present) { if (!mem_offset) /* no bias -> really null */ error ("Attempted dereference of null pointer-to-member"); @@ -1389,7 +1396,7 @@ evaluate_subexp_standard (struct type *expect_type, } if (noside == EVAL_SKIP) goto nosideret; - type = check_typedef (VALUE_TYPE (arg2)); + type = check_typedef (value_type (arg2)); if (TYPE_CODE (type) != TYPE_CODE_PTR) goto bad_pointer_to_member; type = check_typedef (TYPE_TARGET_TYPE (type)); @@ -1418,22 +1425,22 @@ 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); + arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside); /* Do special stuff for HP aCC pointers to members */ - if (hp_som_som_object_present) + if (deprecated_hp_som_som_object_present) { /* 1997-08-19 Can't assign HP aCC pointers to methods. No details of the implementation yet; but the pointer appears to point to a code sequence (thunk) in memory -- in any case it is *not* the address of the function as it would be in a naive implementation. */ - if ((TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR) && - (TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))) == TYPE_CODE_METHOD)) + if ((TYPE_CODE (value_type (arg1)) == TYPE_CODE_PTR) && + (TYPE_CODE (TYPE_TARGET_TYPE (value_type (arg1))) == TYPE_CODE_METHOD)) error ("Assignment to pointers to methods not implemented with HP aCC"); /* HP aCC pointers to data members require a constant bias */ - if ((TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR) && - (TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))) == TYPE_CODE_MEMBER)) + if ((TYPE_CODE (value_type (arg1)) == TYPE_CODE_PTR) && + (TYPE_CODE (TYPE_TARGET_TYPE (value_type (arg1))) == TYPE_CODE_MEMBER)) { unsigned int *ptr = (unsigned int *) VALUE_CONTENTS (arg2); /* forces evaluation */ *ptr |= 0x20000000; /* set 29th bit */ @@ -1450,7 +1457,7 @@ evaluate_subexp_standard (struct type *expect_type, case BINOP_ASSIGN_MODIFY: (*pos) += 2; arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); - arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside); + arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside); if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS) return arg1; op = exp->elts[pc + 1].opcode; @@ -1501,7 +1508,7 @@ evaluate_subexp_standard (struct type *expect_type, return value_x_binop (arg1, arg2, op, OP_NULL, noside); else if (noside == EVAL_AVOID_SIDE_EFFECTS && (op == BINOP_DIV || op == BINOP_REM || op == BINOP_MOD)) - return value_zero (VALUE_TYPE (arg1), not_lval); + return value_zero (value_type (arg1), not_lval); else return value_binop (arg1, arg2, op); @@ -1525,8 +1532,8 @@ evaluate_subexp_standard (struct type *expect_type, array or pointer type (like a plain int variable for example), then report this as an error. */ - COERCE_REF (arg1); - type = check_typedef (VALUE_TYPE (arg1)); + arg1 = coerce_ref (arg1); + type = check_typedef (value_type (arg1)); if (TYPE_CODE (type) != TYPE_CODE_ARRAY && TYPE_CODE (type) != TYPE_CODE_PTR) { @@ -1576,7 +1583,7 @@ evaluate_subexp_standard (struct type *expect_type, type (like a plain int variable for example), then report this as an error. */ - type = TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (arg1))); + type = TYPE_TARGET_TYPE (check_typedef (value_type (arg1))); if (type != NULL) { arg1 = value_zero (type, VALUE_LVAL (arg1)); @@ -1586,7 +1593,7 @@ evaluate_subexp_standard (struct type *expect_type, else { error ("cannot subscript something of type `%s'", - TYPE_NAME (VALUE_TYPE (arg1))); + TYPE_NAME (value_type (arg1))); } } @@ -1603,9 +1610,8 @@ evaluate_subexp_standard (struct type *expect_type, multi_f77_subscript: { - int subscript_array[MAX_FORTRAN_DIMS + 1]; /* 1-based array of - subscripts, max == 7 */ - int array_size_array[MAX_FORTRAN_DIMS + 1]; + int subscript_array[MAX_FORTRAN_DIMS]; + int array_size_array[MAX_FORTRAN_DIMS]; int ndimensions = 1, i; struct type *tmp_type; int offset_item; /* The array offset where the item lives */ @@ -1613,7 +1619,7 @@ evaluate_subexp_standard (struct type *expect_type, if (nargs > MAX_FORTRAN_DIMS) error ("Too many subscripts for F77 (%d Max)", MAX_FORTRAN_DIMS); - tmp_type = check_typedef (VALUE_TYPE (arg1)); + tmp_type = check_typedef (value_type (arg1)); ndimensions = calc_f77_array_dims (type); if (nargs != ndimensions) @@ -1623,7 +1629,8 @@ evaluate_subexp_standard (struct type *expect_type, let us actually find out where this element exists in the array. */ offset_item = 0; - for (i = 1; i <= nargs; i++) + /* Take array indices left to right */ + for (i = 0; i < nargs; i++) { /* Evaluate each subscript, It must be a legal integer in F77 */ arg2 = evaluate_subexp_with_coercion (exp, pos, noside); @@ -1631,7 +1638,11 @@ evaluate_subexp_standard (struct type *expect_type, /* Fill in the subscript and array size arrays */ subscript_array[i] = value_as_long (arg2); + } + /* 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"); @@ -1640,11 +1651,11 @@ evaluate_subexp_standard (struct type *expect_type, if (retcode == BOUND_FETCH_ERROR) error ("Cannot obtain dynamic lower bound"); - array_size_array[i] = upper - lower + 1; + array_size_array[nargs - i - 1] = upper - lower + 1; /* Zero-normalize subscripts so that offsetting will work. */ - subscript_array[i] -= lower; + subscript_array[nargs - i - 1] -= lower; /* If we are at the bottom of a multidimensional array type then keep a ptr to the last ARRAY @@ -1654,17 +1665,17 @@ evaluate_subexp_standard (struct type *expect_type, of base element type that we apply a simple offset to. */ - if (i < nargs) + if (i < nargs - 1) tmp_type = check_typedef (TYPE_TARGET_TYPE (tmp_type)); } /* Now let us calculate the offset for this item */ - offset_item = subscript_array[ndimensions]; + offset_item = subscript_array[ndimensions - 1]; - for (i = ndimensions - 1; i >= 1; i--) + for (i = ndimensions - 1; i > 0; --i) offset_item = - array_size_array[i] * offset_item + subscript_array[i]; + array_size_array[i - 1] * offset_item + subscript_array[i - 1]; /* Construct a value node with the value of the offset */ @@ -1677,7 +1688,7 @@ evaluate_subexp_standard (struct type *expect_type, type, this will ensure that value_subscript() returns the correct type value */ - VALUE_TYPE (arg1) = tmp_type; + arg1->type = tmp_type; return value_ind (value_add (value_coerce_array (arg1), arg2)); } @@ -1735,7 +1746,7 @@ evaluate_subexp_standard (struct type *expect_type, case BINOP_EQUAL: arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); - arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside); + arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside); if (noside == EVAL_SKIP) goto nosideret; if (binop_user_defined_p (op, arg1, arg2)) @@ -1750,7 +1761,7 @@ evaluate_subexp_standard (struct type *expect_type, case BINOP_NOTEQUAL: arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); - arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside); + arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside); if (noside == EVAL_SKIP) goto nosideret; if (binop_user_defined_p (op, arg1, arg2)) @@ -1765,7 +1776,7 @@ evaluate_subexp_standard (struct type *expect_type, case BINOP_LESS: arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); - arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside); + arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside); if (noside == EVAL_SKIP) goto nosideret; if (binop_user_defined_p (op, arg1, arg2)) @@ -1780,7 +1791,7 @@ evaluate_subexp_standard (struct type *expect_type, case BINOP_GTR: arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); - arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside); + arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside); if (noside == EVAL_SKIP) goto nosideret; if (binop_user_defined_p (op, arg1, arg2)) @@ -1795,7 +1806,7 @@ evaluate_subexp_standard (struct type *expect_type, case BINOP_GEQ: arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); - arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside); + arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside); if (noside == EVAL_SKIP) goto nosideret; if (binop_user_defined_p (op, arg1, arg2)) @@ -1810,7 +1821,7 @@ evaluate_subexp_standard (struct type *expect_type, case BINOP_LEQ: arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); - arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside); + arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside); if (noside == EVAL_SKIP) goto nosideret; if (binop_user_defined_p (op, arg1, arg2)) @@ -1828,12 +1839,12 @@ evaluate_subexp_standard (struct type *expect_type, arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside); if (noside == EVAL_SKIP) goto nosideret; - type = check_typedef (VALUE_TYPE (arg2)); + type = check_typedef (value_type (arg2)); if (TYPE_CODE (type) != TYPE_CODE_INT) error ("Non-integral right operand for \"@\" operator."); if (noside == EVAL_AVOID_SIDE_EFFECTS) { - return allocate_repeat_value (VALUE_TYPE (arg1), + return allocate_repeat_value (value_type (arg1), longest_to_int (value_as_long (arg2))); } else @@ -1878,9 +1889,9 @@ evaluate_subexp_standard (struct type *expect_type, if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR) expect_type = TYPE_TARGET_TYPE (check_typedef (expect_type)); arg1 = evaluate_subexp (expect_type, exp, pos, noside); - if ((TYPE_TARGET_TYPE (VALUE_TYPE (arg1))) && - ((TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))) == TYPE_CODE_METHOD) || - (TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))) == TYPE_CODE_MEMBER))) + if ((TYPE_TARGET_TYPE (value_type (arg1))) && + ((TYPE_CODE (TYPE_TARGET_TYPE (value_type (arg1))) == TYPE_CODE_METHOD) || + (TYPE_CODE (TYPE_TARGET_TYPE (value_type (arg1))) == TYPE_CODE_MEMBER))) error ("Attempt to dereference pointer to member without an object"); if (noside == EVAL_SKIP) goto nosideret; @@ -1888,7 +1899,7 @@ evaluate_subexp_standard (struct type *expect_type, return value_x_unop (arg1, op, noside); else if (noside == EVAL_AVOID_SIDE_EFFECTS) { - type = check_typedef (VALUE_TYPE (arg1)); + type = check_typedef (value_type (arg1)); if (TYPE_CODE (type) == TYPE_CODE_PTR || TYPE_CODE (type) == TYPE_CODE_REF /* In C you can dereference an array to get the 1st elt. */ @@ -1924,9 +1935,9 @@ evaluate_subexp_standard (struct type *expect_type, { struct value *retvalp = evaluate_subexp_for_address (exp, pos, noside); /* If HP aCC object, use bias for pointers to members */ - if (hp_som_som_object_present && - (TYPE_CODE (VALUE_TYPE (retvalp)) == TYPE_CODE_PTR) && - (TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (retvalp))) == TYPE_CODE_MEMBER)) + if (deprecated_hp_som_som_object_present && + (TYPE_CODE (value_type (retvalp)) == TYPE_CODE_PTR) && + (TYPE_CODE (TYPE_TARGET_TYPE (value_type (retvalp))) == TYPE_CODE_MEMBER)) { unsigned int *ptr = (unsigned int *) VALUE_CONTENTS (retvalp); /* forces evaluation */ *ptr |= 0x20000000; /* set 29th bit */ @@ -1948,7 +1959,7 @@ evaluate_subexp_standard (struct type *expect_type, arg1 = evaluate_subexp (type, exp, pos, noside); if (noside == EVAL_SKIP) goto nosideret; - if (type != VALUE_TYPE (arg1)) + if (type != value_type (arg1)) arg1 = value_cast (type, arg1); return arg1; @@ -1961,8 +1972,7 @@ evaluate_subexp_standard (struct type *expect_type, return value_zero (exp->elts[pc + 1].type, lval_memory); else return value_at_lazy (exp->elts[pc + 1].type, - value_as_address (arg1), - NULL); + value_as_address (arg1)); case UNOP_PREINCREMENT: arg1 = evaluate_subexp (expect_type, exp, pos, noside); @@ -2120,7 +2130,7 @@ evaluate_subexp_for_address (struct expression *exp, int *pos, { struct value *x = evaluate_subexp (NULL_TYPE, exp, pos, noside); if (VALUE_LVAL (x) == lval_memory) - return value_zero (lookup_pointer_type (VALUE_TYPE (x)), + return value_zero (lookup_pointer_type (value_type (x)), not_lval); else error ("Attempt to take address of non-lval"); @@ -2199,7 +2209,7 @@ evaluate_subexp_for_sizeof (struct expression *exp, int *pos) case UNOP_IND: (*pos)++; val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS); - type = check_typedef (VALUE_TYPE (val)); + type = check_typedef (value_type (val)); if (TYPE_CODE (type) != TYPE_CODE_PTR && TYPE_CODE (type) != TYPE_CODE_REF && TYPE_CODE (type) != TYPE_CODE_ARRAY) @@ -2223,7 +2233,7 @@ evaluate_subexp_for_sizeof (struct expression *exp, int *pos) default: val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS); return value_from_longest (builtin_type_int, - (LONGEST) TYPE_LENGTH (VALUE_TYPE (val))); + (LONGEST) TYPE_LENGTH (value_type (val))); } }