X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;ds=sidebyside;f=gdb%2Fmips-tdep.c;h=6150f3834286af5c4289ec365622f7c16e8c9880;hb=a1f5b8454cd3a0e8c1634b708ef8e2cfcecef2db;hp=c109ed28821c9a81da96d691d837ed0e10325e71;hpb=7ab044018aac127cb2867aadf8faa4a3a2e46142;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/mips-tdep.c b/gdb/mips-tdep.c index c109ed2882..6150f38342 100644 --- a/gdb/mips-tdep.c +++ b/gdb/mips-tdep.c @@ -1,8 +1,8 @@ /* Target-dependent code for the MIPS architecture, for GDB, the GNU Debugger. - Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, - 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software - Foundation, Inc. + Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, + 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 + Free Software Foundation, Inc. Contributed by Alessandro Forin(af@cs.cmu.edu) at CMU and by Per Bothner(bothner@cs.wisc.edu) at U.Wisconsin. @@ -21,8 +21,8 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ + Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ #include "defs.h" #include "gdb_string.h" @@ -145,7 +145,7 @@ struct gdbarch_tdep static int n32n64_floatformat_always_valid (const struct floatformat *fmt, - const char *from) + const void *from) { return 1; } @@ -202,7 +202,7 @@ is_mips16_addr (CORE_ADDR addr) static CORE_ADDR unmake_mips16_addr (CORE_ADDR addr) { - return ((addr) & ~1); + return ((addr) & ~(CORE_ADDR) 1); } /* Return the contents of register REGNUM as a signed integer. */ @@ -312,8 +312,8 @@ msymbol_is_special (struct minimal_symbol *msym) static void mips_xfer_register (struct regcache *regcache, int reg_num, int length, - enum bfd_endian endian, bfd_byte * in, - const bfd_byte * out, int buf_offset) + enum bfd_endian endian, gdb_byte *in, + const gdb_byte *out, int buf_offset) { int reg_offset = 0; gdb_assert (reg_num >= NUM_REGS); @@ -568,7 +568,7 @@ mips_register_reggroup_p (struct gdbarch *gdbarch, int regnum, static void mips_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, - int cookednum, void *buf) + int cookednum, gdb_byte *buf) { int rawnum = cookednum % NUM_REGS; gdb_assert (cookednum >= NUM_REGS && cookednum < 2 * NUM_REGS); @@ -590,7 +590,7 @@ mips_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, static void mips_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, - const void *buf) + const gdb_byte *buf) { int rawnum = cookednum % NUM_REGS; gdb_assert (cookednum >= NUM_REGS && cookednum < 2 * NUM_REGS); @@ -654,18 +654,18 @@ mips_convert_register_p (int regnum, struct type *type) static void mips_register_to_value (struct frame_info *frame, int regnum, - struct type *type, void *to) + struct type *type, gdb_byte *to) { - get_frame_register (frame, regnum + 0, (char *) to + 4); - get_frame_register (frame, regnum + 1, (char *) to + 0); + get_frame_register (frame, regnum + 0, to + 4); + get_frame_register (frame, regnum + 1, to + 0); } static void mips_value_to_register (struct frame_info *frame, int regnum, - struct type *type, const void *from) + struct type *type, const gdb_byte *from) { - put_frame_register (frame, regnum + 0, (const char *) from + 4); - put_frame_register (frame, regnum + 1, (const char *) from + 0); + put_frame_register (frame, regnum + 0, from + 4); + put_frame_register (frame, regnum + 1, from + 0); } /* Return the GDB type object for the "standard" data type of data in @@ -847,7 +847,7 @@ mips_write_pc (CORE_ADDR pc, ptid_t ptid) static ULONGEST mips_fetch_instruction (CORE_ADDR addr) { - char buf[MIPS_INSN32_SIZE]; + gdb_byte buf[MIPS_INSN32_SIZE]; int instlen; int status; @@ -989,14 +989,14 @@ mips32_next_pc (CORE_ADDR pc) unsigned long reg; reg = jtype_target (inst) << 2; /* Upper four bits get never changed... */ - pc = reg + ((pc + 4) & 0xf0000000); + pc = reg + ((pc + 4) & ~(CORE_ADDR) 0x0fffffff); } break; /* FIXME case JALX : */ { unsigned long reg; reg = jtype_target (inst) << 2; - pc = reg + ((pc + 4) & 0xf0000000) + 1; /* yes, +1 */ + pc = reg + ((pc + 4) & ~(CORE_ADDR) 0x0fffffff) + 1; /* yes, +1 */ /* Add 1 to indicate 16 bit mode - Invert ISA mode */ } break; /* The new PC will be alternate mode */ @@ -1108,7 +1108,7 @@ extended_offset (unsigned int extension) static unsigned int fetch_mips_16 (CORE_ADDR pc) { - char buf[8]; + gdb_byte buf[8]; pc &= 0xfffffffe; /* clear the low order bit */ target_read_memory (pc, buf, 2); return extract_unsigned_integer (buf, 2); @@ -1202,7 +1202,7 @@ unpack_mips16 (CORE_ADDR pc, static CORE_ADDR add_offset_16 (CORE_ADDR pc, int offset) { - return ((offset << 2) | ((pc + 2) & (0xf0000000))); + return ((offset << 2) | ((pc + 2) & (~(CORE_ADDR) 0x0fffffff))); } static CORE_ADDR @@ -1659,7 +1659,7 @@ mips_insn16_frame_prev_register (struct frame_info *next_frame, void **this_cache, int regnum, int *optimizedp, enum lval_type *lvalp, CORE_ADDR *addrp, - int *realnump, void *valuep) + int *realnump, gdb_byte *valuep) { struct mips_frame_cache *info = mips_insn16_frame_cache (next_frame, this_cache); @@ -1979,7 +1979,7 @@ mips_insn32_frame_prev_register (struct frame_info *next_frame, void **this_cache, int regnum, int *optimizedp, enum lval_type *lvalp, CORE_ADDR *addrp, - int *realnump, void *valuep) + int *realnump, gdb_byte *valuep) { struct mips_frame_cache *info = mips_insn32_frame_cache (next_frame, this_cache); @@ -2073,7 +2073,7 @@ mips_stub_frame_prev_register (struct frame_info *next_frame, void **this_cache, int regnum, int *optimizedp, enum lval_type *lvalp, CORE_ADDR *addrp, - int *realnump, void *valuep) + int *realnump, gdb_byte *valuep) { struct trad_frame_cache *this_trad_cache = mips_stub_frame_cache (next_frame, this_cache); @@ -2091,11 +2091,21 @@ static const struct frame_unwind mips_stub_frame_unwind = static const struct frame_unwind * mips_stub_frame_sniffer (struct frame_info *next_frame) { + struct obj_section *s; CORE_ADDR pc = frame_pc_unwind (next_frame); + if (in_plt_section (pc, NULL)) return &mips_stub_frame_unwind; - else - return NULL; + + /* Binutils for MIPS puts lazy resolution stubs into .MIPS.stubs. */ + s = find_pc_section (pc); + + if (s != NULL + && strcmp (bfd_get_section_name (s->objfile->obfd, s->the_bfd_section), + ".MIPS.stubs") == 0) + return &mips_stub_frame_unwind; + + return NULL; } static CORE_ADDR @@ -2178,20 +2188,17 @@ mips_addr_bits_remove (CORE_ADDR addr) void mips_software_single_step (enum target_signal sig, int insert_breakpoints_p) { - static CORE_ADDR next_pc; - typedef char binsn_quantum[BREAKPOINT_MAX]; - static binsn_quantum break_mem; - CORE_ADDR pc; + CORE_ADDR pc, next_pc; if (insert_breakpoints_p) { pc = read_register (mips_regnum (current_gdbarch)->pc); next_pc = mips_next_pc (pc); - target_insert_breakpoint (next_pc, break_mem); + insert_single_step_breakpoint (next_pc); } else - target_remove_breakpoint (next_pc, break_mem); + remove_single_step_breakpoints (); } /* Test whether the PC points to the return instruction at the @@ -2316,7 +2323,7 @@ struct mips_objfile_private /* According to the current ABI, should the type be passed in a floating-point register (assuming that there is space)? When there - is no FPU, FP are not even considered as possibile candidates for + is no FPU, FP are not even considered as possible candidates for FP registers and, consequently this returns false - forces FP arguments into integer registers. */ @@ -2432,8 +2439,8 @@ mips_eabi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, from first to last. */ for (argnum = 0; argnum < nargs; argnum++) { - char *val; - char valbuf[MAX_REGISTER_SIZE]; + const gdb_byte *val; + gdb_byte valbuf[MAX_REGISTER_SIZE]; struct value *arg = args[argnum]; struct type *arg_type = check_typedef (value_type (arg)); int len = TYPE_LENGTH (arg_type); @@ -2458,7 +2465,7 @@ mips_eabi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, fprintf_unfiltered (gdb_stdlog, " push"); } else - val = (char *) value_contents (arg); + val = value_contents (arg); /* 32-bit ABIs always start floating point arguments in an even-numbered floating point register. Round the FP register @@ -2637,12 +2644,12 @@ mips_eabi_push_dummy_call (struct gdbarch *gdbarch, struct value *function, return sp; } -/* Determin the return value convention being used. */ +/* Determine the return value convention being used. */ static enum return_value_convention mips_eabi_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, - void *readbuf, const void *writebuf) + gdb_byte *readbuf, const gdb_byte *writebuf) { if (TYPE_LENGTH (type) > 2 * mips_abi_regsize (gdbarch)) return RETURN_VALUE_STRUCT_CONVENTION; @@ -2715,7 +2722,7 @@ mips_n32n64_push_dummy_call (struct gdbarch *gdbarch, struct value *function, from first to last. */ for (argnum = 0; argnum < nargs; argnum++) { - char *val; + const gdb_byte *val; struct value *arg = args[argnum]; struct type *arg_type = check_typedef (value_type (arg)); int len = TYPE_LENGTH (arg_type); @@ -2726,7 +2733,7 @@ mips_n32n64_push_dummy_call (struct gdbarch *gdbarch, struct value *function, "mips_n32n64_push_dummy_call: %d len=%d type=%d", argnum + 1, len, (int) typecode); - val = (char *) value_contents (arg); + val = value_contents (arg); if (fp_register_arg_p (typecode, arg_type) && float_argreg <= MIPS_LAST_FP_ARG_REGNUM) @@ -2892,7 +2899,7 @@ mips_n32n64_push_dummy_call (struct gdbarch *gdbarch, struct value *function, static enum return_value_convention mips_n32n64_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, - void *readbuf, const void *writebuf) + gdb_byte *readbuf, const gdb_byte *writebuf) { struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); if (TYPE_CODE (type) == TYPE_CODE_STRUCT @@ -2900,6 +2907,24 @@ mips_n32n64_return_value (struct gdbarch *gdbarch, || TYPE_CODE (type) == TYPE_CODE_ARRAY || TYPE_LENGTH (type) > 2 * mips_abi_regsize (gdbarch)) return RETURN_VALUE_STRUCT_CONVENTION; + else if (TYPE_CODE (type) == TYPE_CODE_FLT + && TYPE_LENGTH (type) == 16 + && tdep->mips_fpu_type != MIPS_FPU_NONE) + { + /* A 128-bit floating-point value fills both $f0 and $f2. The + two registers are used in the same as memory order, so the + eight bytes with the lower memory address are in $f0. */ + if (mips_debug) + fprintf_unfiltered (gdb_stderr, "Return float in $f0 and $f2\n"); + mips_xfer_register (regcache, + NUM_REGS + mips_regnum (current_gdbarch)->fp0, + 8, TARGET_BYTE_ORDER, readbuf, writebuf, 0); + mips_xfer_register (regcache, + NUM_REGS + mips_regnum (current_gdbarch)->fp0 + 2, + 8, TARGET_BYTE_ORDER, readbuf ? readbuf + 8 : readbuf, + writebuf ? writebuf + 8 : writebuf, 0); + return RETURN_VALUE_REGISTER_CONVENTION; + } else if (TYPE_CODE (type) == TYPE_CODE_FLT && tdep->mips_fpu_type != MIPS_FPU_NONE) { @@ -3055,7 +3080,7 @@ mips_o32_push_dummy_call (struct gdbarch *gdbarch, struct value *function, from first to last. */ for (argnum = 0; argnum < nargs; argnum++) { - char *val; + const gdb_byte *val; struct value *arg = args[argnum]; struct type *arg_type = check_typedef (value_type (arg)); int len = TYPE_LENGTH (arg_type); @@ -3066,7 +3091,7 @@ mips_o32_push_dummy_call (struct gdbarch *gdbarch, struct value *function, "mips_o32_push_dummy_call: %d len=%d type=%d", argnum + 1, len, (int) typecode); - val = (char *) value_contents (arg); + val = value_contents (arg); /* 32-bit ABIs always start floating point arguments in an even-numbered floating point register. Round the FP register @@ -3307,7 +3332,7 @@ mips_o32_push_dummy_call (struct gdbarch *gdbarch, struct value *function, static enum return_value_convention mips_o32_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, - void *readbuf, const void *writebuf) + gdb_byte *readbuf, const gdb_byte *writebuf) { struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); @@ -3376,7 +3401,7 @@ mips_o32_return_value (struct gdbarch *gdbarch, struct type *type, /* A struct that contains one or two floats. Each value is part in the least significant part of their floating point register.. */ - bfd_byte reg[MAX_REGISTER_SIZE]; + gdb_byte reg[MAX_REGISTER_SIZE]; int regnum; int field; for (field = 0, regnum = mips_regnum (current_gdbarch)->fp0; @@ -3509,7 +3534,7 @@ mips_o64_push_dummy_call (struct gdbarch *gdbarch, struct value *function, from first to last. */ for (argnum = 0; argnum < nargs; argnum++) { - char *val; + const gdb_byte *val; struct value *arg = args[argnum]; struct type *arg_type = check_typedef (value_type (arg)); int len = TYPE_LENGTH (arg_type); @@ -3520,7 +3545,7 @@ mips_o64_push_dummy_call (struct gdbarch *gdbarch, struct value *function, "mips_o64_push_dummy_call: %d len=%d type=%d", argnum + 1, len, (int) typecode); - val = (char *) value_contents (arg); + val = value_contents (arg); /* 32-bit ABIs always start floating point arguments in an even-numbered floating point register. Round the FP register @@ -3694,26 +3719,9 @@ mips_o64_push_dummy_call (struct gdbarch *gdbarch, struct value *function, big endian targets. It does not seem to be necessary to do the - same for integral types. - - Also don't do this adjustment on O64 binaries. - - cagney/2001-07-23: gdb/179: Also, GCC, when - outputting LE O32 with sizeof (struct) < - mips_abi_regsize(), generates a left shift as - part of storing the argument in a register a - register (the left shift isn't generated when - sizeof (struct) >= mips_abi_regsize()). Since - it is quite possible that this is GCC - contradicting the LE/O32 ABI, GDB has not been - adjusted to accommodate this. Either someone - needs to demonstrate that the LE/O32 ABI - specifies such a left shift OR this new ABI gets - identified as such and GDB gets tweaked - accordingly. */ + same for integral types. */ - if (mips_abi_regsize (gdbarch) < 8 - && TARGET_BYTE_ORDER == BFD_ENDIAN_BIG + if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG && partial_len < mips_abi_regsize (gdbarch) && (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION)) @@ -3761,9 +3769,47 @@ mips_o64_push_dummy_call (struct gdbarch *gdbarch, struct value *function, static enum return_value_convention mips_o64_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, - void *readbuf, const void *writebuf) + gdb_byte *readbuf, const gdb_byte *writebuf) { - return RETURN_VALUE_STRUCT_CONVENTION; + struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); + + if (TYPE_CODE (type) == TYPE_CODE_STRUCT + || TYPE_CODE (type) == TYPE_CODE_UNION + || TYPE_CODE (type) == TYPE_CODE_ARRAY) + return RETURN_VALUE_STRUCT_CONVENTION; + else if (fp_register_arg_p (TYPE_CODE (type), type)) + { + /* A floating-point value. It fits in the least significant + part of FP0. */ + if (mips_debug) + fprintf_unfiltered (gdb_stderr, "Return float in $fp0\n"); + mips_xfer_register (regcache, + NUM_REGS + mips_regnum (current_gdbarch)->fp0, + TYPE_LENGTH (type), + TARGET_BYTE_ORDER, readbuf, writebuf, 0); + return RETURN_VALUE_REGISTER_CONVENTION; + } + else + { + /* A scalar extract each part but least-significant-byte + justified. */ + int offset; + int regnum; + for (offset = 0, regnum = MIPS_V0_REGNUM; + offset < TYPE_LENGTH (type); + offset += mips_stack_argsize (gdbarch), regnum++) + { + int xfer = mips_stack_argsize (gdbarch); + if (offset + xfer > TYPE_LENGTH (type)) + xfer = TYPE_LENGTH (type) - offset; + if (mips_debug) + fprintf_unfiltered (gdb_stderr, "Return scalar+%d:%d in $%d\n", + offset, xfer, regnum); + mips_xfer_register (regcache, NUM_REGS + regnum, xfer, + TARGET_BYTE_ORDER, readbuf, writebuf, offset); + } + return RETURN_VALUE_REGISTER_CONVENTION; + } } /* Floating point register management. @@ -3819,10 +3865,10 @@ mips_double_register_type (void) static void mips_read_fp_register_single (struct frame_info *frame, int regno, - char *rare_buffer) + gdb_byte *rare_buffer) { int raw_size = register_size (current_gdbarch, regno); - char *raw_buffer = alloca (raw_size); + gdb_byte *raw_buffer = alloca (raw_size); if (!frame_register_read (frame, regno, raw_buffer)) error (_("can't read register %d (%s)"), regno, REGISTER_NAME (regno)); @@ -3851,7 +3897,7 @@ mips_read_fp_register_single (struct frame_info *frame, int regno, static void mips_read_fp_register_double (struct frame_info *frame, int regno, - char *rare_buffer) + gdb_byte *rare_buffer) { int raw_size = register_size (current_gdbarch, regno); @@ -3888,14 +3934,12 @@ static void mips_print_fp_register (struct ui_file *file, struct frame_info *frame, int regnum) { /* do values for FP (float) regs */ - char *raw_buffer; + gdb_byte *raw_buffer; double doub, flt1; /* doubles extracted from raw hex data */ int inv1, inv2; - raw_buffer = - (char *) alloca (2 * - register_size (current_gdbarch, - mips_regnum (current_gdbarch)->fp0)); + raw_buffer = alloca (2 * register_size (current_gdbarch, + mips_regnum (current_gdbarch)->fp0)); fprintf_filtered (file, "%s:", REGISTER_NAME (regnum)); fprintf_filtered (file, "%*s", 4 - (int) strlen (REGISTER_NAME (regnum)), @@ -3962,7 +4006,7 @@ mips_print_register (struct ui_file *file, struct frame_info *frame, int regnum, int all) { struct gdbarch *gdbarch = get_frame_arch (frame); - char raw_buffer[MAX_REGISTER_SIZE]; + gdb_byte raw_buffer[MAX_REGISTER_SIZE]; int offset; if (TYPE_CODE (gdbarch_register_type (gdbarch, regnum)) == TYPE_CODE_FLT) @@ -4023,13 +4067,12 @@ print_gp_register_row (struct ui_file *file, struct frame_info *frame, { struct gdbarch *gdbarch = get_frame_arch (frame); /* do values for GP (int) regs */ - char raw_buffer[MAX_REGISTER_SIZE]; + gdb_byte raw_buffer[MAX_REGISTER_SIZE]; int ncols = (mips_abi_regsize (gdbarch) == 8 ? 4 : 8); /* display cols per row */ int col, byte; int regnum; /* For GP registers, we print a separate row of names above the vals */ - fprintf_filtered (file, " "); for (col = 0, regnum = start_regnum; col < ncols && regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++) { @@ -4038,11 +4081,17 @@ print_gp_register_row (struct ui_file *file, struct frame_info *frame, if (TYPE_CODE (gdbarch_register_type (gdbarch, regnum)) == TYPE_CODE_FLT) break; /* end the row: reached FP register */ + if (col == 0) + fprintf_filtered (file, " "); fprintf_filtered (file, mips_abi_regsize (current_gdbarch) == 8 ? "%17s" : "%9s", REGISTER_NAME (regnum)); col++; } + + if (col == 0) + return regnum; + /* print the R0 to R31 names */ if ((start_regnum % NUM_REGS) < MIPS_NUMREGS) fprintf_filtered (file, "\n R%-4d", start_regnum % NUM_REGS); @@ -4072,11 +4121,11 @@ print_gp_register_row (struct ui_file *file, struct frame_info *frame, register_size (current_gdbarch, regnum) - register_size (current_gdbarch, regnum); byte < register_size (current_gdbarch, regnum); byte++) - fprintf_filtered (file, "%02x", (unsigned char) raw_buffer[byte]); + fprintf_filtered (file, "%02x", raw_buffer[byte]); else for (byte = register_size (current_gdbarch, regnum) - 1; byte >= 0; byte--) - fprintf_filtered (file, "%02x", (unsigned char) raw_buffer[byte]); + fprintf_filtered (file, "%02x", raw_buffer[byte]); fprintf_filtered (file, " "); col++; } @@ -4142,12 +4191,15 @@ mips_single_step_through_delay (struct gdbarch *gdbarch, struct frame_info *frame) { CORE_ADDR pc = get_frame_pc (frame); - char buf[MIPS_INSN32_SIZE]; + gdb_byte buf[MIPS_INSN32_SIZE]; /* There is no branch delay slot on MIPS16. */ if (mips_pc_is_mips16 (pc)) return 0; + if (!breakpoint_here_p (pc + 4)) + return 0; + if (!safe_frame_unwind_memory (frame, pc, buf, sizeof buf)) /* If error reading memory, guess that it is not a delayed branch. */ @@ -4375,14 +4427,14 @@ gdb_print_insn_mips (bfd_vma memaddr, struct disassemble_info *info) (if necessary) to point to the actual memory location where the breakpoint should be inserted. */ -static const unsigned char * +static const gdb_byte * mips_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr) { if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) { if (mips_pc_is_mips16 (*pcptr)) { - static unsigned char mips16_big_breakpoint[] = { 0xe8, 0xa5 }; + static gdb_byte mips16_big_breakpoint[] = { 0xe8, 0xa5 }; *pcptr = unmake_mips16_addr (*pcptr); *lenptr = sizeof (mips16_big_breakpoint); return mips16_big_breakpoint; @@ -4392,9 +4444,9 @@ mips_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr) /* The IDT board uses an unusual breakpoint value, and sometimes gets confused when it sees the usual MIPS breakpoint instruction. */ - static unsigned char big_breakpoint[] = { 0, 0x5, 0, 0xd }; - static unsigned char pmon_big_breakpoint[] = { 0, 0, 0, 0xd }; - static unsigned char idt_big_breakpoint[] = { 0, 0, 0x0a, 0xd }; + static gdb_byte big_breakpoint[] = { 0, 0x5, 0, 0xd }; + static gdb_byte pmon_big_breakpoint[] = { 0, 0, 0, 0xd }; + static gdb_byte idt_big_breakpoint[] = { 0, 0, 0x0a, 0xd }; *lenptr = sizeof (big_breakpoint); @@ -4412,16 +4464,16 @@ mips_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr) { if (mips_pc_is_mips16 (*pcptr)) { - static unsigned char mips16_little_breakpoint[] = { 0xa5, 0xe8 }; + static gdb_byte mips16_little_breakpoint[] = { 0xa5, 0xe8 }; *pcptr = unmake_mips16_addr (*pcptr); *lenptr = sizeof (mips16_little_breakpoint); return mips16_little_breakpoint; } else { - static unsigned char little_breakpoint[] = { 0xd, 0, 0x5, 0 }; - static unsigned char pmon_little_breakpoint[] = { 0xd, 0, 0, 0 }; - static unsigned char idt_little_breakpoint[] = { 0xd, 0x0a, 0, 0 }; + static gdb_byte little_breakpoint[] = { 0xd, 0, 0x5, 0 }; + static gdb_byte pmon_little_breakpoint[] = { 0xd, 0, 0, 0 }; + static gdb_byte idt_little_breakpoint[] = { 0xd, 0x0a, 0, 0 }; *lenptr = sizeof (little_breakpoint); @@ -4600,9 +4652,9 @@ mips_register_sim_regno (int regnum) static CORE_ADDR mips_integer_to_address (struct gdbarch *gdbarch, - struct type *type, const bfd_byte *buf) + struct type *type, const gdb_byte *buf) { - char *tmp = alloca (TYPE_LENGTH (builtin_type_void_data_ptr)); + gdb_byte *tmp = alloca (TYPE_LENGTH (builtin_type_void_data_ptr)); LONGEST val = unpack_long (type, buf); store_signed_integer (tmp, TYPE_LENGTH (builtin_type_void_data_ptr), val); return extract_signed_integer (tmp, @@ -4730,6 +4782,13 @@ mips_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) } } + /* Default 64-bit objects to N64 instead of O32. */ + if (found_abi == MIPS_ABI_UNKNOWN + && info.abfd != NULL + && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour + && elf_elfheader (info.abfd)->e_ident[EI_CLASS] == ELFCLASS64) + found_abi = MIPS_ABI_N64; + if (gdbarch_debug) fprintf_unfiltered (gdb_stdlog, "mips_gdbarch_init: found_abi = %d\n", found_abi); @@ -5059,11 +5118,16 @@ mips_abi_update (char *ignore_args, int from_tty, struct cmd_list_element *c) /* Print out which MIPS ABI is in use. */ static void -show_mips_abi (char *ignore_args, int from_tty) +show_mips_abi (struct ui_file *file, + int from_tty, + struct cmd_list_element *ignored_cmd, + const char *ignored_value) { if (gdbarch_bfd_arch_info (current_gdbarch)->arch != bfd_arch_mips) - printf_filtered - ("The MIPS ABI is unknown because the current architecture is not MIPS.\n"); + fprintf_filtered + (file, + "The MIPS ABI is unknown because the current architecture " + "is not MIPS.\n"); else { enum mips_abi global_abi = global_mips_abi (); @@ -5071,18 +5135,21 @@ show_mips_abi (char *ignore_args, int from_tty) const char *actual_abi_str = mips_abi_strings[actual_abi]; if (global_abi == MIPS_ABI_UNKNOWN) - printf_filtered - ("The MIPS ABI is set automatically (currently \"%s\").\n", + fprintf_filtered + (file, + "The MIPS ABI is set automatically (currently \"%s\").\n", actual_abi_str); else if (global_abi == actual_abi) - printf_filtered - ("The MIPS ABI is assumed to be \"%s\" (due to user setting).\n", + fprintf_filtered + (file, + "The MIPS ABI is assumed to be \"%s\" (due to user setting).\n", actual_abi_str); else { /* Probably shouldn't happen... */ - printf_filtered - ("The (auto detected) MIPS ABI \"%s\" is in use even though the user setting was \"%s\".\n", + fprintf_filtered + (file, + "The (auto detected) MIPS ABI \"%s\" is in use even though the user setting was \"%s\".\n", actual_abi_str, mips_abi_strings[global_abi]); } }