2009-11-12 H.J. Lu <hongjiu.lu@intel.com>

[deliverable/binutils-gdb.git] / gdb / m68hc11-tdep.c

diff --git a/gdb/m68hc11-tdep.c b/gdb/m68hc11-tdep.c
index 1913333a8553c49a0dc09e003b49e4133e7a080b..2202c6902461e90d0095c00e5ec23b72f6497576 100644 (file)
--- a/gdb/m68hc11-tdep.c
+++ b/gdb/m68hc11-tdep.c
@@ -1,6 +1,6 @@
 /* Target-dependent code for Motorola 68HC11 & 68HC12
 
-   Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
+   Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
    Free Software Foundation, Inc.
 
    Contributed by Stephane Carrez, stcarrez@nerim.fr
@@ -284,12 +284,14 @@ m68hc11_pseudo_register_read (struct gdbarch *gdbarch,
                              struct regcache *regcache,
                              int regno, gdb_byte *buf)
 {
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+
   /* The PC is a pseudo reg only for 68HC12 with the memory bank
      addressing mode.  */
   if (regno == M68HC12_HARD_PC_REGNUM)
     {
       ULONGEST pc;
-      const int regsize = TYPE_LENGTH (builtin_type_uint32);
+      const int regsize = 4;
 
       regcache_cooked_read_unsigned (regcache, HARD_PC_REGNUM, &pc);
       if (pc >= 0x8000 && pc < 0xc000)
@@ -301,7 +303,7 @@ m68hc11_pseudo_register_read (struct gdbarch *gdbarch,
           pc += (page << 14);
           pc += 0x1000000;
         }
-      store_unsigned_integer (buf, regsize, pc);
+      store_unsigned_integer (buf, regsize, byte_order, pc);
       return;
     }
 
@@ -325,16 +327,18 @@ m68hc11_pseudo_register_write (struct gdbarch *gdbarch,
                               struct regcache *regcache,
                               int regno, const gdb_byte *buf)
 {
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+
   /* The PC is a pseudo reg only for 68HC12 with the memory bank
      addressing mode.  */
   if (regno == M68HC12_HARD_PC_REGNUM)
     {
-      const int regsize = TYPE_LENGTH (builtin_type_uint32);
+      const int regsize = 4;
       char *tmp = alloca (regsize);
       CORE_ADDR pc;
 
       memcpy (tmp, buf, regsize);
-      pc = extract_unsigned_integer (tmp, regsize);
+      pc = extract_unsigned_integer (tmp, regsize, byte_order);
       if (pc >= 0x1000000)
         {
           pc -= 0x1000000;
@@ -497,9 +501,11 @@ static struct insn_sequence m6812_prologue[] = {
    Returns a pointer to the sequence when it is recognized and
    the optional value (constant/address) associated with it.  */
 static struct insn_sequence *
-m68hc11_analyze_instruction (struct insn_sequence *seq, CORE_ADDR pc,
+m68hc11_analyze_instruction (struct gdbarch *gdbarch,
+                            struct insn_sequence *seq, CORE_ADDR pc,
                              CORE_ADDR *val)
 {
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   unsigned char buffer[MAX_CODES];
   unsigned bufsize;
   unsigned j;
@@ -515,7 +521,7 @@ m68hc11_analyze_instruction (struct insn_sequence *seq, CORE_ADDR pc,
           if (bufsize < j + 1)
             {
               buffer[bufsize] = read_memory_unsigned_integer (pc + bufsize,
-                                                              1);
+                                                              1, byte_order);
               bufsize++;
             }
           /* Continue while we match the opcode.  */
@@ -551,13 +557,13 @@ m68hc11_analyze_instruction (struct insn_sequence *seq, CORE_ADDR pc,
                 }
               else if ((buffer[j] & 0xfe) == 0xf0)
                 {
-                  v = read_memory_unsigned_integer (pc + j + 1, 1);
+                  v = read_memory_unsigned_integer (pc + j + 1, 1, byte_order);
                   if (buffer[j] & 1)
                     v |= 0xff00;
                 }
               else if (buffer[j] == 0xf2)
                 {
-                  v = read_memory_unsigned_integer (pc + j + 1, 2);
+                  v = read_memory_unsigned_integer (pc + j + 1, 2, byte_order);
                 }
               cur_val = v;
               break;
@@ -678,7 +684,7 @@ m68hc11_scan_prologue (struct gdbarch *gdbarch, CORE_ADDR pc,
       struct insn_sequence *seq;
       CORE_ADDR val;
 
-      seq = m68hc11_analyze_instruction (seq_table, pc, &val);
+      seq = m68hc11_analyze_instruction (gdbarch, seq_table, pc, &val);
       if (seq == 0)
         break;
 
@@ -771,7 +777,7 @@ m68hc11_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
    in the stack frame.  sp is even more special: the address we return
    for it IS the sp for the next frame. */
 
-struct m68hc11_unwind_cache *
+static struct m68hc11_unwind_cache *
 m68hc11_frame_unwind_cache (struct frame_info *this_frame,
                             void **this_prologue_cache)
 {
@@ -1158,6 +1164,7 @@ m68hc11_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
                          int nargs, struct value **args, CORE_ADDR sp,
                          int struct_return, CORE_ADDR struct_addr)
 {
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   int argnum;
   int first_stack_argnum;
   struct type *type;
@@ -1180,7 +1187,8 @@ m68hc11_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
         {
           ULONGEST v;
 
-          v = extract_unsigned_integer (value_contents (args[0]), len);
+          v = extract_unsigned_integer (value_contents (args[0]),
+                                       len, byte_order);
           first_stack_argnum = 1;
 
           regcache_cooked_write_unsigned (regcache, HARD_D_REGNUM, v);
@@ -1211,7 +1219,7 @@ m68hc11_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 
   /* Store return address.  */
   sp -= 2;
-  store_unsigned_integer (buf, 2, bp_addr);
+  store_unsigned_integer (buf, 2, byte_order, bp_addr);
   write_memory (sp, buf, 2);
 
   /* Finally, update the stack pointer...  */
@@ -1239,13 +1247,13 @@ m68hc11_register_type (struct gdbarch *gdbarch, int reg_nr)
     case HARD_A_REGNUM:
     case HARD_B_REGNUM:
     case HARD_CCR_REGNUM:
-      return builtin_type_uint8;
+      return builtin_type (gdbarch)->builtin_uint8;
 
     case M68HC12_HARD_PC_REGNUM:
-      return builtin_type_uint32;
+      return builtin_type (gdbarch)->builtin_uint32;
 
     default:
-      return builtin_type_uint16;
+      return builtin_type (gdbarch)->builtin_uint16;
     }
 }
 
@@ -1309,7 +1317,7 @@ m68hc11_extract_return_value (struct type *type, struct regcache *regcache,
     }
 }
 
-enum return_value_convention
+static enum return_value_convention
 m68hc11_return_value (struct gdbarch *gdbarch, struct type *func_type,
                      struct type *valtype, struct regcache *regcache,
                      gdb_byte *readbuf, const gdb_byte *writebuf)