/* 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;
&& 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)
&& 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
/* 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);
}
if (fn.minsym == NULL)
return 0;
/* Found a descriptor. */
- (*desc_addr) = BMSYMBOL_VALUE_ADDRESS (fn);
+ (*desc_addr) = fn.value_address ();
return 1;
}
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)
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)
{
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 (gdb::make_array_view (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)
{
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;