X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Fppc-sysv-tdep.c;h=9a3b02f028d360cf99c974026df2e646541fd1b3;hb=ea764154c27a11619ba764a4c92f395ba5007234;hp=b7dfdca854bb7bed1111561cf37884674f80786d;hpb=73bb0000525a67694c1e8921e7c34ee0d985787e;p=binutils-gdb.git diff --git a/gdb/ppc-sysv-tdep.c b/gdb/ppc-sysv-tdep.c index b7dfdca854b..9a3b02f028d 100644 --- a/gdb/ppc-sysv-tdep.c +++ b/gdb/ppc-sysv-tdep.c @@ -1,7 +1,7 @@ /* Target-dependent code for PowerPC systems using the SVR4 ABI for GDB, the GNU debugger. - Copyright (C) 2000-2018 Free Software Foundation, Inc. + Copyright (C) 2000-2022 Free Software Foundation, Inc. This file is part of GDB. @@ -40,10 +40,10 @@ ppc_sysv_use_opencl_abi (struct type *ftype) { ftype = check_typedef (ftype); - if (TYPE_CODE (ftype) == TYPE_CODE_PTR) + if (ftype->code () == TYPE_CODE_PTR) ftype = check_typedef (TYPE_TARGET_TYPE (ftype)); - return (TYPE_CODE (ftype) == TYPE_CODE_FUNC + return (ftype->code () == TYPE_CODE_FUNC && TYPE_CALLING_CONVENTION (ftype) == DW_CC_GDB_IBM_OpenCL); } @@ -55,16 +55,17 @@ ppc_sysv_use_opencl_abi (struct type *ftype) are passed in user stack. If the function is returning a structure, then the return address is passed - in r3, then the first 7 words of the parametes can be passed in registers, + in r3, then the first 7 words of the parameters can be passed in registers, starting from r4. */ CORE_ADDR ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, - int struct_return, CORE_ADDR struct_addr) + function_call_return_method return_method, + CORE_ADDR struct_addr) { - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + ppc_gdbarch_tdep *tdep = (ppc_gdbarch_tdep *) gdbarch_tdep (gdbarch); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); int opencl_abi = ppc_sysv_use_opencl_abi (value_type (function)); ULONGEST saved_sp; @@ -91,10 +92,10 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, { int argno; /* Next available floating point register for float and double - arguments. */ + arguments. */ int freg = 1; /* Next available general register for non-float, non-vector - arguments. */ + arguments. */ int greg = 3; /* Next available vector register for vector arguments. */ int vreg = 2; @@ -104,10 +105,10 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, int structoffset = argoffset + argspace; /* If the function is returning a `struct', then the first word - (which will be passed in r3) is used for struct return - address. In that case we should advance one word and start - from r4 register to copy parameters. */ - if (struct_return) + (which will be passed in r3) is used for struct return + address. In that case we should advance one word and start + from r4 register to copy parameters. */ + if (return_method == return_method_struct) { if (write_pass) regcache_cooked_write_signed (regcache, @@ -121,20 +122,20 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, struct value *arg = args[argno]; struct type *type = check_typedef (value_type (arg)); int len = TYPE_LENGTH (type); - const bfd_byte *val = value_contents (arg); + const bfd_byte *val = value_contents (arg).data (); - if (TYPE_CODE (type) == TYPE_CODE_FLT && len <= 8 + if (type->code () == TYPE_CODE_FLT && len <= 8 && !tdep->soft_float) { /* Floating point value converted to "double" then - passed in an FP register, when the registers run out, - 8 byte aligned stack is used. */ + passed in an FP register, when the registers run out, + 8 byte aligned stack is used. */ if (freg <= 8) { if (write_pass) { /* Always store the floating point value using - the register's floating-point format. */ + the register's floating-point format. */ gdb_byte regval[PPC_MAX_REGISTER_SIZE]; struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum + freg); @@ -163,7 +164,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, argoffset += len; } } - else if (TYPE_CODE (type) == TYPE_CODE_FLT + else if (type->code () == TYPE_CODE_FLT && len == 16 && !tdep->soft_float && (gdbarch_long_double_format (gdbarch) @@ -190,17 +191,17 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, } } else if (len == 8 - && (TYPE_CODE (type) == TYPE_CODE_INT /* long long */ - || TYPE_CODE (type) == TYPE_CODE_FLT /* double */ - || (TYPE_CODE (type) == TYPE_CODE_DECFLOAT + && (type->code () == TYPE_CODE_INT /* long long */ + || type->code () == TYPE_CODE_FLT /* double */ + || (type->code () == TYPE_CODE_DECFLOAT && tdep->soft_float))) { /* "long long" or soft-float "double" or "_Decimal64" - passed in an odd/even register pair with the low - addressed word in the odd register and the high - addressed word in the even register, or when the - registers run out an 8 byte aligned stack - location. */ + passed in an odd/even register pair with the low + addressed word in the odd register and the high + addressed word in the even register, or when the + registers run out an 8 byte aligned stack + location. */ if (greg > 9) { /* Just in case GREG was 10. */ @@ -226,10 +227,10 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, } } else if (len == 16 - && ((TYPE_CODE (type) == TYPE_CODE_FLT + && ((type->code () == TYPE_CODE_FLT && (gdbarch_long_double_format (gdbarch) == floatformats_ibm_long_double)) - || (TYPE_CODE (type) == TYPE_CODE_DECFLOAT + || (type->code () == TYPE_CODE_DECFLOAT && tdep->soft_float))) { /* Soft-float IBM long double or _Decimal128 passed in @@ -259,11 +260,11 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, greg += 4; } } - else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT && len <= 8 + else if (type->code () == TYPE_CODE_DECFLOAT && len <= 8 && !tdep->soft_float) { /* 32-bit and 64-bit decimal floats go in f1 .. f8. They can - end up in memory. */ + end up in memory. */ if (freg <= 8) { @@ -275,10 +276,10 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, /* 32-bit decimal floats are right aligned in the doubleword. */ if (TYPE_LENGTH (type) == 4) - { - memcpy (regval + 4, val, 4); - p = regval; - } + { + memcpy (regval + 4, val, 4); + p = regval; + } else p = val; @@ -298,7 +299,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, argoffset += len; } } - else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT && len == 16 + else if (type->code () == TYPE_CODE_DECFLOAT && len == 16 && !tdep->soft_float) { /* 128-bit decimal floats go in f2 .. f7, always in even/odd @@ -327,14 +328,14 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, } /* If a 128-bit decimal float goes to the stack because only f7 - and f8 are free (thus there's no even/odd register pair + and f8 are free (thus there's no even/odd register pair available), these registers should be marked as occupied. Hence we increase freg even when writing to memory. */ freg += 2; } else if (len < 16 - && TYPE_CODE (type) == TYPE_CODE_ARRAY - && TYPE_VECTOR (type) + && type->code () == TYPE_CODE_ARRAY + && type->is_vector () && opencl_abi) { /* OpenCL vectors shorter than 16 bytes are passed as if @@ -346,7 +347,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, { const gdb_byte *elval = val + i * TYPE_LENGTH (eltype); - if (TYPE_CODE (eltype) == TYPE_CODE_FLT && !tdep->soft_float) + if (eltype->code () == TYPE_CODE_FLT && !tdep->soft_float) { if (freg <= 8) { @@ -420,8 +421,8 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, } } else if (len >= 16 - && TYPE_CODE (type) == TYPE_CODE_ARRAY - && TYPE_VECTOR (type) + && type->code () == TYPE_CODE_ARRAY + && type->is_vector () && opencl_abi) { /* OpenCL vectors 16 bytes or longer are passed as if @@ -449,12 +450,12 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, } } else if (len == 16 - && TYPE_CODE (type) == TYPE_CODE_ARRAY - && TYPE_VECTOR (type) + && type->code () == TYPE_CODE_ARRAY + && type->is_vector () && tdep->vector_abi == POWERPC_VEC_ALTIVEC) { /* Vector parameter passed in an Altivec register, or - when that runs out, 16 byte aligned stack location. */ + when that runs out, 16 byte aligned stack location. */ if (vreg <= 13) { if (write_pass) @@ -470,17 +471,17 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, } } else if (len == 8 - && TYPE_CODE (type) == TYPE_CODE_ARRAY - && TYPE_VECTOR (type) + && type->code () == TYPE_CODE_ARRAY + && type->is_vector () && tdep->vector_abi == POWERPC_VEC_SPE) { /* Vector parameter passed in an e500 register, or when - that runs out, 8 byte aligned stack location. Note - that since e500 vector and general purpose registers - both map onto the same underlying register set, a - "greg" and not a "vreg" is consumed here. A cooked - write stores the value in the correct locations - within the raw register cache. */ + that runs out, 8 byte aligned stack location. Note + that since e500 vector and general purpose registers + both map onto the same underlying register set, a + "greg" and not a "vreg" is consumed here. A cooked + write stores the value in the correct locations + within the raw register cache. */ if (greg <= 10) { if (write_pass) @@ -498,17 +499,17 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, else { /* Reduce the parameter down to something that fits in a - "word". */ + "word". */ gdb_byte word[PPC_MAX_REGISTER_SIZE]; memset (word, 0, PPC_MAX_REGISTER_SIZE); if (len > tdep->wordsize - || TYPE_CODE (type) == TYPE_CODE_STRUCT - || TYPE_CODE (type) == TYPE_CODE_UNION) + || type->code () == TYPE_CODE_STRUCT + || type->code () == TYPE_CODE_UNION) { /* Structs and large values are put in an aligned stack slot ... */ - if (TYPE_CODE (type) == TYPE_CODE_ARRAY - && TYPE_VECTOR (type) + if (type->code () == TYPE_CODE_ARRAY + && type->is_vector () && len >= 16) structoffset = align_up (structoffset, 16); else @@ -522,7 +523,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, sp + structoffset); structoffset += len; } - else if (TYPE_CODE (type) == TYPE_CODE_INT) + else if (type->code () == TYPE_CODE_INT) /* Sign or zero extend the "int" into a "word". */ store_unsigned_integer (word, tdep->wordsize, byte_order, unpack_long (type, val)); @@ -530,7 +531,7 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, /* Always goes in the low address. */ memcpy (word, val, len); /* Store that "word" in a register, or on the stack. - The words have "4" byte alignment. */ + The words have "4" byte alignment. */ if (greg <= 10) { if (write_pass) @@ -596,9 +597,9 @@ get_decimal_float_return_value (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf) { - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + ppc_gdbarch_tdep *tdep = (ppc_gdbarch_tdep *) gdbarch_tdep (gdbarch); - gdb_assert (TYPE_CODE (valtype) == TYPE_CODE_DECFLOAT); + gdb_assert (valtype->code () == TYPE_CODE_DECFLOAT); /* 32-bit and 64-bit decimal floats in f1. */ if (TYPE_LENGTH (valtype) <= 8) @@ -674,13 +675,13 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type, gdb_byte *readbuf, const gdb_byte *writebuf, int broken_gcc) { - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + ppc_gdbarch_tdep *tdep = (ppc_gdbarch_tdep *) gdbarch_tdep (gdbarch); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); int opencl_abi = func_type? ppc_sysv_use_opencl_abi (func_type) : 0; gdb_assert (tdep->wordsize == 4); - if (TYPE_CODE (type) == TYPE_CODE_FLT + if (type->code () == TYPE_CODE_FLT && TYPE_LENGTH (type) <= 8 && !tdep->soft_float) { @@ -690,7 +691,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type, the required type. */ gdb_byte regval[PPC_MAX_REGISTER_SIZE]; struct type *regtype = register_type (gdbarch, - tdep->ppc_fp0_regnum + 1); + tdep->ppc_fp0_regnum + 1); regcache->cooked_read (tdep->ppc_fp0_regnum + 1, regval); target_float_convert (regval, regtype, readbuf, type); } @@ -705,7 +706,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type, } return RETURN_VALUE_REGISTER_CONVENTION; } - if (TYPE_CODE (type) == TYPE_CODE_FLT + if (type->code () == TYPE_CODE_FLT && TYPE_LENGTH (type) == 16 && !tdep->soft_float && (gdbarch_long_double_format (gdbarch) @@ -725,10 +726,10 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type, return RETURN_VALUE_REGISTER_CONVENTION; } if (TYPE_LENGTH (type) == 16 - && ((TYPE_CODE (type) == TYPE_CODE_FLT + && ((type->code () == TYPE_CODE_FLT && (gdbarch_long_double_format (gdbarch) == floatformats_ibm_long_double)) - || (TYPE_CODE (type) == TYPE_CODE_DECFLOAT && tdep->soft_float))) + || (type->code () == TYPE_CODE_DECFLOAT && tdep->soft_float))) { /* Soft-float IBM long double or _Decimal128 stored in r3, r4, r5, r6. */ @@ -748,9 +749,9 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type, } return RETURN_VALUE_REGISTER_CONVENTION; } - if ((TYPE_CODE (type) == TYPE_CODE_INT && TYPE_LENGTH (type) == 8) - || (TYPE_CODE (type) == TYPE_CODE_FLT && TYPE_LENGTH (type) == 8) - || (TYPE_CODE (type) == TYPE_CODE_DECFLOAT && TYPE_LENGTH (type) == 8 + if ((type->code () == TYPE_CODE_INT && TYPE_LENGTH (type) == 8) + || (type->code () == TYPE_CODE_FLT && TYPE_LENGTH (type) == 8) + || (type->code () == TYPE_CODE_DECFLOAT && TYPE_LENGTH (type) == 8 && tdep->soft_float)) { if (readbuf) @@ -769,15 +770,15 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type, } return RETURN_VALUE_REGISTER_CONVENTION; } - if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT && !tdep->soft_float) + if (type->code () == TYPE_CODE_DECFLOAT && !tdep->soft_float) return get_decimal_float_return_value (gdbarch, type, regcache, readbuf, writebuf); - else if ((TYPE_CODE (type) == TYPE_CODE_INT - || TYPE_CODE (type) == TYPE_CODE_CHAR - || TYPE_CODE (type) == TYPE_CODE_BOOL - || TYPE_CODE (type) == TYPE_CODE_PTR + else if ((type->code () == TYPE_CODE_INT + || type->code () == TYPE_CODE_CHAR + || type->code () == TYPE_CODE_BOOL + || type->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (type) - || TYPE_CODE (type) == TYPE_CODE_ENUM) + || type->code () == TYPE_CODE_ENUM) && TYPE_LENGTH (type) <= tdep->wordsize) { if (readbuf) @@ -802,8 +803,8 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type, } /* OpenCL vectors < 16 bytes are returned as distinct scalars in f1..f2 or r3..r10. */ - if (TYPE_CODE (type) == TYPE_CODE_ARRAY - && TYPE_VECTOR (type) + if (type->code () == TYPE_CODE_ARRAY + && type->is_vector () && TYPE_LENGTH (type) < 16 && opencl_abi) { @@ -814,7 +815,7 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type, { int offset = i * TYPE_LENGTH (eltype); - if (TYPE_CODE (eltype) == TYPE_CODE_FLT) + if (eltype->code () == TYPE_CODE_FLT) { int regnum = tdep->ppc_fp0_regnum + 1 + i; gdb_byte regval[PPC_MAX_REGISTER_SIZE]; @@ -856,8 +857,8 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type, return RETURN_VALUE_REGISTER_CONVENTION; } /* OpenCL vectors >= 16 bytes are returned in v2..v9. */ - if (TYPE_CODE (type) == TYPE_CODE_ARRAY - && TYPE_VECTOR (type) + if (type->code () == TYPE_CODE_ARRAY + && type->is_vector () && TYPE_LENGTH (type) >= 16 && opencl_abi) { @@ -878,8 +879,8 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type, return RETURN_VALUE_REGISTER_CONVENTION; } if (TYPE_LENGTH (type) == 16 - && TYPE_CODE (type) == TYPE_CODE_ARRAY - && TYPE_VECTOR (type) + && type->code () == TYPE_CODE_ARRAY + && type->is_vector () && tdep->vector_abi == POWERPC_VEC_ALTIVEC) { if (readbuf) @@ -895,8 +896,8 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type, return RETURN_VALUE_REGISTER_CONVENTION; } if (TYPE_LENGTH (type) == 16 - && TYPE_CODE (type) == TYPE_CODE_ARRAY - && TYPE_VECTOR (type) + && type->code () == TYPE_CODE_ARRAY + && type->is_vector () && tdep->vector_abi == POWERPC_VEC_GENERIC) { /* GCC -maltivec -mabi=no-altivec returns vectors in r3/r4/r5/r6. @@ -919,8 +920,8 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *func_type, return RETURN_VALUE_REGISTER_CONVENTION; } if (TYPE_LENGTH (type) == 8 - && TYPE_CODE (type) == TYPE_CODE_ARRAY - && TYPE_VECTOR (type) + && type->code () == TYPE_CODE_ARRAY + && type->is_vector () && tdep->vector_abi == POWERPC_VEC_SPE) { /* The e500 ABI places return values for the 64-bit DSP types @@ -1042,7 +1043,7 @@ convert_code_addr_to_desc_addr (CORE_ADDR code_addr, CORE_ADDR *desc_addr) /* Find the minimal symbol that corresponds to CODE_ADDR (should have a name of the form ".FN"). */ dot_fn = lookup_minimal_symbol_by_pc (code_addr); - if (dot_fn.minsym == NULL || MSYMBOL_LINKAGE_NAME (dot_fn.minsym)[0] != '.') + if (dot_fn.minsym == NULL || dot_fn.minsym->linkage_name ()[0] != '.') return 0; /* Get the section that contains CODE_ADDR. Need this for the "objfile" that it contains. */ @@ -1053,7 +1054,7 @@ convert_code_addr_to_desc_addr (CORE_ADDR code_addr, CORE_ADDR *desc_addr) address. Only look for the minimal symbol in ".FN"'s object file - avoids problems when two object files (i.e., shared libraries) contain a minimal symbol with the same name. */ - fn = lookup_minimal_symbol (MSYMBOL_LINKAGE_NAME (dot_fn.minsym) + 1, NULL, + fn = lookup_minimal_symbol (dot_fn.minsym->linkage_name () + 1, NULL, dot_fn_section->objfile); if (fn.minsym == NULL) return 0; @@ -1075,36 +1076,36 @@ ppc64_aggregate_candidate (struct type *type, { type = check_typedef (type); - switch (TYPE_CODE (type)) + switch (type->code ()) { case TYPE_CODE_FLT: case TYPE_CODE_DECFLOAT: if (!*field_type) *field_type = type; - if (TYPE_CODE (*field_type) == TYPE_CODE (type) + if ((*field_type)->code () == type->code () && TYPE_LENGTH (*field_type) == TYPE_LENGTH (type)) return 1; break; case TYPE_CODE_COMPLEX: type = TYPE_TARGET_TYPE (type); - if (TYPE_CODE (type) == TYPE_CODE_FLT - || TYPE_CODE (type) == TYPE_CODE_DECFLOAT) + if (type->code () == TYPE_CODE_FLT + || type->code () == TYPE_CODE_DECFLOAT) { if (!*field_type) *field_type = type; - if (TYPE_CODE (*field_type) == TYPE_CODE (type) + if ((*field_type)->code () == type->code () && TYPE_LENGTH (*field_type) == TYPE_LENGTH (type)) return 2; } break; case TYPE_CODE_ARRAY: - if (TYPE_VECTOR (type)) + if (type->is_vector ()) { if (!*field_type) *field_type = type; - if (TYPE_CODE (*field_type) == TYPE_CODE (type) + if ((*field_type)->code () == type->code () && TYPE_LENGTH (*field_type) == TYPE_LENGTH (type)) return 1; } @@ -1137,19 +1138,19 @@ ppc64_aggregate_candidate (struct type *type, LONGEST count = 0; int i; - for (i = 0; i < TYPE_NFIELDS (type); i++) + for (i = 0; i < type->num_fields (); i++) { LONGEST sub_count; - if (field_is_static (&TYPE_FIELD (type, i))) + if (field_is_static (&type->field (i))) continue; sub_count = ppc64_aggregate_candidate - (TYPE_FIELD_TYPE (type, i), field_type); + (type->field (i).type (), field_type); if (sub_count == -1) return -1; - if (TYPE_CODE (type) == TYPE_CODE_STRUCT) + if (type->code () == TYPE_CODE_STRUCT) count += sub_count; else count = std::max (count, sub_count); @@ -1183,17 +1184,17 @@ ppc64_elfv2_abi_homogeneous_aggregate (struct type *type, { /* Complex types at the top level are treated separately. However, complex types can be elements of homogeneous aggregates. */ - if (TYPE_CODE (type) == TYPE_CODE_STRUCT - || TYPE_CODE (type) == TYPE_CODE_UNION - || (TYPE_CODE (type) == TYPE_CODE_ARRAY && !TYPE_VECTOR (type))) + if (type->code () == TYPE_CODE_STRUCT + || type->code () == TYPE_CODE_UNION + || (type->code () == TYPE_CODE_ARRAY && !type->is_vector ())) { struct type *field_type = NULL; LONGEST field_count = ppc64_aggregate_candidate (type, &field_type); if (field_count > 0) { - int n_regs = ((TYPE_CODE (field_type) == TYPE_CODE_FLT - || TYPE_CODE (field_type) == TYPE_CODE_DECFLOAT)? + int n_regs = ((field_type->code () == TYPE_CODE_FLT + || field_type->code () == TYPE_CODE_DECFLOAT)? (TYPE_LENGTH (field_type) + 7) >> 3 : 1); /* The ELFv2 ABI allows homogeneous aggregates to occupy @@ -1249,7 +1250,7 @@ ppc64_sysv_abi_push_val (struct gdbarch *gdbarch, const bfd_byte *val, int len, int align, struct ppc64_sysv_argpos *argpos) { - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + ppc_gdbarch_tdep *tdep = (ppc_gdbarch_tdep *) gdbarch_tdep (gdbarch); int offset = 0; /* Enforce alignment of stack location, if requested. */ @@ -1286,9 +1287,8 @@ ppc64_sysv_abi_push_val (struct gdbarch *gdbarch, if (len > 0) { if (argpos->regcache && argpos->greg <= 10) - regcache_cooked_write_part (argpos->regcache, - tdep->ppc_gp0_regnum + argpos->greg, - offset, len, val); + argpos->regcache->cooked_write_part + (tdep->ppc_gp0_regnum + argpos->greg, offset, len, val); argpos->greg++; } } @@ -1300,7 +1300,7 @@ static void ppc64_sysv_abi_push_integer (struct gdbarch *gdbarch, ULONGEST val, struct ppc64_sysv_argpos *argpos) { - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + ppc_gdbarch_tdep *tdep = (ppc_gdbarch_tdep *) gdbarch_tdep (gdbarch); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); gdb_byte buf[PPC_MAX_REGISTER_SIZE]; @@ -1318,15 +1318,15 @@ ppc64_sysv_abi_push_freg (struct gdbarch *gdbarch, struct type *type, const bfd_byte *val, struct ppc64_sysv_argpos *argpos) { - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + ppc_gdbarch_tdep *tdep = (ppc_gdbarch_tdep *) gdbarch_tdep (gdbarch); if (tdep->soft_float) return; if (TYPE_LENGTH (type) <= 8 - && TYPE_CODE (type) == TYPE_CODE_FLT) + && type->code () == TYPE_CODE_FLT) { /* Floats and doubles go in f1 .. f13. 32-bit floats are converted - to double first. */ + to double first. */ if (argpos->regcache && argpos->freg <= 13) { int regnum = tdep->ppc_fp0_regnum + argpos->freg; @@ -1340,7 +1340,7 @@ ppc64_sysv_abi_push_freg (struct gdbarch *gdbarch, argpos->freg++; } else if (TYPE_LENGTH (type) <= 8 - && TYPE_CODE (type) == TYPE_CODE_DECFLOAT) + && type->code () == TYPE_CODE_DECFLOAT) { /* Floats and doubles go in f1 .. f13. 32-bit decimal floats are placed in the least significant word. */ @@ -1352,14 +1352,14 @@ ppc64_sysv_abi_push_freg (struct gdbarch *gdbarch, if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) offset = 8 - TYPE_LENGTH (type); - regcache_cooked_write_part (argpos->regcache, regnum, - offset, TYPE_LENGTH (type), val); + argpos->regcache->cooked_write_part (regnum, offset, + TYPE_LENGTH (type), val); } argpos->freg++; } else if (TYPE_LENGTH (type) == 16 - && TYPE_CODE (type) == TYPE_CODE_FLT + && type->code () == TYPE_CODE_FLT && (gdbarch_long_double_format (gdbarch) == floatformats_ibm_long_double)) { @@ -1376,7 +1376,7 @@ ppc64_sysv_abi_push_freg (struct gdbarch *gdbarch, argpos->freg += 2; } else if (TYPE_LENGTH (type) == 16 - && TYPE_CODE (type) == TYPE_CODE_DECFLOAT) + && type->code () == TYPE_CODE_DECFLOAT) { /* 128-bit decimal floating-point values are stored in and even/odd pair of FPRs, with the even FPR holding the most significant half. */ @@ -1403,7 +1403,7 @@ static void ppc64_sysv_abi_push_vreg (struct gdbarch *gdbarch, const bfd_byte *val, struct ppc64_sysv_argpos *argpos) { - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + ppc_gdbarch_tdep *tdep = (ppc_gdbarch_tdep *) gdbarch_tdep (gdbarch); if (argpos->regcache && argpos->vreg <= 13) argpos->regcache->cooked_write (tdep->ppc_vr0_regnum + argpos->vreg, val); @@ -1419,16 +1419,16 @@ ppc64_sysv_abi_push_param (struct gdbarch *gdbarch, struct type *type, const bfd_byte *val, struct ppc64_sysv_argpos *argpos) { - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + ppc_gdbarch_tdep *tdep = (ppc_gdbarch_tdep *) gdbarch_tdep (gdbarch); - if (TYPE_CODE (type) == TYPE_CODE_FLT - || TYPE_CODE (type) == TYPE_CODE_DECFLOAT) + if (type->code () == TYPE_CODE_FLT + || type->code () == TYPE_CODE_DECFLOAT) { /* Floating-point scalars are passed in floating-point registers. */ ppc64_sysv_abi_push_val (gdbarch, val, TYPE_LENGTH (type), 0, argpos); ppc64_sysv_abi_push_freg (gdbarch, type, val, argpos); } - else if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type) + else if (type->code () == TYPE_CODE_ARRAY && type->is_vector () && tdep->vector_abi == POWERPC_VEC_ALTIVEC && TYPE_LENGTH (type) == 16) { @@ -1436,7 +1436,7 @@ ppc64_sysv_abi_push_param (struct gdbarch *gdbarch, ppc64_sysv_abi_push_val (gdbarch, val, TYPE_LENGTH (type), 16, argpos); ppc64_sysv_abi_push_vreg (gdbarch, val, argpos); } - else if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type) + else if (type->code () == TYPE_CODE_ARRAY && type->is_vector () && TYPE_LENGTH (type) >= 16) { /* Non-Altivec vectors are passed by reference. */ @@ -1450,11 +1450,11 @@ ppc64_sysv_abi_push_param (struct gdbarch *gdbarch, /* ... and pass a pointer to the copy as parameter. */ ppc64_sysv_abi_push_integer (gdbarch, addr, argpos); } - else if ((TYPE_CODE (type) == TYPE_CODE_INT - || TYPE_CODE (type) == TYPE_CODE_ENUM - || TYPE_CODE (type) == TYPE_CODE_BOOL - || TYPE_CODE (type) == TYPE_CODE_CHAR - || TYPE_CODE (type) == TYPE_CODE_PTR + else if ((type->code () == TYPE_CODE_INT + || type->code () == TYPE_CODE_ENUM + || type->code () == TYPE_CODE_BOOL + || type->code () == TYPE_CODE_CHAR + || type->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (type)) && TYPE_LENGTH (type) <= tdep->wordsize) { @@ -1467,14 +1467,14 @@ ppc64_sysv_abi_push_param (struct gdbarch *gdbarch, /* Convert any function code addresses into descriptors. */ if (tdep->elf_abi == POWERPC_ELF_V1 - && (TYPE_CODE (type) == TYPE_CODE_PTR - || TYPE_CODE (type) == TYPE_CODE_REF)) + && (type->code () == TYPE_CODE_PTR + || type->code () == TYPE_CODE_REF)) { struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type)); - if (TYPE_CODE (target_type) == TYPE_CODE_FUNC - || TYPE_CODE (target_type) == TYPE_CODE_METHOD) + if (target_type->code () == TYPE_CODE_FUNC + || target_type->code () == TYPE_CODE_METHOD) { CORE_ADDR desc = word; @@ -1493,14 +1493,14 @@ ppc64_sysv_abi_push_param (struct gdbarch *gdbarch, /* The ABI (version 1.9) specifies that structs containing a single floating-point value, at any level of nesting of single-member structs, are passed in floating-point registers. */ - if (TYPE_CODE (type) == TYPE_CODE_STRUCT - && TYPE_NFIELDS (type) == 1) + if (type->code () == TYPE_CODE_STRUCT + && type->num_fields () == 1) { - while (TYPE_CODE (type) == TYPE_CODE_STRUCT - && TYPE_NFIELDS (type) == 1) - type = check_typedef (TYPE_FIELD_TYPE (type, 0)); + while (type->code () == TYPE_CODE_STRUCT + && type->num_fields () == 1) + type = check_typedef (type->field (0).type ()); - if (TYPE_CODE (type) == TYPE_CODE_FLT) + if (type->code () == TYPE_CODE_FLT) ppc64_sysv_abi_push_freg (gdbarch, type, val, argpos); } @@ -1516,11 +1516,11 @@ ppc64_sysv_abi_push_param (struct gdbarch *gdbarch, { const gdb_byte *elval = val + i * TYPE_LENGTH (eltype); - if (TYPE_CODE (eltype) == TYPE_CODE_FLT - || TYPE_CODE (eltype) == TYPE_CODE_DECFLOAT) + if (eltype->code () == TYPE_CODE_FLT + || eltype->code () == TYPE_CODE_DECFLOAT) ppc64_sysv_abi_push_freg (gdbarch, eltype, elval, argpos); - else if (TYPE_CODE (eltype) == TYPE_CODE_ARRAY - && TYPE_VECTOR (eltype) + else if (eltype->code () == TYPE_CODE_ARRAY + && eltype->is_vector () && tdep->vector_abi == POWERPC_VEC_ALTIVEC && TYPE_LENGTH (eltype) == 16) ppc64_sysv_abi_push_vreg (gdbarch, elval, argpos); @@ -1541,10 +1541,11 @@ ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, - int struct_return, CORE_ADDR struct_addr) + function_call_return_method return_method, + CORE_ADDR struct_addr) { CORE_ADDR func_addr = find_function_addr (function, NULL); - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + ppc_gdbarch_tdep *tdep = (ppc_gdbarch_tdep *) gdbarch_tdep (gdbarch); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); int opencl_abi = ppc_sysv_use_opencl_abi (value_type (function)); ULONGEST back_chain; @@ -1621,20 +1622,20 @@ ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, } /* If the function is returning a `struct', then there is an - extra hidden parameter (which will be passed in r3) - containing the address of that struct.. In that case we - should advance one word and start from r4 register to copy - parameters. This also consumes one on-stack parameter slot. */ - if (struct_return) + extra hidden parameter (which will be passed in r3) + containing the address of that struct.. In that case we + should advance one word and start from r4 register to copy + parameters. This also consumes one on-stack parameter slot. */ + if (return_method == return_method_struct) ppc64_sysv_abi_push_integer (gdbarch, struct_addr, &argpos); for (argno = 0; argno < nargs; argno++) { struct value *arg = args[argno]; struct type *type = check_typedef (value_type (arg)); - const bfd_byte *val = value_contents (arg); + const bfd_byte *val = value_contents (arg).data (); - if (TYPE_CODE (type) == TYPE_CODE_COMPLEX) + if (type->code () == TYPE_CODE_COMPLEX) { /* Complex types are passed as if two independent scalars. */ struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type)); @@ -1643,7 +1644,7 @@ ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, ppc64_sysv_abi_push_param (gdbarch, eltype, val + TYPE_LENGTH (eltype), &argpos); } - else if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type) + else if (type->code () == TYPE_CODE_ARRAY && type->is_vector () && opencl_abi) { /* OpenCL vectors shorter than 16 bytes are passed as if @@ -1703,7 +1704,7 @@ ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct type *ftype = check_typedef (value_type (function)); CORE_ADDR desc_addr = value_as_address (function); - if (TYPE_CODE (ftype) == TYPE_CODE_PTR + if (ftype->code () == TYPE_CODE_PTR || convert_code_addr_to_desc_addr (func_addr, &desc_addr)) { /* The TOC is the second double word in the descriptor. */ @@ -1738,22 +1739,39 @@ ppc64_sysv_abi_return_value_base (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf, int index) { - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + ppc_gdbarch_tdep *tdep = (ppc_gdbarch_tdep *) gdbarch_tdep (gdbarch); /* Integers live in GPRs starting at r3. */ - if ((TYPE_CODE (valtype) == TYPE_CODE_INT - || TYPE_CODE (valtype) == TYPE_CODE_ENUM - || TYPE_CODE (valtype) == TYPE_CODE_CHAR - || TYPE_CODE (valtype) == TYPE_CODE_BOOL) + if ((valtype->code () == TYPE_CODE_INT + || valtype->code () == TYPE_CODE_ENUM + || valtype->code () == TYPE_CODE_CHAR + || valtype->code () == TYPE_CODE_BOOL + || valtype->code () == TYPE_CODE_RANGE + || is_fixed_point_type (valtype)) && TYPE_LENGTH (valtype) <= 8) { int regnum = tdep->ppc_gp0_regnum + 3 + index; if (writebuf != NULL) { + LONGEST return_val; + + if (is_fixed_point_type (valtype)) + { + /* Fixed point type values need to be returned unscaled. */ + gdb_mpz unscaled; + + unscaled.read (gdb::make_array_view (writebuf, + TYPE_LENGTH (valtype)), + type_byte_order (valtype), + valtype->is_unsigned ()); + return_val = unscaled.as_integer (); + } + else + return_val = unpack_long (valtype, writebuf); + /* Be careful to sign extend the value. */ - regcache_cooked_write_unsigned (regcache, regnum, - unpack_long (valtype, writebuf)); + regcache_cooked_write_unsigned (regcache, regnum, return_val); } if (readbuf != NULL) { @@ -1771,7 +1789,7 @@ ppc64_sysv_abi_return_value_base (struct gdbarch *gdbarch, struct type *valtype, /* Floats and doubles go in f1 .. f13. 32-bit floats are converted to double first. */ if (TYPE_LENGTH (valtype) <= 8 - && TYPE_CODE (valtype) == TYPE_CODE_FLT) + && valtype->code () == TYPE_CODE_FLT) { int regnum = tdep->ppc_fp0_regnum + 1 + index; struct type *regtype = register_type (gdbarch, regnum); @@ -1793,7 +1811,7 @@ ppc64_sysv_abi_return_value_base (struct gdbarch *gdbarch, struct type *valtype, /* Floats and doubles go in f1 .. f13. 32-bit decimal floats are placed in the least significant word. */ if (TYPE_LENGTH (valtype) <= 8 - && TYPE_CODE (valtype) == TYPE_CODE_DECFLOAT) + && valtype->code () == TYPE_CODE_DECFLOAT) { int regnum = tdep->ppc_fp0_regnum + 1 + index; int offset = 0; @@ -1802,8 +1820,8 @@ ppc64_sysv_abi_return_value_base (struct gdbarch *gdbarch, struct type *valtype, offset = 8 - TYPE_LENGTH (valtype); if (writebuf != NULL) - regcache_cooked_write_part (regcache, regnum, - offset, TYPE_LENGTH (valtype), writebuf); + regcache->cooked_write_part (regnum, offset, TYPE_LENGTH (valtype), + writebuf); if (readbuf != NULL) regcache->cooked_read_part (regnum, offset, TYPE_LENGTH (valtype), readbuf); @@ -1812,7 +1830,7 @@ ppc64_sysv_abi_return_value_base (struct gdbarch *gdbarch, struct type *valtype, /* IBM long double stored in two consecutive FPRs. */ if (TYPE_LENGTH (valtype) == 16 - && TYPE_CODE (valtype) == TYPE_CODE_FLT + && valtype->code () == TYPE_CODE_FLT && (gdbarch_long_double_format (gdbarch) == floatformats_ibm_long_double)) { @@ -1834,7 +1852,7 @@ ppc64_sysv_abi_return_value_base (struct gdbarch *gdbarch, struct type *valtype, /* 128-bit decimal floating-point values are stored in an even/odd pair of FPRs, with the even FPR holding the most significant half. */ if (TYPE_LENGTH (valtype) == 16 - && TYPE_CODE (valtype) == TYPE_CODE_DECFLOAT) + && valtype->code () == TYPE_CODE_DECFLOAT) { int regnum = tdep->ppc_fp0_regnum + 2 + 2 * index; int lopart = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG ? 8 : 0; @@ -1855,7 +1873,7 @@ ppc64_sysv_abi_return_value_base (struct gdbarch *gdbarch, struct type *valtype, /* AltiVec vectors are returned in VRs starting at v2. */ if (TYPE_LENGTH (valtype) == 16 - && TYPE_CODE (valtype) == TYPE_CODE_ARRAY && TYPE_VECTOR (valtype) + && valtype->code () == TYPE_CODE_ARRAY && valtype->is_vector () && tdep->vector_abi == POWERPC_VEC_ALTIVEC) { int regnum = tdep->ppc_vr0_regnum + 2 + index; @@ -1869,7 +1887,7 @@ ppc64_sysv_abi_return_value_base (struct gdbarch *gdbarch, struct type *valtype, /* Short vectors are returned in GPRs starting at r3. */ if (TYPE_LENGTH (valtype) <= 8 - && TYPE_CODE (valtype) == TYPE_CODE_ARRAY && TYPE_VECTOR (valtype)) + && valtype->code () == TYPE_CODE_ARRAY && valtype->is_vector ()) { int regnum = tdep->ppc_gp0_regnum + 3 + index; int offset = 0; @@ -1878,8 +1896,8 @@ ppc64_sysv_abi_return_value_base (struct gdbarch *gdbarch, struct type *valtype, offset = 8 - TYPE_LENGTH (valtype); if (writebuf != NULL) - regcache_cooked_write_part (regcache, regnum, - offset, TYPE_LENGTH (valtype), writebuf); + regcache->cooked_write_part (regnum, offset, TYPE_LENGTH (valtype), + writebuf); if (readbuf != NULL) regcache->cooked_read_part (regnum, offset, TYPE_LENGTH (valtype), readbuf); @@ -1904,11 +1922,11 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf) { - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + ppc_gdbarch_tdep *tdep = (ppc_gdbarch_tdep *) gdbarch_tdep (gdbarch); struct type *func_type = function ? value_type (function) : NULL; int opencl_abi = func_type? ppc_sysv_use_opencl_abi (func_type) : 0; struct type *eltype; - int nelt, i, ok; + int nelt, ok; /* This function exists to support a calling convention that requires floating-point registers. It shouldn't be used on @@ -1916,11 +1934,11 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct value *function, gdb_assert (ppc_floating_point_unit_p (gdbarch)); /* Complex types are returned as if two independent scalars. */ - if (TYPE_CODE (valtype) == TYPE_CODE_COMPLEX) + if (valtype->code () == TYPE_CODE_COMPLEX) { eltype = check_typedef (TYPE_TARGET_TYPE (valtype)); - for (i = 0; i < 2; i++) + for (int i = 0; i < 2; i++) { ok = ppc64_sysv_abi_return_value_base (gdbarch, eltype, regcache, readbuf, writebuf, i); @@ -1937,7 +1955,7 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct value *function, /* OpenCL vectors shorter than 16 bytes are returned as if a series of independent scalars; OpenCL vectors 16 bytes or longer are returned as if a series of AltiVec vectors. */ - if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY && TYPE_VECTOR (valtype) + if (valtype->code () == TYPE_CODE_ARRAY && valtype->is_vector () && opencl_abi) { if (TYPE_LENGTH (valtype) < 16) @@ -1946,7 +1964,7 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct value *function, eltype = register_type (gdbarch, tdep->ppc_vr0_regnum); nelt = TYPE_LENGTH (valtype) / TYPE_LENGTH (eltype); - for (i = 0; i < nelt; i++) + for (int i = 0; i < nelt; i++) { ok = ppc64_sysv_abi_return_value_base (gdbarch, eltype, regcache, readbuf, writebuf, i); @@ -1961,7 +1979,7 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct value *function, } /* All pointers live in r3. */ - if (TYPE_CODE (valtype) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (valtype)) + if (valtype->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (valtype)) { int regnum = tdep->ppc_gp0_regnum + 3; @@ -1973,18 +1991,18 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct value *function, } /* Small character arrays are returned, right justified, in r3. */ - if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY - && !TYPE_VECTOR (valtype) + if (valtype->code () == TYPE_CODE_ARRAY + && !valtype->is_vector () && TYPE_LENGTH (valtype) <= 8 - && TYPE_CODE (TYPE_TARGET_TYPE (valtype)) == TYPE_CODE_INT + && TYPE_TARGET_TYPE (valtype)->code () == TYPE_CODE_INT && TYPE_LENGTH (TYPE_TARGET_TYPE (valtype)) == 1) { int regnum = tdep->ppc_gp0_regnum + 3; int offset = (register_size (gdbarch, regnum) - TYPE_LENGTH (valtype)); if (writebuf != NULL) - regcache_cooked_write_part (regcache, regnum, - offset, TYPE_LENGTH (valtype), writebuf); + regcache->cooked_write_part (regnum, offset, TYPE_LENGTH (valtype), + writebuf); if (readbuf != NULL) regcache->cooked_read_part (regnum, offset, TYPE_LENGTH (valtype), readbuf); @@ -1995,14 +2013,14 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct value *function, aggregates are returned in registers. */ if (tdep->elf_abi == POWERPC_ELF_V2 && ppc64_elfv2_abi_homogeneous_aggregate (valtype, &eltype, &nelt) - && (TYPE_CODE (eltype) == TYPE_CODE_FLT - || TYPE_CODE (eltype) == TYPE_CODE_DECFLOAT - || (TYPE_CODE (eltype) == TYPE_CODE_ARRAY - && TYPE_VECTOR (eltype) + && (eltype->code () == TYPE_CODE_FLT + || eltype->code () == TYPE_CODE_DECFLOAT + || (eltype->code () == TYPE_CODE_ARRAY + && eltype->is_vector () && tdep->vector_abi == POWERPC_VEC_ALTIVEC && TYPE_LENGTH (eltype) == 16))) { - for (i = 0; i < nelt; i++) + for (int i = 0; i < nelt; i++) { ok = ppc64_sysv_abi_return_value_base (gdbarch, eltype, regcache, readbuf, writebuf, i); @@ -2021,16 +2039,15 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct value *function, returned in registers r3:r4. */ if (tdep->elf_abi == POWERPC_ELF_V2 && TYPE_LENGTH (valtype) <= 16 - && (TYPE_CODE (valtype) == TYPE_CODE_STRUCT - || TYPE_CODE (valtype) == TYPE_CODE_UNION - || (TYPE_CODE (valtype) == TYPE_CODE_ARRAY - && !TYPE_VECTOR (valtype)))) + && (valtype->code () == TYPE_CODE_STRUCT + || valtype->code () == TYPE_CODE_UNION + || (valtype->code () == TYPE_CODE_ARRAY + && !valtype->is_vector ()))) { int n_regs = ((TYPE_LENGTH (valtype) + tdep->wordsize - 1) / tdep->wordsize); - int i; - for (i = 0; i < n_regs; i++) + for (int i = 0; i < n_regs; i++) { gdb_byte regval[PPC_MAX_REGISTER_SIZE]; int regnum = tdep->ppc_gp0_regnum + 3 + i;