1 /* Target-dependent code for Analog Devices Blackfin processor, for GDB.
3 Copyright (C) 2005-2014 Free Software Foundation, Inc.
5 Contributed by Analog Devices, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "arch-utils.h"
29 #include "frame-unwind.h"
30 #include "frame-base.h"
31 #include "trad-frame.h"
33 #include "sim-regno.h"
34 #include "gdb/sim-bfin.h"
35 #include "dwarf2-frame.h"
41 #include "xml-syscall.h"
42 #include "bfin-tdep.h"
44 /* Macros used by prologue functions. */
45 #define P_LINKAGE 0xE800
46 #define P_MINUS_SP1 0x0140
47 #define P_MINUS_SP2 0x05C0
48 #define P_MINUS_SP3 0x0540
49 #define P_MINUS_SP4 0x04C0
50 #define P_SP_PLUS 0x6C06
51 #define P_P2_LOW 0xE10A
52 #define P_P2_HIGH 0XE14A
53 #define P_SP_EQ_SP_PLUS_P2 0X5BB2
54 #define P_SP_EQ_P2_PLUS_SP 0x5B96
55 #define P_MINUS_MINUS_SP_EQ_RETS 0x0167
57 /* Macros used for program flow control. */
58 /* 16 bit instruction, max */
59 #define P_16_BIT_INSR_MAX 0xBFFF
60 /* 32 bit instruction, min */
61 #define P_32_BIT_INSR_MIN 0xC000
62 /* 32 bit instruction, max */
63 #define P_32_BIT_INSR_MAX 0xE801
64 /* jump (preg), 16-bit, min */
65 #define P_JUMP_PREG_MIN 0x0050
66 /* jump (preg), 16-bit, max */
67 #define P_JUMP_PREG_MAX 0x0057
68 /* jump (pc+preg), 16-bit, min */
69 #define P_JUMP_PC_PLUS_PREG_MIN 0x0080
70 /* jump (pc+preg), 16-bit, max */
71 #define P_JUMP_PC_PLUS_PREG_MAX 0x0087
72 /* jump.s pcrel13m2, 16-bit, min */
73 #define P_JUMP_S_MIN 0x2000
74 /* jump.s pcrel13m2, 16-bit, max */
75 #define P_JUMP_S_MAX 0x2FFF
76 /* jump.l pcrel25m2, 32-bit, min */
77 #define P_JUMP_L_MIN 0xE200
78 /* jump.l pcrel25m2, 32-bit, max */
79 #define P_JUMP_L_MAX 0xE2FF
80 /* conditional jump pcrel11m2, 16-bit, min */
81 #define P_IF_CC_JUMP_MIN 0x1800
82 /* conditional jump pcrel11m2, 16-bit, max */
83 #define P_IF_CC_JUMP_MAX 0x1BFF
84 /* conditional jump(bp) pcrel11m2, 16-bit, min */
85 #define P_IF_CC_JUMP_BP_MIN 0x1C00
86 /* conditional jump(bp) pcrel11m2, 16-bit, max */
87 #define P_IF_CC_JUMP_BP_MAX 0x1FFF
88 /* conditional !jump pcrel11m2, 16-bit, min */
89 #define P_IF_NOT_CC_JUMP_MIN 0x1000
90 /* conditional !jump pcrel11m2, 16-bit, max */
91 #define P_IF_NOT_CC_JUMP_MAX 0x13FF
92 /* conditional jump(bp) pcrel11m2, 16-bit, min */
93 #define P_IF_NOT_CC_JUMP_BP_MIN 0x1400
94 /* conditional jump(bp) pcrel11m2, 16-bit, max */
95 #define P_IF_NOT_CC_JUMP_BP_MAX 0x17FF
96 /* call (preg), 16-bit, min */
97 #define P_CALL_PREG_MIN 0x0060
98 /* call (preg), 16-bit, max */
99 #define P_CALL_PREG_MAX 0x0067
100 /* call (pc+preg), 16-bit, min */
101 #define P_CALL_PC_PLUS_PREG_MIN 0x0070
102 /* call (pc+preg), 16-bit, max */
103 #define P_CALL_PC_PLUS_PREG_MAX 0x0077
104 /* call pcrel25m2, 32-bit, min */
105 #define P_CALL_MIN 0xE300
106 /* call pcrel25m2, 32-bit, max */
107 #define P_CALL_MAX 0xE3FF
111 #define P_MNOP 0xC803
112 /* EXCPT, 16-bit, min */
113 #define P_EXCPT_MIN 0x00A0
114 /* EXCPT, 16-bit, max */
115 #define P_EXCPT_MAX 0x00AF
116 /* multi instruction mask 1, 16-bit */
117 #define P_BIT_MULTI_INS_1 0xC000
118 /* multi instruction mask 2, 16-bit */
119 #define P_BIT_MULTI_INS_2 0x0800
121 /* The maximum bytes we search to skip the prologue. */
122 #define UPPER_LIMIT 40
125 #define ASTAT_CC_POS 5
126 #define ASTAT_CC (1 << ASTAT_CC_POS)
128 /* Initial value: Register names used in BFIN's ISA documentation. */
130 static const char * const bfin_register_name_strings[] =
132 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
133 "p0", "p1", "p2", "p3", "p4", "p5", "sp", "fp",
134 "i0", "i1", "i2", "i3", "m0", "m1", "m2", "m3",
135 "b0", "b1", "b2", "b3", "l0", "l1", "l2", "l3",
136 "a0x", "a0w", "a1x", "a1w", "astat", "rets",
137 "lc0", "lt0", "lb0", "lc1", "lt1", "lb1", "cycles", "cycles2",
138 "usp", "seqstat", "syscfg", "reti", "retx", "retn", "rete",
142 #define NUM_BFIN_REGNAMES ARRAY_SIZE (bfin_register_name_strings)
145 /* In this diagram successive memory locations increase downwards or the
146 stack grows upwards with negative indices. (PUSH analogy for stack.)
148 The top frame is the "frame" of the current function being executed.
150 +--------------+ SP -
154 +--------------+ FP |
156 +--------------+ | frame
168 +--------------+ | frame
178 +--------------+<- next frame
184 The frame chain is formed as following:
186 FP has the topmost frame.
187 FP + 4 has the previous FP and so on. */
190 /* Map from DWARF2 register number to GDB register number. */
192 static const int map_gcc_gdb[] =
226 BFIN_A0_DOT_X_REGNUM,
227 BFIN_A1_DOT_X_REGNUM,
246 struct bfin_frame_cache
252 int frameless_pc_value;
254 /* Saved registers. */
255 CORE_ADDR saved_regs[BFIN_NUM_REGS];
258 /* Stack space reserved for local variables. */
262 /* Allocate and initialize a frame cache. */
264 static struct bfin_frame_cache *
265 bfin_alloc_frame_cache (void)
267 struct bfin_frame_cache *cache;
270 cache = FRAME_OBSTACK_ZALLOC (struct bfin_frame_cache);
274 cache->sp_offset = -4;
276 cache->frameless_pc_value = 0;
278 /* Saved registers. We initialize these to -1 since zero is a valid
279 offset (that's where fp is supposed to be stored). */
280 for (i = 0; i < BFIN_NUM_REGS; i++)
281 cache->saved_regs[i] = -1;
283 /* Frameless until proven otherwise. */
289 static struct bfin_frame_cache *
290 bfin_frame_cache (struct frame_info *this_frame, void **this_cache)
292 struct bfin_frame_cache *cache;
298 cache = bfin_alloc_frame_cache ();
301 cache->base = get_frame_register_unsigned (this_frame, BFIN_FP_REGNUM);
302 if (cache->base == 0)
305 /* For normal frames, PC is stored at [FP + 4]. */
306 cache->saved_regs[BFIN_PC_REGNUM] = 4;
307 cache->saved_regs[BFIN_FP_REGNUM] = 0;
309 /* Adjust all the saved registers such that they contain addresses
310 instead of offsets. */
311 for (i = 0; i < BFIN_NUM_REGS; i++)
312 if (cache->saved_regs[i] != -1)
313 cache->saved_regs[i] += cache->base;
315 cache->pc = get_frame_func (this_frame) ;
316 if (cache->pc == 0 || cache->pc == get_frame_pc (this_frame))
318 /* Either there is no prologue (frameless function) or we are at
319 the start of a function. In short we do not have a frame.
320 PC is stored in rets register. FP points to previous frame. */
322 cache->saved_regs[BFIN_PC_REGNUM] =
323 get_frame_register_unsigned (this_frame, BFIN_RETS_REGNUM);
324 cache->frameless_pc_value = 1;
325 cache->base = get_frame_register_unsigned (this_frame, BFIN_FP_REGNUM);
326 cache->saved_regs[BFIN_FP_REGNUM] = cache->base;
327 cache->saved_sp = cache->base;
331 cache->frameless_pc_value = 0;
333 /* Now that we have the base address for the stack frame we can
334 calculate the value of SP in the calling frame. */
335 cache->saved_sp = cache->base + 8;
342 bfin_frame_this_id (struct frame_info *this_frame,
344 struct frame_id *this_id)
346 struct bfin_frame_cache *cache = bfin_frame_cache (this_frame, this_cache);
348 /* This marks the outermost frame. */
349 if (cache->base == 0)
352 /* See the end of bfin_push_dummy_call. */
353 *this_id = frame_id_build (cache->base + 8, cache->pc);
356 static struct value *
357 bfin_frame_prev_register (struct frame_info *this_frame,
361 struct gdbarch *gdbarch = get_frame_arch (this_frame);
362 struct bfin_frame_cache *cache = bfin_frame_cache (this_frame, this_cache);
364 if (regnum == gdbarch_sp_regnum (gdbarch) && cache->saved_sp)
365 return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
367 if (regnum < BFIN_NUM_REGS && cache->saved_regs[regnum] != -1)
368 return frame_unwind_got_memory (this_frame, regnum,
369 cache->saved_regs[regnum]);
371 return frame_unwind_got_register (this_frame, regnum, regnum);
374 static const struct frame_unwind bfin_frame_unwind =
377 default_frame_unwind_stop_reason,
379 bfin_frame_prev_register,
381 default_frame_sniffer
384 /* Check for "[--SP] = <reg>;" insns. These are appear in function
385 prologues to save misc registers onto the stack. */
388 is_minus_minus_sp (int op)
392 if ((op == P_MINUS_SP1) || (op == P_MINUS_SP2)
393 || (op == P_MINUS_SP3) || (op == P_MINUS_SP4))
399 /* Skip all the insns that appear in generated function prologues. */
402 bfin_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
404 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
405 int op = read_memory_unsigned_integer (pc, 2, byte_order);
406 CORE_ADDR orig_pc = pc;
409 /* The new gcc prologue generates the register saves BEFORE the link
410 or RETS saving instruction.
411 So, our job is to stop either at those instructions or some upper
412 limit saying there is no frame! */
416 if (is_minus_minus_sp (op))
418 while (is_minus_minus_sp (op))
421 op = read_memory_unsigned_integer (pc, 2, byte_order);
429 else if (op == P_LINKAGE)
434 else if (op == P_MINUS_MINUS_SP_EQ_RETS)
439 else if (op == P_RTS)
443 else if ((op >= P_JUMP_PREG_MIN && op <= P_JUMP_PREG_MAX)
444 || (op >= P_JUMP_PC_PLUS_PREG_MIN
445 && op <= P_JUMP_PC_PLUS_PREG_MAX)
446 || (op == P_JUMP_S_MIN && op <= P_JUMP_S_MAX))
450 else if (pc - orig_pc >= UPPER_LIMIT)
452 warning (_("Function Prologue not recognised; "
453 "pc will point to ENTRY_POINT of the function"));
459 pc += 2; /* Not a terminating instruction go on. */
460 op = read_memory_unsigned_integer (pc, 2, byte_order);
465 Dwarf2 uses entry point value AFTER some register initializations.
466 We should perhaps skip such asssignments as well (R6 = R1, ...). */
471 /* Return the GDB type object for the "standard" data type of data in
472 register N. This should be void pointer for P0-P5, SP, FP;
473 void pointer to function for PC; int otherwise. */
476 bfin_register_type (struct gdbarch *gdbarch, int regnum)
478 if ((regnum >= BFIN_P0_REGNUM && regnum <= BFIN_FP_REGNUM)
479 || regnum == BFIN_USP_REGNUM)
480 return builtin_type (gdbarch)->builtin_data_ptr;
482 if (regnum == BFIN_PC_REGNUM || regnum == BFIN_RETS_REGNUM
483 || regnum == BFIN_RETI_REGNUM || regnum == BFIN_RETX_REGNUM
484 || regnum == BFIN_RETN_REGNUM || regnum == BFIN_RETE_REGNUM
485 || regnum == BFIN_LT0_REGNUM || regnum == BFIN_LB0_REGNUM
486 || regnum == BFIN_LT1_REGNUM || regnum == BFIN_LB1_REGNUM)
487 return builtin_type (gdbarch)->builtin_func_ptr;
489 return builtin_type (gdbarch)->builtin_int32;
493 bfin_push_dummy_call (struct gdbarch *gdbarch,
494 struct value *function,
495 struct regcache *regcache,
501 CORE_ADDR struct_addr)
503 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
504 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
507 long reg_r0, reg_r1, reg_r2;
509 enum bfin_abi abi = bfin_abi (gdbarch);
510 CORE_ADDR func_addr = find_function_addr (function, NULL);
512 for (i = nargs - 1; i >= 0; i--)
514 struct type *value_type = value_enclosing_type (args[i]);
516 total_len += (TYPE_LENGTH (value_type) + 3) & ~3;
519 /* At least twelve bytes of stack space must be allocated for the function's
520 arguments, even for functions that have less than 12 bytes of argument
524 sp -= 12 - total_len;
526 /* Push arguments in reverse order. */
528 for (i = nargs - 1; i >= 0; i--)
530 struct type *value_type = value_enclosing_type (args[i]);
531 struct type *arg_type = check_typedef (value_type);
532 int container_len = (TYPE_LENGTH (value_type) + 3) & ~3;
535 write_memory (sp, value_contents_writeable (args[i]), container_len);
538 /* Initialize R0, R1, and R2 to the first 3 words of parameters. */
540 reg_r0 = read_memory_integer (sp, 4, byte_order);
541 regcache_cooked_write_unsigned (regcache, BFIN_R0_REGNUM, reg_r0);
542 reg_r1 = read_memory_integer (sp + 4, 4, byte_order);
543 regcache_cooked_write_unsigned (regcache, BFIN_R1_REGNUM, reg_r1);
544 reg_r2 = read_memory_integer (sp + 8, 4, byte_order);
545 regcache_cooked_write_unsigned (regcache, BFIN_R2_REGNUM, reg_r2);
547 /* Store struct value address. */
550 regcache_cooked_write_unsigned (regcache, BFIN_P0_REGNUM, struct_addr);
552 /* Set the dummy return value to bp_addr.
553 A dummy breakpoint will be setup to execute the call. */
555 regcache_cooked_write_unsigned (regcache, BFIN_RETS_REGNUM, bp_addr);
557 /* Finally, update the stack pointer. */
559 regcache_cooked_write_unsigned (regcache, BFIN_SP_REGNUM, sp);
564 /* Convert DWARF2 register number REG to the appropriate register number
568 bfin_reg_to_regnum (struct gdbarch *gdbarch, int reg)
570 if (reg > ARRAY_SIZE (map_gcc_gdb))
573 return map_gcc_gdb[reg];
576 /* This function implements the 'breakpoint_from_pc' gdbarch method.
577 It returns a pointer to a string of bytes that encode a breakpoint
578 instruction, stores the length of the string to *lenptr, and
579 adjusts the program counter (if necessary) to point to the actual
580 memory location where the breakpoint should be inserted. */
582 static const unsigned char *
583 bfin_breakpoint_from_pc (struct gdbarch *gdbarch,
584 CORE_ADDR *pcptr, int *lenptr)
586 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
588 static unsigned char bfin_breakpoint[] = {0xa1, 0x00, 0x00, 0x00};
589 static unsigned char bfin_sim_breakpoint[] = {0x25, 0x00, 0x00, 0x00};
591 iw = read_memory_unsigned_integer (*pcptr, 2, byte_order);
593 if ((iw & 0xf000) >= 0xc000)
594 /* 32-bit instruction. */
599 if (strcmp (target_shortname, "sim") == 0)
600 return bfin_sim_breakpoint;
602 return bfin_breakpoint;
606 bfin_extract_return_value (struct type *type,
607 struct regcache *regs,
610 struct gdbarch *gdbarch = get_regcache_arch (regs);
611 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
612 bfd_byte *valbuf = dst;
613 int len = TYPE_LENGTH (type);
615 int regno = BFIN_R0_REGNUM;
617 gdb_assert (len <= 8);
621 regcache_cooked_read_unsigned (regs, regno++, &tmp);
622 store_unsigned_integer (valbuf, (len > 4 ? 4 : len), byte_order, tmp);
628 /* Write into appropriate registers a function return value of type
629 TYPE, given in virtual format. */
632 bfin_store_return_value (struct type *type,
633 struct regcache *regs,
636 const bfd_byte *valbuf = src;
638 /* Integral values greater than one word are stored in consecutive
639 registers starting with R0. This will always be a multiple of
640 the register size. */
642 int len = TYPE_LENGTH (type);
643 int regno = BFIN_R0_REGNUM;
645 gdb_assert (len <= 8);
649 regcache_cooked_write (regs, regno++, valbuf);
655 /* Determine, for architecture GDBARCH, how a return value of TYPE
656 should be returned. If it is supposed to be returned in registers,
657 and READBUF is nonzero, read the appropriate value from REGCACHE,
658 and copy it into READBUF. If WRITEBUF is nonzero, write the value
659 from WRITEBUF into REGCACHE. */
661 static enum return_value_convention
662 bfin_return_value (struct gdbarch *gdbarch,
663 struct value *function,
665 struct regcache *regcache,
667 const gdb_byte *writebuf)
669 if (TYPE_LENGTH (type) > 8)
670 return RETURN_VALUE_STRUCT_CONVENTION;
673 bfin_extract_return_value (type, regcache, readbuf);
676 bfin_store_return_value (type, regcache, writebuf);
678 return RETURN_VALUE_REGISTER_CONVENTION;
681 /* Return the BFIN register name corresponding to register I. */
684 bfin_register_name (struct gdbarch *gdbarch, int i)
686 return bfin_register_name_strings[i];
689 static enum register_status
690 bfin_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
691 int regnum, gdb_byte *buffer)
693 gdb_byte *buf = (gdb_byte *) alloca (MAX_REGISTER_SIZE);
694 enum register_status status;
696 if (regnum != BFIN_CC_REGNUM)
697 internal_error (__FILE__, __LINE__,
698 _("invalid register number %d"), regnum);
700 /* Extract the CC bit from the ASTAT register. */
701 status = regcache_raw_read (regcache, BFIN_ASTAT_REGNUM, buf);
702 if (status == REG_VALID)
704 buffer[1] = buffer[2] = buffer[3] = 0;
705 buffer[0] = !!(buf[0] & ASTAT_CC);
711 bfin_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
712 int regnum, const gdb_byte *buffer)
714 gdb_byte *buf = (gdb_byte *) alloca (MAX_REGISTER_SIZE);
716 if (regnum != BFIN_CC_REGNUM)
717 internal_error (__FILE__, __LINE__,
718 _("invalid register number %d"), regnum);
720 /* Overlay the CC bit in the ASTAT register. */
721 regcache_raw_read (regcache, BFIN_ASTAT_REGNUM, buf);
722 buf[0] = (buf[0] & ~ASTAT_CC) | ((buffer[0] & 1) << ASTAT_CC_POS);
723 regcache_raw_write (regcache, BFIN_ASTAT_REGNUM, buf);
727 bfin_frame_base_address (struct frame_info *this_frame, void **this_cache)
729 struct bfin_frame_cache *cache = bfin_frame_cache (this_frame, this_cache);
735 bfin_frame_local_address (struct frame_info *this_frame, void **this_cache)
737 struct bfin_frame_cache *cache = bfin_frame_cache (this_frame, this_cache);
739 return cache->base - 4;
743 bfin_frame_args_address (struct frame_info *this_frame, void **this_cache)
745 struct bfin_frame_cache *cache = bfin_frame_cache (this_frame, this_cache);
747 return cache->base + 8;
750 static const struct frame_base bfin_frame_base =
753 bfin_frame_base_address,
754 bfin_frame_local_address,
755 bfin_frame_args_address
758 static struct frame_id
759 bfin_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
763 sp = get_frame_register_unsigned (this_frame, BFIN_SP_REGNUM);
765 return frame_id_build (sp, get_frame_pc (this_frame));
769 bfin_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
771 return frame_unwind_register_unsigned (next_frame, BFIN_PC_REGNUM);
775 bfin_frame_align (struct gdbarch *gdbarch, CORE_ADDR address)
777 return (address & ~0x3);
781 bfin_abi (struct gdbarch *gdbarch)
783 return gdbarch_tdep (gdbarch)->bfin_abi;
786 /* Initialize the current architecture based on INFO. If possible,
787 re-use an architecture from ARCHES, which is a list of
788 architectures already created during this debugging session.
790 Called e.g. at program startup, when reading a core file, and when
791 reading a binary file. */
793 static struct gdbarch *
794 bfin_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
796 struct gdbarch_tdep *tdep;
797 struct gdbarch *gdbarch;
801 /* Extract the ELF flags, if available. */
802 if (info.abfd && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
803 elf_flags = elf_elfheader (info.abfd)->e_flags;
809 /* If there is already a candidate, use it. */
811 for (arches = gdbarch_list_lookup_by_info (arches, &info);
813 arches = gdbarch_list_lookup_by_info (arches->next, &info))
815 if (gdbarch_tdep (arches->gdbarch)->bfin_abi != abi)
817 return arches->gdbarch;
820 tdep = XNEW (struct gdbarch_tdep);
821 gdbarch = gdbarch_alloc (&info, tdep);
823 tdep->bfin_abi = abi;
825 set_gdbarch_num_regs (gdbarch, BFIN_NUM_REGS);
826 set_gdbarch_pseudo_register_read (gdbarch, bfin_pseudo_register_read);
827 set_gdbarch_pseudo_register_write (gdbarch, bfin_pseudo_register_write);
828 set_gdbarch_num_pseudo_regs (gdbarch, BFIN_NUM_PSEUDO_REGS);
829 set_gdbarch_sp_regnum (gdbarch, BFIN_SP_REGNUM);
830 set_gdbarch_pc_regnum (gdbarch, BFIN_PC_REGNUM);
831 set_gdbarch_ps_regnum (gdbarch, BFIN_ASTAT_REGNUM);
832 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, bfin_reg_to_regnum);
833 set_gdbarch_register_name (gdbarch, bfin_register_name);
834 set_gdbarch_register_type (gdbarch, bfin_register_type);
835 set_gdbarch_dummy_id (gdbarch, bfin_dummy_id);
836 set_gdbarch_push_dummy_call (gdbarch, bfin_push_dummy_call);
837 set_gdbarch_believe_pcc_promotion (gdbarch, 1);
838 set_gdbarch_return_value (gdbarch, bfin_return_value);
839 set_gdbarch_skip_prologue (gdbarch, bfin_skip_prologue);
840 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
841 set_gdbarch_breakpoint_from_pc (gdbarch, bfin_breakpoint_from_pc);
842 set_gdbarch_decr_pc_after_break (gdbarch, 2);
843 set_gdbarch_frame_args_skip (gdbarch, 8);
844 set_gdbarch_unwind_pc (gdbarch, bfin_unwind_pc);
845 set_gdbarch_frame_align (gdbarch, bfin_frame_align);
846 set_gdbarch_print_insn (gdbarch, print_insn_bfin);
848 /* Hook in ABI-specific overrides, if they have been registered. */
849 gdbarch_init_osabi (info, gdbarch);
851 dwarf2_append_unwinders (gdbarch);
853 frame_base_set_default (gdbarch, &bfin_frame_base);
855 frame_unwind_append_unwinder (gdbarch, &bfin_frame_unwind);
860 /* Provide a prototype to silence -Wmissing-prototypes. */
861 extern initialize_file_ftype _initialize_bfin_tdep;
864 _initialize_bfin_tdep (void)
866 register_gdbarch_init (bfd_arch_bfin, bfin_gdbarch_init);