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