Commit | Line | Data |
---|---|---|
f7e85b1b AC |
1 | /* Semi-dynamic architecture support for GDB, the GNU debugger. |
2 | Copyright 1998, Free Software Foundation, Inc. | |
3 | ||
4 | This file is part of GDB. | |
5 | ||
6 | This program is free software; you can redistribute it and/or modify | |
7 | it under the terms of the GNU General Public License as published by | |
8 | the Free Software Foundation; either version 2 of the License, or | |
9 | (at your option) any later version. | |
10 | ||
11 | This program is distributed in the hope that it will be useful, | |
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | GNU General Public License for more details. | |
15 | ||
16 | You should have received a copy of the GNU General Public License | |
17 | along with this program; if not, write to the Free Software | |
18 | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ | |
19 | ||
20 | #include "defs.h" | |
21 | #include "bfd.h" | |
22 | #include "gdbcmd.h" | |
23 | ||
24 | ||
dcf46491 AC |
25 | /* start-sanitize-carp start-sanitize-vr4xxx */ |
26 | /* Convenience macro for allocting memory. */ | |
27 | ||
28 | #ifndef XMALLOC | |
29 | #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE)) | |
30 | #endif | |
31 | ||
32 | /* end-sanitize-carp end-sanitize-vr4xxx */ | |
33 | ||
5036d102 AC |
34 | /* Non-zero if we want to trace architecture code. */ |
35 | ||
36 | #ifndef GDBARCH_DEBUG | |
dcf46491 | 37 | #define GDBARCH_DEBUG 0 |
5036d102 AC |
38 | #endif |
39 | int gdbarch_debug = GDBARCH_DEBUG; | |
40 | ||
dcf46491 AC |
41 | /* start-sanitize-carp start-sanitize-vr4xxx */ |
42 | ||
43 | /* Maintain the struct gdbarch object */ | |
44 | ||
45 | struct gdbarch | |
46 | { | |
47 | /* basic architectural information */ | |
48 | const struct bfd_arch_info *bfd_arch_info; | |
49 | int byte_order; | |
50 | ||
51 | /* target specific vector. */ | |
52 | struct gdbarch_tdep *tdep; | |
53 | ||
54 | /* per-architecture data-pointers */ | |
55 | int nr_data; | |
56 | void **data; | |
57 | ||
58 | /* per-architecture swap-regions */ | |
59 | struct gdbarch_swap *swap; | |
60 | ||
61 | /* Multi-arch values. | |
62 | ||
63 | When adding to the below you must also: declare/define set/get | |
64 | value functions; override the corresponding macro in gdbarch.h; | |
65 | initialize the value in gdbarch_alloc() (if zero is an unsuitable | |
66 | default); confirm that the target updated the value correctly in | |
67 | verify_gdbarch(); add a fprintf_unfiltered call to | |
68 | gdbarch_update() so that the new field is dumped out; append an | |
69 | initial value to the static variable DEFAULT_GDBARCH (base values | |
70 | on the host's c-type system). */ | |
71 | ||
72 | int long_bit; | |
73 | int long_long_bit; | |
74 | int ptr_bit; | |
75 | ||
76 | }; | |
77 | ||
78 | ||
79 | struct gdbarch_tdep * | |
80 | gdbarch_tdep (gdbarch) | |
81 | struct gdbarch *gdbarch; | |
82 | { | |
83 | return gdbarch->tdep; | |
84 | } | |
85 | ||
86 | const struct bfd_arch_info * | |
87 | gdbarch_bfd_arch_info (gdbarch) | |
88 | struct gdbarch *gdbarch; | |
89 | { | |
90 | return gdbarch->bfd_arch_info; | |
91 | } | |
92 | ||
93 | int | |
94 | gdbarch_byte_order (gdbarch) | |
95 | struct gdbarch *gdbarch; | |
96 | { | |
97 | return gdbarch->byte_order; | |
98 | } | |
99 | ||
100 | int | |
101 | gdbarch_long_bit (gdbarch) | |
102 | struct gdbarch *gdbarch; | |
103 | { | |
104 | return gdbarch->long_bit; | |
105 | } | |
106 | ||
107 | void | |
108 | set_gdbarch_long_bit (gdbarch, long_bit) | |
109 | struct gdbarch *gdbarch; | |
110 | int long_bit; | |
111 | { | |
112 | gdbarch->long_bit = long_bit; | |
113 | } | |
114 | ||
115 | int | |
116 | gdbarch_long_long_bit (gdbarch) | |
117 | struct gdbarch *gdbarch; | |
118 | { | |
119 | return gdbarch->long_long_bit; | |
120 | } | |
121 | ||
122 | void | |
123 | set_gdbarch_long_long_bit (gdbarch, long_long_bit) | |
124 | struct gdbarch *gdbarch; | |
125 | int long_long_bit; | |
126 | { | |
127 | gdbarch->long_long_bit = long_long_bit; | |
128 | } | |
129 | ||
130 | int | |
131 | gdbarch_ptr_bit (gdbarch) | |
132 | struct gdbarch *gdbarch; | |
133 | { | |
134 | return gdbarch->ptr_bit; | |
135 | } | |
136 | ||
137 | void | |
138 | set_gdbarch_ptr_bit (gdbarch, ptr_bit) | |
139 | struct gdbarch *gdbarch; | |
140 | int ptr_bit; | |
141 | { | |
142 | gdbarch->ptr_bit = ptr_bit; | |
143 | } | |
144 | ||
145 | ||
146 | /* Ensure that all values in a GDBARCH are reasonable. XXX - should | |
147 | this instead return a success/fail indication? */ | |
148 | ||
149 | static void | |
150 | verify_gdbarch (gdbarch) | |
151 | struct gdbarch *gdbarch; | |
152 | { | |
153 | /* fundamental */ | |
154 | if (gdbarch->byte_order == 0) | |
155 | fatal ("verify_gdbarch: byte-order unset"); | |
156 | if (gdbarch->bfd_arch_info == NULL) | |
157 | fatal ("verify_gdbarch: bfd_arch_info unset"); | |
158 | /* more general */ | |
159 | if (gdbarch->long_bit == 0) | |
160 | fatal ("verify_gdbarch: long_bit invalid"); | |
161 | if (gdbarch->long_long_bit == 0) | |
162 | fatal ("verify_gdbarch: long_long_bit invalid"); | |
163 | if (gdbarch->ptr_bit == 0) | |
164 | fatal ("verify_gdbarch: ptr_bit invalid"); | |
165 | } | |
166 | ||
167 | ||
168 | /* Keep a registrary of per-architecture data-pointers required by GDB | |
169 | modules. */ | |
170 | ||
171 | struct gdbarch_data | |
172 | { | |
173 | int index; | |
174 | }; | |
175 | ||
176 | struct gdbarch_data_registration | |
177 | { | |
178 | gdbarch_data_ftype *init; | |
179 | struct gdbarch_data *data; | |
180 | struct gdbarch_data_registration *next; | |
181 | }; | |
182 | ||
183 | struct gdbarch_data_registrary | |
184 | { | |
185 | int nr; | |
186 | struct gdbarch_data_registration *registrations; | |
187 | }; | |
188 | ||
189 | struct gdbarch_data_registrary gdbarch_data_registrary = | |
190 | { | |
191 | 0, NULL, | |
192 | }; | |
193 | ||
194 | struct gdbarch_data * | |
195 | register_gdbarch_data (init) | |
196 | gdbarch_data_ftype *init; | |
197 | { | |
198 | struct gdbarch_data_registration **curr; | |
199 | for (curr = &gdbarch_data_registrary.registrations; | |
200 | (*curr) != NULL; | |
201 | curr = &(*curr)->next); | |
202 | (*curr) = XMALLOC (struct gdbarch_data_registration); | |
203 | (*curr)->next = NULL; | |
204 | (*curr)->init = init; | |
205 | (*curr)->data = XMALLOC (struct gdbarch_data); | |
206 | (*curr)->data->index = gdbarch_data_registrary.nr++; | |
207 | return (*curr)->data; | |
208 | } | |
209 | ||
210 | ||
211 | /* Walk through all the registered users initializing each in turn. */ | |
212 | ||
213 | static void init_gdbarch_data PARAMS ((struct gdbarch *)); | |
214 | static void | |
215 | init_gdbarch_data (gdbarch) | |
216 | struct gdbarch *gdbarch; | |
217 | { | |
218 | struct gdbarch_data_registration *rego; | |
219 | gdbarch->nr_data = gdbarch_data_registrary.nr + 1; | |
220 | gdbarch->data = xmalloc (sizeof (void*) * gdbarch->nr_data); | |
221 | for (rego = gdbarch_data_registrary.registrations; | |
222 | rego != NULL; | |
223 | rego = rego->next) | |
224 | { | |
225 | if (rego->data->index < gdbarch->nr_data) | |
226 | gdbarch->data[rego->data->index] = rego->init (); | |
227 | } | |
228 | } | |
229 | ||
230 | ||
231 | /* Return the current value of the specified per-architecture | |
232 | data-pointer. */ | |
233 | ||
234 | void * | |
235 | gdbarch_data (data) | |
236 | struct gdbarch_data *data; | |
237 | { | |
238 | if (data->index >= current_gdbarch->nr_data) | |
239 | fatal ("gdbarch_data: request for non-existant data."); | |
240 | return current_gdbarch->data[data->index]; | |
241 | } | |
242 | ||
243 | ||
244 | ||
245 | /* Keep a registrary of swaped data required by GDB modules. */ | |
246 | ||
247 | struct gdbarch_swap | |
248 | { | |
249 | void *swap; | |
250 | struct gdbarch_swap_registration *source; | |
251 | struct gdbarch_swap *next; | |
252 | }; | |
253 | ||
254 | struct gdbarch_swap_registration | |
255 | { | |
256 | void *data; | |
257 | unsigned long sizeof_data; | |
258 | gdbarch_swap_ftype *init; | |
259 | struct gdbarch_swap_registration *next; | |
260 | }; | |
261 | ||
262 | struct gdbarch_swap_registrary | |
263 | { | |
264 | int nr; | |
265 | struct gdbarch_swap_registration *registrations; | |
266 | }; | |
267 | ||
268 | struct gdbarch_swap_registrary gdbarch_swap_registrary = | |
269 | { | |
270 | 0, NULL, | |
271 | }; | |
272 | ||
273 | void | |
274 | register_gdbarch_swap (data, sizeof_data, init) | |
275 | void *data; | |
276 | unsigned long sizeof_data; | |
277 | gdbarch_swap_ftype *init; | |
278 | { | |
279 | struct gdbarch_swap_registration **rego; | |
280 | for (rego = &gdbarch_swap_registrary.registrations; | |
281 | (*rego) != NULL; | |
282 | rego = &(*rego)->next); | |
283 | (*rego) = XMALLOC (struct gdbarch_swap_registration); | |
284 | (*rego)->next = NULL; | |
285 | (*rego)->init = init; | |
286 | (*rego)->data = data; | |
287 | (*rego)->sizeof_data = sizeof_data; | |
288 | } | |
289 | ||
290 | ||
291 | static void init_gdbarch_swap PARAMS ((struct gdbarch *)); | |
292 | static void | |
293 | init_gdbarch_swap (gdbarch) | |
294 | struct gdbarch *gdbarch; | |
295 | { | |
296 | struct gdbarch_swap_registration *rego; | |
297 | struct gdbarch_swap **curr = &gdbarch->swap; | |
298 | for (rego = gdbarch_swap_registrary.registrations; | |
299 | rego != NULL; | |
300 | rego = rego->next) | |
301 | { | |
302 | if (rego->data != NULL) | |
303 | { | |
304 | (*curr) = XMALLOC (struct gdbarch_swap); | |
305 | (*curr)->source = rego; | |
306 | (*curr)->swap = xmalloc (rego->sizeof_data); | |
307 | (*curr)->next = NULL; | |
308 | memset (rego->data, 0, rego->sizeof_data); | |
309 | curr = &(*curr)->next; | |
310 | } | |
311 | if (rego->init != NULL) | |
312 | rego->init (); | |
313 | } | |
314 | } | |
315 | ||
316 | static void swapout_gdbarch_swap PARAMS ((struct gdbarch *)); | |
317 | static void | |
318 | swapout_gdbarch_swap (gdbarch) | |
319 | struct gdbarch *gdbarch; | |
320 | { | |
321 | struct gdbarch_swap *curr; | |
322 | for (curr = gdbarch->swap; | |
323 | curr != NULL; | |
324 | curr = curr->next) | |
325 | memcpy (curr->swap, curr->source->data, curr->source->sizeof_data); | |
326 | } | |
327 | ||
328 | static void swapin_gdbarch_swap PARAMS ((struct gdbarch *)); | |
329 | static void | |
330 | swapin_gdbarch_swap (gdbarch) | |
331 | struct gdbarch *gdbarch; | |
332 | { | |
333 | struct gdbarch_swap *curr; | |
334 | for (curr = gdbarch->swap; | |
335 | curr != NULL; | |
336 | curr = curr->next) | |
337 | memcpy (curr->source->data, curr->swap, curr->source->sizeof_data); | |
338 | } | |
339 | ||
340 | ||
341 | /* Keep a registrary of the architectures known by GDB. */ | |
342 | ||
343 | struct gdbarch_init_registration | |
344 | { | |
345 | enum bfd_architecture bfd_architecture; | |
346 | gdbarch_init_ftype *init; | |
347 | struct gdbarch_list *arches; | |
348 | struct gdbarch_init_registration *next; | |
349 | }; | |
350 | ||
351 | static struct gdbarch_init_registration *gdbarch_init_registrary = NULL; | |
352 | ||
353 | void | |
354 | register_gdbarch_init (bfd_architecture, init) | |
355 | enum bfd_architecture bfd_architecture; | |
356 | gdbarch_init_ftype *init; | |
357 | { | |
358 | struct gdbarch_init_registration **curr; | |
359 | const struct bfd_arch_info *bfd_arch_info; | |
360 | /* Check that BFD reconizes this architecture */ | |
361 | bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0); | |
362 | if (bfd_arch_info == NULL) | |
363 | { | |
364 | fatal ("Attempt to register unknown architecture (%d)", bfd_architecture); | |
365 | } | |
366 | /* Check that we haven't seen this architecture before */ | |
367 | for (curr = &gdbarch_init_registrary; | |
368 | (*curr) != NULL; | |
369 | curr = &(*curr)->next) | |
370 | { | |
371 | if (bfd_architecture == (*curr)->bfd_architecture) | |
372 | fatal ("Duplicate registraration of architecture (%s)", | |
373 | bfd_arch_info->printable_name); | |
374 | } | |
375 | /* log it */ | |
376 | if (gdbarch_debug) | |
377 | fprintf_unfiltered (stderr, "register_gdbarch_init (%s, 0x%08lx)\n", | |
378 | bfd_arch_info->printable_name, | |
379 | (long) init); | |
380 | /* Append it */ | |
381 | (*curr) = XMALLOC (struct gdbarch_init_registration); | |
382 | (*curr)->bfd_architecture = bfd_architecture; | |
383 | (*curr)->init = init; | |
384 | (*curr)->arches = NULL; | |
385 | (*curr)->next = NULL; | |
386 | } | |
387 | ||
388 | ||
389 | ||
390 | /* Look for an architecture using gdbarch_info. Base search on only | |
391 | BFD_ARCH_INFO and BYTE_ORDER. */ | |
392 | ||
393 | struct gdbarch_list * | |
394 | gdbarch_list_lookup_by_info (arches, info) | |
395 | struct gdbarch_list *arches; | |
396 | const struct gdbarch_info *info; | |
397 | { | |
398 | for (; arches != NULL; arches = arches->next) | |
399 | { | |
400 | if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info) | |
401 | continue; | |
402 | if (info->byte_order != arches->gdbarch->byte_order) | |
403 | continue; | |
404 | return arches; | |
405 | } | |
406 | return NULL; | |
407 | } | |
408 | ||
409 | ||
410 | /* Create a new ``struct gdbarch'' based in information provied by | |
411 | ``struct gdbarch_info'' */ | |
412 | ||
413 | struct gdbarch * | |
414 | gdbarch_alloc (info, tdep) | |
415 | const struct gdbarch_info *info; | |
416 | struct gdbarch_tdep *tdep; | |
417 | { | |
418 | struct gdbarch *gdbarch = XMALLOC (struct gdbarch); | |
419 | memset (gdbarch, 0, sizeof (*gdbarch)); | |
420 | ||
421 | gdbarch->tdep = tdep; | |
422 | ||
423 | gdbarch->bfd_arch_info = info->bfd_arch_info; | |
424 | gdbarch->byte_order = info->byte_order; | |
425 | ||
426 | return gdbarch; | |
427 | } | |
428 | ||
429 | /* Update the current architecture. Return ZERO if the update request | |
430 | failed. */ | |
431 | ||
432 | int | |
433 | gdbarch_update (info) | |
434 | struct gdbarch_info info; | |
435 | { | |
436 | struct gdbarch *new_gdbarch; | |
437 | struct gdbarch_list **list; | |
438 | struct gdbarch_init_registration *rego; | |
439 | ||
440 | /* Fill in any missing bits. Most important is the bfd_architecture | |
441 | which is used to select the target architecture. */ | |
442 | if (info.bfd_architecture == bfd_arch_unknown) | |
443 | { | |
444 | if (info.bfd_arch_info != NULL) | |
445 | info.bfd_architecture = info.bfd_arch_info->arch; | |
446 | else if (info.abfd != NULL) | |
447 | info.bfd_architecture = bfd_get_arch (info.abfd); | |
448 | /* FIXME - should query BFD for its default architecture. */ | |
449 | else | |
450 | info.bfd_architecture = current_gdbarch->bfd_arch_info->arch; | |
451 | } | |
452 | if (info.bfd_arch_info == NULL) | |
453 | { | |
454 | if (target_architecture_auto && info.abfd != NULL) | |
455 | info.bfd_arch_info = bfd_get_arch_info (info.abfd); | |
456 | else | |
457 | info.bfd_arch_info = current_gdbarch->bfd_arch_info; | |
458 | } | |
459 | if (info.byte_order == 0) | |
460 | { | |
461 | if (target_byte_order_auto && info.abfd != NULL) | |
462 | info.byte_order = (bfd_big_endian (info.abfd) ? BIG_ENDIAN | |
463 | : bfd_little_endian (info.abfd) ? LITTLE_ENDIAN | |
464 | : 0); | |
465 | else | |
466 | info.byte_order = current_gdbarch->byte_order; | |
467 | } | |
468 | /* A default for abfd? */ | |
469 | ||
470 | /* Find the target that knows about this architecture. */ | |
471 | for (rego = gdbarch_init_registrary; | |
472 | rego != NULL && rego->bfd_architecture != info.bfd_architecture; | |
473 | rego = rego->next); | |
474 | if (rego == NULL) | |
475 | { | |
476 | if (gdbarch_debug) | |
477 | fprintf_unfiltered (stderr, "gdbarch_update: No matching architecture\n"); | |
478 | return 0; | |
479 | } | |
480 | ||
481 | /* Ask the target for a replacement architecture. */ | |
482 | new_gdbarch = rego->init (&info, rego->arches); | |
483 | ||
484 | /* Did the target like it? No. Reject the change. */ | |
485 | if (new_gdbarch == NULL) | |
486 | { | |
487 | if (gdbarch_debug) | |
488 | fprintf_unfiltered (stderr, "gdbarch_update: Target rejected architecture\n"); | |
489 | return 0; | |
490 | } | |
491 | ||
492 | /* Did the architecture change? No. Do nothing. */ | |
493 | if (current_gdbarch == new_gdbarch) | |
494 | { | |
495 | if (gdbarch_debug) | |
496 | fprintf_unfiltered (stderr, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\n", | |
497 | (long) new_gdbarch, | |
498 | new_gdbarch->bfd_arch_info->printable_name); | |
499 | return 1; | |
500 | } | |
501 | ||
502 | /* Swap all data belonging to the old target out */ | |
503 | swapout_gdbarch_swap (current_gdbarch); | |
504 | ||
505 | /* Is this a pre-existing architecture? Yes. Swap it in. */ | |
506 | for (list = ®o->arches; | |
507 | (*list) != NULL; | |
508 | list = &(*list)->next) | |
509 | { | |
510 | if ((*list)->gdbarch == new_gdbarch) | |
511 | { | |
512 | if (gdbarch_debug) | |
513 | fprintf_unfiltered (stderr, "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n", | |
514 | (long) new_gdbarch, | |
515 | new_gdbarch->bfd_arch_info->printable_name); | |
516 | current_gdbarch = new_gdbarch; | |
517 | swapin_gdbarch_swap (new_gdbarch); | |
518 | return 1; | |
519 | } | |
520 | } | |
521 | ||
522 | /* Append this new architecture to this targets list. */ | |
523 | (*list) = XMALLOC (struct gdbarch_list); | |
524 | (*list)->next = NULL; | |
525 | (*list)->gdbarch = new_gdbarch; | |
526 | ||
527 | /* Switch to this new architecture. Dump it out. */ | |
528 | current_gdbarch = new_gdbarch; | |
529 | if (gdbarch_debug) | |
530 | { | |
531 | fprintf_unfiltered (stderr, "gdbarch_update: New architecture 0x%08lx (%s) selected\n", | |
532 | (long) new_gdbarch, | |
533 | new_gdbarch->bfd_arch_info->printable_name); | |
534 | fprintf_unfiltered (stderr, "TARGET_BYTE_ORDER = %d\n", TARGET_BYTE_ORDER); | |
535 | fprintf_unfiltered (stderr, "TARGET_LONG_BIT = %d\n", TARGET_LONG_BIT); | |
536 | fprintf_unfiltered (stderr, "TARGET_LONG_LONG_BIT = %d\n", TARGET_LONG_LONG_BIT); | |
537 | fprintf_unfiltered (stderr, "TARGET_PTR_BIT = %d\n", TARGET_PTR_BIT); | |
538 | } | |
539 | ||
540 | /* Check that the newly installed architecture is valid. */ | |
541 | verify_gdbarch (new_gdbarch); | |
542 | ||
543 | /* Initialize the per-architecture memory (swap) areas. | |
544 | CURRENT_GDBARCH must be update before these modules are | |
545 | called. */ | |
546 | init_gdbarch_swap (new_gdbarch); | |
547 | ||
548 | /* Initialize the per-architecture data-pointer of all parties that | |
549 | registered an interest in this architecture. CURRENT_GDBARCH | |
550 | must be updated before these modules are called. */ | |
551 | init_gdbarch_data (new_gdbarch); | |
552 | ||
553 | return 1; | |
554 | } | |
555 | ||
556 | ||
557 | /* end-sanitize-carp end-sanitize-vr4xxx */ | |
5036d102 | 558 | |
f7e85b1b AC |
559 | /* Functions to manipulate the endianness of the target. */ |
560 | ||
561 | #ifdef TARGET_BYTE_ORDER_SELECTABLE | |
562 | /* compat - Catch old targets that expect a selectable byte-order to | |
563 | default to BIG_ENDIAN */ | |
564 | #ifndef TARGET_BYTE_ORDER_DEFAULT | |
565 | #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN | |
566 | #endif | |
567 | #endif | |
568 | #ifndef TARGET_BYTE_ORDER_DEFAULT | |
569 | /* compat - Catch old non byte-order selectable targets that do not | |
570 | define TARGET_BYTE_ORDER_DEFAULT and instead expect | |
571 | TARGET_BYTE_ORDER to be used as the default. For targets that | |
572 | defined neither TARGET_BYTE_ORDER nor TARGET_BYTE_ORDER_DEFAULT the | |
573 | below will get a strange compiler warning. */ | |
574 | #define TARGET_BYTE_ORDER_DEFAULT TARGET_BYTE_ORDER | |
575 | #endif | |
576 | int target_byte_order = TARGET_BYTE_ORDER_DEFAULT; | |
577 | int target_byte_order_auto = 1; | |
578 | ||
579 | /* Chain containing the \"set endian\" commands. */ | |
580 | static struct cmd_list_element *endianlist = NULL; | |
581 | ||
582 | /* Called by ``show endian''. */ | |
583 | static void show_endian PARAMS ((char *, int)); | |
584 | static void | |
585 | show_endian (args, from_tty) | |
586 | char *args; | |
587 | int from_tty; | |
588 | { | |
589 | char *msg = | |
590 | (TARGET_BYTE_ORDER_AUTO | |
591 | ? "The target endianness is set automatically (currently %s endian)\n" | |
592 | : "The target is assumed to be %s endian\n"); | |
593 | printf_unfiltered (msg, (TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little")); | |
594 | } | |
595 | ||
596 | /* Called if the user enters ``set endian'' without an argument. */ | |
597 | static void set_endian PARAMS ((char *, int)); | |
598 | static void | |
599 | set_endian (args, from_tty) | |
600 | char *args; | |
601 | int from_tty; | |
602 | { | |
603 | printf_unfiltered ("\"set endian\" must be followed by \"auto\", \"big\" or \"little\".\n"); | |
604 | show_endian (args, from_tty); | |
605 | } | |
606 | ||
607 | /* Called by ``set endian big''. */ | |
608 | static void set_endian_big PARAMS ((char *, int)); | |
609 | static void | |
610 | set_endian_big (args, from_tty) | |
611 | char *args; | |
612 | int from_tty; | |
613 | { | |
614 | if (TARGET_BYTE_ORDER_SELECTABLE_P) | |
615 | { | |
616 | target_byte_order = BIG_ENDIAN; | |
617 | target_byte_order_auto = 0; | |
dcf46491 AC |
618 | /* start-sanitize-carp start-sanitize-vr4xxx */ |
619 | if (GDB_MULTI_ARCH) | |
620 | { | |
621 | struct gdbarch_info info; | |
622 | memset (&info, 0, sizeof info); | |
623 | info.byte_order = BIG_ENDIAN; | |
624 | gdbarch_update (info); | |
625 | } | |
626 | /* end-sanitize-carp end-sanitize-vr4xxx */ | |
f7e85b1b AC |
627 | } |
628 | else | |
629 | { | |
630 | printf_unfiltered ("Byte order is not selectable."); | |
631 | show_endian (args, from_tty); | |
632 | } | |
633 | } | |
634 | ||
635 | /* Called by ``set endian little''. */ | |
636 | static void set_endian_little PARAMS ((char *, int)); | |
637 | static void | |
638 | set_endian_little (args, from_tty) | |
639 | char *args; | |
640 | int from_tty; | |
641 | { | |
642 | if (TARGET_BYTE_ORDER_SELECTABLE_P) | |
643 | { | |
644 | target_byte_order = LITTLE_ENDIAN; | |
645 | target_byte_order_auto = 0; | |
dcf46491 AC |
646 | /* start-sanitize-carp start-sanitize-vr4xxx */ |
647 | if (GDB_MULTI_ARCH) | |
648 | { | |
649 | struct gdbarch_info info; | |
650 | memset (&info, 0, sizeof info); | |
651 | info.byte_order = LITTLE_ENDIAN; | |
652 | gdbarch_update (info); | |
653 | } | |
654 | /* end-sanitize-carp end-sanitize-vr4xxx */ | |
f7e85b1b AC |
655 | } |
656 | else | |
657 | { | |
658 | printf_unfiltered ("Byte order is not selectable."); | |
659 | show_endian (args, from_tty); | |
660 | } | |
661 | } | |
662 | ||
663 | /* Called by ``set endian auto''. */ | |
664 | static void set_endian_auto PARAMS ((char *, int)); | |
665 | static void | |
666 | set_endian_auto (args, from_tty) | |
667 | char *args; | |
668 | int from_tty; | |
669 | { | |
670 | if (TARGET_BYTE_ORDER_SELECTABLE_P) | |
671 | { | |
672 | target_byte_order_auto = 1; | |
673 | } | |
674 | else | |
675 | { | |
676 | printf_unfiltered ("Byte order is not selectable."); | |
677 | show_endian (args, from_tty); | |
678 | } | |
679 | } | |
680 | ||
681 | /* Set the endianness from a BFD. */ | |
682 | static void set_endian_from_file PARAMS ((bfd *)); | |
683 | static void | |
684 | set_endian_from_file (abfd) | |
685 | bfd *abfd; | |
686 | { | |
687 | if (TARGET_BYTE_ORDER_SELECTABLE_P) | |
688 | { | |
689 | int want; | |
690 | ||
691 | if (bfd_big_endian (abfd)) | |
692 | want = BIG_ENDIAN; | |
693 | else | |
694 | want = LITTLE_ENDIAN; | |
695 | if (TARGET_BYTE_ORDER_AUTO) | |
696 | target_byte_order = want; | |
697 | else if (TARGET_BYTE_ORDER != want) | |
698 | warning ("%s endian file does not match %s endian target.", | |
699 | want == BIG_ENDIAN ? "big" : "little", | |
700 | TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little"); | |
701 | } | |
702 | else | |
703 | { | |
704 | if (bfd_big_endian (abfd) | |
705 | ? TARGET_BYTE_ORDER != BIG_ENDIAN | |
706 | : TARGET_BYTE_ORDER == BIG_ENDIAN) | |
707 | warning ("%s endian file does not match %s endian target.", | |
708 | bfd_big_endian (abfd) ? "big" : "little", | |
709 | TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little"); | |
710 | } | |
711 | } | |
712 | ||
713 | ||
714 | ||
715 | /* Functions to manipulate the architecture of the target */ | |
716 | ||
717 | int target_architecture_auto = 1; | |
5036d102 AC |
718 | extern const struct bfd_arch_info bfd_default_arch_struct; |
719 | const struct bfd_arch_info *target_architecture = &bfd_default_arch_struct; | |
720 | int (*target_architecture_hook) PARAMS ((const struct bfd_arch_info *ap)); | |
f7e85b1b AC |
721 | |
722 | /* Do the real work of changing the current architecture */ | |
723 | static void | |
724 | set_arch (arch) | |
5036d102 | 725 | const struct bfd_arch_info *arch; |
f7e85b1b AC |
726 | { |
727 | /* FIXME: Is it compatible with gdb? */ | |
728 | /* Check with the target on the setting */ | |
729 | if (target_architecture_hook != NULL | |
730 | && !target_architecture_hook (arch)) | |
731 | printf_unfiltered ("Target does not support `%s' architecture.\n", | |
732 | arch->printable_name); | |
733 | else | |
734 | { | |
735 | target_architecture_auto = 0; | |
736 | target_architecture = arch; | |
737 | } | |
738 | } | |
739 | ||
740 | /* Called if the user enters ``show architecture'' without an argument. */ | |
741 | static void show_architecture PARAMS ((char *, int)); | |
742 | static void | |
743 | show_architecture (args, from_tty) | |
744 | char *args; | |
745 | int from_tty; | |
746 | { | |
747 | const char *arch; | |
5036d102 | 748 | arch = TARGET_ARCHITECTURE->printable_name; |
f7e85b1b AC |
749 | if (target_architecture_auto) |
750 | printf_filtered ("The target architecture is set automatically (currently %s)\n", arch); | |
751 | else | |
752 | printf_filtered ("The target architecture is assumed to be %s\n", arch); | |
753 | } | |
754 | ||
755 | /* Called if the user enters ``set architecture'' with or without an | |
756 | argument. */ | |
757 | static void set_architecture PARAMS ((char *, int)); | |
758 | static void | |
759 | set_architecture (args, from_tty) | |
760 | char *args; | |
761 | int from_tty; | |
762 | { | |
763 | if (args == NULL) | |
764 | { | |
765 | printf_unfiltered ("\"set architecture\" must be followed by \"auto\" or an architecture name.\n"); | |
766 | } | |
767 | else if (strcmp (args, "auto") == 0) | |
768 | { | |
769 | target_architecture_auto = 1; | |
770 | } | |
dcf46491 AC |
771 | /* start-sanitize-carp start-sanitize-vr4xxx */ |
772 | else if (GDB_MULTI_ARCH) | |
773 | { | |
774 | const struct bfd_arch_info *arch = bfd_scan_arch (args); | |
775 | if (arch == NULL) | |
776 | printf_unfiltered ("Architecture `%s' not reconized.\n", args); | |
777 | else | |
778 | { | |
779 | struct gdbarch_info info; | |
780 | memset (&info, 0, sizeof info); | |
781 | info.bfd_arch_info = arch; | |
782 | if (gdbarch_update (info)) | |
783 | target_architecture_auto = 0; | |
784 | else | |
785 | printf_unfiltered ("Architecture `%s' not reconized.\n", args); | |
786 | } | |
787 | } | |
788 | /* end-sanitize-carp end-sanitize-vr4xxx */ | |
f7e85b1b AC |
789 | else |
790 | { | |
5036d102 | 791 | const struct bfd_arch_info *arch = bfd_scan_arch (args); |
f7e85b1b AC |
792 | if (arch != NULL) |
793 | set_arch (arch); | |
794 | else | |
795 | printf_unfiltered ("Architecture `%s' not reconized.\n", args); | |
796 | } | |
797 | } | |
798 | ||
799 | /* Called if the user enters ``info architecture'' without an argument. */ | |
800 | static void info_architecture PARAMS ((char *, int)); | |
801 | static void | |
802 | info_architecture (args, from_tty) | |
803 | char *args; | |
804 | int from_tty; | |
805 | { | |
806 | enum bfd_architecture a; | |
dcf46491 AC |
807 | /* start-sanitize-carp start-sanitize-vr4xxx */ |
808 | if (GDB_MULTI_ARCH) | |
809 | { | |
810 | if (gdbarch_init_registrary != NULL) | |
811 | { | |
812 | struct gdbarch_init_registration *rego; | |
813 | printf_filtered ("Available architectures are:\n"); | |
814 | for (rego = gdbarch_init_registrary; | |
815 | rego != NULL; | |
816 | rego = rego->next) | |
817 | { | |
818 | const struct bfd_arch_info *ap; | |
819 | ap = bfd_lookup_arch (rego->bfd_architecture, 0); | |
820 | if (ap != NULL) | |
821 | { | |
822 | do | |
823 | { | |
824 | printf_filtered (" %s", ap->printable_name); | |
825 | ap = ap->next; | |
826 | } | |
827 | while (ap != NULL); | |
828 | printf_filtered ("\n"); | |
829 | } | |
830 | } | |
831 | } | |
832 | else | |
833 | { | |
834 | printf_filtered ("There are no available architectures.\n"); | |
835 | } | |
836 | return; | |
837 | } | |
838 | /* end-sanitize-carp end-sanitize-vr4xxx */ | |
f7e85b1b AC |
839 | printf_filtered ("Available architectures are:\n"); |
840 | for (a = bfd_arch_obscure + 1; a < bfd_arch_last; a++) | |
841 | { | |
5036d102 | 842 | const struct bfd_arch_info *ap = bfd_lookup_arch (a, 0); |
f7e85b1b AC |
843 | if (ap != NULL) |
844 | { | |
845 | do | |
846 | { | |
847 | printf_filtered (" %s", ap->printable_name); | |
848 | ap = ap->next; | |
849 | } | |
850 | while (ap != NULL); | |
851 | printf_filtered ("\n"); | |
852 | } | |
853 | } | |
854 | } | |
855 | ||
856 | /* Set the architecture from arch/machine */ | |
857 | void | |
858 | set_architecture_from_arch_mach (arch, mach) | |
859 | enum bfd_architecture arch; | |
860 | unsigned long mach; | |
861 | { | |
5036d102 | 862 | const struct bfd_arch_info *wanted = bfd_lookup_arch (arch, mach); |
f7e85b1b AC |
863 | if (wanted != NULL) |
864 | set_arch (wanted); | |
865 | else | |
866 | fatal ("hardwired architecture/machine not reconized"); | |
867 | } | |
868 | ||
869 | /* Set the architecture from a BFD */ | |
870 | static void set_architecture_from_file PARAMS ((bfd *)); | |
871 | static void | |
872 | set_architecture_from_file (abfd) | |
873 | bfd *abfd; | |
874 | { | |
5036d102 | 875 | const struct bfd_arch_info *wanted = bfd_get_arch_info (abfd); |
f7e85b1b AC |
876 | if (target_architecture_auto) |
877 | { | |
878 | if (target_architecture_hook != NULL | |
879 | && !target_architecture_hook (wanted)) | |
880 | warning ("Target may not support %s architecture", | |
881 | wanted->printable_name); | |
882 | target_architecture = wanted; | |
883 | } | |
884 | else if (wanted != target_architecture) | |
885 | { | |
886 | warning ("%s architecture file may be incompatible with %s target.", | |
887 | wanted->printable_name, | |
888 | target_architecture->printable_name); | |
889 | } | |
890 | } | |
891 | ||
892 | ||
893 | ||
894 | /* Disassembler */ | |
895 | ||
896 | /* Pointer to the target-dependent disassembly function. */ | |
897 | int (*tm_print_insn) PARAMS ((bfd_vma, disassemble_info *)); | |
898 | disassemble_info tm_print_insn_info; | |
899 | ||
900 | ||
901 | ||
902 | /* Set the dynamic target-system-dependant parameters (architecture, | |
903 | byte-order) using information found in the BFD */ | |
904 | ||
905 | void | |
906 | set_gdbarch_from_file (abfd) | |
907 | bfd *abfd; | |
908 | { | |
dcf46491 AC |
909 | /* start-sanitize-carp start-sanitize-vr4xxx */ |
910 | if (GDB_MULTI_ARCH) | |
911 | { | |
912 | struct gdbarch_info info; | |
913 | memset (&info, 0, sizeof info); | |
914 | info.abfd = abfd; | |
915 | gdbarch_update (info); | |
916 | return; | |
917 | } | |
918 | /* end-sanitize-carp end-sanitize-vr4xxx */ | |
f7e85b1b AC |
919 | set_architecture_from_file (abfd); |
920 | set_endian_from_file (abfd); | |
921 | } | |
922 | ||
dcf46491 AC |
923 | /* start-sanitize-carp start-sanitize-vr4xxx */ |
924 | ||
925 | /* The default architecture uses host values (for want of a better | |
926 | choice). */ | |
927 | ||
928 | struct gdbarch default_gdbarch = { | |
929 | /* basic architecture information */ | |
930 | &bfd_default_arch_struct, | |
931 | TARGET_BYTE_ORDER_DEFAULT, | |
932 | /* target specific vector */ | |
933 | NULL, | |
934 | /*per-architecture data-pointers and swap regions */ | |
935 | 0, NULL, NULL, | |
936 | /* Multi-arch values */ | |
937 | 8 * sizeof (long), /* long */ | |
938 | 8 * sizeof (LONGEST), /* long long */ | |
939 | 8 * sizeof (void*), /* ptr */ | |
940 | }; | |
941 | struct gdbarch *current_gdbarch = &default_gdbarch; | |
942 | ||
943 | /* end-sanitize-carp end-sanitize-vr4xxx */ | |
f7e85b1b AC |
944 | |
945 | extern void _initialize_gdbarch PARAMS ((void)); | |
946 | void | |
947 | _initialize_gdbarch () | |
948 | { | |
949 | add_prefix_cmd ("endian", class_support, set_endian, | |
950 | "Set endianness of target.", | |
951 | &endianlist, "set endian ", 0, &setlist); | |
952 | add_cmd ("big", class_support, set_endian_big, | |
953 | "Set target as being big endian.", &endianlist); | |
954 | add_cmd ("little", class_support, set_endian_little, | |
955 | "Set target as being little endian.", &endianlist); | |
956 | add_cmd ("auto", class_support, set_endian_auto, | |
957 | "Select target endianness automatically.", &endianlist); | |
958 | add_cmd ("endian", class_support, show_endian, | |
959 | "Show endianness of target.", &showlist); | |
960 | ||
961 | add_cmd ("architecture", class_support, set_architecture, | |
962 | "Set architecture of target.", &setlist); | |
963 | add_alias_cmd ("processor", "architecture", class_support, 1, &setlist); | |
964 | add_cmd ("architecture", class_support, show_architecture, | |
965 | "Show architecture of target.", &showlist); | |
966 | add_cmd ("architecture", class_support, info_architecture, | |
967 | "List supported target architectures", &infolist); | |
968 | ||
969 | INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered); | |
970 | tm_print_insn_info.flavour = bfd_target_unknown_flavour; | |
971 | tm_print_insn_info.read_memory_func = dis_asm_read_memory; | |
972 | tm_print_insn_info.memory_error_func = dis_asm_memory_error; | |
973 | tm_print_insn_info.print_address_func = dis_asm_print_address; | |
5036d102 AC |
974 | |
975 | #ifdef MAINTENANCE_CMDS | |
976 | add_show_from_set (add_set_cmd ("archdebug", | |
977 | class_maintenance, | |
978 | var_zinteger, | |
979 | (char *)&gdbarch_debug, | |
980 | "Set architecture debugging.\n\ | |
981 | When non-zero, architecture debugging is enabled.", &setlist), | |
982 | &showlist); | |
983 | #endif | |
f7e85b1b | 984 | } |