Commit | Line | Data |
---|---|---|
5ecb7103 KB |
1 | /* Target-dependent code for GNU/Linux running on the Fujitsu FR-V, |
2 | for GDB. | |
155bd5d1 | 3 | |
42a4f53d | 4 | Copyright (C) 2004-2019 Free Software Foundation, Inc. |
5ecb7103 KB |
5 | |
6 | This file is part of GDB. | |
7 | ||
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 | |
a9762ec7 | 10 | the Free Software Foundation; either version 3 of the License, or |
5ecb7103 KB |
11 | (at your option) any later version. |
12 | ||
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. | |
17 | ||
18 | You should have received a copy of the GNU General Public License | |
a9762ec7 | 19 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
5ecb7103 KB |
20 | |
21 | #include "defs.h" | |
d55e5aa6 TT |
22 | |
23 | /* Local non-gdb includes. */ | |
5ecb7103 KB |
24 | #include "elf-bfd.h" |
25 | #include "elf/frv.h" | |
9df0bb3f | 26 | #include "frame-unwind.h" |
d55e5aa6 TT |
27 | #include "frame.h" |
28 | #include "frv-tdep.h" | |
29 | #include "gdbcore.h" | |
a5ee0f0c | 30 | #include "linux-tdep.h" |
d55e5aa6 TT |
31 | #include "osabi.h" |
32 | #include "regcache.h" | |
33 | #include "regset.h" | |
34 | #include "target.h" | |
35 | #include "trad-frame.h" | |
5ecb7103 KB |
36 | |
37 | /* Define the size (in bytes) of an FR-V instruction. */ | |
38 | static const int frv_instr_size = 4; | |
39 | ||
40 | enum { | |
41 | NORMAL_SIGTRAMP = 1, | |
42 | RT_SIGTRAMP = 2 | |
43 | }; | |
44 | ||
45 | static int | |
2c02bd72 DE |
46 | frv_linux_pc_in_sigtramp (struct gdbarch *gdbarch, CORE_ADDR pc, |
47 | const char *name) | |
5ecb7103 | 48 | { |
e17a4113 | 49 | enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); |
e362b510 | 50 | gdb_byte buf[frv_instr_size]; |
5ecb7103 KB |
51 | LONGEST instr; |
52 | int retval = 0; | |
53 | ||
54 | if (target_read_memory (pc, buf, sizeof buf) != 0) | |
55 | return 0; | |
56 | ||
e17a4113 | 57 | instr = extract_unsigned_integer (buf, sizeof buf, byte_order); |
5ecb7103 KB |
58 | |
59 | if (instr == 0x8efc0077) /* setlos #__NR_sigreturn, gr7 */ | |
60 | retval = NORMAL_SIGTRAMP; | |
137a83b9 | 61 | else if (instr == 0x8efc00ad) /* setlos #__NR_rt_sigreturn, gr7 */ |
5ecb7103 KB |
62 | retval = RT_SIGTRAMP; |
63 | else | |
64 | return 0; | |
65 | ||
66 | if (target_read_memory (pc + frv_instr_size, buf, sizeof buf) != 0) | |
67 | return 0; | |
e17a4113 | 68 | instr = extract_unsigned_integer (buf, sizeof buf, byte_order); |
5ecb7103 KB |
69 | if (instr != 0xc0700000) /* tira gr0, 0 */ |
70 | return 0; | |
71 | ||
72 | /* If we get this far, we'll return a non-zero value, either | |
73 | NORMAL_SIGTRAMP (1) or RT_SIGTRAMP (2). */ | |
74 | return retval; | |
75 | } | |
76 | ||
f79d2c3c | 77 | /* Given NEXT_FRAME, the "callee" frame of the sigtramp frame that we |
5ecb7103 KB |
78 | wish to decode, and REGNO, one of the frv register numbers defined |
79 | in frv-tdep.h, return the address of the saved register (corresponding | |
80 | to REGNO) in the sigtramp frame. Return -1 if the register is not | |
81 | found in the sigtramp frame. The magic numbers in the code below | |
82 | were computed by examining the following kernel structs: | |
83 | ||
f79d2c3c | 84 | From arch/frv/kernel/signal.c: |
5ecb7103 KB |
85 | |
86 | struct sigframe | |
87 | { | |
88 | void (*pretcode)(void); | |
89 | int sig; | |
90 | struct sigcontext sc; | |
91 | unsigned long extramask[_NSIG_WORDS-1]; | |
92 | uint32_t retcode[2]; | |
93 | }; | |
94 | ||
95 | struct rt_sigframe | |
96 | { | |
97 | void (*pretcode)(void); | |
98 | int sig; | |
99 | struct siginfo *pinfo; | |
100 | void *puc; | |
101 | struct siginfo info; | |
102 | struct ucontext uc; | |
103 | uint32_t retcode[2]; | |
104 | }; | |
105 | ||
f79d2c3c | 106 | From include/asm-frv/ucontext.h: |
5ecb7103 KB |
107 | |
108 | struct ucontext { | |
109 | unsigned long uc_flags; | |
110 | struct ucontext *uc_link; | |
111 | stack_t uc_stack; | |
112 | struct sigcontext uc_mcontext; | |
113 | sigset_t uc_sigmask; | |
114 | }; | |
115 | ||
f79d2c3c KB |
116 | From include/asm-frv/signal.h: |
117 | ||
118 | typedef struct sigaltstack { | |
119 | void *ss_sp; | |
120 | int ss_flags; | |
121 | size_t ss_size; | |
122 | } stack_t; | |
123 | ||
124 | From include/asm-frv/sigcontext.h: | |
5ecb7103 KB |
125 | |
126 | struct sigcontext { | |
127 | struct user_context sc_context; | |
128 | unsigned long sc_oldmask; | |
129 | } __attribute__((aligned(8))); | |
130 | ||
f79d2c3c | 131 | From include/asm-frv/registers.h: |
5ecb7103 KB |
132 | struct user_int_regs |
133 | { | |
134 | unsigned long psr; | |
135 | unsigned long isr; | |
136 | unsigned long ccr; | |
137 | unsigned long cccr; | |
138 | unsigned long lr; | |
139 | unsigned long lcr; | |
140 | unsigned long pc; | |
141 | unsigned long __status; | |
142 | unsigned long syscallno; | |
143 | unsigned long orig_gr8; | |
144 | unsigned long gner[2]; | |
145 | unsigned long long iacc[1]; | |
146 | ||
147 | union { | |
148 | unsigned long tbr; | |
149 | unsigned long gr[64]; | |
150 | }; | |
151 | }; | |
152 | ||
153 | struct user_fpmedia_regs | |
154 | { | |
155 | unsigned long fr[64]; | |
156 | unsigned long fner[2]; | |
157 | unsigned long msr[2]; | |
158 | unsigned long acc[8]; | |
159 | unsigned char accg[8]; | |
160 | unsigned long fsr[1]; | |
161 | }; | |
162 | ||
163 | struct user_context | |
164 | { | |
165 | struct user_int_regs i; | |
166 | struct user_fpmedia_regs f; | |
167 | ||
168 | void *extension; | |
169 | } __attribute__((aligned(8))); */ | |
170 | ||
9df0bb3f | 171 | static LONGEST |
94afd7a6 | 172 | frv_linux_sigcontext_reg_addr (struct frame_info *this_frame, int regno, |
5ecb7103 KB |
173 | CORE_ADDR *sc_addr_cache_ptr) |
174 | { | |
e17a4113 UW |
175 | struct gdbarch *gdbarch = get_frame_arch (this_frame); |
176 | enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); | |
5ecb7103 KB |
177 | CORE_ADDR sc_addr; |
178 | ||
179 | if (sc_addr_cache_ptr && *sc_addr_cache_ptr) | |
180 | { | |
181 | sc_addr = *sc_addr_cache_ptr; | |
182 | } | |
183 | else | |
184 | { | |
185 | CORE_ADDR pc, sp; | |
e362b510 | 186 | gdb_byte buf[4]; |
5ecb7103 KB |
187 | int tramp_type; |
188 | ||
94afd7a6 | 189 | pc = get_frame_pc (this_frame); |
e17a4113 | 190 | tramp_type = frv_linux_pc_in_sigtramp (gdbarch, pc, 0); |
5ecb7103 | 191 | |
94afd7a6 | 192 | get_frame_register (this_frame, sp_regnum, buf); |
e17a4113 | 193 | sp = extract_unsigned_integer (buf, sizeof buf, byte_order); |
5ecb7103 KB |
194 | |
195 | if (tramp_type == NORMAL_SIGTRAMP) | |
196 | { | |
197 | /* For a normal sigtramp frame, the sigcontext struct starts | |
198 | at SP + 8. */ | |
199 | sc_addr = sp + 8; | |
200 | } | |
201 | else if (tramp_type == RT_SIGTRAMP) | |
202 | { | |
203 | /* For a realtime sigtramp frame, SP + 12 contains a pointer | |
4f0d78e0 | 204 | to a ucontext struct. The ucontext struct contains a |
f79d2c3c KB |
205 | sigcontext struct starting 24 bytes in. (The offset of |
206 | uc_mcontext within struct ucontext is derived as follows: | |
207 | stack_t is a 12-byte struct and struct sigcontext is | |
208 | 8-byte aligned. This gives an offset of 8 + 12 + 4 (for | |
0963b4bd | 209 | padding) = 24.) */ |
5ecb7103 KB |
210 | if (target_read_memory (sp + 12, buf, sizeof buf) != 0) |
211 | { | |
8a3fe4f8 | 212 | warning (_("Can't read realtime sigtramp frame.")); |
5ecb7103 KB |
213 | return 0; |
214 | } | |
e17a4113 | 215 | sc_addr = extract_unsigned_integer (buf, sizeof buf, byte_order); |
f79d2c3c | 216 | sc_addr += 24; |
5ecb7103 KB |
217 | } |
218 | else | |
e2e0b3e5 | 219 | internal_error (__FILE__, __LINE__, _("not a signal trampoline")); |
5ecb7103 KB |
220 | |
221 | if (sc_addr_cache_ptr) | |
222 | *sc_addr_cache_ptr = sc_addr; | |
223 | } | |
224 | ||
225 | switch (regno) | |
226 | { | |
227 | case psr_regnum : | |
228 | return sc_addr + 0; | |
229 | /* sc_addr + 4 has "isr", the Integer Status Register. */ | |
230 | case ccr_regnum : | |
231 | return sc_addr + 8; | |
232 | case cccr_regnum : | |
233 | return sc_addr + 12; | |
234 | case lr_regnum : | |
235 | return sc_addr + 16; | |
236 | case lcr_regnum : | |
237 | return sc_addr + 20; | |
238 | case pc_regnum : | |
239 | return sc_addr + 24; | |
240 | /* sc_addr + 28 is __status, the exception status. | |
241 | sc_addr + 32 is syscallno, the syscall number or -1. | |
242 | sc_addr + 36 is orig_gr8, the original syscall arg #1. | |
243 | sc_addr + 40 is gner[0]. | |
0963b4bd | 244 | sc_addr + 44 is gner[1]. */ |
5ecb7103 KB |
245 | case iacc0h_regnum : |
246 | return sc_addr + 48; | |
247 | case iacc0l_regnum : | |
248 | return sc_addr + 52; | |
249 | default : | |
250 | if (first_gpr_regnum <= regno && regno <= last_gpr_regnum) | |
251 | return sc_addr + 56 + 4 * (regno - first_gpr_regnum); | |
252 | else if (first_fpr_regnum <= regno && regno <= last_fpr_regnum) | |
253 | return sc_addr + 312 + 4 * (regno - first_fpr_regnum); | |
254 | else | |
0963b4bd | 255 | return -1; /* not saved. */ |
5ecb7103 KB |
256 | } |
257 | } | |
258 | ||
9df0bb3f AC |
259 | /* Signal trampolines. */ |
260 | ||
261 | static struct trad_frame_cache * | |
0963b4bd MS |
262 | frv_linux_sigtramp_frame_cache (struct frame_info *this_frame, |
263 | void **this_cache) | |
9df0bb3f | 264 | { |
e17a4113 | 265 | struct gdbarch *gdbarch = get_frame_arch (this_frame); |
e17a4113 | 266 | enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); |
9df0bb3f | 267 | struct trad_frame_cache *cache; |
9df0bb3f | 268 | CORE_ADDR addr; |
e362b510 | 269 | gdb_byte buf[4]; |
9df0bb3f AC |
270 | int regnum; |
271 | CORE_ADDR sc_addr_cache_val = 0; | |
272 | struct frame_id this_id; | |
273 | ||
274 | if (*this_cache) | |
9a3c8263 | 275 | return (struct trad_frame_cache *) *this_cache; |
9df0bb3f | 276 | |
94afd7a6 | 277 | cache = trad_frame_cache_zalloc (this_frame); |
9df0bb3f AC |
278 | |
279 | /* FIXME: cagney/2004-05-01: This is is long standing broken code. | |
280 | The frame ID's code address should be the start-address of the | |
281 | signal trampoline and not the current PC within that | |
282 | trampoline. */ | |
94afd7a6 | 283 | get_frame_register (this_frame, sp_regnum, buf); |
e17a4113 UW |
284 | addr = extract_unsigned_integer (buf, sizeof buf, byte_order); |
285 | this_id = frame_id_build (addr, get_frame_pc (this_frame)); | |
9df0bb3f AC |
286 | trad_frame_set_id (cache, this_id); |
287 | ||
288 | for (regnum = 0; regnum < frv_num_regs; regnum++) | |
289 | { | |
94afd7a6 | 290 | LONGEST reg_addr = frv_linux_sigcontext_reg_addr (this_frame, regnum, |
9df0bb3f AC |
291 | &sc_addr_cache_val); |
292 | if (reg_addr != -1) | |
293 | trad_frame_set_reg_addr (cache, regnum, reg_addr); | |
294 | } | |
295 | ||
296 | *this_cache = cache; | |
297 | return cache; | |
298 | } | |
299 | ||
300 | static void | |
0963b4bd MS |
301 | frv_linux_sigtramp_frame_this_id (struct frame_info *this_frame, |
302 | void **this_cache, | |
303 | struct frame_id *this_id) | |
9df0bb3f | 304 | { |
0963b4bd MS |
305 | struct trad_frame_cache *cache |
306 | = frv_linux_sigtramp_frame_cache (this_frame, this_cache); | |
9df0bb3f AC |
307 | trad_frame_get_id (cache, this_id); |
308 | } | |
309 | ||
94afd7a6 UW |
310 | static struct value * |
311 | frv_linux_sigtramp_frame_prev_register (struct frame_info *this_frame, | |
312 | void **this_cache, int regnum) | |
9df0bb3f AC |
313 | { |
314 | /* Make sure we've initialized the cache. */ | |
0963b4bd MS |
315 | struct trad_frame_cache *cache |
316 | = frv_linux_sigtramp_frame_cache (this_frame, this_cache); | |
94afd7a6 | 317 | return trad_frame_get_register (cache, this_frame, regnum); |
9df0bb3f AC |
318 | } |
319 | ||
94afd7a6 UW |
320 | static int |
321 | frv_linux_sigtramp_frame_sniffer (const struct frame_unwind *self, | |
322 | struct frame_info *this_frame, | |
323 | void **this_cache) | |
9df0bb3f | 324 | { |
e17a4113 | 325 | struct gdbarch *gdbarch = get_frame_arch (this_frame); |
94afd7a6 | 326 | CORE_ADDR pc = get_frame_pc (this_frame); |
2c02bd72 | 327 | const char *name; |
9df0bb3f AC |
328 | |
329 | find_pc_partial_function (pc, &name, NULL, NULL); | |
e17a4113 | 330 | if (frv_linux_pc_in_sigtramp (gdbarch, pc, name)) |
94afd7a6 | 331 | return 1; |
9df0bb3f | 332 | |
94afd7a6 | 333 | return 0; |
9df0bb3f AC |
334 | } |
335 | ||
94afd7a6 UW |
336 | static const struct frame_unwind frv_linux_sigtramp_frame_unwind = |
337 | { | |
338 | SIGTRAMP_FRAME, | |
8fbca658 | 339 | default_frame_unwind_stop_reason, |
94afd7a6 UW |
340 | frv_linux_sigtramp_frame_this_id, |
341 | frv_linux_sigtramp_frame_prev_register, | |
342 | NULL, | |
343 | frv_linux_sigtramp_frame_sniffer | |
344 | }; | |
7c699b81 KB |
345 | \f |
346 | /* The FRV kernel defines ELF_NGREG as 46. We add 2 in order to include | |
347 | the loadmap addresses in the register set. (See below for more info.) */ | |
348 | #define FRV_ELF_NGREG (46 + 2) | |
349 | typedef unsigned char frv_elf_greg_t[4]; | |
350 | typedef struct { frv_elf_greg_t reg[FRV_ELF_NGREG]; } frv_elf_gregset_t; | |
351 | ||
352 | typedef unsigned char frv_elf_fpreg_t[4]; | |
353 | typedef struct | |
354 | { | |
355 | frv_elf_fpreg_t fr[64]; | |
356 | frv_elf_fpreg_t fner[2]; | |
357 | frv_elf_fpreg_t msr[2]; | |
358 | frv_elf_fpreg_t acc[8]; | |
359 | unsigned char accg[8]; | |
360 | frv_elf_fpreg_t fsr[1]; | |
361 | } frv_elf_fpregset_t; | |
362 | ||
901e1b23 AA |
363 | /* Register maps. */ |
364 | ||
365 | static const struct regcache_map_entry frv_linux_gregmap[] = | |
366 | { | |
367 | { 1, psr_regnum, 4 }, | |
368 | { 1, REGCACHE_MAP_SKIP, 4 }, /* isr */ | |
369 | { 1, ccr_regnum, 4 }, | |
370 | { 1, cccr_regnum, 4 }, | |
371 | { 1, lr_regnum, 4 }, | |
372 | { 1, lcr_regnum, 4 }, | |
373 | { 1, pc_regnum, 4 }, | |
374 | { 1, REGCACHE_MAP_SKIP, 4 }, /* __status */ | |
375 | { 1, REGCACHE_MAP_SKIP, 4 }, /* syscallno */ | |
376 | { 1, REGCACHE_MAP_SKIP, 4 }, /* orig_gr8 */ | |
377 | { 1, gner0_regnum, 4 }, | |
378 | { 1, gner1_regnum, 4 }, | |
379 | { 1, REGCACHE_MAP_SKIP, 8 }, /* iacc0 */ | |
380 | { 1, tbr_regnum, 4 }, | |
381 | { 31, first_gpr_regnum + 1, 4 }, /* gr1 ... gr31 */ | |
382 | ||
383 | /* Technically, the loadmap addresses are not part of `pr_reg' as | |
384 | found in the elf_prstatus struct. The fields which communicate | |
385 | the loadmap address appear (by design) immediately after | |
386 | `pr_reg' though, and the BFD function elf32_frv_grok_prstatus() | |
387 | has been implemented to include these fields in the register | |
388 | section that it extracts from the core file. So, for our | |
389 | purposes, they may be viewed as registers. */ | |
390 | ||
391 | { 1, fdpic_loadmap_exec_regnum, 4 }, | |
392 | { 1, fdpic_loadmap_interp_regnum, 4 }, | |
393 | { 0 } | |
394 | }; | |
395 | ||
396 | static const struct regcache_map_entry frv_linux_fpregmap[] = | |
397 | { | |
398 | { 64, first_fpr_regnum, 4 }, /* fr0 ... fr63 */ | |
399 | { 1, fner0_regnum, 4 }, | |
400 | { 1, fner1_regnum, 4 }, | |
401 | { 1, msr0_regnum, 4 }, | |
402 | { 1, msr1_regnum, 4 }, | |
403 | { 8, acc0_regnum, 4 }, /* acc0 ... acc7 */ | |
404 | { 1, accg0123_regnum, 4 }, | |
405 | { 1, accg4567_regnum, 4 }, | |
406 | { 1, fsr0_regnum, 4 }, | |
407 | { 0 } | |
408 | }; | |
7c699b81 KB |
409 | |
410 | /* Unpack an frv_elf_gregset_t into GDB's register cache. */ | |
411 | ||
412 | static void | |
413 | frv_linux_supply_gregset (const struct regset *regset, | |
414 | struct regcache *regcache, | |
415 | int regnum, const void *gregs, size_t len) | |
416 | { | |
417 | int regi; | |
7c699b81 KB |
418 | |
419 | /* gr0 always contains 0. Also, the kernel passes the TBR value in | |
420 | this slot. */ | |
f81fdd35 | 421 | regcache->raw_supply_zeroed (first_gpr_regnum); |
7c699b81 | 422 | |
901e1b23 AA |
423 | /* Fill gr32, ..., gr63 with zeros. */ |
424 | for (regi = first_gpr_regnum + 32; regi <= last_gpr_regnum; regi++) | |
f81fdd35 | 425 | regcache->raw_supply_zeroed (regi); |
7c699b81 | 426 | |
901e1b23 | 427 | regcache_supply_regset (regset, regcache, regnum, gregs, len); |
7c699b81 KB |
428 | } |
429 | ||
155bd5d1 | 430 | /* FRV Linux kernel register sets. */ |
7c699b81 | 431 | |
3ca7dae4 | 432 | static const struct regset frv_linux_gregset = |
7c699b81 | 433 | { |
901e1b23 AA |
434 | frv_linux_gregmap, |
435 | frv_linux_supply_gregset, regcache_collect_regset | |
7c699b81 KB |
436 | }; |
437 | ||
3ca7dae4 | 438 | static const struct regset frv_linux_fpregset = |
7c699b81 | 439 | { |
901e1b23 AA |
440 | frv_linux_fpregmap, |
441 | regcache_supply_regset, regcache_collect_regset | |
7c699b81 KB |
442 | }; |
443 | ||
66afae4f AA |
444 | static void |
445 | frv_linux_iterate_over_regset_sections (struct gdbarch *gdbarch, | |
446 | iterate_over_regset_sections_cb *cb, | |
447 | void *cb_data, | |
448 | const struct regcache *regcache) | |
7c699b81 | 449 | { |
a616bb94 AH |
450 | cb (".reg", sizeof (frv_elf_gregset_t), sizeof (frv_elf_gregset_t), |
451 | &frv_linux_gregset, NULL, cb_data); | |
452 | cb (".reg2", sizeof (frv_elf_fpregset_t), sizeof (frv_elf_fpregset_t), | |
453 | &frv_linux_fpregset, NULL, cb_data); | |
7c699b81 KB |
454 | } |
455 | ||
456 | \f | |
5ecb7103 KB |
457 | static void |
458 | frv_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) | |
459 | { | |
a5ee0f0c PA |
460 | linux_init_abi (info, gdbarch); |
461 | ||
9df0bb3f | 462 | /* Set the sigtramp frame sniffer. */ |
94afd7a6 | 463 | frame_unwind_append_unwinder (gdbarch, &frv_linux_sigtramp_frame_unwind); |
a5ee0f0c | 464 | |
66afae4f AA |
465 | set_gdbarch_iterate_over_regset_sections |
466 | (gdbarch, frv_linux_iterate_over_regset_sections); | |
5ecb7103 KB |
467 | } |
468 | ||
469 | static enum gdb_osabi | |
470 | frv_linux_elf_osabi_sniffer (bfd *abfd) | |
471 | { | |
472 | int elf_flags; | |
473 | ||
474 | elf_flags = elf_elfheader (abfd)->e_flags; | |
475 | ||
476 | /* Assume GNU/Linux if using the FDPIC ABI. If/when another OS shows | |
477 | up that uses this ABI, we'll need to start using .note sections | |
478 | or some such. */ | |
479 | if (elf_flags & EF_FRV_FDPIC) | |
480 | return GDB_OSABI_LINUX; | |
481 | else | |
482 | return GDB_OSABI_UNKNOWN; | |
483 | } | |
484 | ||
5ecb7103 KB |
485 | void |
486 | _initialize_frv_linux_tdep (void) | |
487 | { | |
0963b4bd MS |
488 | gdbarch_register_osabi (bfd_arch_frv, 0, GDB_OSABI_LINUX, |
489 | frv_linux_init_abi); | |
5ecb7103 KB |
490 | gdbarch_register_osabi_sniffer (bfd_arch_frv, |
491 | bfd_target_elf_flavour, | |
492 | frv_linux_elf_osabi_sniffer); | |
493 | } |