X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fvalops.c;h=bde4684a82b14fc0a00bcde773fd8dc10d13fa7e;hb=refs%2Fheads%2Fconcurrent-displaced-stepping-2020-04-01;hp=03c6482ee1e9136a54b8a6327f67bd51ee941032;hpb=6b4a335bf7b7996e904e895b3fdc35443c40cfca;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/valops.c b/gdb/valops.c index 03c6482ee1..bde4684a82 100644 --- a/gdb/valops.c +++ b/gdb/valops.c @@ -139,7 +139,7 @@ find_function_in_inferior (const char *name, struct objfile **objf_p) if (msymbol.minsym != NULL) { struct objfile *objfile = msymbol.objfile; - struct gdbarch *gdbarch = get_objfile_arch (objfile); + struct gdbarch *gdbarch = objfile->arch (); struct type *type; CORE_ADDR maddr; @@ -175,7 +175,7 @@ value_allocate_space_in_inferior (int len) { struct objfile *objf; struct value *val = find_function_in_inferior ("malloc", &objf); - struct gdbarch *gdbarch = get_objfile_arch (objf); + struct gdbarch *gdbarch = objf->arch (); struct value *blocklen; blocklen = value_from_longest (builtin_type (gdbarch)->builtin_int, len); @@ -215,24 +215,24 @@ value_cast_structs (struct type *type, struct value *v2) t2 = check_typedef (value_type (v2)); /* Check preconditions. */ - gdb_assert ((TYPE_CODE (t1) == TYPE_CODE_STRUCT - || TYPE_CODE (t1) == TYPE_CODE_UNION) + gdb_assert ((t1->code () == TYPE_CODE_STRUCT + || t1->code () == TYPE_CODE_UNION) && !!"Precondition is that type is of STRUCT or UNION kind."); - gdb_assert ((TYPE_CODE (t2) == TYPE_CODE_STRUCT - || TYPE_CODE (t2) == TYPE_CODE_UNION) + gdb_assert ((t2->code () == TYPE_CODE_STRUCT + || t2->code () == TYPE_CODE_UNION) && !!"Precondition is that value is of STRUCT or UNION kind"); - if (TYPE_NAME (t1) != NULL - && TYPE_NAME (t2) != NULL - && !strcmp (TYPE_NAME (t1), TYPE_NAME (t2))) + if (t1->name () != NULL + && t2->name () != NULL + && !strcmp (t1->name (), t2->name ())) return NULL; /* Upcasting: look in the type of the source to see if it contains the type of the target as a superclass. If so, we'll need to offset the pointer rather than just change its type. */ - if (TYPE_NAME (t1) != NULL) + if (t1->name () != NULL) { - v = search_struct_field (TYPE_NAME (t1), + v = search_struct_field (t1->name (), v2, t2, 1); if (v) return v; @@ -241,7 +241,7 @@ value_cast_structs (struct type *type, struct value *v2) /* Downcasting: look in the type of the target to see if it contains the type of the source as a superclass. If so, we'll need to offset the pointer rather than just change its type. */ - if (TYPE_NAME (t2) != NULL) + if (t2->name () != NULL) { /* Try downcasting using the run-time type of the value. */ int full, using_enc; @@ -257,11 +257,11 @@ value_cast_structs (struct type *type, struct value *v2) /* We might be trying to cast to the outermost enclosing type, in which case search_struct_field won't work. */ - if (TYPE_NAME (real_type) != NULL - && !strcmp (TYPE_NAME (real_type), TYPE_NAME (t1))) + if (real_type->name () != NULL + && !strcmp (real_type->name (), t1->name ())) return v; - v = search_struct_field (TYPE_NAME (t2), v, real_type, 1); + v = search_struct_field (t2->name (), v, real_type, 1); if (v) return v; } @@ -269,7 +269,7 @@ value_cast_structs (struct type *type, struct value *v2) /* Try downcasting using information from the destination type T2. This wouldn't work properly for classes with virtual bases, but those were handled above. */ - v = search_struct_field (TYPE_NAME (t2), + v = search_struct_field (t2->name (), value_zero (t1, not_lval), t1, 1); if (v) { @@ -300,8 +300,8 @@ value_cast_pointers (struct type *type, struct value *arg2, struct type *t1 = check_typedef (TYPE_TARGET_TYPE (type1)); struct type *t2 = check_typedef (TYPE_TARGET_TYPE (type2)); - if (TYPE_CODE (t1) == TYPE_CODE_STRUCT - && TYPE_CODE (t2) == TYPE_CODE_STRUCT + if (t1->code () == TYPE_CODE_STRUCT + && t2->code () == TYPE_CODE_STRUCT && (subclass_check || !value_logical_not (arg2))) { struct value *v2; @@ -310,7 +310,7 @@ value_cast_pointers (struct type *type, struct value *arg2, v2 = coerce_ref (arg2); else v2 = value_ind (arg2); - gdb_assert (TYPE_CODE (check_typedef (value_type (v2))) + gdb_assert (check_typedef (value_type (v2))->code () == TYPE_CODE_STRUCT && !!"Why did coercion fail?"); v2 = value_cast_structs (t1, v2); /* At this point we have what we can have, un-dereference if needed. */ @@ -359,7 +359,7 @@ value_cast (struct type *type, struct value *arg2) struct type *dereftype = check_typedef (TYPE_TARGET_TYPE (t1)); struct value *val = value_cast (dereftype, arg2); - return value_ref (val, TYPE_CODE (t1)); + return value_ref (val, t1->code ()); } if (TYPE_IS_REFERENCE (check_typedef (value_type (arg2)))) @@ -372,7 +372,7 @@ value_cast (struct type *type, struct value *arg2) struct type *to_type = type; type = check_typedef (type); - code1 = TYPE_CODE (type); + code1 = type->code (); arg2 = coerce_ref (arg2); type2 = check_typedef (value_type (arg2)); @@ -415,15 +415,15 @@ value_cast (struct type *type, struct value *arg2) } if (current_language->c_style_arrays - && TYPE_CODE (type2) == TYPE_CODE_ARRAY + && type2->code () == TYPE_CODE_ARRAY && !TYPE_VECTOR (type2)) arg2 = value_coerce_array (arg2); - if (TYPE_CODE (type2) == TYPE_CODE_FUNC) + if (type2->code () == TYPE_CODE_FUNC) arg2 = value_coerce_function (arg2); type2 = check_typedef (value_type (arg2)); - code2 = TYPE_CODE (type2); + code2 = type2->code (); if (code1 == TYPE_CODE_COMPLEX) return cast_into_complex (to_type, arg2); @@ -443,7 +443,7 @@ value_cast (struct type *type, struct value *arg2) if ((code1 == TYPE_CODE_STRUCT || code1 == TYPE_CODE_UNION) && (code2 == TYPE_CODE_STRUCT || code2 == TYPE_CODE_UNION) - && TYPE_NAME (type) != 0) + && type->name () != 0) { struct value *v = value_cast_structs (to_type, arg2); @@ -590,8 +590,8 @@ value_reinterpret_cast (struct type *type, struct value *arg) arg_type = value_type (arg); - dest_code = TYPE_CODE (real_type); - arg_code = TYPE_CODE (arg_type); + dest_code = real_type->code (); + arg_code = arg_type->code (); /* We can convert pointer types, or any pointer type to int, or int type to pointer. */ @@ -611,7 +611,7 @@ value_reinterpret_cast (struct type *type, struct value *arg) if (is_ref) result = value_cast (type, value_ref (value_ind (result), - TYPE_CODE (type))); + type->code ())); return result; } @@ -722,24 +722,24 @@ value_dynamic_cast (struct type *type, struct value *arg) CORE_ADDR addr; int is_ref = TYPE_IS_REFERENCE (resolved_type); - if (TYPE_CODE (resolved_type) != TYPE_CODE_PTR + if (resolved_type->code () != TYPE_CODE_PTR && !TYPE_IS_REFERENCE (resolved_type)) error (_("Argument to dynamic_cast must be a pointer or reference type")); - if (TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) != TYPE_CODE_VOID - && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) != TYPE_CODE_STRUCT) + if (TYPE_TARGET_TYPE (resolved_type)->code () != TYPE_CODE_VOID + && TYPE_TARGET_TYPE (resolved_type)->code () != TYPE_CODE_STRUCT) error (_("Argument to dynamic_cast must be pointer to class or `void *'")); class_type = check_typedef (TYPE_TARGET_TYPE (resolved_type)); - if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR) + if (resolved_type->code () == TYPE_CODE_PTR) { - if (TYPE_CODE (arg_type) != TYPE_CODE_PTR - && ! (TYPE_CODE (arg_type) == TYPE_CODE_INT + if (arg_type->code () != TYPE_CODE_PTR + && ! (arg_type->code () == TYPE_CODE_INT && value_as_long (arg) == 0)) error (_("Argument to dynamic_cast does not have pointer type")); - if (TYPE_CODE (arg_type) == TYPE_CODE_PTR) + if (arg_type->code () == TYPE_CODE_PTR) { arg_type = check_typedef (TYPE_TARGET_TYPE (arg_type)); - if (TYPE_CODE (arg_type) != TYPE_CODE_STRUCT) + if (arg_type->code () != TYPE_CODE_STRUCT) error (_("Argument to dynamic_cast does " "not have pointer to class type")); } @@ -752,7 +752,7 @@ value_dynamic_cast (struct type *type, struct value *arg) } else { - if (TYPE_CODE (arg_type) != TYPE_CODE_STRUCT) + if (arg_type->code () != TYPE_CODE_STRUCT) error (_("Argument to dynamic_cast does not have class type")); } @@ -786,8 +786,8 @@ value_dynamic_cast (struct type *type, struct value *arg) /* dynamic_cast means to return a pointer to the most-derived object. */ - if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR - && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) == TYPE_CODE_VOID) + if (resolved_type->code () == TYPE_CODE_PTR + && TYPE_TARGET_TYPE (resolved_type)->code () == TYPE_CODE_VOID) return value_at_lazy (type, addr); tem = value_at (type, addr); @@ -808,7 +808,7 @@ value_dynamic_cast (struct type *type, struct value *arg) &result) == 1) return value_cast (type, is_ref - ? value_ref (result, TYPE_CODE (resolved_type)) + ? value_ref (result, resolved_type->code ()) : value_addr (result)); } @@ -822,10 +822,10 @@ value_dynamic_cast (struct type *type, struct value *arg) rtti_type, &result) == 1) return value_cast (type, is_ref - ? value_ref (result, TYPE_CODE (resolved_type)) + ? value_ref (result, resolved_type->code ()) : value_addr (result)); - if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR) + if (resolved_type->code () == TYPE_CODE_PTR) return value_zero (type, not_lval); error (_("dynamic_cast failed")); @@ -854,7 +854,7 @@ value_one (struct type *type) { val = value_from_longest (type, (LONGEST) 1); } - else if (TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1)) + else if (type1->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type1)) { struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type1)); int i; @@ -893,7 +893,7 @@ get_value_at (struct type *type, CORE_ADDR addr, int lazy) { struct value *val; - if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID) + if (check_typedef (type)->code () == TYPE_CODE_VOID) error (_("Attempt to dereference a generic pointer.")); val = value_from_contents_and_address (type, NULL, addr); @@ -1249,7 +1249,7 @@ value_assign (struct value *toval, struct value *fromval) in the case of pointer types. For object types, the enclosing type and embedded offset must *not* be copied: the target object refered to by TOVAL retains its original dynamic type after assignment. */ - if (TYPE_CODE (type) == TYPE_CODE_PTR) + if (type->code () == TYPE_CODE_PTR) { set_value_enclosing_type (val, value_enclosing_type (fromval)); set_value_pointed_to_offset (val, value_pointed_to_offset (fromval)); @@ -1306,7 +1306,7 @@ address_of_variable (struct symbol *var, const struct block *b) type = value_type (val); if ((VALUE_LVAL (val) == lval_memory && value_lazy (val)) - || TYPE_CODE (type) == TYPE_CODE_FUNC) + || type->code () == TYPE_CODE_FUNC) { CORE_ADDR addr = value_address (val); @@ -1358,7 +1358,7 @@ value_must_coerce_to_target (struct value *val) valtype = check_typedef (value_type (val)); - switch (TYPE_CODE (valtype)) + switch (valtype->code ()) { case TYPE_CODE_ARRAY: return TYPE_VECTOR (valtype) ? 0 : 1; @@ -1478,7 +1478,7 @@ value_addr (struct value *arg1) return arg2; } } - if (TYPE_CODE (type) == TYPE_CODE_FUNC) + if (type->code () == TYPE_CODE_FUNC) return value_coerce_function (arg1); /* If this is an array that has not yet been pushed to the target, @@ -1514,9 +1514,9 @@ value_ref (struct value *arg1, enum type_code refcode) gdb_assert (refcode == TYPE_CODE_REF || refcode == TYPE_CODE_RVALUE_REF); - if ((TYPE_CODE (type) == TYPE_CODE_REF - || TYPE_CODE (type) == TYPE_CODE_RVALUE_REF) - && TYPE_CODE (type) == refcode) + if ((type->code () == TYPE_CODE_REF + || type->code () == TYPE_CODE_RVALUE_REF) + && type->code () == refcode) return arg1; arg2 = value_addr (arg1); @@ -1550,7 +1550,7 @@ value_ind (struct value *arg1) } } - if (TYPE_CODE (base_type) == TYPE_CODE_PTR) + if (base_type->code () == TYPE_CODE_PTR) { struct type *enc_type; @@ -1559,8 +1559,8 @@ value_ind (struct value *arg1) enc_type = check_typedef (value_enclosing_type (arg1)); enc_type = TYPE_TARGET_TYPE (enc_type); - if (TYPE_CODE (check_typedef (enc_type)) == TYPE_CODE_FUNC - || TYPE_CODE (check_typedef (enc_type)) == TYPE_CODE_METHOD) + if (check_typedef (enc_type)->code () == TYPE_CODE_FUNC + || check_typedef (enc_type)->code () == TYPE_CODE_METHOD) /* For functions, go through find_function_addr, which knows how to handle function descriptors. */ arg2 = value_at_lazy (enc_type, @@ -1707,7 +1707,7 @@ typecmp (int staticp, int varargs, int nargs, t2 ++; for (i = 0; - (i < nargs) && TYPE_CODE (t1[i].type) != TYPE_CODE_VOID; + (i < nargs) && t1[i].type->code () != TYPE_CODE_VOID; i++) { struct type *tt1, *tt2; @@ -1720,13 +1720,13 @@ typecmp (int staticp, int varargs, int nargs, if (TYPE_IS_REFERENCE (tt1) /* We should be doing hairy argument matching, as below. */ - && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1))) - == TYPE_CODE (tt2))) + && (check_typedef (TYPE_TARGET_TYPE (tt1))->code () + == tt2->code ())) { - if (TYPE_CODE (tt2) == TYPE_CODE_ARRAY) + if (tt2->code () == TYPE_CODE_ARRAY) t2[i] = value_coerce_array (t2[i]); else - t2[i] = value_ref (t2[i], TYPE_CODE (tt1)); + t2[i] = value_ref (t2[i], tt1->code ()); continue; } @@ -1736,17 +1736,17 @@ typecmp (int staticp, int varargs, int nargs, char *>, and properly access map["hello"], because the argument to [] will be a reference to a pointer to a char, and the argument will be a pointer to a char. */ - while (TYPE_IS_REFERENCE (tt1) || TYPE_CODE (tt1) == TYPE_CODE_PTR) + while (TYPE_IS_REFERENCE (tt1) || tt1->code () == TYPE_CODE_PTR) { - tt1 = check_typedef( TYPE_TARGET_TYPE(tt1) ); + tt1 = check_typedef ( TYPE_TARGET_TYPE (tt1) ); } - while (TYPE_CODE(tt2) == TYPE_CODE_ARRAY - || TYPE_CODE(tt2) == TYPE_CODE_PTR + while (tt2->code () == TYPE_CODE_ARRAY + || tt2->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (tt2)) { - tt2 = check_typedef (TYPE_TARGET_TYPE(tt2)); + tt2 = check_typedef (TYPE_TARGET_TYPE (tt2)); } - if (TYPE_CODE (tt1) == TYPE_CODE (tt2)) + if (tt1->code () == tt2->code ()) continue; /* Array to pointer is a `trivial conversion' according to the ARM. */ @@ -1754,7 +1754,7 @@ typecmp (int staticp, int varargs, int nargs, /* We should be doing much hairier argument matching (see section 13.2 of the ARM), but as a quick kludge, just check for the same type code. */ - if (TYPE_CODE (t1[i].type) != TYPE_CODE (value_type (t2[i]))) + if (t1[i].type->code () != value_type (t2[i])->code ()) return i + 1; } if (varargs || t2[i] == NULL) @@ -1805,7 +1805,7 @@ do_search_struct_field (const char *name, struct value *arg1, LONGEST offset, nbases = TYPE_N_BASECLASSES (type); if (!looking_for_baseclass) - for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--) + for (i = type->num_fields () - 1; i >= nbases; i--) { const char *t_field_name = TYPE_FIELD_NAME (type, i); @@ -1813,7 +1813,7 @@ do_search_struct_field (const char *name, struct value *arg1, LONGEST offset, { struct value *v; - if (field_is_static (&TYPE_FIELD (type, i))) + if (field_is_static (&type->field (i))) v = value_static_field (type, i); else v = value_primitive_field (arg1, offset, i, type); @@ -1826,8 +1826,8 @@ do_search_struct_field (const char *name, struct value *arg1, LONGEST offset, { struct type *field_type = TYPE_FIELD_TYPE (type, i); - if (TYPE_CODE (field_type) == TYPE_CODE_UNION - || TYPE_CODE (field_type) == TYPE_CODE_STRUCT) + if (field_type->code () == TYPE_CODE_UNION + || field_type->code () == TYPE_CODE_STRUCT) { /* Look for a match through the fields of an anonymous union, or anonymous struct. C++ provides anonymous @@ -1850,8 +1850,8 @@ do_search_struct_field (const char *name, struct value *arg1, LONGEST offset, from GDB) implementation of variant records, the bitpos is zero in an anonymous union field, so we have to add the offset of the union here. */ - if (TYPE_CODE (field_type) == TYPE_CODE_STRUCT - || (TYPE_NFIELDS (field_type) > 0 + if (field_type->code () == TYPE_CODE_STRUCT + || (field_type->num_fields () > 0 && TYPE_FIELD_BITPOS (field_type, 0) == 0)) new_offset += TYPE_FIELD_BITPOS (type, i) / 8; @@ -2007,7 +2007,7 @@ search_struct_method (const char *name, struct value **arg1p, { if (!typecmp (TYPE_FN_FIELD_STATIC_P (f, j), TYPE_VARARGS (TYPE_FN_FIELD_TYPE (f, j)), - TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f, j)), + TYPE_FN_FIELD_TYPE (f, j)->num_fields (), TYPE_FN_FIELD_ARGS (f, j), args)) { if (TYPE_FN_FIELD_VIRTUAL_P (f, j)) @@ -2119,17 +2119,17 @@ value_struct_elt (struct value **argp, struct value **args, /* Follow pointers until we get to a non-pointer. */ - while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t)) + while (t->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t)) { *argp = value_ind (*argp); /* Don't coerce fn pointer to fn and then back again! */ - if (TYPE_CODE (check_typedef (value_type (*argp))) != TYPE_CODE_FUNC) + if (check_typedef (value_type (*argp))->code () != TYPE_CODE_FUNC) *argp = coerce_array (*argp); t = check_typedef (value_type (*argp)); } - if (TYPE_CODE (t) != TYPE_CODE_STRUCT - && TYPE_CODE (t) != TYPE_CODE_UNION) + if (t->code () != TYPE_CODE_STRUCT + && t->code () != TYPE_CODE_UNION) error (_("Attempt to extract a component of a value that is not a %s."), err); @@ -2206,22 +2206,22 @@ value_struct_elt_bitpos (struct value **argp, int bitpos, struct type *ftype, t = check_typedef (value_type (*argp)); - while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t)) + while (t->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t)) { *argp = value_ind (*argp); - if (TYPE_CODE (check_typedef (value_type (*argp))) != TYPE_CODE_FUNC) + if (check_typedef (value_type (*argp))->code () != TYPE_CODE_FUNC) *argp = coerce_array (*argp); t = check_typedef (value_type (*argp)); } - if (TYPE_CODE (t) != TYPE_CODE_STRUCT - && TYPE_CODE (t) != TYPE_CODE_UNION) + if (t->code () != TYPE_CODE_STRUCT + && t->code () != TYPE_CODE_UNION) error (_("Attempt to extract a component of a value that is not a %s."), err); - for (i = TYPE_N_BASECLASSES (t); i < TYPE_NFIELDS (t); i++) + for (i = TYPE_N_BASECLASSES (t); i < t->num_fields (); i++) { - if (!field_is_static (&TYPE_FIELD (t, i)) + if (!field_is_static (&t->field (i)) && bitpos == TYPE_FIELD_BITPOS (t, i) && types_equal (ftype, TYPE_FIELD_TYPE (t, i))) return value_primitive_field (*argp, 0, i, t); @@ -2233,50 +2233,6 @@ value_struct_elt_bitpos (struct value **argp, int bitpos, struct type *ftype, return NULL; } -/* See value.h. */ - -int -value_union_variant (struct type *union_type, const gdb_byte *contents) -{ - gdb_assert (TYPE_CODE (union_type) == TYPE_CODE_UNION - && TYPE_FLAG_DISCRIMINATED_UNION (union_type)); - - struct dynamic_prop *discriminant_prop - = get_dyn_prop (DYN_PROP_DISCRIMINATED, union_type); - gdb_assert (discriminant_prop != nullptr); - - struct discriminant_info *info - = (struct discriminant_info *) discriminant_prop->data.baton; - gdb_assert (info != nullptr); - - /* If this is a univariant union, just return the sole field. */ - if (TYPE_NFIELDS (union_type) == 1) - return 0; - /* This should only happen for univariants, which we already dealt - with. */ - gdb_assert (info->discriminant_index != -1); - - /* Compute the discriminant. Note that unpack_field_as_long handles - sign extension when necessary, as does the DWARF reader -- so - signed discriminants will be handled correctly despite the use of - an unsigned type here. */ - ULONGEST discriminant = unpack_field_as_long (union_type, contents, - info->discriminant_index); - - for (int i = 0; i < TYPE_NFIELDS (union_type); ++i) - { - if (i != info->default_index - && i != info->discriminant_index - && discriminant == info->discriminants[i]) - return i; - } - - if (info->default_index == -1) - error (_("Could not find variant corresponding to discriminant %s"), - pulongest (discriminant)); - return info->default_index; -} - /* Search through the methods of an object (and its bases) to find a specified method. Return a reference to the fn_field list METHODS of overloaded instances defined in the source language. If available @@ -2403,17 +2359,17 @@ value_find_oload_method_list (struct value **argp, const char *method, t = check_typedef (value_type (*argp)); /* Code snarfed from value_struct_elt. */ - while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t)) + while (t->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t)) { *argp = value_ind (*argp); /* Don't coerce fn pointer to fn and then back again! */ - if (TYPE_CODE (check_typedef (value_type (*argp))) != TYPE_CODE_FUNC) + if (check_typedef (value_type (*argp))->code () != TYPE_CODE_FUNC) *argp = coerce_array (*argp); t = check_typedef (value_type (*argp)); } - if (TYPE_CODE (t) != TYPE_CODE_STRUCT - && TYPE_CODE (t) != TYPE_CODE_UNION) + if (t->code () != TYPE_CODE_STRUCT + && t->code () != TYPE_CODE_UNION) error (_("Attempt to extract a component of a " "value that is not a struct or union")); @@ -2521,13 +2477,13 @@ find_overload_match (gdb::array_view args, /* OBJ may be a pointer value rather than the object itself. */ obj = coerce_ref (obj); - while (TYPE_CODE (check_typedef (value_type (obj))) == TYPE_CODE_PTR) + while (check_typedef (value_type (obj))->code () == TYPE_CODE_PTR) obj = coerce_ref (value_ind (obj)); - obj_type_name = TYPE_NAME (value_type (obj)); + obj_type_name = value_type (obj)->name (); /* First check whether this is a data member, e.g. a pointer to a function. */ - if (TYPE_CODE (check_typedef (value_type (obj))) == TYPE_CODE_STRUCT) + if (check_typedef (value_type (obj))->code () == TYPE_CODE_STRUCT) { *valp = search_struct_field (name, obj, check_typedef (value_type (obj)), 0); @@ -2650,8 +2606,8 @@ find_overload_match (gdb::array_view args, the function part. Do not try this for non-functions (e.g. function pointers). */ if (qualified_name - && TYPE_CODE (check_typedef (SYMBOL_TYPE (fsym))) - == TYPE_CODE_FUNC) + && (check_typedef (SYMBOL_TYPE (fsym))->code () + == TYPE_CODE_FUNC)) { temp_func = cp_func_name (qualified_name); @@ -2796,8 +2752,8 @@ find_overload_match (gdb::array_view args, struct type *temp_type = check_typedef (value_type (temp)); struct type *objtype = check_typedef (obj_type); - if (TYPE_CODE (temp_type) != TYPE_CODE_PTR - && (TYPE_CODE (objtype) == TYPE_CODE_PTR + if (temp_type->code () != TYPE_CODE_PTR + && (objtype->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (objtype))) { temp = value_addr (temp); @@ -3001,11 +2957,11 @@ find_oload_champ (gdb::array_view args, if (methods != NULL) { - nparms = TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (methods, ix)); + nparms = TYPE_FN_FIELD_TYPE (methods, ix)->num_fields (); static_offset = oload_method_static_p (methods, ix); } else - nparms = TYPE_NFIELDS (SYMBOL_TYPE (functions[ix])); + nparms = SYMBOL_TYPE (functions[ix])->num_fields (); parm_types.reserve (nparms); for (jj = 0; jj < nparms; jj++) @@ -3162,10 +3118,10 @@ enum_constant_from_type (struct type *type, const char *name) int i; int name_len = strlen (name); - gdb_assert (TYPE_CODE (type) == TYPE_CODE_ENUM + gdb_assert (type->code () == TYPE_CODE_ENUM && TYPE_DECLARED_CLASS (type)); - for (i = TYPE_N_BASECLASSES (type); i < TYPE_NFIELDS (type); ++i) + for (i = TYPE_N_BASECLASSES (type); i < type->num_fields (); ++i) { const char *fname = TYPE_FIELD_NAME (type, i); int len; @@ -3185,7 +3141,7 @@ enum_constant_from_type (struct type *type, const char *name) } error (_("no constant named \"%s\" in enum \"%s\""), - name, TYPE_NAME (type)); + name, type->name ()); } /* C++: Given an aggregate type CURTYPE, and a member name NAME, @@ -3199,7 +3155,7 @@ value_aggregate_elt (struct type *curtype, const char *name, struct type *expect_type, int want_address, enum noside noside) { - switch (TYPE_CODE (curtype)) + switch (curtype->code ()) { case TYPE_CODE_STRUCT: case TYPE_CODE_UNION: @@ -3233,14 +3189,14 @@ compare_parameters (struct type *t1, struct type *t2, int skip_artificial) { int start = 0; - if (TYPE_NFIELDS (t1) > 0 && TYPE_FIELD_ARTIFICIAL (t1, 0)) + if (t1->num_fields () > 0 && TYPE_FIELD_ARTIFICIAL (t1, 0)) ++start; /* If skipping artificial fields, find the first real field in T1. */ if (skip_artificial) { - while (start < TYPE_NFIELDS (t1) + while (start < t1->num_fields () && TYPE_FIELD_ARTIFICIAL (t1, start)) ++start; } @@ -3249,15 +3205,15 @@ compare_parameters (struct type *t1, struct type *t2, int skip_artificial) /* Special case: a method taking void. T1 will contain no non-artificial fields, and T2 will contain TYPE_CODE_VOID. */ - if ((TYPE_NFIELDS (t1) - start) == 0 && TYPE_NFIELDS (t2) == 1 - && TYPE_CODE (TYPE_FIELD_TYPE (t2, 0)) == TYPE_CODE_VOID) + if ((t1->num_fields () - start) == 0 && t2->num_fields () == 1 + && TYPE_FIELD_TYPE (t2, 0)->code () == TYPE_CODE_VOID) return 1; - if ((TYPE_NFIELDS (t1) - start) == TYPE_NFIELDS (t2)) + if ((t1->num_fields () - start) == t2->num_fields ()) { int i; - for (i = 0; i < TYPE_NFIELDS (t2); ++i) + for (i = 0; i < t2->num_fields (); ++i) { if (compare_ranks (rank_one_type (TYPE_FIELD_TYPE (t1, start + i), TYPE_FIELD_TYPE (t2, i), NULL), @@ -3332,18 +3288,18 @@ value_struct_elt_for_reference (struct type *domain, int offset, int i; struct value *result; - if (TYPE_CODE (t) != TYPE_CODE_STRUCT - && TYPE_CODE (t) != TYPE_CODE_UNION) + if (t->code () != TYPE_CODE_STRUCT + && t->code () != TYPE_CODE_UNION) error (_("Internal error: non-aggregate type " "to value_struct_elt_for_reference")); - for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--) + for (i = t->num_fields () - 1; i >= TYPE_N_BASECLASSES (t); i--) { const char *t_field_name = TYPE_FIELD_NAME (t, i); if (t_field_name && strcmp (t_field_name, name) == 0) { - if (field_is_static (&TYPE_FIELD (t, i))) + if (field_is_static (&t->field (i))) { struct value *v = value_static_field (t, i); if (want_address) @@ -3374,7 +3330,7 @@ value_struct_elt_for_reference (struct type *domain, int offset, ptr = value_aggregate_elt (domain, name, NULL, 1, noside); type = check_typedef (value_type (ptr)); gdb_assert (type != NULL - && TYPE_CODE (type) == TYPE_CODE_MEMBERPTR); + && type->code () == TYPE_CODE_MEMBERPTR); tmp = lookup_pointer_type (TYPE_SELF_TYPE (type)); v = value_cast_pointers (tmp, v, 1); mem_offset = value_as_long (ptr); @@ -3411,7 +3367,7 @@ value_struct_elt_for_reference (struct type *domain, int offset, as a pointer to a method. */ /* Perform all necessary dereferencing. */ - while (intype && TYPE_CODE (intype) == TYPE_CODE_PTR) + while (intype && intype->code () == TYPE_CODE_PTR) intype = TYPE_TARGET_TYPE (intype); for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i) @@ -3572,7 +3528,7 @@ value_namespace_elt (const struct type *curtype, if (retval == NULL) error (_("No symbol \"%s\" in namespace \"%s\"."), - name, TYPE_NAME (curtype)); + name, curtype->name ()); return retval; } @@ -3588,7 +3544,7 @@ value_maybe_namespace_elt (const struct type *curtype, const char *name, int want_address, enum noside noside) { - const char *namespace_name = TYPE_NAME (curtype); + const char *namespace_name = curtype->name (); struct block_symbol sym; struct value *result; @@ -3625,7 +3581,7 @@ value_rtti_indirect_type (struct value *v, int *full, type = check_typedef (type); if (TYPE_IS_REFERENCE (type)) target = coerce_ref (v); - else if (TYPE_CODE (type) == TYPE_CODE_PTR) + else if (type->code () == TYPE_CODE_PTR) { try @@ -3656,8 +3612,8 @@ value_rtti_indirect_type (struct value *v, int *full, real_type = make_cv_type (TYPE_CONST (target_type), TYPE_VOLATILE (target_type), real_type, NULL); if (TYPE_IS_REFERENCE (type)) - real_type = lookup_reference_type (real_type, TYPE_CODE (type)); - else if (TYPE_CODE (type) == TYPE_CODE_PTR) + real_type = lookup_reference_type (real_type, type->code ()); + else if (type->code () == TYPE_CODE_PTR) real_type = lookup_pointer_type (real_type); else internal_error (__FILE__, __LINE__, _("Unexpected value type.")); @@ -3728,7 +3684,7 @@ value_full_object (struct value *argp, { warning (_("Couldn't retrieve complete object of RTTI " "type %s; object may be in register(s)."), - TYPE_NAME (real_type)); + real_type->name ()); return argp; } @@ -3804,8 +3760,8 @@ value_slice (struct value *array, int lowbound, int length) struct type *array_type; array_type = check_typedef (value_type (array)); - if (TYPE_CODE (array_type) != TYPE_CODE_ARRAY - && TYPE_CODE (array_type) != TYPE_CODE_STRING) + if (array_type->code () != TYPE_CODE_ARRAY + && array_type->code () != TYPE_CODE_STRING) error (_("cannot take slice of non-array")); if (type_not_allocated (array_type)) @@ -3836,7 +3792,7 @@ value_slice (struct value *array, int lowbound, int length) slice_type = create_array_type (NULL, element_type, slice_range_type); - TYPE_CODE (slice_type) = TYPE_CODE (array_type); + slice_type->set_code (array_type->code ()); if (VALUE_LVAL (array) == lval_memory && value_lazy (array)) slice = allocate_value_lazy (slice_type); @@ -3883,7 +3839,7 @@ value_real_part (struct value *value) struct type *type = check_typedef (value_type (value)); struct type *ttype = TYPE_TARGET_TYPE (type); - gdb_assert (TYPE_CODE (type) == TYPE_CODE_COMPLEX); + gdb_assert (type->code () == TYPE_CODE_COMPLEX); return value_from_component (value, ttype, 0); } @@ -3895,7 +3851,7 @@ value_imaginary_part (struct value *value) struct type *type = check_typedef (value_type (value)); struct type *ttype = TYPE_TARGET_TYPE (type); - gdb_assert (TYPE_CODE (type) == TYPE_CODE_COMPLEX); + gdb_assert (type->code () == TYPE_CODE_COMPLEX); return value_from_component (value, ttype, TYPE_LENGTH (check_typedef (ttype))); } @@ -3907,7 +3863,7 @@ cast_into_complex (struct type *type, struct value *val) { struct type *real_type = TYPE_TARGET_TYPE (type); - if (TYPE_CODE (value_type (val)) == TYPE_CODE_COMPLEX) + if (value_type (val)->code () == TYPE_CODE_COMPLEX) { struct type *val_real_type = TYPE_TARGET_TYPE (value_type (val)); struct value *re_val = allocate_value (val_real_type); @@ -3921,8 +3877,8 @@ cast_into_complex (struct type *type, struct value *val) return value_literal_complex (re_val, im_val, type); } - else if (TYPE_CODE (value_type (val)) == TYPE_CODE_FLT - || TYPE_CODE (value_type (val)) == TYPE_CODE_INT) + else if (value_type (val)->code () == TYPE_CODE_FLT + || value_type (val)->code () == TYPE_CODE_INT) return value_literal_complex (val, value_zero (real_type, not_lval), type);