1 /* Common target dependent code for GDB on ARM systems.
3 Copyright (C) 1988, 1989, 1991, 1992, 1993, 1995, 1996, 1998, 1999, 2000,
4 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
23 #include <ctype.h> /* XXX for isupper () */
30 #include "gdb_string.h"
31 #include "dis-asm.h" /* For register styles. */
35 #include "arch-utils.h"
37 #include "frame-unwind.h"
38 #include "frame-base.h"
39 #include "trad-frame.h"
41 #include "dwarf2-frame.h"
43 #include "prologue-value.h"
46 #include "gdb/sim-arm.h"
49 #include "coff/internal.h"
52 #include "gdb_assert.h"
56 /* Macros for setting and testing a bit in a minimal symbol that marks
57 it as Thumb function. The MSB of the minimal symbol's "info" field
58 is used for this purpose.
60 MSYMBOL_SET_SPECIAL Actually sets the "special" bit.
61 MSYMBOL_IS_SPECIAL Tests the "special" bit in a minimal symbol. */
63 #define MSYMBOL_SET_SPECIAL(msym) \
64 MSYMBOL_INFO (msym) = (char *) (((long) MSYMBOL_INFO (msym)) \
67 #define MSYMBOL_IS_SPECIAL(msym) \
68 (((long) MSYMBOL_INFO (msym) & 0x80000000) != 0)
70 /* The list of available "set arm ..." and "show arm ..." commands. */
71 static struct cmd_list_element
*setarmcmdlist
= NULL
;
72 static struct cmd_list_element
*showarmcmdlist
= NULL
;
74 /* The type of floating-point to use. Keep this in sync with enum
75 arm_float_model, and the help string in _initialize_arm_tdep. */
76 static const char *fp_model_strings
[] =
86 /* A variable that can be configured by the user. */
87 static enum arm_float_model arm_fp_model
= ARM_FLOAT_AUTO
;
88 static const char *current_fp_model
= "auto";
90 /* The ABI to use. Keep this in sync with arm_abi_kind. */
91 static const char *arm_abi_strings
[] =
99 /* A variable that can be configured by the user. */
100 static enum arm_abi_kind arm_abi_global
= ARM_ABI_AUTO
;
101 static const char *arm_abi_string
= "auto";
103 /* Number of different reg name sets (options). */
104 static int num_disassembly_options
;
106 /* We have more registers than the disassembler as gdb can print the value
107 of special registers as well.
108 The general register names are overwritten by whatever is being used by
109 the disassembler at the moment. We also adjust the case of cpsr and fps. */
111 /* Initial value: Register names used in ARM's ISA documentation. */
112 static char * arm_register_name_strings
[] =
113 {"r0", "r1", "r2", "r3", /* 0 1 2 3 */
114 "r4", "r5", "r6", "r7", /* 4 5 6 7 */
115 "r8", "r9", "r10", "r11", /* 8 9 10 11 */
116 "r12", "sp", "lr", "pc", /* 12 13 14 15 */
117 "f0", "f1", "f2", "f3", /* 16 17 18 19 */
118 "f4", "f5", "f6", "f7", /* 20 21 22 23 */
119 "fps", "cpsr" }; /* 24 25 */
120 static char **arm_register_names
= arm_register_name_strings
;
122 /* Valid register name styles. */
123 static const char **valid_disassembly_styles
;
125 /* Disassembly style to use. Default to "std" register names. */
126 static const char *disassembly_style
;
127 /* Index to that option in the opcodes table. */
128 static int current_option
;
130 /* This is used to keep the bfd arch_info in sync with the disassembly
132 static void set_disassembly_style_sfunc(char *, int,
133 struct cmd_list_element
*);
134 static void set_disassembly_style (void);
136 static void convert_from_extended (const struct floatformat
*, const void *,
138 static void convert_to_extended (const struct floatformat
*, void *,
141 struct arm_prologue_cache
143 /* The stack pointer at the time this frame was created; i.e. the
144 caller's stack pointer when this function was called. It is used
145 to identify this frame. */
148 /* The frame base for this frame is just prev_sp + frame offset -
149 frame size. FRAMESIZE is the size of this stack frame, and
150 FRAMEOFFSET if the initial offset from the stack pointer (this
151 frame's stack pointer, not PREV_SP) to the frame base. */
156 /* The register used to hold the frame pointer for this frame. */
159 /* Saved register offsets. */
160 struct trad_frame_saved_reg
*saved_regs
;
163 /* Addresses for calling Thumb functions have the bit 0 set.
164 Here are some macros to test, set, or clear bit 0 of addresses. */
165 #define IS_THUMB_ADDR(addr) ((addr) & 1)
166 #define MAKE_THUMB_ADDR(addr) ((addr) | 1)
167 #define UNMAKE_THUMB_ADDR(addr) ((addr) & ~1)
169 /* Set to true if the 32-bit mode is in use. */
173 /* Determine if the program counter specified in MEMADDR is in a Thumb
177 arm_pc_is_thumb (CORE_ADDR memaddr
)
179 struct minimal_symbol
*sym
;
181 /* If bit 0 of the address is set, assume this is a Thumb address. */
182 if (IS_THUMB_ADDR (memaddr
))
185 /* Thumb functions have a "special" bit set in minimal symbols. */
186 sym
= lookup_minimal_symbol_by_pc (memaddr
);
189 return (MSYMBOL_IS_SPECIAL (sym
));
197 /* Remove useless bits from addresses in a running program. */
199 arm_addr_bits_remove (CORE_ADDR val
)
202 return (val
& (arm_pc_is_thumb (val
) ? 0xfffffffe : 0xfffffffc));
204 return (val
& 0x03fffffc);
207 /* When reading symbols, we need to zap the low bit of the address,
208 which may be set to 1 for Thumb functions. */
210 arm_smash_text_address (CORE_ADDR val
)
215 /* Analyze a Thumb prologue, looking for a recognizable stack frame
216 and frame pointer. Scan until we encounter a store that could
217 clobber the stack frame unexpectedly, or an unknown instruction. */
220 thumb_analyze_prologue (struct gdbarch
*gdbarch
,
221 CORE_ADDR start
, CORE_ADDR limit
,
222 struct arm_prologue_cache
*cache
)
226 struct pv_area
*stack
;
227 struct cleanup
*back_to
;
230 for (i
= 0; i
< 16; i
++)
231 regs
[i
] = pv_register (i
, 0);
232 stack
= make_pv_area (ARM_SP_REGNUM
);
233 back_to
= make_cleanup_free_pv_area (stack
);
235 /* The call instruction saved PC in LR, and the current PC is not
236 interesting. Due to this file's conventions, we want the value
237 of LR at this function's entry, not at the call site, so we do
238 not record the save of the PC - when the ARM prologue analyzer
239 has also been converted to the pv mechanism, we could record the
240 save here and remove the hack in prev_register. */
241 regs
[ARM_PC_REGNUM
] = pv_unknown ();
243 while (start
< limit
)
247 insn
= read_memory_unsigned_integer (start
, 2);
249 if ((insn
& 0xfe00) == 0xb400) /* push { rlist } */
255 /* Bits 0-7 contain a mask for registers R0-R7. Bit 8 says
256 whether to save LR (R14). */
257 mask
= (insn
& 0xff) | ((insn
& 0x100) << 6);
259 /* Calculate offsets of saved R0-R7 and LR. */
260 for (regno
= ARM_LR_REGNUM
; regno
>= 0; regno
--)
261 if (mask
& (1 << regno
))
263 if (pv_area_store_would_trash (stack
, regs
[ARM_SP_REGNUM
]))
269 regs
[ARM_SP_REGNUM
] = pv_add_constant (regs
[ARM_SP_REGNUM
],
271 pv_area_store (stack
, regs
[ARM_SP_REGNUM
], 4, regs
[regno
]);
277 else if ((insn
& 0xff00) == 0xb000) /* add sp, #simm OR
280 offset
= (insn
& 0x7f) << 2; /* get scaled offset */
281 if (insn
& 0x80) /* Check for SUB. */
282 regs
[ARM_SP_REGNUM
] = pv_add_constant (regs
[ARM_SP_REGNUM
],
285 regs
[ARM_SP_REGNUM
] = pv_add_constant (regs
[ARM_SP_REGNUM
],
288 else if ((insn
& 0xff00) == 0xaf00) /* add r7, sp, #imm */
289 regs
[THUMB_FP_REGNUM
] = pv_add_constant (regs
[ARM_SP_REGNUM
],
291 else if ((insn
& 0xff00) == 0x4600) /* mov hi, lo or mov lo, hi */
293 int dst_reg
= (insn
& 0x7) + ((insn
& 0x80) >> 4);
294 int src_reg
= (insn
& 0x78) >> 3;
295 regs
[dst_reg
] = regs
[src_reg
];
297 else if ((insn
& 0xf800) == 0x9000) /* str rd, [sp, #off] */
299 /* Handle stores to the stack. Normally pushes are used,
300 but with GCC -mtpcs-frame, there may be other stores
301 in the prologue to create the frame. */
302 int regno
= (insn
>> 8) & 0x7;
305 offset
= (insn
& 0xff) << 2;
306 addr
= pv_add_constant (regs
[ARM_SP_REGNUM
], offset
);
308 if (pv_area_store_would_trash (stack
, addr
))
311 pv_area_store (stack
, addr
, 4, regs
[regno
]);
315 /* We don't know what this instruction is. We're finished
316 scanning. NOTE: Recognizing more safe-to-ignore
317 instructions here will improve support for optimized
327 do_cleanups (back_to
);
331 /* frameoffset is unused for this unwinder. */
332 cache
->frameoffset
= 0;
334 if (pv_is_register (regs
[ARM_FP_REGNUM
], ARM_SP_REGNUM
))
336 /* Frame pointer is fp. Frame size is constant. */
337 cache
->framereg
= ARM_FP_REGNUM
;
338 cache
->framesize
= -regs
[ARM_FP_REGNUM
].k
;
340 else if (pv_is_register (regs
[THUMB_FP_REGNUM
], ARM_SP_REGNUM
))
342 /* Frame pointer is r7. Frame size is constant. */
343 cache
->framereg
= THUMB_FP_REGNUM
;
344 cache
->framesize
= -regs
[THUMB_FP_REGNUM
].k
;
346 else if (pv_is_register (regs
[ARM_SP_REGNUM
], ARM_SP_REGNUM
))
348 /* Try the stack pointer... this is a bit desperate. */
349 cache
->framereg
= ARM_SP_REGNUM
;
350 cache
->framesize
= -regs
[ARM_SP_REGNUM
].k
;
354 /* We're just out of luck. We don't know where the frame is. */
355 cache
->framereg
= -1;
356 cache
->framesize
= 0;
359 for (i
= 0; i
< 16; i
++)
360 if (pv_area_find_reg (stack
, gdbarch
, i
, &offset
))
361 cache
->saved_regs
[i
].addr
= offset
;
363 do_cleanups (back_to
);
367 /* Advance the PC across any function entry prologue instructions to
368 reach some "real" code.
370 The APCS (ARM Procedure Call Standard) defines the following
374 [stmfd sp!, {a1,a2,a3,a4}]
375 stmfd sp!, {...,fp,ip,lr,pc}
376 [stfe f7, [sp, #-12]!]
377 [stfe f6, [sp, #-12]!]
378 [stfe f5, [sp, #-12]!]
379 [stfe f4, [sp, #-12]!]
380 sub fp, ip, #nn @@ nn == 20 or 4 depending on second insn */
383 arm_skip_prologue (CORE_ADDR pc
)
387 CORE_ADDR func_addr
, func_end
= 0;
389 struct symtab_and_line sal
;
391 /* If we're in a dummy frame, don't even try to skip the prologue. */
392 if (deprecated_pc_in_call_dummy (pc
))
395 /* See what the symbol table says. */
397 if (find_pc_partial_function (pc
, &func_name
, &func_addr
, &func_end
))
401 /* Found a function. */
402 sym
= lookup_symbol (func_name
, NULL
, VAR_DOMAIN
, NULL
, NULL
);
403 if (sym
&& SYMBOL_LANGUAGE (sym
) != language_asm
)
405 /* Don't use this trick for assembly source files. */
406 sal
= find_pc_line (func_addr
, 0);
407 if ((sal
.line
!= 0) && (sal
.end
< func_end
))
412 /* Can't find the prologue end in the symbol table, try it the hard way
413 by disassembling the instructions. */
415 /* Like arm_scan_prologue, stop no later than pc + 64. */
416 if (func_end
== 0 || func_end
> pc
+ 64)
419 /* Check if this is Thumb code. */
420 if (arm_pc_is_thumb (pc
))
421 return thumb_analyze_prologue (current_gdbarch
, pc
, func_end
, NULL
);
423 for (skip_pc
= pc
; skip_pc
< func_end
; skip_pc
+= 4)
425 inst
= read_memory_unsigned_integer (skip_pc
, 4);
427 /* "mov ip, sp" is no longer a required part of the prologue. */
428 if (inst
== 0xe1a0c00d) /* mov ip, sp */
431 if ((inst
& 0xfffff000) == 0xe28dc000) /* add ip, sp #n */
434 if ((inst
& 0xfffff000) == 0xe24dc000) /* sub ip, sp #n */
437 /* Some prologues begin with "str lr, [sp, #-4]!". */
438 if (inst
== 0xe52de004) /* str lr, [sp, #-4]! */
441 if ((inst
& 0xfffffff0) == 0xe92d0000) /* stmfd sp!,{a1,a2,a3,a4} */
444 if ((inst
& 0xfffff800) == 0xe92dd800) /* stmfd sp!,{fp,ip,lr,pc} */
447 /* Any insns after this point may float into the code, if it makes
448 for better instruction scheduling, so we skip them only if we
449 find them, but still consider the function to be frame-ful. */
451 /* We may have either one sfmfd instruction here, or several stfe
452 insns, depending on the version of floating point code we
454 if ((inst
& 0xffbf0fff) == 0xec2d0200) /* sfmfd fn, <cnt>, [sp]! */
457 if ((inst
& 0xffff8fff) == 0xed6d0103) /* stfe fn, [sp, #-12]! */
460 if ((inst
& 0xfffff000) == 0xe24cb000) /* sub fp, ip, #nn */
463 if ((inst
& 0xfffff000) == 0xe24dd000) /* sub sp, sp, #nn */
466 if ((inst
& 0xffffc000) == 0xe54b0000 || /* strb r(0123),[r11,#-nn] */
467 (inst
& 0xffffc0f0) == 0xe14b00b0 || /* strh r(0123),[r11,#-nn] */
468 (inst
& 0xffffc000) == 0xe50b0000) /* str r(0123),[r11,#-nn] */
471 if ((inst
& 0xffffc000) == 0xe5cd0000 || /* strb r(0123),[sp,#nn] */
472 (inst
& 0xffffc0f0) == 0xe1cd00b0 || /* strh r(0123),[sp,#nn] */
473 (inst
& 0xffffc000) == 0xe58d0000) /* str r(0123),[sp,#nn] */
476 /* Un-recognized instruction; stop scanning. */
480 return skip_pc
; /* End of prologue */
484 /* Function: thumb_scan_prologue (helper function for arm_scan_prologue)
485 This function decodes a Thumb function prologue to determine:
486 1) the size of the stack frame
487 2) which registers are saved on it
488 3) the offsets of saved regs
489 4) the offset from the stack pointer to the frame pointer
491 A typical Thumb function prologue would create this stack frame
492 (offsets relative to FP)
493 old SP -> 24 stack parameters
496 R7 -> 0 local variables (16 bytes)
497 SP -> -12 additional stack space (12 bytes)
498 The frame size would thus be 36 bytes, and the frame offset would be
499 12 bytes. The frame register is R7.
501 The comments for thumb_skip_prolog() describe the algorithm we use
502 to detect the end of the prolog. */
506 thumb_scan_prologue (CORE_ADDR prev_pc
, struct arm_prologue_cache
*cache
)
508 CORE_ADDR prologue_start
;
509 CORE_ADDR prologue_end
;
510 CORE_ADDR current_pc
;
511 /* Which register has been copied to register n? */
514 bit 0 - push { rlist }
515 bit 1 - mov r7, sp OR add r7, sp, #imm (setting of r7)
516 bit 2 - sub sp, #simm OR add sp, #simm (adjusting of sp)
521 if (find_pc_partial_function (prev_pc
, NULL
, &prologue_start
, &prologue_end
))
523 struct symtab_and_line sal
= find_pc_line (prologue_start
, 0);
525 if (sal
.line
== 0) /* no line info, use current PC */
526 prologue_end
= prev_pc
;
527 else if (sal
.end
< prologue_end
) /* next line begins after fn end */
528 prologue_end
= sal
.end
; /* (probably means no prologue) */
531 /* We're in the boondocks: we have no idea where the start of the
535 prologue_end
= min (prologue_end
, prev_pc
);
537 thumb_analyze_prologue (current_gdbarch
, prologue_start
, prologue_end
,
541 /* This function decodes an ARM function prologue to determine:
542 1) the size of the stack frame
543 2) which registers are saved on it
544 3) the offsets of saved regs
545 4) the offset from the stack pointer to the frame pointer
546 This information is stored in the "extra" fields of the frame_info.
548 There are two basic forms for the ARM prologue. The fixed argument
549 function call will look like:
552 stmfd sp!, {fp, ip, lr, pc}
556 Which would create this stack frame (offsets relative to FP):
557 IP -> 4 (caller's stack)
558 FP -> 0 PC (points to address of stmfd instruction + 8 in callee)
559 -4 LR (return address in caller)
560 -8 IP (copy of caller's SP)
562 SP -> -28 Local variables
564 The frame size would thus be 32 bytes, and the frame offset would be
565 28 bytes. The stmfd call can also save any of the vN registers it
566 plans to use, which increases the frame size accordingly.
568 Note: The stored PC is 8 off of the STMFD instruction that stored it
569 because the ARM Store instructions always store PC + 8 when you read
572 A variable argument function call will look like:
575 stmfd sp!, {a1, a2, a3, a4}
576 stmfd sp!, {fp, ip, lr, pc}
579 Which would create this stack frame (offsets relative to FP):
580 IP -> 20 (caller's stack)
585 FP -> 0 PC (points to address of stmfd instruction + 8 in callee)
586 -4 LR (return address in caller)
587 -8 IP (copy of caller's SP)
589 SP -> -28 Local variables
591 The frame size would thus be 48 bytes, and the frame offset would be
594 There is another potential complication, which is that the optimizer
595 will try to separate the store of fp in the "stmfd" instruction from
596 the "sub fp, ip, #NN" instruction. Almost anything can be there, so
597 we just key on the stmfd, and then scan for the "sub fp, ip, #NN"...
599 Also, note, the original version of the ARM toolchain claimed that there
602 instruction at the end of the prologue. I have never seen GCC produce
603 this, and the ARM docs don't mention it. We still test for it below in
609 arm_scan_prologue (struct frame_info
*next_frame
, struct arm_prologue_cache
*cache
)
611 int regno
, sp_offset
, fp_offset
, ip_offset
;
612 CORE_ADDR prologue_start
, prologue_end
, current_pc
;
613 CORE_ADDR prev_pc
= frame_pc_unwind (next_frame
);
615 /* Assume there is no frame until proven otherwise. */
616 cache
->framereg
= ARM_SP_REGNUM
;
617 cache
->framesize
= 0;
618 cache
->frameoffset
= 0;
620 /* Check for Thumb prologue. */
621 if (arm_pc_is_thumb (prev_pc
))
623 thumb_scan_prologue (prev_pc
, cache
);
627 /* Find the function prologue. If we can't find the function in
628 the symbol table, peek in the stack frame to find the PC. */
629 if (find_pc_partial_function (prev_pc
, NULL
, &prologue_start
, &prologue_end
))
631 /* One way to find the end of the prologue (which works well
632 for unoptimized code) is to do the following:
634 struct symtab_and_line sal = find_pc_line (prologue_start, 0);
637 prologue_end = prev_pc;
638 else if (sal.end < prologue_end)
639 prologue_end = sal.end;
641 This mechanism is very accurate so long as the optimizer
642 doesn't move any instructions from the function body into the
643 prologue. If this happens, sal.end will be the last
644 instruction in the first hunk of prologue code just before
645 the first instruction that the scheduler has moved from
646 the body to the prologue.
648 In order to make sure that we scan all of the prologue
649 instructions, we use a slightly less accurate mechanism which
650 may scan more than necessary. To help compensate for this
651 lack of accuracy, the prologue scanning loop below contains
652 several clauses which'll cause the loop to terminate early if
653 an implausible prologue instruction is encountered.
659 is a suitable endpoint since it accounts for the largest
660 possible prologue plus up to five instructions inserted by
663 if (prologue_end
> prologue_start
+ 64)
665 prologue_end
= prologue_start
+ 64; /* See above. */
670 /* We have no symbol information. Our only option is to assume this
671 function has a standard stack frame and the normal frame register.
672 Then, we can find the value of our frame pointer on entrance to
673 the callee (or at the present moment if this is the innermost frame).
674 The value stored there should be the address of the stmfd + 8. */
676 LONGEST return_value
;
678 frame_loc
= frame_unwind_register_unsigned (next_frame
, ARM_FP_REGNUM
);
679 if (!safe_read_memory_integer (frame_loc
, 4, &return_value
))
683 prologue_start
= ADDR_BITS_REMOVE (return_value
) - 8;
684 prologue_end
= prologue_start
+ 64; /* See above. */
688 if (prev_pc
< prologue_end
)
689 prologue_end
= prev_pc
;
691 /* Now search the prologue looking for instructions that set up the
692 frame pointer, adjust the stack pointer, and save registers.
694 Be careful, however, and if it doesn't look like a prologue,
695 don't try to scan it. If, for instance, a frameless function
696 begins with stmfd sp!, then we will tell ourselves there is
697 a frame, which will confuse stack traceback, as well as "finish"
698 and other operations that rely on a knowledge of the stack
701 In the APCS, the prologue should start with "mov ip, sp" so
702 if we don't see this as the first insn, we will stop.
704 [Note: This doesn't seem to be true any longer, so it's now an
705 optional part of the prologue. - Kevin Buettner, 2001-11-20]
707 [Note further: The "mov ip,sp" only seems to be missing in
708 frameless functions at optimization level "-O2" or above,
709 in which case it is often (but not always) replaced by
710 "str lr, [sp, #-4]!". - Michael Snyder, 2002-04-23] */
712 sp_offset
= fp_offset
= ip_offset
= 0;
714 for (current_pc
= prologue_start
;
715 current_pc
< prologue_end
;
718 unsigned int insn
= read_memory_unsigned_integer (current_pc
, 4);
720 if (insn
== 0xe1a0c00d) /* mov ip, sp */
725 else if ((insn
& 0xfffff000) == 0xe28dc000) /* add ip, sp #n */
727 unsigned imm
= insn
& 0xff; /* immediate value */
728 unsigned rot
= (insn
& 0xf00) >> 7; /* rotate amount */
729 imm
= (imm
>> rot
) | (imm
<< (32 - rot
));
733 else if ((insn
& 0xfffff000) == 0xe24dc000) /* sub ip, sp #n */
735 unsigned imm
= insn
& 0xff; /* immediate value */
736 unsigned rot
= (insn
& 0xf00) >> 7; /* rotate amount */
737 imm
= (imm
>> rot
) | (imm
<< (32 - rot
));
741 else if (insn
== 0xe52de004) /* str lr, [sp, #-4]! */
744 cache
->saved_regs
[ARM_LR_REGNUM
].addr
= sp_offset
;
747 else if ((insn
& 0xffff0000) == 0xe92d0000)
748 /* stmfd sp!, {..., fp, ip, lr, pc}
750 stmfd sp!, {a1, a2, a3, a4} */
752 int mask
= insn
& 0xffff;
754 /* Calculate offsets of saved registers. */
755 for (regno
= ARM_PC_REGNUM
; regno
>= 0; regno
--)
756 if (mask
& (1 << regno
))
759 cache
->saved_regs
[regno
].addr
= sp_offset
;
762 else if ((insn
& 0xffffc000) == 0xe54b0000 || /* strb rx,[r11,#-n] */
763 (insn
& 0xffffc0f0) == 0xe14b00b0 || /* strh rx,[r11,#-n] */
764 (insn
& 0xffffc000) == 0xe50b0000) /* str rx,[r11,#-n] */
766 /* No need to add this to saved_regs -- it's just an arg reg. */
769 else if ((insn
& 0xffffc000) == 0xe5cd0000 || /* strb rx,[sp,#n] */
770 (insn
& 0xffffc0f0) == 0xe1cd00b0 || /* strh rx,[sp,#n] */
771 (insn
& 0xffffc000) == 0xe58d0000) /* str rx,[sp,#n] */
773 /* No need to add this to saved_regs -- it's just an arg reg. */
776 else if ((insn
& 0xfffff000) == 0xe24cb000) /* sub fp, ip #n */
778 unsigned imm
= insn
& 0xff; /* immediate value */
779 unsigned rot
= (insn
& 0xf00) >> 7; /* rotate amount */
780 imm
= (imm
>> rot
) | (imm
<< (32 - rot
));
781 fp_offset
= -imm
+ ip_offset
;
782 cache
->framereg
= ARM_FP_REGNUM
;
784 else if ((insn
& 0xfffff000) == 0xe24dd000) /* sub sp, sp #n */
786 unsigned imm
= insn
& 0xff; /* immediate value */
787 unsigned rot
= (insn
& 0xf00) >> 7; /* rotate amount */
788 imm
= (imm
>> rot
) | (imm
<< (32 - rot
));
791 else if ((insn
& 0xffff7fff) == 0xed6d0103) /* stfe f?, [sp, -#c]! */
794 regno
= ARM_F0_REGNUM
+ ((insn
>> 12) & 0x07);
795 cache
->saved_regs
[regno
].addr
= sp_offset
;
797 else if ((insn
& 0xffbf0fff) == 0xec2d0200) /* sfmfd f0, 4, [sp!] */
800 unsigned int fp_start_reg
, fp_bound_reg
;
802 if ((insn
& 0x800) == 0x800) /* N0 is set */
804 if ((insn
& 0x40000) == 0x40000) /* N1 is set */
811 if ((insn
& 0x40000) == 0x40000) /* N1 is set */
817 fp_start_reg
= ARM_F0_REGNUM
+ ((insn
>> 12) & 0x7);
818 fp_bound_reg
= fp_start_reg
+ n_saved_fp_regs
;
819 for (; fp_start_reg
< fp_bound_reg
; fp_start_reg
++)
822 cache
->saved_regs
[fp_start_reg
++].addr
= sp_offset
;
825 else if ((insn
& 0xf0000000) != 0xe0000000)
826 break; /* Condition not true, exit early */
827 else if ((insn
& 0xfe200000) == 0xe8200000) /* ldm? */
828 break; /* Don't scan past a block load */
830 /* The optimizer might shove anything into the prologue,
831 so we just skip what we don't recognize. */
835 /* The frame size is just the negative of the offset (from the
836 original SP) of the last thing thing we pushed on the stack.
837 The frame offset is [new FP] - [new SP]. */
838 cache
->framesize
= -sp_offset
;
839 if (cache
->framereg
== ARM_FP_REGNUM
)
840 cache
->frameoffset
= fp_offset
- sp_offset
;
842 cache
->frameoffset
= 0;
845 static struct arm_prologue_cache
*
846 arm_make_prologue_cache (struct frame_info
*next_frame
)
849 struct arm_prologue_cache
*cache
;
850 CORE_ADDR unwound_fp
;
852 cache
= FRAME_OBSTACK_ZALLOC (struct arm_prologue_cache
);
853 cache
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
855 arm_scan_prologue (next_frame
, cache
);
857 unwound_fp
= frame_unwind_register_unsigned (next_frame
, cache
->framereg
);
861 cache
->prev_sp
= unwound_fp
+ cache
->framesize
- cache
->frameoffset
;
863 /* Calculate actual addresses of saved registers using offsets
864 determined by arm_scan_prologue. */
865 for (reg
= 0; reg
< NUM_REGS
; reg
++)
866 if (trad_frame_addr_p (cache
->saved_regs
, reg
))
867 cache
->saved_regs
[reg
].addr
+= cache
->prev_sp
;
872 /* Our frame ID for a normal frame is the current function's starting PC
873 and the caller's SP when we were called. */
876 arm_prologue_this_id (struct frame_info
*next_frame
,
878 struct frame_id
*this_id
)
880 struct arm_prologue_cache
*cache
;
884 if (*this_cache
== NULL
)
885 *this_cache
= arm_make_prologue_cache (next_frame
);
888 func
= frame_func_unwind (next_frame
);
890 /* This is meant to halt the backtrace at "_start". Make sure we
891 don't halt it at a generic dummy frame. */
892 if (func
<= LOWEST_PC
)
895 /* If we've hit a wall, stop. */
896 if (cache
->prev_sp
== 0)
899 id
= frame_id_build (cache
->prev_sp
, func
);
904 arm_prologue_prev_register (struct frame_info
*next_frame
,
908 enum lval_type
*lvalp
,
913 struct arm_prologue_cache
*cache
;
915 if (*this_cache
== NULL
)
916 *this_cache
= arm_make_prologue_cache (next_frame
);
919 /* If we are asked to unwind the PC, then we need to return the LR
920 instead. The saved value of PC points into this frame's
921 prologue, not the next frame's resume location. */
922 if (prev_regnum
== ARM_PC_REGNUM
)
923 prev_regnum
= ARM_LR_REGNUM
;
925 /* SP is generally not saved to the stack, but this frame is
926 identified by NEXT_FRAME's stack pointer at the time of the call.
927 The value was already reconstructed into PREV_SP. */
928 if (prev_regnum
== ARM_SP_REGNUM
)
932 store_unsigned_integer (valuep
, 4, cache
->prev_sp
);
936 trad_frame_get_prev_register (next_frame
, cache
->saved_regs
, prev_regnum
,
937 optimized
, lvalp
, addrp
, realnump
, valuep
);
940 struct frame_unwind arm_prologue_unwind
= {
942 arm_prologue_this_id
,
943 arm_prologue_prev_register
946 static const struct frame_unwind
*
947 arm_prologue_unwind_sniffer (struct frame_info
*next_frame
)
949 return &arm_prologue_unwind
;
952 static struct arm_prologue_cache
*
953 arm_make_stub_cache (struct frame_info
*next_frame
)
956 struct arm_prologue_cache
*cache
;
957 CORE_ADDR unwound_fp
;
959 cache
= FRAME_OBSTACK_ZALLOC (struct arm_prologue_cache
);
960 cache
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
962 cache
->prev_sp
= frame_unwind_register_unsigned (next_frame
, ARM_SP_REGNUM
);
967 /* Our frame ID for a stub frame is the current SP and LR. */
970 arm_stub_this_id (struct frame_info
*next_frame
,
972 struct frame_id
*this_id
)
974 struct arm_prologue_cache
*cache
;
976 if (*this_cache
== NULL
)
977 *this_cache
= arm_make_stub_cache (next_frame
);
980 *this_id
= frame_id_build (cache
->prev_sp
,
981 frame_pc_unwind (next_frame
));
984 struct frame_unwind arm_stub_unwind
= {
987 arm_prologue_prev_register
990 static const struct frame_unwind
*
991 arm_stub_unwind_sniffer (struct frame_info
*next_frame
)
995 if (in_plt_section (frame_unwind_address_in_block (next_frame
), NULL
)
996 || target_read_memory (frame_pc_unwind (next_frame
), dummy
, 4) != 0)
997 return &arm_stub_unwind
;
1003 arm_normal_frame_base (struct frame_info
*next_frame
, void **this_cache
)
1005 struct arm_prologue_cache
*cache
;
1007 if (*this_cache
== NULL
)
1008 *this_cache
= arm_make_prologue_cache (next_frame
);
1009 cache
= *this_cache
;
1011 return cache
->prev_sp
+ cache
->frameoffset
- cache
->framesize
;
1014 struct frame_base arm_normal_base
= {
1015 &arm_prologue_unwind
,
1016 arm_normal_frame_base
,
1017 arm_normal_frame_base
,
1018 arm_normal_frame_base
1021 /* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
1022 dummy frame. The frame ID's base needs to match the TOS value
1023 saved by save_dummy_frame_tos() and returned from
1024 arm_push_dummy_call, and the PC needs to match the dummy frame's
1027 static struct frame_id
1028 arm_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1030 return frame_id_build (frame_unwind_register_unsigned (next_frame
, ARM_SP_REGNUM
),
1031 frame_pc_unwind (next_frame
));
1034 /* Given THIS_FRAME, find the previous frame's resume PC (which will
1035 be used to construct the previous frame's ID, after looking up the
1036 containing function). */
1039 arm_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
1042 pc
= frame_unwind_register_unsigned (this_frame
, ARM_PC_REGNUM
);
1043 return arm_addr_bits_remove (pc
);
1047 arm_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
1049 return frame_unwind_register_unsigned (this_frame
, ARM_SP_REGNUM
);
1052 /* When arguments must be pushed onto the stack, they go on in reverse
1053 order. The code below implements a FILO (stack) to do this. */
1058 struct stack_item
*prev
;
1062 static struct stack_item
*
1063 push_stack_item (struct stack_item
*prev
, void *contents
, int len
)
1065 struct stack_item
*si
;
1066 si
= xmalloc (sizeof (struct stack_item
));
1067 si
->data
= xmalloc (len
);
1070 memcpy (si
->data
, contents
, len
);
1074 static struct stack_item
*
1075 pop_stack_item (struct stack_item
*si
)
1077 struct stack_item
*dead
= si
;
1085 /* Return the alignment (in bytes) of the given type. */
1088 arm_type_align (struct type
*t
)
1094 t
= check_typedef (t
);
1095 switch (TYPE_CODE (t
))
1098 /* Should never happen. */
1099 internal_error (__FILE__
, __LINE__
, _("unknown type alignment"));
1103 case TYPE_CODE_ENUM
:
1107 case TYPE_CODE_RANGE
:
1108 case TYPE_CODE_BITSTRING
:
1110 case TYPE_CODE_CHAR
:
1111 case TYPE_CODE_BOOL
:
1112 return TYPE_LENGTH (t
);
1114 case TYPE_CODE_ARRAY
:
1115 case TYPE_CODE_COMPLEX
:
1116 /* TODO: What about vector types? */
1117 return arm_type_align (TYPE_TARGET_TYPE (t
));
1119 case TYPE_CODE_STRUCT
:
1120 case TYPE_CODE_UNION
:
1122 for (n
= 0; n
< TYPE_NFIELDS (t
); n
++)
1124 falign
= arm_type_align (TYPE_FIELD_TYPE (t
, n
));
1132 /* We currently only support passing parameters in integer registers. This
1133 conforms with GCC's default model. Several other variants exist and
1134 we should probably support some of them based on the selected ABI. */
1137 arm_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
1138 struct regcache
*regcache
, CORE_ADDR bp_addr
, int nargs
,
1139 struct value
**args
, CORE_ADDR sp
, int struct_return
,
1140 CORE_ADDR struct_addr
)
1145 struct stack_item
*si
= NULL
;
1147 /* Set the return address. For the ARM, the return breakpoint is
1148 always at BP_ADDR. */
1149 /* XXX Fix for Thumb. */
1150 regcache_cooked_write_unsigned (regcache
, ARM_LR_REGNUM
, bp_addr
);
1152 /* Walk through the list of args and determine how large a temporary
1153 stack is required. Need to take care here as structs may be
1154 passed on the stack, and we have to to push them. */
1157 argreg
= ARM_A1_REGNUM
;
1160 /* The struct_return pointer occupies the first parameter
1161 passing register. */
1165 fprintf_unfiltered (gdb_stdlog
, "struct return in %s = 0x%s\n",
1166 REGISTER_NAME (argreg
), paddr (struct_addr
));
1167 regcache_cooked_write_unsigned (regcache
, argreg
, struct_addr
);
1171 for (argnum
= 0; argnum
< nargs
; argnum
++)
1174 struct type
*arg_type
;
1175 struct type
*target_type
;
1176 enum type_code typecode
;
1180 arg_type
= check_typedef (value_type (args
[argnum
]));
1181 len
= TYPE_LENGTH (arg_type
);
1182 target_type
= TYPE_TARGET_TYPE (arg_type
);
1183 typecode
= TYPE_CODE (arg_type
);
1184 val
= value_contents_writeable (args
[argnum
]);
1186 align
= arm_type_align (arg_type
);
1187 /* Round alignment up to a whole number of words. */
1188 align
= (align
+ INT_REGISTER_SIZE
- 1) & ~(INT_REGISTER_SIZE
- 1);
1189 /* Different ABIs have different maximum alignments. */
1190 if (gdbarch_tdep (gdbarch
)->arm_abi
== ARM_ABI_APCS
)
1192 /* The APCS ABI only requires word alignment. */
1193 align
= INT_REGISTER_SIZE
;
1197 /* The AAPCS requires at most doubleword alignment. */
1198 if (align
> INT_REGISTER_SIZE
* 2)
1199 align
= INT_REGISTER_SIZE
* 2;
1202 /* Push stack padding for dowubleword alignment. */
1203 if (nstack
& (align
- 1))
1205 si
= push_stack_item (si
, val
, INT_REGISTER_SIZE
);
1206 nstack
+= INT_REGISTER_SIZE
;
1209 /* Doubleword aligned quantities must go in even register pairs. */
1210 if (argreg
<= ARM_LAST_ARG_REGNUM
1211 && align
> INT_REGISTER_SIZE
1215 /* If the argument is a pointer to a function, and it is a
1216 Thumb function, create a LOCAL copy of the value and set
1217 the THUMB bit in it. */
1218 if (TYPE_CODE_PTR
== typecode
1219 && target_type
!= NULL
1220 && TYPE_CODE_FUNC
== TYPE_CODE (target_type
))
1222 CORE_ADDR regval
= extract_unsigned_integer (val
, len
);
1223 if (arm_pc_is_thumb (regval
))
1226 store_unsigned_integer (val
, len
, MAKE_THUMB_ADDR (regval
));
1230 /* Copy the argument to general registers or the stack in
1231 register-sized pieces. Large arguments are split between
1232 registers and stack. */
1235 int partial_len
= len
< DEPRECATED_REGISTER_SIZE
? len
: DEPRECATED_REGISTER_SIZE
;
1237 if (argreg
<= ARM_LAST_ARG_REGNUM
)
1239 /* The argument is being passed in a general purpose
1241 CORE_ADDR regval
= extract_unsigned_integer (val
, partial_len
);
1243 fprintf_unfiltered (gdb_stdlog
, "arg %d in %s = 0x%s\n",
1244 argnum
, REGISTER_NAME (argreg
),
1245 phex (regval
, DEPRECATED_REGISTER_SIZE
));
1246 regcache_cooked_write_unsigned (regcache
, argreg
, regval
);
1251 /* Push the arguments onto the stack. */
1253 fprintf_unfiltered (gdb_stdlog
, "arg %d @ sp + %d\n",
1255 si
= push_stack_item (si
, val
, DEPRECATED_REGISTER_SIZE
);
1256 nstack
+= DEPRECATED_REGISTER_SIZE
;
1263 /* If we have an odd number of words to push, then decrement the stack
1264 by one word now, so first stack argument will be dword aligned. */
1271 write_memory (sp
, si
->data
, si
->len
);
1272 si
= pop_stack_item (si
);
1275 /* Finally, update teh SP register. */
1276 regcache_cooked_write_unsigned (regcache
, ARM_SP_REGNUM
, sp
);
1282 /* Always align the frame to an 8-byte boundary. This is required on
1283 some platforms and harmless on the rest. */
1286 arm_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
1288 /* Align the stack to eight bytes. */
1289 return sp
& ~ (CORE_ADDR
) 7;
1293 print_fpu_flags (int flags
)
1295 if (flags
& (1 << 0))
1296 fputs ("IVO ", stdout
);
1297 if (flags
& (1 << 1))
1298 fputs ("DVZ ", stdout
);
1299 if (flags
& (1 << 2))
1300 fputs ("OFL ", stdout
);
1301 if (flags
& (1 << 3))
1302 fputs ("UFL ", stdout
);
1303 if (flags
& (1 << 4))
1304 fputs ("INX ", stdout
);
1308 /* Print interesting information about the floating point processor
1309 (if present) or emulator. */
1311 arm_print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
1312 struct frame_info
*frame
, const char *args
)
1314 unsigned long status
= read_register (ARM_FPS_REGNUM
);
1317 type
= (status
>> 24) & 127;
1318 if (status
& (1 << 31))
1319 printf (_("Hardware FPU type %d\n"), type
);
1321 printf (_("Software FPU type %d\n"), type
);
1322 /* i18n: [floating point unit] mask */
1323 fputs (_("mask: "), stdout
);
1324 print_fpu_flags (status
>> 16);
1325 /* i18n: [floating point unit] flags */
1326 fputs (_("flags: "), stdout
);
1327 print_fpu_flags (status
);
1330 /* Return the GDB type object for the "standard" data type of data in
1333 static struct type
*
1334 arm_register_type (struct gdbarch
*gdbarch
, int regnum
)
1336 if (regnum
>= ARM_F0_REGNUM
&& regnum
< ARM_F0_REGNUM
+ NUM_FREGS
)
1338 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
1339 return builtin_type_arm_ext_big
;
1341 return builtin_type_arm_ext_littlebyte_bigword
;
1343 else if (regnum
== ARM_SP_REGNUM
)
1344 return builtin_type_void_data_ptr
;
1345 else if (regnum
== ARM_PC_REGNUM
)
1346 return builtin_type_void_func_ptr
;
1348 return builtin_type_uint32
;
1351 /* Index within `registers' of the first byte of the space for
1355 arm_register_byte (int regnum
)
1357 if (regnum
< ARM_F0_REGNUM
)
1358 return regnum
* INT_REGISTER_SIZE
;
1359 else if (regnum
< ARM_PS_REGNUM
)
1360 return (NUM_GREGS
* INT_REGISTER_SIZE
1361 + (regnum
- ARM_F0_REGNUM
) * FP_REGISTER_SIZE
);
1363 return (NUM_GREGS
* INT_REGISTER_SIZE
1364 + NUM_FREGS
* FP_REGISTER_SIZE
1365 + (regnum
- ARM_FPS_REGNUM
) * STATUS_REGISTER_SIZE
);
1368 /* Map GDB internal REGNUM onto the Arm simulator register numbers. */
1370 arm_register_sim_regno (int regnum
)
1373 gdb_assert (reg
>= 0 && reg
< NUM_REGS
);
1375 if (reg
< NUM_GREGS
)
1376 return SIM_ARM_R0_REGNUM
+ reg
;
1379 if (reg
< NUM_FREGS
)
1380 return SIM_ARM_FP0_REGNUM
+ reg
;
1383 if (reg
< NUM_SREGS
)
1384 return SIM_ARM_FPS_REGNUM
+ reg
;
1387 internal_error (__FILE__
, __LINE__
, _("Bad REGNUM %d"), regnum
);
1390 /* NOTE: cagney/2001-08-20: Both convert_from_extended() and
1391 convert_to_extended() use floatformat_arm_ext_littlebyte_bigword.
1392 It is thought that this is is the floating-point register format on
1393 little-endian systems. */
1396 convert_from_extended (const struct floatformat
*fmt
, const void *ptr
,
1400 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
1401 floatformat_to_doublest (&floatformat_arm_ext_big
, ptr
, &d
);
1403 floatformat_to_doublest (&floatformat_arm_ext_littlebyte_bigword
,
1405 floatformat_from_doublest (fmt
, &d
, dbl
);
1409 convert_to_extended (const struct floatformat
*fmt
, void *dbl
, const void *ptr
)
1412 floatformat_to_doublest (fmt
, ptr
, &d
);
1413 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
1414 floatformat_from_doublest (&floatformat_arm_ext_big
, &d
, dbl
);
1416 floatformat_from_doublest (&floatformat_arm_ext_littlebyte_bigword
,
1421 condition_true (unsigned long cond
, unsigned long status_reg
)
1423 if (cond
== INST_AL
|| cond
== INST_NV
)
1429 return ((status_reg
& FLAG_Z
) != 0);
1431 return ((status_reg
& FLAG_Z
) == 0);
1433 return ((status_reg
& FLAG_C
) != 0);
1435 return ((status_reg
& FLAG_C
) == 0);
1437 return ((status_reg
& FLAG_N
) != 0);
1439 return ((status_reg
& FLAG_N
) == 0);
1441 return ((status_reg
& FLAG_V
) != 0);
1443 return ((status_reg
& FLAG_V
) == 0);
1445 return ((status_reg
& (FLAG_C
| FLAG_Z
)) == FLAG_C
);
1447 return ((status_reg
& (FLAG_C
| FLAG_Z
)) != FLAG_C
);
1449 return (((status_reg
& FLAG_N
) == 0) == ((status_reg
& FLAG_V
) == 0));
1451 return (((status_reg
& FLAG_N
) == 0) != ((status_reg
& FLAG_V
) == 0));
1453 return (((status_reg
& FLAG_Z
) == 0) &&
1454 (((status_reg
& FLAG_N
) == 0) == ((status_reg
& FLAG_V
) == 0)));
1456 return (((status_reg
& FLAG_Z
) != 0) ||
1457 (((status_reg
& FLAG_N
) == 0) != ((status_reg
& FLAG_V
) == 0)));
1462 /* Support routines for single stepping. Calculate the next PC value. */
1463 #define submask(x) ((1L << ((x) + 1)) - 1)
1464 #define bit(obj,st) (((obj) >> (st)) & 1)
1465 #define bits(obj,st,fn) (((obj) >> (st)) & submask ((fn) - (st)))
1466 #define sbits(obj,st,fn) \
1467 ((long) (bits(obj,st,fn) | ((long) bit(obj,fn) * ~ submask (fn - st))))
1468 #define BranchDest(addr,instr) \
1469 ((CORE_ADDR) (((long) (addr)) + 8 + (sbits (instr, 0, 23) << 2)))
1472 static unsigned long
1473 shifted_reg_val (unsigned long inst
, int carry
, unsigned long pc_val
,
1474 unsigned long status_reg
)
1476 unsigned long res
, shift
;
1477 int rm
= bits (inst
, 0, 3);
1478 unsigned long shifttype
= bits (inst
, 5, 6);
1482 int rs
= bits (inst
, 8, 11);
1483 shift
= (rs
== 15 ? pc_val
+ 8 : read_register (rs
)) & 0xFF;
1486 shift
= bits (inst
, 7, 11);
1489 ? ((pc_val
| (ARM_PC_32
? 0 : status_reg
))
1490 + (bit (inst
, 4) ? 12 : 8))
1491 : read_register (rm
));
1496 res
= shift
>= 32 ? 0 : res
<< shift
;
1500 res
= shift
>= 32 ? 0 : res
>> shift
;
1506 res
= ((res
& 0x80000000L
)
1507 ? ~((~res
) >> shift
) : res
>> shift
);
1510 case 3: /* ROR/RRX */
1513 res
= (res
>> 1) | (carry
? 0x80000000L
: 0);
1515 res
= (res
>> shift
) | (res
<< (32 - shift
));
1519 return res
& 0xffffffff;
1522 /* Return number of 1-bits in VAL. */
1525 bitcount (unsigned long val
)
1528 for (nbits
= 0; val
!= 0; nbits
++)
1529 val
&= val
- 1; /* delete rightmost 1-bit in val */
1534 thumb_get_next_pc (CORE_ADDR pc
)
1536 unsigned long pc_val
= ((unsigned long) pc
) + 4; /* PC after prefetch */
1537 unsigned short inst1
= read_memory_unsigned_integer (pc
, 2);
1538 CORE_ADDR nextpc
= pc
+ 2; /* default is next instruction */
1539 unsigned long offset
;
1541 if ((inst1
& 0xff00) == 0xbd00) /* pop {rlist, pc} */
1545 /* Fetch the saved PC from the stack. It's stored above
1546 all of the other registers. */
1547 offset
= bitcount (bits (inst1
, 0, 7)) * DEPRECATED_REGISTER_SIZE
;
1548 sp
= read_register (ARM_SP_REGNUM
);
1549 nextpc
= (CORE_ADDR
) read_memory_unsigned_integer (sp
+ offset
, 4);
1550 nextpc
= ADDR_BITS_REMOVE (nextpc
);
1552 error (_("Infinite loop detected"));
1554 else if ((inst1
& 0xf000) == 0xd000) /* conditional branch */
1556 unsigned long status
= read_register (ARM_PS_REGNUM
);
1557 unsigned long cond
= bits (inst1
, 8, 11);
1558 if (cond
!= 0x0f && condition_true (cond
, status
)) /* 0x0f = SWI */
1559 nextpc
= pc_val
+ (sbits (inst1
, 0, 7) << 1);
1561 else if ((inst1
& 0xf800) == 0xe000) /* unconditional branch */
1563 nextpc
= pc_val
+ (sbits (inst1
, 0, 10) << 1);
1565 else if ((inst1
& 0xf800) == 0xf000) /* long branch with link, and blx */
1567 unsigned short inst2
= read_memory_unsigned_integer (pc
+ 2, 2);
1568 offset
= (sbits (inst1
, 0, 10) << 12) + (bits (inst2
, 0, 10) << 1);
1569 nextpc
= pc_val
+ offset
;
1570 /* For BLX make sure to clear the low bits. */
1571 if (bits (inst2
, 11, 12) == 1)
1572 nextpc
= nextpc
& 0xfffffffc;
1574 else if ((inst1
& 0xff00) == 0x4700) /* bx REG, blx REG */
1576 if (bits (inst1
, 3, 6) == 0x0f)
1579 nextpc
= read_register (bits (inst1
, 3, 6));
1581 nextpc
= ADDR_BITS_REMOVE (nextpc
);
1583 error (_("Infinite loop detected"));
1590 arm_get_next_pc (CORE_ADDR pc
)
1592 unsigned long pc_val
;
1593 unsigned long this_instr
;
1594 unsigned long status
;
1597 if (arm_pc_is_thumb (pc
))
1598 return thumb_get_next_pc (pc
);
1600 pc_val
= (unsigned long) pc
;
1601 this_instr
= read_memory_unsigned_integer (pc
, 4);
1602 status
= read_register (ARM_PS_REGNUM
);
1603 nextpc
= (CORE_ADDR
) (pc_val
+ 4); /* Default case */
1605 if (condition_true (bits (this_instr
, 28, 31), status
))
1607 switch (bits (this_instr
, 24, 27))
1610 case 0x1: /* data processing */
1614 unsigned long operand1
, operand2
, result
= 0;
1618 if (bits (this_instr
, 12, 15) != 15)
1621 if (bits (this_instr
, 22, 25) == 0
1622 && bits (this_instr
, 4, 7) == 9) /* multiply */
1623 error (_("Invalid update to pc in instruction"));
1625 /* BX <reg>, BLX <reg> */
1626 if (bits (this_instr
, 4, 27) == 0x12fff1
1627 || bits (this_instr
, 4, 27) == 0x12fff3)
1629 rn
= bits (this_instr
, 0, 3);
1630 result
= (rn
== 15) ? pc_val
+ 8 : read_register (rn
);
1631 nextpc
= (CORE_ADDR
) ADDR_BITS_REMOVE (result
);
1634 error (_("Infinite loop detected"));
1639 /* Multiply into PC */
1640 c
= (status
& FLAG_C
) ? 1 : 0;
1641 rn
= bits (this_instr
, 16, 19);
1642 operand1
= (rn
== 15) ? pc_val
+ 8 : read_register (rn
);
1644 if (bit (this_instr
, 25))
1646 unsigned long immval
= bits (this_instr
, 0, 7);
1647 unsigned long rotate
= 2 * bits (this_instr
, 8, 11);
1648 operand2
= ((immval
>> rotate
) | (immval
<< (32 - rotate
)))
1651 else /* operand 2 is a shifted register */
1652 operand2
= shifted_reg_val (this_instr
, c
, pc_val
, status
);
1654 switch (bits (this_instr
, 21, 24))
1657 result
= operand1
& operand2
;
1661 result
= operand1
^ operand2
;
1665 result
= operand1
- operand2
;
1669 result
= operand2
- operand1
;
1673 result
= operand1
+ operand2
;
1677 result
= operand1
+ operand2
+ c
;
1681 result
= operand1
- operand2
+ c
;
1685 result
= operand2
- operand1
+ c
;
1691 case 0xb: /* tst, teq, cmp, cmn */
1692 result
= (unsigned long) nextpc
;
1696 result
= operand1
| operand2
;
1700 /* Always step into a function. */
1705 result
= operand1
& ~operand2
;
1712 nextpc
= (CORE_ADDR
) ADDR_BITS_REMOVE (result
);
1715 error (_("Infinite loop detected"));
1720 case 0x5: /* data transfer */
1723 if (bit (this_instr
, 20))
1726 if (bits (this_instr
, 12, 15) == 15)
1732 if (bit (this_instr
, 22))
1733 error (_("Invalid update to pc in instruction"));
1735 /* byte write to PC */
1736 rn
= bits (this_instr
, 16, 19);
1737 base
= (rn
== 15) ? pc_val
+ 8 : read_register (rn
);
1738 if (bit (this_instr
, 24))
1741 int c
= (status
& FLAG_C
) ? 1 : 0;
1742 unsigned long offset
=
1743 (bit (this_instr
, 25)
1744 ? shifted_reg_val (this_instr
, c
, pc_val
, status
)
1745 : bits (this_instr
, 0, 11));
1747 if (bit (this_instr
, 23))
1752 nextpc
= (CORE_ADDR
) read_memory_integer ((CORE_ADDR
) base
,
1755 nextpc
= ADDR_BITS_REMOVE (nextpc
);
1758 error (_("Infinite loop detected"));
1764 case 0x9: /* block transfer */
1765 if (bit (this_instr
, 20))
1768 if (bit (this_instr
, 15))
1773 if (bit (this_instr
, 23))
1776 unsigned long reglist
= bits (this_instr
, 0, 14);
1777 offset
= bitcount (reglist
) * 4;
1778 if (bit (this_instr
, 24)) /* pre */
1781 else if (bit (this_instr
, 24))
1785 unsigned long rn_val
=
1786 read_register (bits (this_instr
, 16, 19));
1788 (CORE_ADDR
) read_memory_integer ((CORE_ADDR
) (rn_val
1792 nextpc
= ADDR_BITS_REMOVE (nextpc
);
1794 error (_("Infinite loop detected"));
1799 case 0xb: /* branch & link */
1800 case 0xa: /* branch */
1802 nextpc
= BranchDest (pc
, this_instr
);
1805 if (bits (this_instr
, 28, 31) == INST_NV
)
1806 nextpc
|= bit (this_instr
, 24) << 1;
1808 nextpc
= ADDR_BITS_REMOVE (nextpc
);
1810 error (_("Infinite loop detected"));
1816 case 0xe: /* coproc ops */
1821 fprintf_filtered (gdb_stderr
, _("Bad bit-field extraction\n"));
1829 /* single_step() is called just before we want to resume the inferior,
1830 if we want to single-step it but there is no hardware or kernel
1831 single-step support. We find the target of the coming instruction
1834 single_step() is also called just after the inferior stops. If we
1835 had set up a simulated single-step, we undo our damage. */
1838 arm_software_single_step (enum target_signal sig
, int insert_bpt
)
1840 /* NOTE: This may insert the wrong breakpoint instruction when
1841 single-stepping over a mode-changing instruction, if the
1842 CPSR heuristics are used. */
1846 CORE_ADDR next_pc
= arm_get_next_pc (read_register (ARM_PC_REGNUM
));
1848 insert_single_step_breakpoint (next_pc
);
1851 remove_single_step_breakpoints ();
1854 #include "bfd-in2.h"
1855 #include "libcoff.h"
1858 gdb_print_insn_arm (bfd_vma memaddr
, disassemble_info
*info
)
1860 if (arm_pc_is_thumb (memaddr
))
1862 static asymbol
*asym
;
1863 static combined_entry_type ce
;
1864 static struct coff_symbol_struct csym
;
1865 static struct bfd fake_bfd
;
1866 static bfd_target fake_target
;
1868 if (csym
.native
== NULL
)
1870 /* Create a fake symbol vector containing a Thumb symbol.
1871 This is solely so that the code in print_insn_little_arm()
1872 and print_insn_big_arm() in opcodes/arm-dis.c will detect
1873 the presence of a Thumb symbol and switch to decoding
1874 Thumb instructions. */
1876 fake_target
.flavour
= bfd_target_coff_flavour
;
1877 fake_bfd
.xvec
= &fake_target
;
1878 ce
.u
.syment
.n_sclass
= C_THUMBEXTFUNC
;
1880 csym
.symbol
.the_bfd
= &fake_bfd
;
1881 csym
.symbol
.name
= "fake";
1882 asym
= (asymbol
*) & csym
;
1885 memaddr
= UNMAKE_THUMB_ADDR (memaddr
);
1886 info
->symbols
= &asym
;
1889 info
->symbols
= NULL
;
1891 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
1892 return print_insn_big_arm (memaddr
, info
);
1894 return print_insn_little_arm (memaddr
, info
);
1897 /* The following define instruction sequences that will cause ARM
1898 cpu's to take an undefined instruction trap. These are used to
1899 signal a breakpoint to GDB.
1901 The newer ARMv4T cpu's are capable of operating in ARM or Thumb
1902 modes. A different instruction is required for each mode. The ARM
1903 cpu's can also be big or little endian. Thus four different
1904 instructions are needed to support all cases.
1906 Note: ARMv4 defines several new instructions that will take the
1907 undefined instruction trap. ARM7TDMI is nominally ARMv4T, but does
1908 not in fact add the new instructions. The new undefined
1909 instructions in ARMv4 are all instructions that had no defined
1910 behaviour in earlier chips. There is no guarantee that they will
1911 raise an exception, but may be treated as NOP's. In practice, it
1912 may only safe to rely on instructions matching:
1914 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
1915 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
1916 C C C C 0 1 1 x x x x x x x x x x x x x x x x x x x x 1 x x x x
1918 Even this may only true if the condition predicate is true. The
1919 following use a condition predicate of ALWAYS so it is always TRUE.
1921 There are other ways of forcing a breakpoint. GNU/Linux, RISC iX,
1922 and NetBSD all use a software interrupt rather than an undefined
1923 instruction to force a trap. This can be handled by by the
1924 abi-specific code during establishment of the gdbarch vector. */
1927 /* NOTE rearnsha 2002-02-18: for now we allow a non-multi-arch gdb to
1928 override these definitions. */
1929 #ifndef ARM_LE_BREAKPOINT
1930 #define ARM_LE_BREAKPOINT {0xFE,0xDE,0xFF,0xE7}
1932 #ifndef ARM_BE_BREAKPOINT
1933 #define ARM_BE_BREAKPOINT {0xE7,0xFF,0xDE,0xFE}
1935 #ifndef THUMB_LE_BREAKPOINT
1936 #define THUMB_LE_BREAKPOINT {0xfe,0xdf}
1938 #ifndef THUMB_BE_BREAKPOINT
1939 #define THUMB_BE_BREAKPOINT {0xdf,0xfe}
1942 static const char arm_default_arm_le_breakpoint
[] = ARM_LE_BREAKPOINT
;
1943 static const char arm_default_arm_be_breakpoint
[] = ARM_BE_BREAKPOINT
;
1944 static const char arm_default_thumb_le_breakpoint
[] = THUMB_LE_BREAKPOINT
;
1945 static const char arm_default_thumb_be_breakpoint
[] = THUMB_BE_BREAKPOINT
;
1947 /* Determine the type and size of breakpoint to insert at PCPTR. Uses
1948 the program counter value to determine whether a 16-bit or 32-bit
1949 breakpoint should be used. It returns a pointer to a string of
1950 bytes that encode a breakpoint instruction, stores the length of
1951 the string to *lenptr, and adjusts the program counter (if
1952 necessary) to point to the actual memory location where the
1953 breakpoint should be inserted. */
1955 static const unsigned char *
1956 arm_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
1958 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1960 if (arm_pc_is_thumb (*pcptr
))
1962 *pcptr
= UNMAKE_THUMB_ADDR (*pcptr
);
1963 *lenptr
= tdep
->thumb_breakpoint_size
;
1964 return tdep
->thumb_breakpoint
;
1968 *lenptr
= tdep
->arm_breakpoint_size
;
1969 return tdep
->arm_breakpoint
;
1973 /* Extract from an array REGBUF containing the (raw) register state a
1974 function return value of type TYPE, and copy that, in virtual
1975 format, into VALBUF. */
1978 arm_extract_return_value (struct type
*type
, struct regcache
*regs
,
1981 if (TYPE_CODE_FLT
== TYPE_CODE (type
))
1983 switch (gdbarch_tdep (current_gdbarch
)->fp_model
)
1987 /* The value is in register F0 in internal format. We need to
1988 extract the raw value and then convert it to the desired
1990 bfd_byte tmpbuf
[FP_REGISTER_SIZE
];
1992 regcache_cooked_read (regs
, ARM_F0_REGNUM
, tmpbuf
);
1993 convert_from_extended (floatformat_from_type (type
), tmpbuf
,
1998 case ARM_FLOAT_SOFT_FPA
:
1999 case ARM_FLOAT_SOFT_VFP
:
2000 regcache_cooked_read (regs
, ARM_A1_REGNUM
, valbuf
);
2001 if (TYPE_LENGTH (type
) > 4)
2002 regcache_cooked_read (regs
, ARM_A1_REGNUM
+ 1,
2003 valbuf
+ INT_REGISTER_SIZE
);
2008 (__FILE__
, __LINE__
,
2009 _("arm_extract_return_value: Floating point model not supported"));
2013 else if (TYPE_CODE (type
) == TYPE_CODE_INT
2014 || TYPE_CODE (type
) == TYPE_CODE_CHAR
2015 || TYPE_CODE (type
) == TYPE_CODE_BOOL
2016 || TYPE_CODE (type
) == TYPE_CODE_PTR
2017 || TYPE_CODE (type
) == TYPE_CODE_REF
2018 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
2020 /* If the the type is a plain integer, then the access is
2021 straight-forward. Otherwise we have to play around a bit more. */
2022 int len
= TYPE_LENGTH (type
);
2023 int regno
= ARM_A1_REGNUM
;
2028 /* By using store_unsigned_integer we avoid having to do
2029 anything special for small big-endian values. */
2030 regcache_cooked_read_unsigned (regs
, regno
++, &tmp
);
2031 store_unsigned_integer (valbuf
,
2032 (len
> INT_REGISTER_SIZE
2033 ? INT_REGISTER_SIZE
: len
),
2035 len
-= INT_REGISTER_SIZE
;
2036 valbuf
+= INT_REGISTER_SIZE
;
2041 /* For a structure or union the behaviour is as if the value had
2042 been stored to word-aligned memory and then loaded into
2043 registers with 32-bit load instruction(s). */
2044 int len
= TYPE_LENGTH (type
);
2045 int regno
= ARM_A1_REGNUM
;
2046 bfd_byte tmpbuf
[INT_REGISTER_SIZE
];
2050 regcache_cooked_read (regs
, regno
++, tmpbuf
);
2051 memcpy (valbuf
, tmpbuf
,
2052 len
> INT_REGISTER_SIZE
? INT_REGISTER_SIZE
: len
);
2053 len
-= INT_REGISTER_SIZE
;
2054 valbuf
+= INT_REGISTER_SIZE
;
2060 /* Will a function return an aggregate type in memory or in a
2061 register? Return 0 if an aggregate type can be returned in a
2062 register, 1 if it must be returned in memory. */
2065 arm_return_in_memory (struct gdbarch
*gdbarch
, struct type
*type
)
2068 enum type_code code
;
2070 CHECK_TYPEDEF (type
);
2072 /* In the ARM ABI, "integer" like aggregate types are returned in
2073 registers. For an aggregate type to be integer like, its size
2074 must be less than or equal to DEPRECATED_REGISTER_SIZE and the
2075 offset of each addressable subfield must be zero. Note that bit
2076 fields are not addressable, and all addressable subfields of
2077 unions always start at offset zero.
2079 This function is based on the behaviour of GCC 2.95.1.
2080 See: gcc/arm.c: arm_return_in_memory() for details.
2082 Note: All versions of GCC before GCC 2.95.2 do not set up the
2083 parameters correctly for a function returning the following
2084 structure: struct { float f;}; This should be returned in memory,
2085 not a register. Richard Earnshaw sent me a patch, but I do not
2086 know of any way to detect if a function like the above has been
2087 compiled with the correct calling convention. */
2089 /* All aggregate types that won't fit in a register must be returned
2091 if (TYPE_LENGTH (type
) > DEPRECATED_REGISTER_SIZE
)
2096 /* The AAPCS says all aggregates not larger than a word are returned
2098 if (gdbarch_tdep (gdbarch
)->arm_abi
!= ARM_ABI_APCS
)
2101 /* The only aggregate types that can be returned in a register are
2102 structs and unions. Arrays must be returned in memory. */
2103 code
= TYPE_CODE (type
);
2104 if ((TYPE_CODE_STRUCT
!= code
) && (TYPE_CODE_UNION
!= code
))
2109 /* Assume all other aggregate types can be returned in a register.
2110 Run a check for structures, unions and arrays. */
2113 if ((TYPE_CODE_STRUCT
== code
) || (TYPE_CODE_UNION
== code
))
2116 /* Need to check if this struct/union is "integer" like. For
2117 this to be true, its size must be less than or equal to
2118 DEPRECATED_REGISTER_SIZE and the offset of each addressable
2119 subfield must be zero. Note that bit fields are not
2120 addressable, and unions always start at offset zero. If any
2121 of the subfields is a floating point type, the struct/union
2122 cannot be an integer type. */
2124 /* For each field in the object, check:
2125 1) Is it FP? --> yes, nRc = 1;
2126 2) Is it addressable (bitpos != 0) and
2127 not packed (bitsize == 0)?
2131 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
2133 enum type_code field_type_code
;
2134 field_type_code
= TYPE_CODE (check_typedef (TYPE_FIELD_TYPE (type
, i
)));
2136 /* Is it a floating point type field? */
2137 if (field_type_code
== TYPE_CODE_FLT
)
2143 /* If bitpos != 0, then we have to care about it. */
2144 if (TYPE_FIELD_BITPOS (type
, i
) != 0)
2146 /* Bitfields are not addressable. If the field bitsize is
2147 zero, then the field is not packed. Hence it cannot be
2148 a bitfield or any other packed type. */
2149 if (TYPE_FIELD_BITSIZE (type
, i
) == 0)
2161 /* Write into appropriate registers a function return value of type
2162 TYPE, given in virtual format. */
2165 arm_store_return_value (struct type
*type
, struct regcache
*regs
,
2166 const gdb_byte
*valbuf
)
2168 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
2170 char buf
[MAX_REGISTER_SIZE
];
2172 switch (gdbarch_tdep (current_gdbarch
)->fp_model
)
2176 convert_to_extended (floatformat_from_type (type
), buf
, valbuf
);
2177 regcache_cooked_write (regs
, ARM_F0_REGNUM
, buf
);
2180 case ARM_FLOAT_SOFT_FPA
:
2181 case ARM_FLOAT_SOFT_VFP
:
2182 regcache_cooked_write (regs
, ARM_A1_REGNUM
, valbuf
);
2183 if (TYPE_LENGTH (type
) > 4)
2184 regcache_cooked_write (regs
, ARM_A1_REGNUM
+ 1,
2185 valbuf
+ INT_REGISTER_SIZE
);
2190 (__FILE__
, __LINE__
,
2191 _("arm_store_return_value: Floating point model not supported"));
2195 else if (TYPE_CODE (type
) == TYPE_CODE_INT
2196 || TYPE_CODE (type
) == TYPE_CODE_CHAR
2197 || TYPE_CODE (type
) == TYPE_CODE_BOOL
2198 || TYPE_CODE (type
) == TYPE_CODE_PTR
2199 || TYPE_CODE (type
) == TYPE_CODE_REF
2200 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
2202 if (TYPE_LENGTH (type
) <= 4)
2204 /* Values of one word or less are zero/sign-extended and
2206 bfd_byte tmpbuf
[INT_REGISTER_SIZE
];
2207 LONGEST val
= unpack_long (type
, valbuf
);
2209 store_signed_integer (tmpbuf
, INT_REGISTER_SIZE
, val
);
2210 regcache_cooked_write (regs
, ARM_A1_REGNUM
, tmpbuf
);
2214 /* Integral values greater than one word are stored in consecutive
2215 registers starting with r0. This will always be a multiple of
2216 the regiser size. */
2217 int len
= TYPE_LENGTH (type
);
2218 int regno
= ARM_A1_REGNUM
;
2222 regcache_cooked_write (regs
, regno
++, valbuf
);
2223 len
-= INT_REGISTER_SIZE
;
2224 valbuf
+= INT_REGISTER_SIZE
;
2230 /* For a structure or union the behaviour is as if the value had
2231 been stored to word-aligned memory and then loaded into
2232 registers with 32-bit load instruction(s). */
2233 int len
= TYPE_LENGTH (type
);
2234 int regno
= ARM_A1_REGNUM
;
2235 bfd_byte tmpbuf
[INT_REGISTER_SIZE
];
2239 memcpy (tmpbuf
, valbuf
,
2240 len
> INT_REGISTER_SIZE
? INT_REGISTER_SIZE
: len
);
2241 regcache_cooked_write (regs
, regno
++, tmpbuf
);
2242 len
-= INT_REGISTER_SIZE
;
2243 valbuf
+= INT_REGISTER_SIZE
;
2249 /* Handle function return values. */
2251 static enum return_value_convention
2252 arm_return_value (struct gdbarch
*gdbarch
, struct type
*valtype
,
2253 struct regcache
*regcache
, gdb_byte
*readbuf
,
2254 const gdb_byte
*writebuf
)
2256 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2258 if (TYPE_CODE (valtype
) == TYPE_CODE_STRUCT
2259 || TYPE_CODE (valtype
) == TYPE_CODE_UNION
2260 || TYPE_CODE (valtype
) == TYPE_CODE_ARRAY
)
2262 if (tdep
->struct_return
== pcc_struct_return
2263 || arm_return_in_memory (gdbarch
, valtype
))
2264 return RETURN_VALUE_STRUCT_CONVENTION
;
2268 arm_store_return_value (valtype
, regcache
, writebuf
);
2271 arm_extract_return_value (valtype
, regcache
, readbuf
);
2273 return RETURN_VALUE_REGISTER_CONVENTION
;
2278 arm_get_longjmp_target (CORE_ADDR
*pc
)
2281 char buf
[INT_REGISTER_SIZE
];
2282 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
2284 jb_addr
= read_register (ARM_A1_REGNUM
);
2286 if (target_read_memory (jb_addr
+ tdep
->jb_pc
* tdep
->jb_elt_size
, buf
,
2290 *pc
= extract_unsigned_integer (buf
, INT_REGISTER_SIZE
);
2294 /* Return non-zero if the PC is inside a thumb call thunk. */
2297 arm_in_call_stub (CORE_ADDR pc
, char *name
)
2299 CORE_ADDR start_addr
;
2301 /* Find the starting address of the function containing the PC. If
2302 the caller didn't give us a name, look it up at the same time. */
2303 if (0 == find_pc_partial_function (pc
, name
? NULL
: &name
,
2307 return strncmp (name
, "_call_via_r", 11) == 0;
2310 /* If PC is in a Thumb call or return stub, return the address of the
2311 target PC, which is in a register. The thunk functions are called
2312 _called_via_xx, where x is the register name. The possible names
2313 are r0-r9, sl, fp, ip, sp, and lr. */
2316 arm_skip_stub (CORE_ADDR pc
)
2319 CORE_ADDR start_addr
;
2321 /* Find the starting address and name of the function containing the PC. */
2322 if (find_pc_partial_function (pc
, &name
, &start_addr
, NULL
) == 0)
2325 /* Call thunks always start with "_call_via_". */
2326 if (strncmp (name
, "_call_via_", 10) == 0)
2328 /* Use the name suffix to determine which register contains the
2330 static char *table
[15] =
2331 {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2332 "r8", "r9", "sl", "fp", "ip", "sp", "lr"
2336 for (regno
= 0; regno
<= 14; regno
++)
2337 if (strcmp (&name
[10], table
[regno
]) == 0)
2338 return read_register (regno
);
2341 return 0; /* not a stub */
2345 set_arm_command (char *args
, int from_tty
)
2347 printf_unfiltered (_("\
2348 \"set arm\" must be followed by an apporpriate subcommand.\n"));
2349 help_list (setarmcmdlist
, "set arm ", all_commands
, gdb_stdout
);
2353 show_arm_command (char *args
, int from_tty
)
2355 cmd_show_list (showarmcmdlist
, from_tty
, "");
2359 arm_update_current_architecture (void)
2361 struct gdbarch_info info
;
2363 /* If the current architecture is not ARM, we have nothing to do. */
2364 if (gdbarch_bfd_arch_info (current_gdbarch
)->arch
!= bfd_arch_arm
)
2367 /* Update the architecture. */
2368 gdbarch_info_init (&info
);
2370 if (!gdbarch_update_p (info
))
2371 internal_error (__FILE__
, __LINE__
, "could not update architecture");
2375 set_fp_model_sfunc (char *args
, int from_tty
,
2376 struct cmd_list_element
*c
)
2378 enum arm_float_model fp_model
;
2380 for (fp_model
= ARM_FLOAT_AUTO
; fp_model
!= ARM_FLOAT_LAST
; fp_model
++)
2381 if (strcmp (current_fp_model
, fp_model_strings
[fp_model
]) == 0)
2383 arm_fp_model
= fp_model
;
2387 if (fp_model
== ARM_FLOAT_LAST
)
2388 internal_error (__FILE__
, __LINE__
, _("Invalid fp model accepted: %s."),
2391 arm_update_current_architecture ();
2395 show_fp_model (struct ui_file
*file
, int from_tty
,
2396 struct cmd_list_element
*c
, const char *value
)
2398 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
2400 if (arm_fp_model
== ARM_FLOAT_AUTO
2401 && gdbarch_bfd_arch_info (current_gdbarch
)->arch
== bfd_arch_arm
)
2402 fprintf_filtered (file
, _("\
2403 The current ARM floating point model is \"auto\" (currently \"%s\").\n"),
2404 fp_model_strings
[tdep
->fp_model
]);
2406 fprintf_filtered (file
, _("\
2407 The current ARM floating point model is \"%s\".\n"),
2408 fp_model_strings
[arm_fp_model
]);
2412 arm_set_abi (char *args
, int from_tty
,
2413 struct cmd_list_element
*c
)
2415 enum arm_abi_kind arm_abi
;
2417 for (arm_abi
= ARM_ABI_AUTO
; arm_abi
!= ARM_ABI_LAST
; arm_abi
++)
2418 if (strcmp (arm_abi_string
, arm_abi_strings
[arm_abi
]) == 0)
2420 arm_abi_global
= arm_abi
;
2424 if (arm_abi
== ARM_ABI_LAST
)
2425 internal_error (__FILE__
, __LINE__
, _("Invalid ABI accepted: %s."),
2428 arm_update_current_architecture ();
2432 arm_show_abi (struct ui_file
*file
, int from_tty
,
2433 struct cmd_list_element
*c
, const char *value
)
2435 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
2437 if (arm_abi_global
== ARM_ABI_AUTO
2438 && gdbarch_bfd_arch_info (current_gdbarch
)->arch
== bfd_arch_arm
)
2439 fprintf_filtered (file
, _("\
2440 The current ARM ABI is \"auto\" (currently \"%s\").\n"),
2441 arm_abi_strings
[tdep
->arm_abi
]);
2443 fprintf_filtered (file
, _("The current ARM ABI is \"%s\".\n"),
2447 /* If the user changes the register disassembly style used for info
2448 register and other commands, we have to also switch the style used
2449 in opcodes for disassembly output. This function is run in the "set
2450 arm disassembly" command, and does that. */
2453 set_disassembly_style_sfunc (char *args
, int from_tty
,
2454 struct cmd_list_element
*c
)
2456 set_disassembly_style ();
2459 /* Return the ARM register name corresponding to register I. */
2461 arm_register_name (int i
)
2463 return arm_register_names
[i
];
2467 set_disassembly_style (void)
2469 const char *setname
, *setdesc
, *const *regnames
;
2472 /* Find the style that the user wants in the opcodes table. */
2474 numregs
= get_arm_regnames (current
, &setname
, &setdesc
, ®names
);
2475 while ((disassembly_style
!= setname
)
2476 && (current
< num_disassembly_options
))
2477 get_arm_regnames (++current
, &setname
, &setdesc
, ®names
);
2478 current_option
= current
;
2480 /* Fill our copy. */
2481 for (j
= 0; j
< numregs
; j
++)
2482 arm_register_names
[j
] = (char *) regnames
[j
];
2485 if (isupper (*regnames
[ARM_PC_REGNUM
]))
2487 arm_register_names
[ARM_FPS_REGNUM
] = "FPS";
2488 arm_register_names
[ARM_PS_REGNUM
] = "CPSR";
2492 arm_register_names
[ARM_FPS_REGNUM
] = "fps";
2493 arm_register_names
[ARM_PS_REGNUM
] = "cpsr";
2496 /* Synchronize the disassembler. */
2497 set_arm_regname_option (current
);
2500 /* Test whether the coff symbol specific value corresponds to a Thumb
2504 coff_sym_is_thumb (int val
)
2506 return (val
== C_THUMBEXT
||
2507 val
== C_THUMBSTAT
||
2508 val
== C_THUMBEXTFUNC
||
2509 val
== C_THUMBSTATFUNC
||
2510 val
== C_THUMBLABEL
);
2513 /* arm_coff_make_msymbol_special()
2514 arm_elf_make_msymbol_special()
2516 These functions test whether the COFF or ELF symbol corresponds to
2517 an address in thumb code, and set a "special" bit in a minimal
2518 symbol to indicate that it does. */
2521 arm_elf_make_msymbol_special(asymbol
*sym
, struct minimal_symbol
*msym
)
2523 /* Thumb symbols are of type STT_LOPROC, (synonymous with
2525 if (ELF_ST_TYPE (((elf_symbol_type
*)sym
)->internal_elf_sym
.st_info
)
2527 MSYMBOL_SET_SPECIAL (msym
);
2531 arm_coff_make_msymbol_special(int val
, struct minimal_symbol
*msym
)
2533 if (coff_sym_is_thumb (val
))
2534 MSYMBOL_SET_SPECIAL (msym
);
2538 arm_write_pc (CORE_ADDR pc
, ptid_t ptid
)
2540 write_register_pid (ARM_PC_REGNUM
, pc
, ptid
);
2542 /* If necessary, set the T bit. */
2545 CORE_ADDR val
= read_register_pid (ARM_PS_REGNUM
, ptid
);
2546 if (arm_pc_is_thumb (pc
))
2547 write_register_pid (ARM_PS_REGNUM
, val
| 0x20, ptid
);
2549 write_register_pid (ARM_PS_REGNUM
, val
& ~(CORE_ADDR
) 0x20, ptid
);
2553 static enum gdb_osabi
2554 arm_elf_osabi_sniffer (bfd
*abfd
)
2556 unsigned int elfosabi
;
2557 enum gdb_osabi osabi
= GDB_OSABI_UNKNOWN
;
2559 elfosabi
= elf_elfheader (abfd
)->e_ident
[EI_OSABI
];
2561 if (elfosabi
== ELFOSABI_ARM
)
2562 /* GNU tools use this value. Check note sections in this case,
2564 bfd_map_over_sections (abfd
,
2565 generic_elf_osabi_sniff_abi_tag_sections
,
2568 /* Anything else will be handled by the generic ELF sniffer. */
2573 /* Initialize the current architecture based on INFO. If possible,
2574 re-use an architecture from ARCHES, which is a list of
2575 architectures already created during this debugging session.
2577 Called e.g. at program startup, when reading a core file, and when
2578 reading a binary file. */
2580 static struct gdbarch
*
2581 arm_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
2583 struct gdbarch_tdep
*tdep
;
2584 struct gdbarch
*gdbarch
;
2585 struct gdbarch_list
*best_arch
;
2586 enum arm_abi_kind arm_abi
= arm_abi_global
;
2587 enum arm_float_model fp_model
= arm_fp_model
;
2589 /* If we have an object to base this architecture on, try to determine
2592 if (arm_abi
== ARM_ABI_AUTO
&& info
.abfd
!= NULL
)
2594 int ei_osabi
, e_flags
;
2596 switch (bfd_get_flavour (info
.abfd
))
2598 case bfd_target_aout_flavour
:
2599 /* Assume it's an old APCS-style ABI. */
2600 arm_abi
= ARM_ABI_APCS
;
2603 case bfd_target_coff_flavour
:
2604 /* Assume it's an old APCS-style ABI. */
2606 arm_abi
= ARM_ABI_APCS
;
2609 case bfd_target_elf_flavour
:
2610 ei_osabi
= elf_elfheader (info
.abfd
)->e_ident
[EI_OSABI
];
2611 e_flags
= elf_elfheader (info
.abfd
)->e_flags
;
2613 if (ei_osabi
== ELFOSABI_ARM
)
2615 /* GNU tools used to use this value, but do not for EABI
2616 objects. There's nowhere to tag an EABI version
2617 anyway, so assume APCS. */
2618 arm_abi
= ARM_ABI_APCS
;
2620 else if (ei_osabi
== ELFOSABI_NONE
)
2622 int eabi_ver
= EF_ARM_EABI_VERSION (e_flags
);
2626 case EF_ARM_EABI_UNKNOWN
:
2627 /* Assume GNU tools. */
2628 arm_abi
= ARM_ABI_APCS
;
2631 case EF_ARM_EABI_VER4
:
2632 case EF_ARM_EABI_VER5
:
2633 arm_abi
= ARM_ABI_AAPCS
;
2634 /* EABI binaries default to VFP float ordering. */
2635 if (fp_model
== ARM_FLOAT_AUTO
)
2636 fp_model
= ARM_FLOAT_SOFT_VFP
;
2640 /* Leave it as "auto". */
2641 warning (_("unknown ARM EABI version 0x%x"), eabi_ver
);
2646 if (fp_model
== ARM_FLOAT_AUTO
)
2648 int e_flags
= elf_elfheader (info
.abfd
)->e_flags
;
2650 switch (e_flags
& (EF_ARM_SOFT_FLOAT
| EF_ARM_VFP_FLOAT
))
2653 /* Leave it as "auto". Strictly speaking this case
2654 means FPA, but almost nobody uses that now, and
2655 many toolchains fail to set the appropriate bits
2656 for the floating-point model they use. */
2658 case EF_ARM_SOFT_FLOAT
:
2659 fp_model
= ARM_FLOAT_SOFT_FPA
;
2661 case EF_ARM_VFP_FLOAT
:
2662 fp_model
= ARM_FLOAT_VFP
;
2664 case EF_ARM_SOFT_FLOAT
| EF_ARM_VFP_FLOAT
:
2665 fp_model
= ARM_FLOAT_SOFT_VFP
;
2672 /* Leave it as "auto". */
2677 /* Now that we have inferred any architecture settings that we
2678 can, try to inherit from the last ARM ABI. */
2681 if (arm_abi
== ARM_ABI_AUTO
)
2682 arm_abi
= gdbarch_tdep (arches
->gdbarch
)->arm_abi
;
2684 if (fp_model
== ARM_FLOAT_AUTO
)
2685 fp_model
= gdbarch_tdep (arches
->gdbarch
)->fp_model
;
2689 /* There was no prior ARM architecture; fill in default values. */
2691 if (arm_abi
== ARM_ABI_AUTO
)
2692 arm_abi
= ARM_ABI_APCS
;
2694 /* We used to default to FPA for generic ARM, but almost nobody
2695 uses that now, and we now provide a way for the user to force
2696 the model. So default to the most useful variant. */
2697 if (fp_model
== ARM_FLOAT_AUTO
)
2698 fp_model
= ARM_FLOAT_SOFT_FPA
;
2701 /* If there is already a candidate, use it. */
2702 for (best_arch
= gdbarch_list_lookup_by_info (arches
, &info
);
2704 best_arch
= gdbarch_list_lookup_by_info (best_arch
->next
, &info
))
2706 if (arm_abi
!= gdbarch_tdep (best_arch
->gdbarch
)->arm_abi
)
2709 if (fp_model
!= gdbarch_tdep (best_arch
->gdbarch
)->fp_model
)
2712 /* Found a match. */
2716 if (best_arch
!= NULL
)
2717 return best_arch
->gdbarch
;
2719 tdep
= xcalloc (1, sizeof (struct gdbarch_tdep
));
2720 gdbarch
= gdbarch_alloc (&info
, tdep
);
2722 /* Record additional information about the architecture we are defining.
2723 These are gdbarch discriminators, like the OSABI. */
2724 tdep
->arm_abi
= arm_abi
;
2725 tdep
->fp_model
= fp_model
;
2728 switch (info
.byte_order
)
2730 case BFD_ENDIAN_BIG
:
2731 tdep
->arm_breakpoint
= arm_default_arm_be_breakpoint
;
2732 tdep
->arm_breakpoint_size
= sizeof (arm_default_arm_be_breakpoint
);
2733 tdep
->thumb_breakpoint
= arm_default_thumb_be_breakpoint
;
2734 tdep
->thumb_breakpoint_size
= sizeof (arm_default_thumb_be_breakpoint
);
2738 case BFD_ENDIAN_LITTLE
:
2739 tdep
->arm_breakpoint
= arm_default_arm_le_breakpoint
;
2740 tdep
->arm_breakpoint_size
= sizeof (arm_default_arm_le_breakpoint
);
2741 tdep
->thumb_breakpoint
= arm_default_thumb_le_breakpoint
;
2742 tdep
->thumb_breakpoint_size
= sizeof (arm_default_thumb_le_breakpoint
);
2747 internal_error (__FILE__
, __LINE__
,
2748 _("arm_gdbarch_init: bad byte order for float format"));
2751 /* On ARM targets char defaults to unsigned. */
2752 set_gdbarch_char_signed (gdbarch
, 0);
2754 /* This should be low enough for everything. */
2755 tdep
->lowest_pc
= 0x20;
2756 tdep
->jb_pc
= -1; /* Longjump support not enabled by default. */
2758 /* The default, for both APCS and AAPCS, is to return small
2759 structures in registers. */
2760 tdep
->struct_return
= reg_struct_return
;
2762 set_gdbarch_push_dummy_call (gdbarch
, arm_push_dummy_call
);
2763 set_gdbarch_frame_align (gdbarch
, arm_frame_align
);
2765 set_gdbarch_write_pc (gdbarch
, arm_write_pc
);
2767 /* Frame handling. */
2768 set_gdbarch_unwind_dummy_id (gdbarch
, arm_unwind_dummy_id
);
2769 set_gdbarch_unwind_pc (gdbarch
, arm_unwind_pc
);
2770 set_gdbarch_unwind_sp (gdbarch
, arm_unwind_sp
);
2772 frame_base_set_default (gdbarch
, &arm_normal_base
);
2774 /* Address manipulation. */
2775 set_gdbarch_smash_text_address (gdbarch
, arm_smash_text_address
);
2776 set_gdbarch_addr_bits_remove (gdbarch
, arm_addr_bits_remove
);
2778 /* Advance PC across function entry code. */
2779 set_gdbarch_skip_prologue (gdbarch
, arm_skip_prologue
);
2781 /* The stack grows downward. */
2782 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
2784 /* Breakpoint manipulation. */
2785 set_gdbarch_breakpoint_from_pc (gdbarch
, arm_breakpoint_from_pc
);
2787 /* Information about registers, etc. */
2788 set_gdbarch_print_float_info (gdbarch
, arm_print_float_info
);
2789 set_gdbarch_deprecated_fp_regnum (gdbarch
, ARM_FP_REGNUM
); /* ??? */
2790 set_gdbarch_sp_regnum (gdbarch
, ARM_SP_REGNUM
);
2791 set_gdbarch_pc_regnum (gdbarch
, ARM_PC_REGNUM
);
2792 set_gdbarch_deprecated_register_byte (gdbarch
, arm_register_byte
);
2793 set_gdbarch_num_regs (gdbarch
, NUM_GREGS
+ NUM_FREGS
+ NUM_SREGS
);
2794 set_gdbarch_register_type (gdbarch
, arm_register_type
);
2796 /* Internal <-> external register number maps. */
2797 set_gdbarch_register_sim_regno (gdbarch
, arm_register_sim_regno
);
2799 /* Integer registers are 4 bytes. */
2800 set_gdbarch_deprecated_register_size (gdbarch
, 4);
2801 set_gdbarch_register_name (gdbarch
, arm_register_name
);
2803 /* Returning results. */
2804 set_gdbarch_return_value (gdbarch
, arm_return_value
);
2806 /* Single stepping. */
2807 /* XXX For an RDI target we should ask the target if it can single-step. */
2808 set_gdbarch_software_single_step (gdbarch
, arm_software_single_step
);
2811 set_gdbarch_print_insn (gdbarch
, gdb_print_insn_arm
);
2813 /* Minsymbol frobbing. */
2814 set_gdbarch_elf_make_msymbol_special (gdbarch
, arm_elf_make_msymbol_special
);
2815 set_gdbarch_coff_make_msymbol_special (gdbarch
,
2816 arm_coff_make_msymbol_special
);
2818 /* Virtual tables. */
2819 set_gdbarch_vbit_in_delta (gdbarch
, 1);
2821 /* Hook in the ABI-specific overrides, if they have been registered. */
2822 gdbarch_init_osabi (info
, gdbarch
);
2824 /* Add some default predicates. */
2825 frame_unwind_append_sniffer (gdbarch
, arm_stub_unwind_sniffer
);
2826 frame_unwind_append_sniffer (gdbarch
, dwarf2_frame_sniffer
);
2827 frame_unwind_append_sniffer (gdbarch
, arm_prologue_unwind_sniffer
);
2829 /* Now we have tuned the configuration, set a few final things,
2830 based on what the OS ABI has told us. */
2832 if (tdep
->jb_pc
>= 0)
2833 set_gdbarch_get_longjmp_target (gdbarch
, arm_get_longjmp_target
);
2835 /* Floating point sizes and format. */
2836 switch (info
.byte_order
)
2838 case BFD_ENDIAN_BIG
:
2839 set_gdbarch_float_format (gdbarch
, &floatformat_ieee_single_big
);
2840 set_gdbarch_double_format (gdbarch
, &floatformat_ieee_double_big
);
2841 set_gdbarch_long_double_format (gdbarch
, &floatformat_ieee_double_big
);
2844 case BFD_ENDIAN_LITTLE
:
2845 set_gdbarch_float_format (gdbarch
, &floatformat_ieee_single_little
);
2846 if (fp_model
== ARM_FLOAT_SOFT_FPA
|| fp_model
== ARM_FLOAT_FPA
)
2848 set_gdbarch_double_format
2849 (gdbarch
, &floatformat_ieee_double_littlebyte_bigword
);
2850 set_gdbarch_long_double_format
2851 (gdbarch
, &floatformat_ieee_double_littlebyte_bigword
);
2855 set_gdbarch_double_format (gdbarch
, &floatformat_ieee_double_little
);
2856 set_gdbarch_long_double_format (gdbarch
,
2857 &floatformat_ieee_double_little
);
2862 internal_error (__FILE__
, __LINE__
,
2863 _("arm_gdbarch_init: bad byte order for float format"));
2870 arm_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
2872 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
2877 fprintf_unfiltered (file
, _("arm_dump_tdep: Lowest pc = 0x%lx"),
2878 (unsigned long) tdep
->lowest_pc
);
2881 extern initialize_file_ftype _initialize_arm_tdep
; /* -Wmissing-prototypes */
2884 _initialize_arm_tdep (void)
2886 struct ui_file
*stb
;
2888 struct cmd_list_element
*new_set
, *new_show
;
2889 const char *setname
;
2890 const char *setdesc
;
2891 const char *const *regnames
;
2893 static char *helptext
;
2894 char regdesc
[1024], *rdptr
= regdesc
;
2895 size_t rest
= sizeof (regdesc
);
2897 gdbarch_register (bfd_arch_arm
, arm_gdbarch_init
, arm_dump_tdep
);
2899 /* Register an ELF OS ABI sniffer for ARM binaries. */
2900 gdbarch_register_osabi_sniffer (bfd_arch_arm
,
2901 bfd_target_elf_flavour
,
2902 arm_elf_osabi_sniffer
);
2904 /* Get the number of possible sets of register names defined in opcodes. */
2905 num_disassembly_options
= get_arm_regname_num_options ();
2907 /* Add root prefix command for all "set arm"/"show arm" commands. */
2908 add_prefix_cmd ("arm", no_class
, set_arm_command
,
2909 _("Various ARM-specific commands."),
2910 &setarmcmdlist
, "set arm ", 0, &setlist
);
2912 add_prefix_cmd ("arm", no_class
, show_arm_command
,
2913 _("Various ARM-specific commands."),
2914 &showarmcmdlist
, "show arm ", 0, &showlist
);
2916 /* Sync the opcode insn printer with our register viewer. */
2917 parse_arm_disassembler_option ("reg-names-std");
2919 /* Initialize the array that will be passed to
2920 add_setshow_enum_cmd(). */
2921 valid_disassembly_styles
2922 = xmalloc ((num_disassembly_options
+ 1) * sizeof (char *));
2923 for (i
= 0; i
< num_disassembly_options
; i
++)
2925 numregs
= get_arm_regnames (i
, &setname
, &setdesc
, ®names
);
2926 valid_disassembly_styles
[i
] = setname
;
2927 length
= snprintf (rdptr
, rest
, "%s - %s\n", setname
, setdesc
);
2930 /* Copy the default names (if found) and synchronize disassembler. */
2931 if (!strcmp (setname
, "std"))
2933 disassembly_style
= setname
;
2935 for (j
= 0; j
< numregs
; j
++)
2936 arm_register_names
[j
] = (char *) regnames
[j
];
2937 set_arm_regname_option (i
);
2940 /* Mark the end of valid options. */
2941 valid_disassembly_styles
[num_disassembly_options
] = NULL
;
2943 /* Create the help text. */
2944 stb
= mem_fileopen ();
2945 fprintf_unfiltered (stb
, "%s%s%s",
2946 _("The valid values are:\n"),
2948 _("The default is \"std\"."));
2949 helptext
= ui_file_xstrdup (stb
, &length
);
2950 ui_file_delete (stb
);
2952 add_setshow_enum_cmd("disassembler", no_class
,
2953 valid_disassembly_styles
, &disassembly_style
,
2954 _("Set the disassembly style."),
2955 _("Show the disassembly style."),
2957 set_disassembly_style_sfunc
,
2958 NULL
, /* FIXME: i18n: The disassembly style is \"%s\". */
2959 &setarmcmdlist
, &showarmcmdlist
);
2961 add_setshow_boolean_cmd ("apcs32", no_class
, &arm_apcs_32
,
2962 _("Set usage of ARM 32-bit mode."),
2963 _("Show usage of ARM 32-bit mode."),
2964 _("When off, a 26-bit PC will be used."),
2966 NULL
, /* FIXME: i18n: Usage of ARM 32-bit mode is %s. */
2967 &setarmcmdlist
, &showarmcmdlist
);
2969 /* Add a command to allow the user to force the FPU model. */
2970 add_setshow_enum_cmd ("fpu", no_class
, fp_model_strings
, ¤t_fp_model
,
2971 _("Set the floating point type."),
2972 _("Show the floating point type."),
2973 _("auto - Determine the FP typefrom the OS-ABI.\n\
2974 softfpa - Software FP, mixed-endian doubles on little-endian ARMs.\n\
2975 fpa - FPA co-processor (GCC compiled).\n\
2976 softvfp - Software FP with pure-endian doubles.\n\
2977 vfp - VFP co-processor."),
2978 set_fp_model_sfunc
, show_fp_model
,
2979 &setarmcmdlist
, &showarmcmdlist
);
2981 /* Add a command to allow the user to force the ABI. */
2982 add_setshow_enum_cmd ("abi", class_support
, arm_abi_strings
, &arm_abi_string
,
2985 NULL
, arm_set_abi
, arm_show_abi
,
2986 &setarmcmdlist
, &showarmcmdlist
);
2988 /* Debugging flag. */
2989 add_setshow_boolean_cmd ("arm", class_maintenance
, &arm_debug
,
2990 _("Set ARM debugging."),
2991 _("Show ARM debugging."),
2992 _("When on, arm-specific debugging is enabled."),
2994 NULL
, /* FIXME: i18n: "ARM debugging is %s. */
2995 &setdebuglist
, &showdebuglist
);