/* Target-dependent code for PowerPC systems using the SVR4 ABI
for GDB, the GNU debugger.
- Copyright (C) 2000-2020 Free Software Foundation, Inc.
+ Copyright (C) 2000-2022 Free Software Foundation, Inc.
This file is part of GDB.
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;
{
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;
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. */
+ (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)
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_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);
&& 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. */
&& !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)
{
/* 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;
}
/* 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_CODE_ARRAY
- && TYPE_VECTOR (type)
+ && type->is_vector ()
&& opencl_abi)
{
/* OpenCL vectors shorter than 16 bytes are passed as if
}
else if (len >= 16
&& type->code () == TYPE_CODE_ARRAY
- && TYPE_VECTOR (type)
+ && type->is_vector ()
&& opencl_abi)
{
/* OpenCL vectors 16 bytes or longer are passed as if
}
else if (len == 16
&& type->code () == TYPE_CODE_ARRAY
- && TYPE_VECTOR (type)
+ && 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)
}
else if (len == 8
&& type->code () == TYPE_CODE_ARRAY
- && TYPE_VECTOR (type)
+ && 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)
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
/* Structs and large values are put in an
aligned stack slot ... */
if (type->code () == TYPE_CODE_ARRAY
- && TYPE_VECTOR (type)
+ && type->is_vector ()
&& len >= 16)
structoffset = align_up (structoffset, 16);
else
/* 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)
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 (valtype->code () == TYPE_CODE_DECFLOAT);
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;
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);
}
/* OpenCL vectors < 16 bytes are returned as distinct
scalars in f1..f2 or r3..r10. */
if (type->code () == TYPE_CODE_ARRAY
- && TYPE_VECTOR (type)
+ && type->is_vector ()
&& TYPE_LENGTH (type) < 16
&& opencl_abi)
{
}
/* OpenCL vectors >= 16 bytes are returned in v2..v9. */
if (type->code () == TYPE_CODE_ARRAY
- && TYPE_VECTOR (type)
+ && type->is_vector ()
&& TYPE_LENGTH (type) >= 16
&& opencl_abi)
{
}
if (TYPE_LENGTH (type) == 16
&& type->code () == TYPE_CODE_ARRAY
- && TYPE_VECTOR (type)
+ && type->is_vector ()
&& tdep->vector_abi == POWERPC_VEC_ALTIVEC)
{
if (readbuf)
}
if (TYPE_LENGTH (type) == 16
&& type->code () == TYPE_CODE_ARRAY
- && TYPE_VECTOR (type)
+ && type->is_vector ()
&& tdep->vector_abi == POWERPC_VEC_GENERIC)
{
/* GCC -maltivec -mabi=no-altivec returns vectors in r3/r4/r5/r6.
}
if (TYPE_LENGTH (type) == 8
&& type->code () == TYPE_CODE_ARRAY
- && TYPE_VECTOR (type)
+ && type->is_vector ()
&& tdep->vector_abi == POWERPC_VEC_SPE)
{
/* The e500 ABI places return values for the 64-bit DSP types
break;
case TYPE_CODE_ARRAY:
- if (TYPE_VECTOR (type))
+ if (type->is_vector ())
{
if (!*field_type)
*field_type = type;
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;
complex types can be elements of homogeneous aggregates. */
if (type->code () == TYPE_CODE_STRUCT
|| type->code () == TYPE_CODE_UNION
- || (type->code () == TYPE_CODE_ARRAY && !TYPE_VECTOR (type)))
+ || (type->code () == TYPE_CODE_ARRAY && !type->is_vector ()))
{
struct type *field_type = NULL;
LONGEST field_count = ppc64_aggregate_candidate (type, &field_type);
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. */
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];
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;
&& 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;
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);
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_CODE_FLT
|| type->code () == TYPE_CODE_DECFLOAT)
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_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)
{
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_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. */
{
while (type->code () == TYPE_CODE_STRUCT
&& type->num_fields () == 1)
- type = check_typedef (TYPE_FIELD_TYPE (type, 0));
+ type = check_typedef (type->field (0).type ());
if (type->code () == TYPE_CODE_FLT)
ppc64_sysv_abi_push_freg (gdbarch, type, val, argpos);
|| eltype->code () == TYPE_CODE_DECFLOAT)
ppc64_sysv_abi_push_freg (gdbarch, eltype, elval, argpos);
else if (eltype->code () == TYPE_CODE_ARRAY
- && TYPE_VECTOR (eltype)
+ && eltype->is_vector ()
&& tdep->vector_abi == POWERPC_VEC_ALTIVEC
&& TYPE_LENGTH (eltype) == 16)
ppc64_sysv_abi_push_vreg (gdbarch, elval, argpos);
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;
}
/* 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. */
+ 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);
{
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_CODE_COMPLEX)
{
ppc64_sysv_abi_push_param (gdbarch, eltype,
val + TYPE_LENGTH (eltype), &argpos);
}
- else if (type->code () == 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
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 ((valtype->code () == TYPE_CODE_INT
|| valtype->code () == TYPE_CODE_ENUM
|| valtype->code () == TYPE_CODE_CHAR
- || valtype->code () == TYPE_CODE_BOOL)
+ || 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 ({writebuf, TYPE_LENGTH (valtype)},
+ type_byte_order (valtype),
+ valtype->is_unsigned ());
+ return_val = unscaled.as_integer<LONGEST> ();
+ }
+ 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)
{
/* AltiVec vectors are returned in VRs starting at v2. */
if (TYPE_LENGTH (valtype) == 16
- && valtype->code () == 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;
/* Short vectors are returned in GPRs starting at r3. */
if (TYPE_LENGTH (valtype) <= 8
- && valtype->code () == 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;
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;
/* 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 (valtype->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (valtype)
+ if (valtype->code () == TYPE_CODE_ARRAY && valtype->is_vector ()
&& opencl_abi)
{
if (TYPE_LENGTH (valtype) < 16)
/* Small character arrays are returned, right justified, in r3. */
if (valtype->code () == TYPE_CODE_ARRAY
- && !TYPE_VECTOR (valtype)
+ && !valtype->is_vector ()
&& TYPE_LENGTH (valtype) <= 8
&& TYPE_TARGET_TYPE (valtype)->code () == TYPE_CODE_INT
&& TYPE_LENGTH (TYPE_TARGET_TYPE (valtype)) == 1)
&& (eltype->code () == TYPE_CODE_FLT
|| eltype->code () == TYPE_CODE_DECFLOAT
|| (eltype->code () == TYPE_CODE_ARRAY
- && TYPE_VECTOR (eltype)
+ && eltype->is_vector ()
&& tdep->vector_abi == POWERPC_VEC_ALTIVEC
&& TYPE_LENGTH (eltype) == 16)))
{
&& (valtype->code () == TYPE_CODE_STRUCT
|| valtype->code () == TYPE_CODE_UNION
|| (valtype->code () == TYPE_CODE_ARRAY
- && !TYPE_VECTOR (valtype))))
+ && !valtype->is_vector ())))
{
int n_regs = ((TYPE_LENGTH (valtype) + tdep->wordsize - 1)
/ tdep->wordsize);