diff options
| -rw-r--r-- | gdb/ChangeLog | 5 | ||||
| -rw-r--r-- | gdb/ppc-sysv-tdep.c | 490 |
2 files changed, 241 insertions, 254 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index faca64f..18f03da 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,5 +1,10 @@ 2003-09-12 Andrew Cagney <cagney@redhat.com> + * ppc-sysv-tdep.c (align_up, align_down): Replace "round2" macro. + (ppc_sysv_abi_push_dummy_call): Rewrite, use a two pass loop. + +2003-09-12 Andrew Cagney <cagney@redhat.com> + * objfiles.h (struct entry_info): Deprecate "entry_file_lowpc" and "entry_file_highpc". Update comments. * defs.h (deprecated_inside_entry_file): Rename diff --git a/gdb/ppc-sysv-tdep.c b/gdb/ppc-sysv-tdep.c index 2f13e29..777cbbc 100644 --- a/gdb/ppc-sysv-tdep.c +++ b/gdb/ppc-sysv-tdep.c @@ -29,11 +29,20 @@ #include "ppc-tdep.h" -/* round2 rounds x up to the nearest multiple of s assuming that s is a - power of 2 */ +/* Ensure that X is aligned to an S byte boundary (assuming that S is + a power of 2) rounding up/down where necessary. */ -#undef round2 -#define round2(x,s) ((((long) (x) - 1) & ~(long)((s)-1)) + (s)) +static ULONGEST +align_up (ULONGEST x, int s) +{ + return (x + s - 1) & -s; +} + +static ULONGEST +align_down (ULONGEST x, int s) +{ + return (x & -s); +} /* Pass the arguments in either registers, or in the stack. Using the ppc sysv ABI, the first eight words of the argument list (that might @@ -52,298 +61,271 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr) { - int argno; - /* Next available general register for non-float, non-vector arguments. */ - int greg; - /* Next available floating point register for float arguments. */ - int freg; - /* Next available vector register for vector arguments. */ - int vreg; - int argstkspace; - int structstkspace; - int argoffset; - int structoffset; - struct type *type; - int len; - char old_sp_buf[4]; - CORE_ADDR saved_sp; struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); + const CORE_ADDR saved_sp = read_sp (); + int argspace = 0; /* 0 is an initial wrong guess. */ + int write_pass; - greg = 3; - freg = 1; - vreg = 2; - argstkspace = 0; - structstkspace = 0; + /* Go through the argument list twice. - /* 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) - { - regcache_raw_write_signed (regcache, tdep->ppc_gp0_regnum + greg, - struct_addr); - greg++; - } + Pass 1: Figure out how much new stack space is required for + arguments and pushed values. Unlike the PowerOpen ABI, the SysV + ABI doesn't reserve any extra space for parameters which are put + in registers, but does always push structures and then pass their + address. - /* Figure out how much new stack space is required for arguments - which don't fit in registers. Unlike the PowerOpen ABI, the - SysV ABI doesn't reserve any extra space for parameters which - are put in registers. */ - for (argno = 0; argno < nargs; argno++) - { - struct value *arg = args[argno]; - type = check_typedef (VALUE_TYPE (arg)); - len = TYPE_LENGTH (type); + Pass 2: Replay the same computation but this time also write the + values out to the target. */ - if (TYPE_CODE (type) == TYPE_CODE_FLT - && ppc_floating_point_unit_p (current_gdbarch)) + for (write_pass = 0; write_pass < 2; write_pass++) + { + int argno; + /* Next available floating point register for float and double + arguments. */ + int freg = 1; + /* Next available general register for non-float, non-vector + arguments. */ + int greg = 3; + /* Next available vector register for vector arguments. */ + int vreg = 2; + /* Arguments start above the "LR save word" and "Back chain". */ + int argoffset = 2 * tdep->wordsize; + /* Structures start after the arguments. */ + 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) { - if (freg <= 8) - freg++; - else - { - /* SysV ABI converts floats to doubles when placed in - memory and requires 8 byte alignment */ - if (argstkspace & 0x4) - argstkspace += 4; - argstkspace += 8; - } + if (write_pass) + regcache_cooked_write_signed (regcache, + tdep->ppc_gp0_regnum + greg, + struct_addr); + greg++; } - else if (len == 8 - && (TYPE_CODE (type) == TYPE_CODE_INT /* long long */ - || (!ppc_floating_point_unit_p (current_gdbarch) - && TYPE_CODE (type) == TYPE_CODE_FLT))) /* double */ + + for (argno = 0; argno < nargs; argno++) { - if (greg > 9) + struct value *arg = args[argno]; + struct type *type = check_typedef (VALUE_TYPE (arg)); + int len = TYPE_LENGTH (type); + char *val = VALUE_CONTENTS (arg); + + if (TYPE_CODE (type) == TYPE_CODE_FLT + && ppc_floating_point_unit_p (current_gdbarch) + && len <= 8) { - greg = 11; - if (argstkspace & 0x4) - argstkspace += 4; - argstkspace += 8; - } - else - { - if ((greg & 1) == 0) - greg++; - greg += 2; - } - } - else if (!TYPE_VECTOR (type)) - { - if (len > 4 - || TYPE_CODE (type) == TYPE_CODE_STRUCT - || TYPE_CODE (type) == TYPE_CODE_UNION) - { - /* Rounding to the nearest multiple of 8 may not be necessary, - but it is safe. Particularly since we don't know the - field types of the structure */ - structstkspace += round2 (len, 8); - } - if (greg <= 10) - greg++; - else - argstkspace += 4; - } - else - { - if (len == 16 - && TYPE_CODE (type) == TYPE_CODE_ARRAY - && TYPE_VECTOR (type)) - { - if (vreg <= 13) - vreg++; + /* Floating point value converted to "double" then + 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. */ + char regval[MAX_REGISTER_SIZE]; + struct type *regtype + = register_type (gdbarch, FP0_REGNUM + freg); + convert_typed_floating (val, type, regval, regtype); + regcache_cooked_write (regcache, FP0_REGNUM + freg, + regval); + } + freg++; + } else { - /* Vector arguments must be aligned to 16 bytes on - the stack. */ - argstkspace += round2 (argstkspace, 16); - argstkspace += 16; + /* SysV ABI converts floats to doubles before + writing them to an 8 byte aligned stack location. */ + argoffset = align_up (argoffset, 8); + if (write_pass) + { + char memval[8]; + struct type *memtype; + switch (TARGET_BYTE_ORDER) + { + case BFD_ENDIAN_BIG: + memtype = builtin_type_ieee_double_big; + break; + case BFD_ENDIAN_LITTLE: + memtype = builtin_type_ieee_double_little; + break; + default: + internal_error (__FILE__, __LINE__, "bad switch"); + } + convert_typed_floating (val, type, memval, memtype); + write_memory (sp + argoffset, val, len); + } + argoffset += 8; } } - else if (len == 8 - && TYPE_CODE (type) == TYPE_CODE_ARRAY - && TYPE_VECTOR (type)) - { - if (greg <= 10) - greg++; - else - { - /* Vector arguments must be aligned to 8 bytes on - the stack. */ - argstkspace += round2 (argstkspace, 8); - argstkspace += 8; - } - } - } - } - - /* Get current SP location */ - saved_sp = read_sp (); - - sp -= argstkspace + structstkspace; - - /* Allocate space for backchain and callee's saved lr */ - sp -= 8; - - /* Make sure that we maintain 16 byte alignment */ - sp &= ~0x0f; - - /* Update %sp before proceeding any further. */ - regcache_raw_write_signed (regcache, SP_REGNUM, sp); - - /* write the backchain */ - store_unsigned_integer (old_sp_buf, 4, saved_sp); - write_memory (sp, old_sp_buf, 4); - - argoffset = 8; - structoffset = argoffset + argstkspace; - freg = 1; - greg = 3; - vreg = 2; - - /* Fill in r3 with the return structure, if any */ - if (struct_return) - { - write_register (tdep->ppc_gp0_regnum + greg, struct_addr); - greg++; - } - - /* Now fill in the registers and stack... */ - for (argno = 0; argno < nargs; argno++) - { - struct value *arg = args[argno]; - char *val = VALUE_CONTENTS (arg); - type = check_typedef (VALUE_TYPE (arg)); - len = TYPE_LENGTH (type); - - if (TYPE_CODE (type) == TYPE_CODE_FLT - && ppc_floating_point_unit_p (current_gdbarch)) - { - if (freg <= 8) + else if (len == 8 + && (TYPE_CODE (type) == TYPE_CODE_INT /* long long */ + || (!ppc_floating_point_unit_p (current_gdbarch) + && TYPE_CODE (type) == TYPE_CODE_FLT))) /* double */ { - ULONGEST regval; - if (len > 8) - printf_unfiltered ( - "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno); - regval = extract_unsigned_integer (val, len); - write_register (FP0_REGNUM + freg, regval); - freg++; - } - else - { - /* SysV ABI converts floats to doubles when placed in - memory and requires 8 byte alignment */ - /* FIXME: Convert floats to doubles */ - if (argoffset & 0x4) - argoffset += 4; - write_memory (sp + argoffset, val, len); - argoffset += 8; - } - } - else if (len == 8 - && (TYPE_CODE (type) == TYPE_CODE_INT /* long long */ - || (!ppc_floating_point_unit_p (current_gdbarch) - && TYPE_CODE (type) == TYPE_CODE_FLT))) /* double */ - { - if (greg > 9) - { - greg = 11; - if (argoffset & 0x4) - argoffset += 4; - write_memory (sp + argoffset, val, len); - argoffset += 8; - } - else - { - ULONGEST regval; - if ((greg & 1) == 0) - greg++; - regval = extract_unsigned_integer (val, 4); - write_register (tdep->ppc_gp0_regnum + greg, regval); - regval = extract_unsigned_integer (val + 4, 4); - write_register (tdep->ppc_gp0_regnum + greg + 1, regval); - greg += 2; - } - } - else if (!TYPE_VECTOR (type)) - { - char val_buf[4]; - if (len > 4 - || TYPE_CODE (type) == TYPE_CODE_STRUCT - || TYPE_CODE (type) == TYPE_CODE_UNION) - { - write_memory (sp + structoffset, val, len); - store_unsigned_integer (val_buf, 4, sp + structoffset); - structoffset += round2 (len, 8); - } - else - { - memset (val_buf, 0, 4); - memcpy (val_buf, val, len); - } - if (greg <= 10) - { - ULONGEST regval = extract_unsigned_integer (val_buf, 4); - write_register (tdep->ppc_gp0_regnum + greg, regval); - greg++; - } - else - { - write_memory (sp + argoffset, val_buf, 4); - argoffset += 4; + /* "long long" or "double" 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. */ + greg = 11; + argoffset = align_up (argoffset, 8); + if (write_pass) + write_memory (sp + argoffset, val, len); + argoffset += 8; + } + else if (tdep->wordsize == 8) + { + if (write_pass) + regcache_cooked_write (regcache, + tdep->ppc_gp0_regnum + greg, + val); + greg += 1; + } + else + { + /* Must start on an odd register - r3/r4 etc. */ + if ((greg & 1) == 0) + greg++; + if (write_pass) + { + regcache_cooked_write (regcache, + tdep->ppc_gp0_regnum + greg + 0, + val + 0); + regcache_cooked_write (regcache, + tdep->ppc_gp0_regnum + greg + 1, + val + 4); + } + greg += 2; + } } - } - else - { - if (len == 16 - && TYPE_CODE (type) == TYPE_CODE_ARRAY - && TYPE_VECTOR (type)) + else if (len == 16 + && TYPE_CODE (type) == TYPE_CODE_ARRAY + && TYPE_VECTOR (type) + && tdep->ppc_vr0_regnum >= 0) { - char *v_val_buf = alloca (16); - memset (v_val_buf, 0, 16); - memcpy (v_val_buf, val, len); + /* Vector parameter passed in an Altivec register, or + when that runs out, 16 byte aligned stack location. */ if (vreg <= 13) { - regcache_cooked_write (current_regcache, - tdep->ppc_vr0_regnum + vreg, - v_val_buf); + if (write_pass) + regcache_cooked_write (current_regcache, + tdep->ppc_vr0_regnum + vreg, + val); vreg++; } else { - write_memory (sp + argoffset, v_val_buf, 16); + argoffset = align_up (argoffset, 16); + if (write_pass) + write_memory (sp + argoffset, val, 16); argoffset += 16; } } else if (len == 8 && TYPE_CODE (type) == TYPE_CODE_ARRAY - && TYPE_VECTOR (type)) + && TYPE_VECTOR (type) + && tdep->ppc_ev0_regnum >= 0) { - char *v_val_buf = alloca (8); - memset (v_val_buf, 0, 8); - memcpy (v_val_buf, val, len); + /* 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. */ if (greg <= 10) { - regcache_cooked_write (current_regcache, - tdep->ppc_ev0_regnum + greg, - v_val_buf); + if (write_pass) + regcache_cooked_write (current_regcache, + tdep->ppc_ev0_regnum + greg, + val); greg++; } else { - write_memory (sp + argoffset, v_val_buf, 8); + argoffset = align_up (argoffset, 8); + if (write_pass) + write_memory (sp + argoffset, val, 8); argoffset += 8; } } - } + else + { + /* Reduce the parameter down to something that fits in a + "word". */ + char word[MAX_REGISTER_SIZE]; + memset (word, 0, MAX_REGISTER_SIZE); + if (len > tdep->wordsize + || TYPE_CODE (type) == TYPE_CODE_STRUCT + || TYPE_CODE (type) == TYPE_CODE_UNION) + { + /* Structs and large values are put on an 8 byte + aligned stack ... */ + structoffset = align_up (structoffset, 8); + if (write_pass) + write_memory (sp + structoffset, val, len); + /* ... and then a "word" pointing to that address is + passed as the parameter. */ + store_unsigned_integer (word, tdep->wordsize, + sp + structoffset); + structoffset += len; + } + else if (TYPE_CODE (type) == TYPE_CODE_INT) + /* Sign or zero extend the "int" into a "word". */ + store_unsigned_integer (word, tdep->wordsize, + unpack_long (type, val)); + 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. */ + if (greg <= 10) + { + if (write_pass) + regcache_cooked_write (regcache, + tdep->ppc_gp0_regnum + greg, + word); + greg++; + } + else + { + argoffset = align_up (argoffset, tdep->wordsize); + if (write_pass) + write_memory (sp + argoffset, word, tdep->wordsize); + argoffset += tdep->wordsize; + } + } + } + + /* Compute the actual stack space requirements. */ + if (!write_pass) + { + /* Remember the amount of space needed by the arguments. */ + argspace = argoffset; + /* Allocate space for both the arguments and the structures. */ + sp -= (argoffset + structoffset); + /* Ensure that the stack is still 16 byte aligned. */ + sp = align_down (sp, 16); + } } + /* Update %sp. */ + regcache_cooked_write_signed (regcache, SP_REGNUM, sp); + + /* Write the backchain (it occupies WORDSIZED bytes). */ + write_memory_signed_integer (sp, tdep->wordsize, saved_sp); + /* Point the inferior function call's return address at the dummy's breakpoint. */ - regcache_raw_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr); + regcache_cooked_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr); - target_store_registers (-1); return sp; } |