#include <ctype.h>
#include "defs.h"
#include "frame.h"
#include "inferior.h"
#include "gdbcmd.h"
#include "gdbcore.h"
#include "symfile.h"
#include "gdb_string.h"
#include "dis-asm.h"
#include "regcache.h"
#include "doublest.h"
#include "value.h"
#include "arch-utils.h"
#include "solib-svr4.h"
#include "arm-tdep.h"
#include "gdb/sim-arm.h"
#include "elf-bfd.h"
#include "coff/internal.h"
#include "elf/arm.h"
#include "gdb_assert.h"
static int arm_debug;
#ifdef SIGCONTEXT_REGISTER_ADDRESS
#ifndef SIGCONTEXT_REGISTER_ADDRESS_P
#define SIGCONTEXT_REGISTER_ADDRESS_P() 1
#endif
#else
#define SIGCONTEXT_REGISTER_ADDRESS(SP,PC,REG) 0
#define SIGCONTEXT_REGISTER_ADDRESS_P() 0
#endif
#define MSYMBOL_SET_SPECIAL(msym) \
MSYMBOL_INFO (msym) = (char *) (((long) MSYMBOL_INFO (msym)) \
| 0x80000000)
#define MSYMBOL_IS_SPECIAL(msym) \
(((long) MSYMBOL_INFO (msym) & 0x80000000) != 0)
#define MSYMBOL_SIZE(msym) \
((long) MSYMBOL_INFO (msym) & 0x7fffffff)
static int num_flavor_options;
static char * arm_register_name_strings[] =
{"r0", "r1", "r2", "r3",
"r4", "r5", "r6", "r7",
"r8", "r9", "r10", "r11",
"r12", "sp", "lr", "pc",
"f0", "f1", "f2", "f3",
"f4", "f5", "f6", "f7",
"fps", "cpsr" };
static char **arm_register_names = arm_register_name_strings;
static const char **valid_flavors;
static const char *disassembly_flavor;
static int current_option;
static void set_disassembly_flavor_sfunc(char *, int,
struct cmd_list_element *);
static void set_disassembly_flavor (void);
static void convert_from_extended (void *ptr, void *dbl);
struct frame_extra_info
{
int framesize;
int frameoffset;
int framereg;
};
#define IS_THUMB_ADDR(addr) ((addr) & 1)
#define MAKE_THUMB_ADDR(addr) ((addr) | 1)
#define UNMAKE_THUMB_ADDR(addr) ((addr) & ~1)
static int
arm_frame_chain_valid (CORE_ADDR chain, struct frame_info *thisframe)
{
return (chain != 0 && (FRAME_SAVED_PC (thisframe) >= LOWEST_PC));
}
int arm_apcs_32 = 1;
static int target_is_thumb;
static int caller_is_thumb;
int
arm_pc_is_thumb (CORE_ADDR memaddr)
{
struct minimal_symbol *sym;
if (IS_THUMB_ADDR (memaddr))
return 1;
sym = lookup_minimal_symbol_by_pc (memaddr);
if (sym)
{
return (MSYMBOL_IS_SPECIAL (sym));
}
else
{
return 0;
}
}
int
arm_pc_is_thumb_dummy (CORE_ADDR memaddr)
{
CORE_ADDR sp = read_sp ();
if (PC_IN_CALL_DUMMY (memaddr, sp, sp + 1024))
return caller_is_thumb;
else
return 0;
}
static CORE_ADDR
arm_addr_bits_remove (CORE_ADDR val)
{
if (arm_apcs_32)
return (val & (arm_pc_is_thumb (val) ? 0xfffffffe : 0xfffffffc));
else
return (val & 0x03fffffc);
}
static CORE_ADDR
arm_smash_text_address (CORE_ADDR val)
{
return val & ~1;
}
static CORE_ADDR
arm_saved_pc_after_call (struct frame_info *frame)
{
return ADDR_BITS_REMOVE (read_register (ARM_LR_REGNUM));
}
static int
arm_frameless_function_invocation (struct frame_info *fi)
{
CORE_ADDR func_start, after_prologue;
int frameless;
func_start = (get_pc_function_start ((fi)->pc) + FUNCTION_START_OFFSET);
after_prologue = SKIP_PROLOGUE (func_start);
frameless = (after_prologue < func_start + 12);
return frameless;
}
static CORE_ADDR
arm_frame_args_address (struct frame_info *fi)
{
return fi->frame;
}
static CORE_ADDR
arm_frame_locals_address (struct frame_info *fi)
{
return fi->frame;
}
static int
arm_frame_num_args (struct frame_info *fi)
{
return -1;
}
static CORE_ADDR
thumb_skip_prologue (CORE_ADDR pc, CORE_ADDR func_end)
{
CORE_ADDR current_pc;
int findmask = 0;
for (current_pc = pc;
current_pc + 2 < func_end && current_pc < pc + 40;
current_pc += 2)
{
unsigned short insn = read_memory_unsigned_integer (current_pc, 2);
if ((insn & 0xfe00) == 0xb400)
{
findmask |= 1;
}
else if ((insn & 0xff00) == 0xb000)
{
if ((findmask & 1) == 0)
continue;
else
findmask |= 4;
}
else if ((insn & 0xff00) == 0xaf00)
{
findmask |= 2;
}
else if (insn == 0x466f)
{
findmask |= 2;
}
else if (findmask == (4+2+1))
{
break;
}
else
continue;
}
return current_pc;
}
static CORE_ADDR
arm_skip_prologue (CORE_ADDR pc)
{
unsigned long inst;
CORE_ADDR skip_pc;
CORE_ADDR func_addr, func_end = 0;
char *func_name;
struct symtab_and_line sal;
if (USE_GENERIC_DUMMY_FRAMES
&& PC_IN_CALL_DUMMY (pc, 0, 0))
return pc;
if (find_pc_partial_function (pc, &func_name, &func_addr, &func_end))
{
struct symbol *sym;
sym = lookup_symbol (func_name, NULL, VAR_NAMESPACE, NULL, NULL);
if (sym && SYMBOL_LANGUAGE (sym) != language_asm)
{
sal = find_pc_line (func_addr, 0);
if ((sal.line != 0) && (sal.end < func_end))
return sal.end;
}
}
if (arm_pc_is_thumb (pc))
return thumb_skip_prologue (pc, func_end);
if (func_end == 0 || func_end > pc + 64)
func_end = pc + 64;
for (skip_pc = pc; skip_pc < func_end; skip_pc += 4)
{
inst = read_memory_integer (skip_pc, 4);
if (inst == 0xe1a0c00d)
continue;
if (inst == 0xe52de004)
continue;
if ((inst & 0xfffffff0) == 0xe92d0000)
continue;
if ((inst & 0xfffff800) == 0xe92dd800)
continue;
if ((inst & 0xffbf0fff) == 0xec2d0200)
continue;
if ((inst & 0xffff8fff) == 0xed6d0103)
continue;
if ((inst & 0xfffff000) == 0xe24cb000)
continue;
if ((inst & 0xfffff000) == 0xe24dd000)
continue;
if ((inst & 0xffffc000) == 0xe54b0000 ||
(inst & 0xffffc0f0) == 0xe14b00b0 ||
(inst & 0xffffc000) == 0xe50b0000)
continue;
if ((inst & 0xffffc000) == 0xe5cd0000 ||
(inst & 0xffffc0f0) == 0xe1cd00b0 ||
(inst & 0xffffc000) == 0xe58d0000)
continue;
break;
}
return skip_pc;
}
static void
thumb_scan_prologue (struct frame_info *fi)
{
CORE_ADDR prologue_start;
CORE_ADDR prologue_end;
CORE_ADDR current_pc;
int saved_reg[16];
int findmask = 0;
int i;
if (USE_GENERIC_DUMMY_FRAMES
&& fi != NULL
&& PC_IN_CALL_DUMMY (fi->pc, 0, 0))
return;
if (find_pc_partial_function (fi->pc, NULL, &prologue_start, &prologue_end))
{
struct symtab_and_line sal = find_pc_line (prologue_start, 0);
if (sal.line == 0)
prologue_end = fi->pc;
else if (sal.end < prologue_end)
prologue_end = sal.end;
}
else
prologue_end = prologue_start + 40;
prologue_end = min (prologue_end, fi->pc);
for (i = 0; i < 16; i++)
saved_reg[i] = i;
fi->extra_info->framesize = 0;
for (current_pc = prologue_start;
(current_pc < prologue_end) && ((findmask & 7) != 7);
current_pc += 2)
{
unsigned short insn;
int regno;
int offset;
insn = read_memory_unsigned_integer (current_pc, 2);
if ((insn & 0xfe00) == 0xb400)
{
int mask;
findmask |= 1;
mask = (insn & 0xff) | ((insn & 0x100) << 6);
for (regno = ARM_LR_REGNUM; regno >= 0; regno--)
if (mask & (1 << regno))
{
fi->extra_info->framesize += 4;
fi->saved_regs[saved_reg[regno]] =
-(fi->extra_info->framesize);
saved_reg[regno] = regno;
}
}
else if ((insn & 0xff00) == 0xb000)
{
if ((findmask & 1) == 0)
continue;
else
findmask |= 4;
offset = (insn & 0x7f) << 2;
if (insn & 0x80)
{
fi->extra_info->frameoffset += offset;
offset = -offset;
}
fi->extra_info->framesize -= offset;
}
else if ((insn & 0xff00) == 0xaf00)
{
findmask |= 2;
fi->extra_info->framereg = THUMB_FP_REGNUM;
fi->extra_info->frameoffset = (insn & 0xff) << 2;
}
else if (insn == 0x466f)
{
findmask |= 2;
fi->extra_info->framereg = THUMB_FP_REGNUM;
fi->extra_info->frameoffset = 0;
saved_reg[THUMB_FP_REGNUM] = ARM_SP_REGNUM;
}
else if ((insn & 0xffc0) == 0x4640)
{
int lo_reg = insn & 7;
int hi_reg = ((insn >> 3) & 7) + 8;
saved_reg[lo_reg] = hi_reg;
}
else
continue;
}
}
static struct frame_info prologue_cache;
static int
check_prologue_cache (struct frame_info *fi)
{
int i;
if (fi->pc == prologue_cache.pc)
{
fi->extra_info->framereg = prologue_cache.extra_info->framereg;
fi->extra_info->framesize = prologue_cache.extra_info->framesize;
fi->extra_info->frameoffset = prologue_cache.extra_info->frameoffset;
for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
fi->saved_regs[i] = prologue_cache.saved_regs[i];
return 1;
}
else
return 0;
}
static void
save_prologue_cache (struct frame_info *fi)
{
int i;
prologue_cache.pc = fi->pc;
prologue_cache.extra_info->framereg = fi->extra_info->framereg;
prologue_cache.extra_info->framesize = fi->extra_info->framesize;
prologue_cache.extra_info->frameoffset = fi->extra_info->frameoffset;
for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
prologue_cache.saved_regs[i] = fi->saved_regs[i];
}
static void
arm_scan_prologue (struct frame_info *fi)
{
int regno, sp_offset, fp_offset;
LONGEST return_value;
CORE_ADDR prologue_start, prologue_end, current_pc;
if (check_prologue_cache (fi))
return;
fi->extra_info->framereg = ARM_SP_REGNUM;
fi->extra_info->framesize = 0;
fi->extra_info->frameoffset = 0;
if (arm_pc_is_thumb (fi->pc))
{
thumb_scan_prologue (fi);
save_prologue_cache (fi);
return;
}
if (find_pc_partial_function (fi->pc, NULL, &prologue_start, &prologue_end))
{
if (prologue_end > prologue_start + 64)
{
prologue_end = prologue_start + 64;
}
}
else
{
if (!safe_read_memory_integer (fi->frame, 4, &return_value))
return;
else
{
prologue_start = ADDR_BITS_REMOVE (return_value) - 8;
prologue_end = prologue_start + 64;
}
}
sp_offset = fp_offset = 0;
for (current_pc = prologue_start;
current_pc < prologue_end;
current_pc += 4)
{
unsigned int insn = read_memory_unsigned_integer (current_pc, 4);
if (insn == 0xe1a0c00d)
{
continue;
}
else if (insn == 0xe52de004)
{
continue;
}
else if ((insn & 0xffff0000) == 0xe92d0000)
{
int mask = insn & 0xffff;
for (regno = ARM_PC_REGNUM; regno >= 0; regno--)
if (mask & (1 << regno))
{
sp_offset -= 4;
fi->saved_regs[regno] = sp_offset;
}
}
else if ((insn & 0xffffc000) == 0xe54b0000 ||
(insn & 0xffffc0f0) == 0xe14b00b0 ||
(insn & 0xffffc000) == 0xe50b0000)
{
continue;
}
else if ((insn & 0xffffc000) == 0xe5cd0000 ||
(insn & 0xffffc0f0) == 0xe1cd00b0 ||
(insn & 0xffffc000) == 0xe58d0000)
{
continue;
}
else if ((insn & 0xfffff000) == 0xe24cb000)
{
unsigned imm = insn & 0xff;
unsigned rot = (insn & 0xf00) >> 7;
imm = (imm >> rot) | (imm << (32 - rot));
fp_offset = -imm;
fi->extra_info->framereg = ARM_FP_REGNUM;
}
else if ((insn & 0xfffff000) == 0xe24dd000)
{
unsigned imm = insn & 0xff;
unsigned rot = (insn & 0xf00) >> 7;
imm = (imm >> rot) | (imm << (32 - rot));
sp_offset -= imm;
}
else if ((insn & 0xffff7fff) == 0xed6d0103)
{
sp_offset -= 12;
regno = ARM_F0_REGNUM + ((insn >> 12) & 0x07);
fi->saved_regs[regno] = sp_offset;
}
else if ((insn & 0xffbf0fff) == 0xec2d0200)
{
int n_saved_fp_regs;
unsigned int fp_start_reg, fp_bound_reg;
if ((insn & 0x800) == 0x800)
{
if ((insn & 0x40000) == 0x40000)
n_saved_fp_regs = 3;
else
n_saved_fp_regs = 1;
}
else
{
if ((insn & 0x40000) == 0x40000)
n_saved_fp_regs = 2;
else
n_saved_fp_regs = 4;
}
fp_start_reg = ARM_F0_REGNUM + ((insn >> 12) & 0x7);
fp_bound_reg = fp_start_reg + n_saved_fp_regs;
for (; fp_start_reg < fp_bound_reg; fp_start_reg++)
{
sp_offset -= 12;
fi->saved_regs[fp_start_reg++] = sp_offset;
}
}
else if ((insn & 0xf0000000) != 0xe0000000)
break;
else if ((insn & 0xfe200000) == 0xe8200000)
break;
else
continue;
}
fi->extra_info->framesize = -sp_offset;
if (fi->extra_info->framereg == ARM_FP_REGNUM)
fi->extra_info->frameoffset = fp_offset - sp_offset;
else
fi->extra_info->frameoffset = 0;
save_prologue_cache (fi);
}
static CORE_ADDR
arm_find_callers_reg (struct frame_info *fi, int regnum)
{
for (; fi; fi = fi->next)
{
if (USE_GENERIC_DUMMY_FRAMES
&& PC_IN_CALL_DUMMY (fi->pc, 0, 0))
{
return deprecated_read_register_dummy (fi->pc, fi->frame, regnum);
}
else if (fi->saved_regs[regnum] != 0)
{
return read_memory_integer (fi->saved_regs[regnum],
REGISTER_RAW_SIZE (regnum));
}
}
return read_register (regnum);
}
static CORE_ADDR
arm_frame_chain (struct frame_info *fi)
{
CORE_ADDR caller_pc;
int framereg = fi->extra_info->framereg;
if (USE_GENERIC_DUMMY_FRAMES
&& PC_IN_CALL_DUMMY (fi->pc, 0, 0))
return fi->frame;
if (fi->pc < LOWEST_PC)
return 0;
caller_pc = FRAME_SAVED_PC (fi);
if (arm_pc_is_thumb (caller_pc) != arm_pc_is_thumb (fi->pc))
{
struct frame_info caller_fi;
struct cleanup *old_chain;
memset (&caller_fi, 0, sizeof (caller_fi));
caller_fi.extra_info = (struct frame_extra_info *)
xcalloc (1, sizeof (struct frame_extra_info));
old_chain = make_cleanup (xfree, caller_fi.extra_info);
caller_fi.saved_regs = (CORE_ADDR *)
xcalloc (1, SIZEOF_FRAME_SAVED_REGS);
make_cleanup (xfree, caller_fi.saved_regs);
caller_fi.pc = caller_pc;
arm_scan_prologue (&caller_fi);
framereg = caller_fi.extra_info->framereg;
do_cleanups (old_chain);
}
if (framereg == ARM_FP_REGNUM || framereg == THUMB_FP_REGNUM)
return arm_find_callers_reg (fi, framereg);
else
return fi->frame + fi->extra_info->framesize;
}
static void
arm_init_extra_frame_info (int fromleaf, struct frame_info *fi)
{
int reg;
CORE_ADDR sp;
if (fi->saved_regs == NULL)
frame_saved_regs_zalloc (fi);
fi->extra_info = (struct frame_extra_info *)
frame_obstack_alloc (sizeof (struct frame_extra_info));
fi->extra_info->framesize = 0;
fi->extra_info->frameoffset = 0;
fi->extra_info->framereg = 0;
if (fi->next)
fi->pc = FRAME_SAVED_PC (fi->next);
memset (fi->saved_regs, '\000', sizeof fi->saved_regs);
if (!fi->next)
sp = read_sp();
else if (USE_GENERIC_DUMMY_FRAMES
&& PC_IN_CALL_DUMMY (fi->next->pc, 0, 0))
sp = deprecated_read_register_dummy (fi->next->pc, fi->next->frame,
ARM_SP_REGNUM);
else
sp = (fi->next->frame - fi->next->extra_info->frameoffset
+ fi->next->extra_info->framesize);
if (SIGCONTEXT_REGISTER_ADDRESS_P ()
&& (fi->signal_handler_caller || PC_IN_SIGTRAMP (fi->pc, (char *)0)))
{
for (reg = 0; reg < NUM_REGS; reg++)
fi->saved_regs[reg] = SIGCONTEXT_REGISTER_ADDRESS (sp, fi->pc, reg);
fi->extra_info->framereg = ARM_SP_REGNUM;
fi->frame =
read_memory_integer (fi->saved_regs[fi->extra_info->framereg],
REGISTER_RAW_SIZE (fi->extra_info->framereg));
fi->extra_info->framesize = 0;
fi->extra_info->frameoffset = 0;
}
else if (!USE_GENERIC_DUMMY_FRAMES
&& PC_IN_CALL_DUMMY (fi->pc, sp, fi->frame))
{
CORE_ADDR rp;
CORE_ADDR callers_sp;
rp = fi->frame - REGISTER_SIZE;
fi->saved_regs[ARM_PS_REGNUM] = rp;
rp -= REGISTER_RAW_SIZE (ARM_PS_REGNUM);
for (reg = ARM_PC_REGNUM; reg >= 0; reg--)
{
fi->saved_regs[reg] = rp;
rp -= REGISTER_RAW_SIZE (reg);
}
callers_sp = read_memory_integer (fi->saved_regs[ARM_SP_REGNUM],
REGISTER_RAW_SIZE (ARM_SP_REGNUM));
if (arm_pc_is_thumb (fi->pc))
fi->extra_info->framereg = THUMB_FP_REGNUM;
else
fi->extra_info->framereg = ARM_FP_REGNUM;
fi->extra_info->framesize = callers_sp - sp;
fi->extra_info->frameoffset = fi->frame - sp;
}
else
{
arm_scan_prologue (fi);
if (!fi->next)
fi->frame = read_register (fi->extra_info->framereg);
else if (USE_GENERIC_DUMMY_FRAMES
&& PC_IN_CALL_DUMMY (fi->next->pc, 0, 0))
fi->frame = fi->next->frame;
else if (fi->extra_info->framereg == ARM_FP_REGNUM
|| fi->extra_info->framereg == THUMB_FP_REGNUM)
{
if (fi->next->saved_regs[fi->extra_info->framereg] != 0)
fi->frame =
read_memory_integer (fi->next
->saved_regs[fi->extra_info->framereg], 4);
else if (fromleaf)
fi->frame = read_fp ();
}
for (reg = 0; reg < NUM_REGS; reg++)
if (fi->saved_regs[reg] != 0)
fi->saved_regs[reg] += (fi->frame + fi->extra_info->framesize
- fi->extra_info->frameoffset);
}
}
static CORE_ADDR
arm_frame_saved_pc (struct frame_info *fi)
{
if (USE_GENERIC_DUMMY_FRAMES
&& PC_IN_CALL_DUMMY (fi->pc, 0, 0))
return deprecated_read_register_dummy (fi->pc, fi->frame, ARM_PC_REGNUM);
if (PC_IN_CALL_DUMMY (fi->pc, fi->frame - fi->extra_info->frameoffset,
fi->frame))
{
return read_memory_integer (fi->saved_regs[ARM_PC_REGNUM],
REGISTER_RAW_SIZE (ARM_PC_REGNUM));
}
else
{
CORE_ADDR pc = arm_find_callers_reg (fi, ARM_LR_REGNUM);
return IS_THUMB_ADDR (pc) ? UNMAKE_THUMB_ADDR (pc) : pc;
}
}
static CORE_ADDR
arm_read_fp (void)
{
if (read_register (ARM_PS_REGNUM) & 0x20)
return read_register (THUMB_FP_REGNUM);
else
return read_register (ARM_FP_REGNUM);
}
static void
arm_frame_init_saved_regs (struct frame_info *fip)
{
if (fip->saved_regs)
return;
arm_init_extra_frame_info (0, fip);
}
static CORE_ADDR
arm_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
{
write_register (ARM_LR_REGNUM, CALL_DUMMY_ADDRESS ());
return sp;
}
static void
arm_push_dummy_frame (void)
{
CORE_ADDR old_sp = read_register (ARM_SP_REGNUM);
CORE_ADDR sp = old_sp;
CORE_ADDR fp, prologue_start;
int regnum;
sp = push_word (sp, 0xe24cb004);
prologue_start = sp = push_word (sp, 0xe92ddfff);
fp = sp = push_word (sp, prologue_start + 12);
sp = push_word (sp, read_register (ARM_PS_REGNUM));
for (regnum = ARM_PC_REGNUM; regnum >= 0; regnum--)
sp = push_word (sp, read_register (regnum));
write_register (ARM_FP_REGNUM, fp);
write_register (THUMB_FP_REGNUM, fp);
write_register (ARM_SP_REGNUM, sp);
}
static LONGEST arm_call_dummy_words[] =
{
0xe1a0e00f, 0xe1a0f004, 0xe7ffdefe
};
static void
arm_set_call_dummy_breakpoint_offset (void)
{
if (caller_is_thumb)
set_gdbarch_call_dummy_breakpoint_offset (current_gdbarch, 4);
else
set_gdbarch_call_dummy_breakpoint_offset (current_gdbarch, 8);
}
static void
arm_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
struct value **args, struct type *type, int gcc_p)
{
static short thumb_dummy[4] =
{
0xf000, 0xf801,
0xdf18,
0x4720,
};
static unsigned long arm_bx_r4 = 0xe12fff14;
caller_is_thumb = arm_pc_is_thumb (read_pc ());
arm_set_call_dummy_breakpoint_offset ();
target_is_thumb = arm_pc_is_thumb (fun);
if (target_is_thumb)
{
fun |= 1;
if (!caller_is_thumb)
store_unsigned_integer (dummy + 4, sizeof (arm_bx_r4), arm_bx_r4);
}
if (caller_is_thumb)
{
int i;
char *p = dummy;
int len = sizeof (thumb_dummy) / sizeof (thumb_dummy[0]);
for (i = 0; i < len; i++)
{
store_unsigned_integer (p, sizeof (thumb_dummy[0]), thumb_dummy[i]);
p += sizeof (thumb_dummy[0]);
}
}
write_register (4, fun);
}
static CORE_ADDR
arm_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
int struct_return, CORE_ADDR struct_addr)
{
CORE_ADDR fp;
int argnum;
int argreg;
int nstack;
int simd_argreg;
int second_pass;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
nstack = 0;
fp = sp;
for (second_pass = 0; second_pass < 2; second_pass++)
{
if (second_pass)
fp = sp - nstack;
simd_argreg = 0;
argreg = ARM_A1_REGNUM;
nstack = 0;
if (struct_return)
{
if (second_pass)
{
if (arm_debug)
fprintf_unfiltered (gdb_stdlog,
"struct return in %s = 0x%s\n",
REGISTER_NAME (argreg),
paddr (struct_addr));
write_register (argreg, struct_addr);
}
argreg++;
}
for (argnum = 0; argnum < nargs; argnum++)
{
int len;
struct type *arg_type;
struct type *target_type;
enum type_code typecode;
char *val;
arg_type = check_typedef (VALUE_TYPE (args[argnum]));
len = TYPE_LENGTH (arg_type);
target_type = TYPE_TARGET_TYPE (arg_type);
typecode = TYPE_CODE (arg_type);
val = VALUE_CONTENTS (args[argnum]);
if (second_pass
&& TYPE_CODE_PTR == typecode
&& target_type != NULL
&& TYPE_CODE_FUNC == TYPE_CODE (target_type))
{
CORE_ADDR regval = extract_address (val, len);
if (arm_pc_is_thumb (regval))
{
val = alloca (len);
store_address (val, len, MAKE_THUMB_ADDR (regval));
}
}
while (len > 0)
{
int partial_len = len < REGISTER_SIZE ? len : REGISTER_SIZE;
if (argreg <= ARM_LAST_ARG_REGNUM)
{
if (second_pass)
{
CORE_ADDR regval = extract_address (val,
partial_len);
if (arm_debug)
fprintf_unfiltered (gdb_stdlog,
"arg %d in %s = 0x%s\n",
argnum,
REGISTER_NAME (argreg),
phex (regval, REGISTER_SIZE));
write_register (argreg, regval);
}
argreg++;
}
else
{
if (second_pass)
{
if (arm_debug)
fprintf_unfiltered (gdb_stdlog,
"arg %d @ 0x%s + %d\n",
argnum, paddr (fp), nstack);
write_memory (fp + nstack, val, REGISTER_SIZE);
}
nstack += REGISTER_SIZE;
}
len -= partial_len;
val += partial_len;
}
}
}
return fp;
}
static void
arm_pop_frame (void)
{
int regnum;
struct frame_info *frame = get_current_frame ();
CORE_ADDR old_SP = (frame->frame - frame->extra_info->frameoffset
+ frame->extra_info->framesize);
if (USE_GENERIC_DUMMY_FRAMES
&& PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
{
generic_pop_dummy_frame ();
flush_cached_frames ();
return;
}
for (regnum = 0; regnum < NUM_REGS; regnum++)
if (frame->saved_regs[regnum] != 0)
write_register (regnum,
read_memory_integer (frame->saved_regs[regnum],
REGISTER_RAW_SIZE (regnum)));
write_register (ARM_PC_REGNUM, FRAME_SAVED_PC (frame));
write_register (ARM_SP_REGNUM, old_SP);
flush_cached_frames ();
}
static void
print_fpu_flags (int flags)
{
if (flags & (1 << 0))
fputs ("IVO ", stdout);
if (flags & (1 << 1))
fputs ("DVZ ", stdout);
if (flags & (1 << 2))
fputs ("OFL ", stdout);
if (flags & (1 << 3))
fputs ("UFL ", stdout);
if (flags & (1 << 4))
fputs ("INX ", stdout);
putchar ('\n');
}
static void
arm_print_float_info (struct gdbarch *gdbarch, struct ui_file *file,
struct frame_info *frame, const char *args)
{
register unsigned long status = read_register (ARM_FPS_REGNUM);
int type;
type = (status >> 24) & 127;
printf ("%s FPU type %d\n",
(status & (1 << 31)) ? "Hardware" : "Software",
type);
fputs ("mask: ", stdout);
print_fpu_flags (status >> 16);
fputs ("flags: ", stdout);
print_fpu_flags (status);
}
static struct type *
arm_register_type (int regnum)
{
if (regnum >= ARM_F0_REGNUM && regnum < ARM_F0_REGNUM + NUM_FREGS)
{
if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
return builtin_type_arm_ext_big;
else
return builtin_type_arm_ext_littlebyte_bigword;
}
else
return builtin_type_int32;
}
static int
arm_register_byte (int regnum)
{
if (regnum < ARM_F0_REGNUM)
return regnum * INT_REGISTER_RAW_SIZE;
else if (regnum < ARM_PS_REGNUM)
return (NUM_GREGS * INT_REGISTER_RAW_SIZE
+ (regnum - ARM_F0_REGNUM) * FP_REGISTER_RAW_SIZE);
else
return (NUM_GREGS * INT_REGISTER_RAW_SIZE
+ NUM_FREGS * FP_REGISTER_RAW_SIZE
+ (regnum - ARM_FPS_REGNUM) * STATUS_REGISTER_SIZE);
}
static int
arm_register_raw_size (int regnum)
{
if (regnum < ARM_F0_REGNUM)
return INT_REGISTER_RAW_SIZE;
else if (regnum < ARM_FPS_REGNUM)
return FP_REGISTER_RAW_SIZE;
else
return STATUS_REGISTER_SIZE;
}
static int
arm_register_virtual_size (int regnum)
{
if (regnum < ARM_F0_REGNUM)
return INT_REGISTER_VIRTUAL_SIZE;
else if (regnum < ARM_FPS_REGNUM)
return FP_REGISTER_VIRTUAL_SIZE;
else
return STATUS_REGISTER_SIZE;
}
static int
arm_register_sim_regno (int regnum)
{
int reg = regnum;
gdb_assert (reg >= 0 && reg < NUM_REGS);
if (reg < NUM_GREGS)
return SIM_ARM_R0_REGNUM + reg;
reg -= NUM_GREGS;
if (reg < NUM_FREGS)
return SIM_ARM_FP0_REGNUM + reg;
reg -= NUM_FREGS;
if (reg < NUM_SREGS)
return SIM_ARM_FPS_REGNUM + reg;
reg -= NUM_SREGS;
internal_error (__FILE__, __LINE__, "Bad REGNUM %d", regnum);
}
static void
convert_from_extended (void *ptr, void *dbl)
{
DOUBLEST d;
if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
floatformat_to_doublest (&floatformat_arm_ext_big, ptr, &d);
else
floatformat_to_doublest (&floatformat_arm_ext_littlebyte_bigword,
ptr, &d);
floatformat_from_doublest (TARGET_DOUBLE_FORMAT, &d, dbl);
}
static void
convert_to_extended (void *dbl, void *ptr)
{
DOUBLEST d;
floatformat_to_doublest (TARGET_DOUBLE_FORMAT, ptr, &d);
if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
floatformat_from_doublest (&floatformat_arm_ext_big, &d, dbl);
else
floatformat_from_doublest (&floatformat_arm_ext_littlebyte_bigword,
&d, dbl);
}
static int
condition_true (unsigned long cond, unsigned long status_reg)
{
if (cond == INST_AL || cond == INST_NV)
return 1;
switch (cond)
{
case INST_EQ:
return ((status_reg & FLAG_Z) != 0);
case INST_NE:
return ((status_reg & FLAG_Z) == 0);
case INST_CS:
return ((status_reg & FLAG_C) != 0);
case INST_CC:
return ((status_reg & FLAG_C) == 0);
case INST_MI:
return ((status_reg & FLAG_N) != 0);
case INST_PL:
return ((status_reg & FLAG_N) == 0);
case INST_VS:
return ((status_reg & FLAG_V) != 0);
case INST_VC:
return ((status_reg & FLAG_V) == 0);
case INST_HI:
return ((status_reg & (FLAG_C | FLAG_Z)) == FLAG_C);
case INST_LS:
return ((status_reg & (FLAG_C | FLAG_Z)) != FLAG_C);
case INST_GE:
return (((status_reg & FLAG_N) == 0) == ((status_reg & FLAG_V) == 0));
case INST_LT:
return (((status_reg & FLAG_N) == 0) != ((status_reg & FLAG_V) == 0));
case INST_GT:
return (((status_reg & FLAG_Z) == 0) &&
(((status_reg & FLAG_N) == 0) == ((status_reg & FLAG_V) == 0)));
case INST_LE:
return (((status_reg & FLAG_Z) != 0) ||
(((status_reg & FLAG_N) == 0) != ((status_reg & FLAG_V) == 0)));
}
return 1;
}
#define submask(x) ((1L << ((x) + 1)) - 1)
#define bit(obj,st) (((obj) >> (st)) & 1)
#define bits(obj,st,fn) (((obj) >> (st)) & submask ((fn) - (st)))
#define sbits(obj,st,fn) \
((long) (bits(obj,st,fn) | ((long) bit(obj,fn) * ~ submask (fn - st))))
#define BranchDest(addr,instr) \
((CORE_ADDR) (((long) (addr)) + 8 + (sbits (instr, 0, 23) << 2)))
#define ARM_PC_32 1
static unsigned long
shifted_reg_val (unsigned long inst, int carry, unsigned long pc_val,
unsigned long status_reg)
{
unsigned long res, shift;
int rm = bits (inst, 0, 3);
unsigned long shifttype = bits (inst, 5, 6);
if (bit (inst, 4))
{
int rs = bits (inst, 8, 11);
shift = (rs == 15 ? pc_val + 8 : read_register (rs)) & 0xFF;
}
else
shift = bits (inst, 7, 11);
res = (rm == 15
? ((pc_val | (ARM_PC_32 ? 0 : status_reg))
+ (bit (inst, 4) ? 12 : 8))
: read_register (rm));
switch (shifttype)
{
case 0:
res = shift >= 32 ? 0 : res << shift;
break;
case 1:
res = shift >= 32 ? 0 : res >> shift;
break;
case 2:
if (shift >= 32)
shift = 31;
res = ((res & 0x80000000L)
? ~((~res) >> shift) : res >> shift);
break;
case 3:
shift &= 31;
if (shift == 0)
res = (res >> 1) | (carry ? 0x80000000L : 0);
else
res = (res >> shift) | (res << (32 - shift));
break;
}
return res & 0xffffffff;
}
static int
bitcount (unsigned long val)
{
int nbits;
for (nbits = 0; val != 0; nbits++)
val &= val - 1;
return nbits;
}
CORE_ADDR
thumb_get_next_pc (CORE_ADDR pc)
{
unsigned long pc_val = ((unsigned long) pc) + 4;
unsigned short inst1 = read_memory_integer (pc, 2);
CORE_ADDR nextpc = pc + 2;
unsigned long offset;
if ((inst1 & 0xff00) == 0xbd00)
{
CORE_ADDR sp;
offset = bitcount (bits (inst1, 0, 7)) * REGISTER_SIZE;
sp = read_register (ARM_SP_REGNUM);
nextpc = (CORE_ADDR) read_memory_integer (sp + offset, 4);
nextpc = ADDR_BITS_REMOVE (nextpc);
if (nextpc == pc)
error ("Infinite loop detected");
}
else if ((inst1 & 0xf000) == 0xd000)
{
unsigned long status = read_register (ARM_PS_REGNUM);
unsigned long cond = bits (inst1, 8, 11);
if (cond != 0x0f && condition_true (cond, status))
nextpc = pc_val + (sbits (inst1, 0, 7) << 1);
}
else if ((inst1 & 0xf800) == 0xe000)
{
nextpc = pc_val + (sbits (inst1, 0, 10) << 1);
}
else if ((inst1 & 0xf800) == 0xf000)
{
unsigned short inst2 = read_memory_integer (pc + 2, 2);
offset = (sbits (inst1, 0, 10) << 12) + (bits (inst2, 0, 10) << 1);
nextpc = pc_val + offset;
}
return nextpc;
}
CORE_ADDR
arm_get_next_pc (CORE_ADDR pc)
{
unsigned long pc_val;
unsigned long this_instr;
unsigned long status;
CORE_ADDR nextpc;
if (arm_pc_is_thumb (pc))
return thumb_get_next_pc (pc);
pc_val = (unsigned long) pc;
this_instr = read_memory_integer (pc, 4);
status = read_register (ARM_PS_REGNUM);
nextpc = (CORE_ADDR) (pc_val + 4);
if (condition_true (bits (this_instr, 28, 31), status))
{
switch (bits (this_instr, 24, 27))
{
case 0x0:
case 0x1:
case 0x2:
case 0x3:
{
unsigned long operand1, operand2, result = 0;
unsigned long rn;
int c;
if (bits (this_instr, 12, 15) != 15)
break;
if (bits (this_instr, 22, 25) == 0
&& bits (this_instr, 4, 7) == 9)
error ("Illegal update to pc in instruction");
c = (status & FLAG_C) ? 1 : 0;
rn = bits (this_instr, 16, 19);
operand1 = (rn == 15) ? pc_val + 8 : read_register (rn);
if (bit (this_instr, 25))
{
unsigned long immval = bits (this_instr, 0, 7);
unsigned long rotate = 2 * bits (this_instr, 8, 11);
operand2 = ((immval >> rotate) | (immval << (32 - rotate)))
& 0xffffffff;
}
else
operand2 = shifted_reg_val (this_instr, c, pc_val, status);
switch (bits (this_instr, 21, 24))
{
case 0x0:
result = operand1 & operand2;
break;
case 0x1:
result = operand1 ^ operand2;
break;
case 0x2:
result = operand1 - operand2;
break;
case 0x3:
result = operand2 - operand1;
break;
case 0x4:
result = operand1 + operand2;
break;
case 0x5:
result = operand1 + operand2 + c;
break;
case 0x6:
result = operand1 - operand2 + c;
break;
case 0x7:
result = operand2 - operand1 + c;
break;
case 0x8:
case 0x9:
case 0xa:
case 0xb:
result = (unsigned long) nextpc;
break;
case 0xc:
result = operand1 | operand2;
break;
case 0xd:
result = operand2;
break;
case 0xe:
result = operand1 & ~operand2;
break;
case 0xf:
result = ~operand2;
break;
}
nextpc = (CORE_ADDR) ADDR_BITS_REMOVE (result);
if (nextpc == pc)
error ("Infinite loop detected");
break;
}
case 0x4:
case 0x5:
case 0x6:
case 0x7:
if (bit (this_instr, 20))
{
if (bits (this_instr, 12, 15) == 15)
{
unsigned long rn;
unsigned long base;
if (bit (this_instr, 22))
error ("Illegal update to pc in instruction");
rn = bits (this_instr, 16, 19);
base = (rn == 15) ? pc_val + 8 : read_register (rn);
if (bit (this_instr, 24))
{
int c = (status & FLAG_C) ? 1 : 0;
unsigned long offset =
(bit (this_instr, 25)
? shifted_reg_val (this_instr, c, pc_val, status)
: bits (this_instr, 0, 11));
if (bit (this_instr, 23))
base += offset;
else
base -= offset;
}
nextpc = (CORE_ADDR) read_memory_integer ((CORE_ADDR) base,
4);
nextpc = ADDR_BITS_REMOVE (nextpc);
if (nextpc == pc)
error ("Infinite loop detected");
}
}
break;
case 0x8:
case 0x9:
if (bit (this_instr, 20))
{
if (bit (this_instr, 15))
{
int offset = 0;
if (bit (this_instr, 23))
{
unsigned long reglist = bits (this_instr, 0, 14);
offset = bitcount (reglist) * 4;
if (bit (this_instr, 24))
offset += 4;
}
else if (bit (this_instr, 24))
offset = -4;
{
unsigned long rn_val =
read_register (bits (this_instr, 16, 19));
nextpc =
(CORE_ADDR) read_memory_integer ((CORE_ADDR) (rn_val
+ offset),
4);
}
nextpc = ADDR_BITS_REMOVE (nextpc);
if (nextpc == pc)
error ("Infinite loop detected");
}
}
break;
case 0xb:
case 0xa:
{
nextpc = BranchDest (pc, this_instr);
nextpc = ADDR_BITS_REMOVE (nextpc);
if (nextpc == pc)
error ("Infinite loop detected");
break;
}
case 0xc:
case 0xd:
case 0xe:
case 0xf:
break;
default:
fprintf_filtered (gdb_stderr, "Bad bit-field extraction\n");
return (pc);
}
}
return nextpc;
}
static void
arm_software_single_step (enum target_signal sig, int insert_bpt)
{
static int next_pc;
static char break_mem[BREAKPOINT_MAX];
if (insert_bpt)
{
next_pc = arm_get_next_pc (read_register (ARM_PC_REGNUM));
target_insert_breakpoint (next_pc, break_mem);
}
else
target_remove_breakpoint (next_pc, break_mem);
}
#include "bfd-in2.h"
#include "libcoff.h"
static int
gdb_print_insn_arm (bfd_vma memaddr, disassemble_info *info)
{
if (arm_pc_is_thumb (memaddr))
{
static asymbol *asym;
static combined_entry_type ce;
static struct coff_symbol_struct csym;
static struct _bfd fake_bfd;
static bfd_target fake_target;
if (csym.native == NULL)
{
fake_target.flavour = bfd_target_coff_flavour;
fake_bfd.xvec = &fake_target;
ce.u.syment.n_sclass = C_THUMBEXTFUNC;
csym.native = &ce;
csym.symbol.the_bfd = &fake_bfd;
csym.symbol.name = "fake";
asym = (asymbol *) & csym;
}
memaddr = UNMAKE_THUMB_ADDR (memaddr);
info->symbols = &asym;
}
else
info->symbols = NULL;
if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
return print_insn_big_arm (memaddr, info);
else
return print_insn_little_arm (memaddr, info);
}
#ifndef ARM_LE_BREAKPOINT
#define ARM_LE_BREAKPOINT {0xFE,0xDE,0xFF,0xE7}
#endif
#ifndef ARM_BE_BREAKPOINT
#define ARM_BE_BREAKPOINT {0xE7,0xFF,0xDE,0xFE}
#endif
#ifndef THUMB_LE_BREAKPOINT
#define THUMB_LE_BREAKPOINT {0xfe,0xdf}
#endif
#ifndef THUMB_BE_BREAKPOINT
#define THUMB_BE_BREAKPOINT {0xdf,0xfe}
#endif
static const char arm_default_arm_le_breakpoint[] = ARM_LE_BREAKPOINT;
static const char arm_default_arm_be_breakpoint[] = ARM_BE_BREAKPOINT;
static const char arm_default_thumb_le_breakpoint[] = THUMB_LE_BREAKPOINT;
static const char arm_default_thumb_be_breakpoint[] = THUMB_BE_BREAKPOINT;
static const unsigned char *
arm_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
if (arm_pc_is_thumb (*pcptr) || arm_pc_is_thumb_dummy (*pcptr))
{
*pcptr = UNMAKE_THUMB_ADDR (*pcptr);
*lenptr = tdep->thumb_breakpoint_size;
return tdep->thumb_breakpoint;
}
else
{
*lenptr = tdep->arm_breakpoint_size;
return tdep->arm_breakpoint;
}
}
static void
arm_extract_return_value (struct type *type,
char regbuf[REGISTER_BYTES],
char *valbuf)
{
if (TYPE_CODE_FLT == TYPE_CODE (type))
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
switch (tdep->fp_model)
{
case ARM_FLOAT_FPA:
convert_from_extended (®buf[REGISTER_BYTE (ARM_F0_REGNUM)],
valbuf);
break;
case ARM_FLOAT_SOFT:
case ARM_FLOAT_SOFT_VFP:
memcpy (valbuf, ®buf[REGISTER_BYTE (ARM_A1_REGNUM)],
TYPE_LENGTH (type));
break;
default:
internal_error
(__FILE__, __LINE__,
"arm_extract_return_value: Floating point model not supported");
break;
}
}
else
memcpy (valbuf, ®buf[REGISTER_BYTE (ARM_A1_REGNUM)],
TYPE_LENGTH (type));
}
static CORE_ADDR
arm_extract_struct_value_address (struct regcache *regcache)
{
ULONGEST ret;
regcache_cooked_read_unsigned (regcache, ARM_A1_REGNUM, &ret);
return ret;
}
static int
arm_use_struct_convention (int gcc_p, struct type *type)
{
int nRc;
register enum type_code code;
if (TYPE_LENGTH (type) > REGISTER_SIZE)
{
return 1;
}
code = TYPE_CODE (type);
if ((TYPE_CODE_STRUCT != code) && (TYPE_CODE_UNION != code))
{
return 1;
}
nRc = 0;
if ((TYPE_CODE_STRUCT == code) || (TYPE_CODE_UNION == code))
{
int i;
for (i = 0; i < TYPE_NFIELDS (type); i++)
{
enum type_code field_type_code;
field_type_code = TYPE_CODE (TYPE_FIELD_TYPE (type, i));
if (field_type_code == TYPE_CODE_FLT)
{
nRc = 1;
break;
}
if (TYPE_FIELD_BITPOS (type, i) != 0)
{
if (TYPE_FIELD_BITSIZE (type, i) == 0)
{
nRc = 1;
break;
}
}
}
}
return nRc;
}
static void
arm_store_return_value (struct type *type, char *valbuf)
{
if (TYPE_CODE (type) == TYPE_CODE_FLT)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
char buf[ARM_MAX_REGISTER_RAW_SIZE];
switch (tdep->fp_model)
{
case ARM_FLOAT_FPA:
convert_to_extended (valbuf, buf);
write_register_bytes (REGISTER_BYTE (ARM_F0_REGNUM), buf,
FP_REGISTER_RAW_SIZE);
break;
case ARM_FLOAT_SOFT:
case ARM_FLOAT_SOFT_VFP:
write_register_bytes (ARM_A1_REGNUM, valbuf, TYPE_LENGTH (type));
break;
default:
internal_error
(__FILE__, __LINE__,
"arm_store_return_value: Floating point model not supported");
break;
}
}
else
write_register_bytes (ARM_A1_REGNUM, valbuf, TYPE_LENGTH (type));
}
static void
arm_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
{
write_register (ARM_A1_REGNUM, addr);
}
static int
arm_get_longjmp_target (CORE_ADDR *pc)
{
CORE_ADDR jb_addr;
char buf[INT_REGISTER_RAW_SIZE];
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
jb_addr = read_register (ARM_A1_REGNUM);
if (target_read_memory (jb_addr + tdep->jb_pc * tdep->jb_elt_size, buf,
INT_REGISTER_RAW_SIZE))
return 0;
*pc = extract_address (buf, INT_REGISTER_RAW_SIZE);
return 1;
}
int
arm_in_call_stub (CORE_ADDR pc, char *name)
{
CORE_ADDR start_addr;
if (0 == find_pc_partial_function (pc, name ? NULL : &name,
&start_addr, NULL))
return 0;
return strncmp (name, "_call_via_r", 11) == 0;
}
CORE_ADDR
arm_skip_stub (CORE_ADDR pc)
{
char *name;
CORE_ADDR start_addr;
if (find_pc_partial_function (pc, &name, &start_addr, NULL) == 0)
return 0;
if (strncmp (name, "_call_via_", 10) == 0)
{
static char *table[15] =
{"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
"r8", "r9", "sl", "fp", "ip", "sp", "lr"
};
int regno;
for (regno = 0; regno <= 14; regno++)
if (strcmp (&name[10], table[regno]) == 0)
return read_register (regno);
}
return 0;
}
static void
set_disassembly_flavor_sfunc (char *args, int from_tty,
struct cmd_list_element *c)
{
set_disassembly_flavor ();
}
static const char *
arm_register_name (int i)
{
return arm_register_names[i];
}
static void
set_disassembly_flavor (void)
{
const char *setname, *setdesc, **regnames;
int numregs, j;
int current = 0;
numregs = get_arm_regnames (current, &setname, &setdesc, ®names);
while ((disassembly_flavor != setname)
&& (current < num_flavor_options))
get_arm_regnames (++current, &setname, &setdesc, ®names);
current_option = current;
for (j = 0; j < numregs; j++)
arm_register_names[j] = (char *) regnames[j];
if (isupper (*regnames[ARM_PC_REGNUM]))
{
arm_register_names[ARM_FPS_REGNUM] = "FPS";
arm_register_names[ARM_PS_REGNUM] = "CPSR";
}
else
{
arm_register_names[ARM_FPS_REGNUM] = "fps";
arm_register_names[ARM_PS_REGNUM] = "cpsr";
}
set_arm_regname_option (current);
}
static void
arm_othernames (char *names, int n)
{
current_option = (current_option + 1) % num_flavor_options;
disassembly_flavor = valid_flavors[current_option];
set_disassembly_flavor ();
}
struct link_map_offsets *
arm_linux_svr4_fetch_link_map_offsets (void)
{
static struct link_map_offsets lmo;
static struct link_map_offsets *lmp = 0;
if (lmp == 0)
{
lmp = &lmo;
lmo.r_debug_size = 8;
lmo.r_map_offset = 4;
lmo.r_map_size = 4;
lmo.link_map_size = 20;
lmo.l_addr_offset = 0;
lmo.l_addr_size = 4;
lmo.l_name_offset = 4;
lmo.l_name_size = 4;
lmo.l_next_offset = 12;
lmo.l_next_size = 4;
lmo.l_prev_offset = 16;
lmo.l_prev_size = 4;
}
return lmp;
}
static int
coff_sym_is_thumb (int val)
{
return (val == C_THUMBEXT ||
val == C_THUMBSTAT ||
val == C_THUMBEXTFUNC ||
val == C_THUMBSTATFUNC ||
val == C_THUMBLABEL);
}
static void
arm_elf_make_msymbol_special(asymbol *sym, struct minimal_symbol *msym)
{
if (ELF_ST_TYPE (((elf_symbol_type *)sym)->internal_elf_sym.st_info)
== STT_LOPROC)
MSYMBOL_SET_SPECIAL (msym);
}
static void
arm_coff_make_msymbol_special(int val, struct minimal_symbol *msym)
{
if (coff_sym_is_thumb (val))
MSYMBOL_SET_SPECIAL (msym);
}
static enum gdb_osabi
arm_elf_osabi_sniffer (bfd *abfd)
{
unsigned int elfosabi, eflags;
enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
elfosabi = elf_elfheader (abfd)->e_ident[EI_OSABI];
switch (elfosabi)
{
case ELFOSABI_NONE:
bfd_map_over_sections (abfd,
generic_elf_osabi_sniff_abi_tag_sections,
&osabi);
if (osabi == GDB_OSABI_UNKNOWN)
{
eflags = EF_ARM_EABI_VERSION(elf_elfheader(abfd)->e_flags);
switch (eflags)
{
case EF_ARM_EABI_VER1:
osabi = GDB_OSABI_ARM_EABI_V1;
break;
case EF_ARM_EABI_VER2:
osabi = GDB_OSABI_ARM_EABI_V2;
break;
case EF_ARM_EABI_UNKNOWN:
osabi = GDB_OSABI_ARM_APCS;
break;
default:
internal_error (__FILE__, __LINE__,
"arm_elf_osabi_sniffer: Unknown ARM EABI "
"version 0x%x", eflags);
}
}
break;
case ELFOSABI_ARM:
bfd_map_over_sections (abfd,
generic_elf_osabi_sniff_abi_tag_sections,
&osabi);
if (osabi == GDB_OSABI_UNKNOWN)
{
osabi = GDB_OSABI_ARM_APCS;
}
break;
case ELFOSABI_FREEBSD:
osabi = GDB_OSABI_FREEBSD_ELF;
break;
case ELFOSABI_NETBSD:
osabi = GDB_OSABI_NETBSD_ELF;
break;
case ELFOSABI_LINUX:
osabi = GDB_OSABI_LINUX;
break;
}
return osabi;
}
static struct gdbarch *
arm_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
{
struct gdbarch_tdep *tdep;
struct gdbarch *gdbarch;
enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
if (info.abfd != NULL)
{
osabi = gdbarch_lookup_osabi (info.abfd);
if (osabi == GDB_OSABI_UNKNOWN)
{
switch (bfd_get_flavour (info.abfd))
{
case bfd_target_aout_flavour:
osabi = GDB_OSABI_ARM_APCS;
break;
case bfd_target_coff_flavour:
osabi = GDB_OSABI_ARM_APCS;
break;
default:
}
}
}
for (arches = gdbarch_list_lookup_by_info (arches, &info);
arches != NULL;
arches = gdbarch_list_lookup_by_info (arches->next, &info))
{
tdep = gdbarch_tdep (arches->gdbarch);
if (tdep && tdep->osabi == osabi)
return arches->gdbarch;
}
tdep = xmalloc (sizeof (struct gdbarch_tdep));
gdbarch = gdbarch_alloc (&info, tdep);
tdep->osabi = osabi;
tdep->fp_model = ARM_FLOAT_FPA;
switch (info.byte_order)
{
case BFD_ENDIAN_BIG:
tdep->arm_breakpoint = arm_default_arm_be_breakpoint;
tdep->arm_breakpoint_size = sizeof (arm_default_arm_be_breakpoint);
tdep->thumb_breakpoint = arm_default_thumb_be_breakpoint;
tdep->thumb_breakpoint_size = sizeof (arm_default_thumb_be_breakpoint);
break;
case BFD_ENDIAN_LITTLE:
tdep->arm_breakpoint = arm_default_arm_le_breakpoint;
tdep->arm_breakpoint_size = sizeof (arm_default_arm_le_breakpoint);
tdep->thumb_breakpoint = arm_default_thumb_le_breakpoint;
tdep->thumb_breakpoint_size = sizeof (arm_default_thumb_le_breakpoint);
break;
default:
internal_error (__FILE__, __LINE__,
"arm_gdbarch_init: bad byte order for float format");
}
set_gdbarch_char_signed (gdbarch, 0);
tdep->lowest_pc = 0x20;
tdep->jb_pc = -1;
#if OLD_STYLE_ARM_DUMMY_FRAMES
set_gdbarch_use_generic_dummy_frames (gdbarch, 0);
set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 8);
set_gdbarch_call_dummy_p (gdbarch, 1);
set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
set_gdbarch_call_dummy_words (gdbarch, arm_call_dummy_words);
set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (arm_call_dummy_words));
set_gdbarch_call_dummy_start_offset (gdbarch, 0);
set_gdbarch_call_dummy_length (gdbarch, 0);
set_gdbarch_fix_call_dummy (gdbarch, arm_fix_call_dummy);
set_gdbarch_pc_in_call_dummy (gdbarch, pc_in_call_dummy_on_stack);
#else
set_gdbarch_use_generic_dummy_frames (gdbarch, 1);
set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
set_gdbarch_call_dummy_p (gdbarch, 1);
set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
set_gdbarch_call_dummy_words (gdbarch, arm_call_dummy_words);
set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
set_gdbarch_call_dummy_start_offset (gdbarch, 0);
set_gdbarch_call_dummy_length (gdbarch, 0);
set_gdbarch_fix_call_dummy (gdbarch, generic_fix_call_dummy);
set_gdbarch_pc_in_call_dummy (gdbarch, generic_pc_in_call_dummy);
set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
set_gdbarch_push_return_address (gdbarch, arm_push_return_address);
#endif
set_gdbarch_get_saved_register (gdbarch, generic_get_saved_register);
set_gdbarch_push_arguments (gdbarch, arm_push_arguments);
set_gdbarch_coerce_float_to_double (gdbarch,
standard_coerce_float_to_double);
set_gdbarch_frame_chain_valid (gdbarch, arm_frame_chain_valid);
set_gdbarch_init_extra_frame_info (gdbarch, arm_init_extra_frame_info);
set_gdbarch_read_fp (gdbarch, arm_read_fp);
set_gdbarch_frame_chain (gdbarch, arm_frame_chain);
set_gdbarch_frameless_function_invocation
(gdbarch, arm_frameless_function_invocation);
set_gdbarch_frame_saved_pc (gdbarch, arm_frame_saved_pc);
set_gdbarch_frame_args_address (gdbarch, arm_frame_args_address);
set_gdbarch_frame_locals_address (gdbarch, arm_frame_locals_address);
set_gdbarch_frame_num_args (gdbarch, arm_frame_num_args);
set_gdbarch_frame_args_skip (gdbarch, 0);
set_gdbarch_frame_init_saved_regs (gdbarch, arm_frame_init_saved_regs);
#if OLD_STYLE_ARM_DUMMY_FRAMES
set_gdbarch_push_dummy_frame (gdbarch, arm_push_dummy_frame);
#else
set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame);
#endif
set_gdbarch_pop_frame (gdbarch, arm_pop_frame);
set_gdbarch_smash_text_address (gdbarch, arm_smash_text_address);
set_gdbarch_addr_bits_remove (gdbarch, arm_addr_bits_remove);
set_gdbarch_function_start_offset (gdbarch, 0);
set_gdbarch_skip_prologue (gdbarch, arm_skip_prologue);
set_gdbarch_saved_pc_after_call (gdbarch, arm_saved_pc_after_call);
set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
set_gdbarch_breakpoint_from_pc (gdbarch, arm_breakpoint_from_pc);
set_gdbarch_decr_pc_after_break (gdbarch, 0);
set_gdbarch_print_float_info (gdbarch, arm_print_float_info);
set_gdbarch_fp_regnum (gdbarch, ARM_FP_REGNUM);
set_gdbarch_sp_regnum (gdbarch, ARM_SP_REGNUM);
set_gdbarch_pc_regnum (gdbarch, ARM_PC_REGNUM);
set_gdbarch_register_byte (gdbarch, arm_register_byte);
set_gdbarch_register_bytes (gdbarch,
(NUM_GREGS * INT_REGISTER_RAW_SIZE
+ NUM_FREGS * FP_REGISTER_RAW_SIZE
+ NUM_SREGS * STATUS_REGISTER_SIZE));
set_gdbarch_num_regs (gdbarch, NUM_GREGS + NUM_FREGS + NUM_SREGS);
set_gdbarch_register_raw_size (gdbarch, arm_register_raw_size);
set_gdbarch_register_virtual_size (gdbarch, arm_register_virtual_size);
set_gdbarch_max_register_raw_size (gdbarch, FP_REGISTER_RAW_SIZE);
set_gdbarch_max_register_virtual_size (gdbarch, FP_REGISTER_VIRTUAL_SIZE);
set_gdbarch_register_virtual_type (gdbarch, arm_register_type);
set_gdbarch_register_sim_regno (gdbarch, arm_register_sim_regno);
set_gdbarch_register_size (gdbarch, 4);
set_gdbarch_register_name (gdbarch, arm_register_name);
set_gdbarch_deprecated_extract_return_value (gdbarch, arm_extract_return_value);
set_gdbarch_deprecated_store_return_value (gdbarch, arm_store_return_value);
set_gdbarch_store_struct_return (gdbarch, arm_store_struct_return);
set_gdbarch_use_struct_convention (gdbarch, arm_use_struct_convention);
set_gdbarch_extract_struct_value_address (gdbarch,
arm_extract_struct_value_address);
set_gdbarch_software_single_step (gdbarch, arm_software_single_step);
set_gdbarch_elf_make_msymbol_special (gdbarch, arm_elf_make_msymbol_special);
set_gdbarch_coff_make_msymbol_special (gdbarch,
arm_coff_make_msymbol_special);
gdbarch_init_osabi (info, gdbarch, osabi);
if (tdep->jb_pc >= 0)
set_gdbarch_get_longjmp_target (gdbarch, arm_get_longjmp_target);
switch (info.byte_order)
{
case BFD_ENDIAN_BIG:
set_gdbarch_float_format (gdbarch, &floatformat_ieee_single_big);
set_gdbarch_double_format (gdbarch, &floatformat_ieee_double_big);
set_gdbarch_long_double_format (gdbarch, &floatformat_ieee_double_big);
break;
case BFD_ENDIAN_LITTLE:
set_gdbarch_float_format (gdbarch, &floatformat_ieee_single_little);
if (tdep->fp_model == ARM_FLOAT_VFP
|| tdep->fp_model == ARM_FLOAT_SOFT_VFP)
{
set_gdbarch_double_format (gdbarch, &floatformat_ieee_double_little);
set_gdbarch_long_double_format (gdbarch,
&floatformat_ieee_double_little);
}
else
{
set_gdbarch_double_format
(gdbarch, &floatformat_ieee_double_littlebyte_bigword);
set_gdbarch_long_double_format
(gdbarch, &floatformat_ieee_double_littlebyte_bigword);
}
break;
default:
internal_error (__FILE__, __LINE__,
"arm_gdbarch_init: bad byte order for float format");
}
if (prologue_cache.saved_regs != NULL)
xfree (prologue_cache.saved_regs);
prologue_cache.saved_regs = (CORE_ADDR *)
xcalloc (1, (sizeof (CORE_ADDR)
* (gdbarch_num_regs (gdbarch)
+ gdbarch_num_pseudo_regs (gdbarch))));
return gdbarch;
}
static void
arm_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
if (tdep == NULL)
return;
fprintf_unfiltered (file, "arm_dump_tdep: OS ABI = %s\n",
gdbarch_osabi_name (tdep->osabi));
fprintf_unfiltered (file, "arm_dump_tdep: Lowest pc = 0x%lx",
(unsigned long) tdep->lowest_pc);
}
static void
arm_init_abi_eabi_v1 (struct gdbarch_info info,
struct gdbarch *gdbarch)
{
}
static void
arm_init_abi_eabi_v2 (struct gdbarch_info info,
struct gdbarch *gdbarch)
{
}
static void
arm_init_abi_apcs (struct gdbarch_info info,
struct gdbarch *gdbarch)
{
}
void
_initialize_arm_tdep (void)
{
struct ui_file *stb;
long length;
struct cmd_list_element *new_cmd;
const char *setname;
const char *setdesc;
const char **regnames;
int numregs, i, j;
static char *helptext;
if (GDB_MULTI_ARCH)
gdbarch_register (bfd_arch_arm, arm_gdbarch_init, arm_dump_tdep);
gdbarch_register_osabi_sniffer (bfd_arch_arm,
bfd_target_elf_flavour,
arm_elf_osabi_sniffer);
gdbarch_register_osabi (bfd_arch_arm, GDB_OSABI_ARM_EABI_V1,
arm_init_abi_eabi_v1);
gdbarch_register_osabi (bfd_arch_arm, GDB_OSABI_ARM_EABI_V2,
arm_init_abi_eabi_v2);
gdbarch_register_osabi (bfd_arch_arm, GDB_OSABI_ARM_APCS,
arm_init_abi_apcs);
tm_print_insn = gdb_print_insn_arm;
num_flavor_options = get_arm_regname_num_options ();
parse_arm_disassembler_option ("reg-names-std");
stb = mem_fileopen ();
fprintf_unfiltered (stb, "Set the disassembly flavor.\n\
The valid values are:\n");
valid_flavors = xmalloc ((num_flavor_options + 1) * sizeof (char *));
for (i = 0; i < num_flavor_options; i++)
{
numregs = get_arm_regnames (i, &setname, &setdesc, ®names);
valid_flavors[i] = setname;
fprintf_unfiltered (stb, "%s - %s\n", setname,
setdesc);
if (!strcmp (setname, "std"))
{
disassembly_flavor = setname;
current_option = i;
for (j = 0; j < numregs; j++)
arm_register_names[j] = (char *) regnames[j];
set_arm_regname_option (i);
}
}
valid_flavors[num_flavor_options] = NULL;
fprintf_unfiltered (stb, "The default is \"std\".");
helptext = ui_file_xstrdup (stb, &length);
ui_file_delete (stb);
new_cmd = add_set_enum_cmd ("disassembly-flavor", no_class,
valid_flavors,
&disassembly_flavor,
helptext,
&setlist);
set_cmd_sfunc (new_cmd, set_disassembly_flavor_sfunc);
add_show_from_set (new_cmd, &showlist);
add_show_from_set (add_set_cmd ("apcs32", no_class,
var_zinteger, (char *) &arm_apcs_32,
"Set usage of ARM 32-bit mode.\n", &setlist),
&showlist);
add_com ("othernames", class_obscure, arm_othernames,
"Switch to the next set of register names.");
prologue_cache.saved_regs = NULL;
prologue_cache.extra_info = (struct frame_extra_info *)
xcalloc (1, sizeof (struct frame_extra_info));
add_show_from_set (add_set_cmd ("arm", class_maintenance, var_zinteger,
&arm_debug, "Set arm debugging.\n\
When non-zero, arm specific debugging is enabled.", &setdebuglist),
&showdebuglist);
}