Bug Summary

File:src/gnu/usr.bin/binutils/gdb/arch-utils.c
Warning:line 516, column 19
Value stored to 'old_gdbarch' during its initialization is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name arch-utils.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/binutils/obj/gdb -resource-dir /usr/local/lib/clang/13.0.0 -D PIE_DEFAULT=1 -I . -I /usr/src/gnu/usr.bin/binutils/gdb -I /usr/src/gnu/usr.bin/binutils/gdb/config -D LOCALEDIR="/usr/share/locale" -D HAVE_CONFIG_H -I /usr/src/gnu/usr.bin/binutils/gdb/../include/opcode -I ../bfd -I /usr/src/gnu/usr.bin/binutils/gdb/../bfd -I /usr/src/gnu/usr.bin/binutils/gdb/../include -I ../intl -I /usr/src/gnu/usr.bin/binutils/gdb/../intl -D MI_OUT=1 -D TUI=1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/gnu/usr.bin/binutils/obj/gdb -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -fcommon -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/gnu/usr.bin/binutils/gdb/arch-utils.c
1/* Dynamic architecture support for GDB, the GNU debugger.
2
3 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
4 Foundation, Inc.
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
10 the Free Software Foundation; either version 2 of the License, or
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
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
22
23#include "defs.h"
24
25#include "arch-utils.h"
26#include "buildsym.h"
27#include "gdbcmd.h"
28#include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
29#include "gdb_string.h"
30#include "regcache.h"
31#include "gdb_assert.h"
32#include "sim-regno.h"
33#include "gdbcore.h"
34#include "osabi.h"
35
36#include "version.h"
37
38#include "floatformat.h"
39
40/* Implementation of extract return value that grubs around in the
41 register cache. */
42void
43legacy_extract_return_value (struct type *type, struct regcache *regcache,
44 void *valbuf)
45{
46 char *registers = deprecated_grub_regcache_for_registers (regcache);
47 bfd_byte *buf = valbuf;
48 DEPRECATED_EXTRACT_RETURN_VALUE (type, registers, buf)(gdbarch_deprecated_extract_return_value (current_gdbarch, type
, registers, buf)); /* OK */
49}
50
51/* Implementation of store return value that grubs the register cache.
52 Takes a local copy of the buffer to avoid const problems. */
53void
54legacy_store_return_value (struct type *type, struct regcache *regcache,
55 const void *buf)
56{
57 bfd_byte *b = alloca (TYPE_LENGTH (type))__builtin_alloca((type)->length);
58 gdb_assert (regcache == current_regcache)((void) ((regcache == current_regcache) ? 0 : (internal_error
("/usr/src/gnu/usr.bin/binutils/gdb/arch-utils.c", 58, "%s: Assertion `%s' failed."
, __PRETTY_FUNCTION__, "regcache == current_regcache"), 0)));
59 memcpy (b, buf, TYPE_LENGTH (type)(type)->length);
60 DEPRECATED_STORE_RETURN_VALUE (type, b)(gdbarch_deprecated_store_return_value (current_gdbarch, type
, b));
61}
62
63int
64always_use_struct_convention (int gcc_p, struct type *value_type)
65{
66 return 1;
67}
68
69enum return_value_convention
70legacy_return_value (struct gdbarch *gdbarch, struct type *valtype,
71 struct regcache *regcache, void *readbuf,
72 const void *writebuf)
73{
74 /* NOTE: cagney/2004-06-13: The gcc_p parameter to
75 USE_STRUCT_CONVENTION isn't used. */
76 int struct_return = ((TYPE_CODE (valtype)(valtype)->main_type->code == TYPE_CODE_STRUCT
77 || TYPE_CODE (valtype)(valtype)->main_type->code == TYPE_CODE_UNION
78 || TYPE_CODE (valtype)(valtype)->main_type->code == TYPE_CODE_ARRAY)
79 && DEPRECATED_USE_STRUCT_CONVENTION (0, valtype)(gdbarch_deprecated_use_struct_convention (current_gdbarch, 0
, valtype)));
80
81 if (writebuf != NULL((void*)0))
82 {
83 gdb_assert (!struct_return)((void) ((!struct_return) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/arch-utils.c"
, 83, "%s: Assertion `%s' failed.", __PRETTY_FUNCTION__, "!struct_return"
), 0)));
84 /* NOTE: cagney/2004-06-13: See stack.c:return_command. Old
85 architectures don't expect STORE_RETURN_VALUE to handle small
86 structures. Should not be called with such types. */
87 gdb_assert (TYPE_CODE (valtype) != TYPE_CODE_STRUCT((void) (((valtype)->main_type->code != TYPE_CODE_STRUCT
&& (valtype)->main_type->code != TYPE_CODE_UNION
) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/arch-utils.c"
, 88, "%s: Assertion `%s' failed.", __PRETTY_FUNCTION__, "TYPE_CODE (valtype) != TYPE_CODE_STRUCT && TYPE_CODE (valtype) != TYPE_CODE_UNION"
), 0)))
88 && TYPE_CODE (valtype) != TYPE_CODE_UNION)((void) (((valtype)->main_type->code != TYPE_CODE_STRUCT
&& (valtype)->main_type->code != TYPE_CODE_UNION
) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/arch-utils.c"
, 88, "%s: Assertion `%s' failed.", __PRETTY_FUNCTION__, "TYPE_CODE (valtype) != TYPE_CODE_STRUCT && TYPE_CODE (valtype) != TYPE_CODE_UNION"
), 0)));
89 STORE_RETURN_VALUE (valtype, regcache, writebuf)(gdbarch_store_return_value (current_gdbarch, valtype, regcache
, writebuf));
90 }
91
92 if (readbuf != NULL((void*)0))
93 {
94 gdb_assert (!struct_return)((void) ((!struct_return) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/arch-utils.c"
, 94, "%s: Assertion `%s' failed.", __PRETTY_FUNCTION__, "!struct_return"
), 0)));
95 EXTRACT_RETURN_VALUE (valtype, regcache, readbuf)(gdbarch_extract_return_value (current_gdbarch, valtype, regcache
, readbuf));
96 }
97
98 if (struct_return)
99 return RETURN_VALUE_STRUCT_CONVENTION;
100 else
101 return RETURN_VALUE_REGISTER_CONVENTION;
102}
103
104int
105legacy_register_sim_regno (int regnum)
106{
107 /* Only makes sense to supply raw registers. */
108 gdb_assert (regnum >= 0 && regnum < NUM_REGS)((void) ((regnum >= 0 && regnum < (gdbarch_num_regs
(current_gdbarch))) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/arch-utils.c"
, 108, "%s: Assertion `%s' failed.", __PRETTY_FUNCTION__, "regnum >= 0 && regnum < NUM_REGS"
), 0)));
109 /* NOTE: cagney/2002-05-13: The old code did it this way and it is
110 suspected that some GDB/SIM combinations may rely on this
111 behavour. The default should be one2one_register_sim_regno
112 (below). */
113 if (REGISTER_NAME (regnum)(gdbarch_register_name (current_gdbarch, regnum)) != NULL((void*)0)
114 && REGISTER_NAME (regnum)(gdbarch_register_name (current_gdbarch, regnum))[0] != '\0')
115 return regnum;
116 else
117 return LEGACY_SIM_REGNO_IGNORE;
118}
119
120CORE_ADDR
121generic_skip_trampoline_code (CORE_ADDR pc)
122{
123 return 0;
124}
125
126CORE_ADDR
127generic_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
128{
129 return 0;
130}
131
132int
133generic_in_solib_call_trampoline (CORE_ADDR pc, char *name)
134{
135 return 0;
136}
137
138int
139generic_in_solib_return_trampoline (CORE_ADDR pc, char *name)
140{
141 return 0;
142}
143
144int
145generic_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
146{
147 return 0;
148}
149
150void
151generic_remote_translate_xfer_address (struct gdbarch *gdbarch,
152 struct regcache *regcache,
153 CORE_ADDR gdb_addr, int gdb_len,
154 CORE_ADDR * rem_addr, int *rem_len)
155{
156 *rem_addr = gdb_addr;
157 *rem_len = gdb_len;
158}
159
160/* Helper functions for INNER_THAN */
161
162int
163core_addr_lessthan (CORE_ADDR lhs, CORE_ADDR rhs)
164{
165 return (lhs < rhs);
166}
167
168int
169core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs)
170{
171 return (lhs > rhs);
172}
173
174
175/* Helper functions for TARGET_{FLOAT,DOUBLE}_FORMAT */
176
177const struct floatformat *
178default_float_format (struct gdbarch *gdbarch)
179{
180 int byte_order = gdbarch_byte_order (gdbarch);
181 switch (byte_order)
182 {
183 case BFD_ENDIAN_BIG:
184 return &floatformat_ieee_single_big;
185 case BFD_ENDIAN_LITTLE:
186 return &floatformat_ieee_single_little;
187 default:
188 internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/arch-utils.c", __LINE__188,
189 "default_float_format: bad byte order");
190 }
191}
192
193
194const struct floatformat *
195default_double_format (struct gdbarch *gdbarch)
196{
197 int byte_order = gdbarch_byte_order (gdbarch);
198 switch (byte_order)
199 {
200 case BFD_ENDIAN_BIG:
201 return &floatformat_ieee_double_big;
202 case BFD_ENDIAN_LITTLE:
203 return &floatformat_ieee_double_little;
204 default:
205 internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/arch-utils.c", __LINE__205,
206 "default_double_format: bad byte order");
207 }
208}
209
210/* Misc helper functions for targets. */
211
212CORE_ADDR
213core_addr_identity (CORE_ADDR addr)
214{
215 return addr;
216}
217
218CORE_ADDR
219convert_from_func_ptr_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr,
220 struct target_ops *targ)
221{
222 return addr;
223}
224
225int
226no_op_reg_to_regnum (int reg)
227{
228 return reg;
229}
230
231void
232default_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
233{
234 return;
235}
236
237void
238default_coff_make_msymbol_special (int val, struct minimal_symbol *msym)
239{
240 return;
241}
242
243int
244cannot_register_not (int regnum)
245{
246 return 0;
247}
248
249/* Legacy version of target_virtual_frame_pointer(). Assumes that
250 there is an DEPRECATED_FP_REGNUM and that it is the same, cooked or
251 raw. */
252
253void
254legacy_virtual_frame_pointer (CORE_ADDR pc,
255 int *frame_regnum,
256 LONGESTlong *frame_offset)
257{
258 /* FIXME: cagney/2002-09-13: This code is used when identifying the
259 frame pointer of the current PC. It is assuming that a single
260 register and an offset can determine this. I think it should
261 instead generate a byte code expression as that would work better
262 with things like Dwarf2's CFI. */
263 if (DEPRECATED_FP_REGNUM(gdbarch_deprecated_fp_regnum (current_gdbarch)) >= 0 && DEPRECATED_FP_REGNUM(gdbarch_deprecated_fp_regnum (current_gdbarch)) < NUM_REGS(gdbarch_num_regs (current_gdbarch)))
264 *frame_regnum = DEPRECATED_FP_REGNUM(gdbarch_deprecated_fp_regnum (current_gdbarch));
265 else if (SP_REGNUM(gdbarch_sp_regnum (current_gdbarch)) >= 0 && SP_REGNUM(gdbarch_sp_regnum (current_gdbarch)) < NUM_REGS(gdbarch_num_regs (current_gdbarch)))
266 *frame_regnum = SP_REGNUM(gdbarch_sp_regnum (current_gdbarch));
267 else
268 /* Should this be an internal error? I guess so, it is reflecting
269 an architectural limitation in the current design. */
270 internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/arch-utils.c", __LINE__270, "No virtual frame pointer available");
271 *frame_offset = 0;
272}
273
274/* Assume the world is sane, every register's virtual and real size
275 is identical. */
276
277int
278generic_register_size (int regnum)
279{
280 gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS)((void) ((regnum >= 0 && regnum < (gdbarch_num_regs
(current_gdbarch)) + (gdbarch_num_pseudo_regs (current_gdbarch
))) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/arch-utils.c"
, 280, "%s: Assertion `%s' failed.", __PRETTY_FUNCTION__, "regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS"
), 0)));
281 return TYPE_LENGTH (gdbarch_register_type (current_gdbarch, regnum))(gdbarch_register_type (current_gdbarch, regnum))->length;
282}
283
284/* Assume all registers are adjacent. */
285
286int
287generic_register_byte (int regnum)
288{
289 int byte;
290 int i;
291 gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS)((void) ((regnum >= 0 && regnum < (gdbarch_num_regs
(current_gdbarch)) + (gdbarch_num_pseudo_regs (current_gdbarch
))) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/arch-utils.c"
, 291, "%s: Assertion `%s' failed.", __PRETTY_FUNCTION__, "regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS"
), 0)));
292 byte = 0;
293 for (i = 0; i < regnum; i++)
294 {
295 byte += generic_register_size (i);
296 }
297 return byte;
298}
299
300
301int
302legacy_pc_in_sigtramp (CORE_ADDR pc, char *name)
303{
304#if defined (DEPRECATED_IN_SIGTRAMP)
305 return DEPRECATED_IN_SIGTRAMP (pc, name);
306#else
307 return name && strcmp ("_sigtramp", name) == 0;
308#endif
309}
310
311int
312generic_convert_register_p (int regnum, struct type *type)
313{
314 return 0;
315}
316
317int
318default_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
319{
320 if (DEPRECATED_REG_STRUCT_HAS_ADDR_P ()(gdbarch_deprecated_reg_struct_has_addr_p (current_gdbarch))
321 && DEPRECATED_REG_STRUCT_HAS_ADDR (processing_gcc_compilation, type)(gdbarch_deprecated_reg_struct_has_addr (current_gdbarch, processing_gcc_compilation
, type)))
322 {
323 CHECK_TYPEDEF (type)(type) = check_typedef (type);
324
325 return (TYPE_CODE (type)(type)->main_type->code == TYPE_CODE_STRUCT
326 || TYPE_CODE (type)(type)->main_type->code == TYPE_CODE_UNION
327 || TYPE_CODE (type)(type)->main_type->code == TYPE_CODE_SET
328 || TYPE_CODE (type)(type)->main_type->code == TYPE_CODE_BITSTRING);
329 }
330
331 return 0;
332}
333
334
335/* Functions to manipulate the endianness of the target. */
336
337/* ``target_byte_order'' is only used when non- multi-arch.
338 Multi-arch targets obtain the current byte order using the
339 TARGET_BYTE_ORDER gdbarch method.
340
341 The choice of initial value is entirely arbitrary. During startup,
342 the function initialize_current_architecture() updates this value
343 based on default byte-order information extracted from BFD. */
344static int target_byte_order = BFD_ENDIAN_BIG;
345static int target_byte_order_auto = 1;
346
347enum bfd_endian
348selected_byte_order (void)
349{
350 if (target_byte_order_auto)
351 return BFD_ENDIAN_UNKNOWN;
352 else
353 return target_byte_order;
354}
355
356static const char endian_big[] = "big";
357static const char endian_little[] = "little";
358static const char endian_auto[] = "auto";
359static const char *endian_enum[] =
360{
361 endian_big,
362 endian_little,
363 endian_auto,
364 NULL((void*)0),
365};
366static const char *set_endian_string;
367
368/* Called by ``show endian''. */
369
370static void
371show_endian (char *args, int from_tty)
372{
373 if (target_byte_order_auto)
374 printf_unfiltered ("The target endianness is set automatically (currently %s endian)\n",
375 (TARGET_BYTE_ORDER(gdbarch_byte_order (current_gdbarch)) == BFD_ENDIAN_BIG ? "big" : "little"));
376 else
377 printf_unfiltered ("The target is assumed to be %s endian\n",
378 (TARGET_BYTE_ORDER(gdbarch_byte_order (current_gdbarch)) == BFD_ENDIAN_BIG ? "big" : "little"));
379}
380
381static void
382set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c)
383{
384 if (set_endian_string == endian_auto)
385 {
386 target_byte_order_auto = 1;
387 }
388 else if (set_endian_string == endian_little)
389 {
390 struct gdbarch_info info;
391 target_byte_order_auto = 0;
392 gdbarch_info_init (&info);
393 info.byte_order = BFD_ENDIAN_LITTLE;
394 if (! gdbarch_update_p (info))
395 printf_unfiltered ("Little endian target not supported by GDB\n");
396 }
397 else if (set_endian_string == endian_big)
398 {
399 struct gdbarch_info info;
400 target_byte_order_auto = 0;
401 gdbarch_info_init (&info);
402 info.byte_order = BFD_ENDIAN_BIG;
403 if (! gdbarch_update_p (info))
404 printf_unfiltered ("Big endian target not supported by GDB\n");
405 }
406 else
407 internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/arch-utils.c", __LINE__407,
408 "set_endian: bad value");
409 show_endian (NULL((void*)0), from_tty);
410}
411
412/* Functions to manipulate the architecture of the target */
413
414enum set_arch { set_arch_auto, set_arch_manual };
415
416static int target_architecture_auto = 1;
417
418static const char *set_architecture_string;
419
420const char *
421selected_architecture_name (void)
422{
423 if (target_architecture_auto)
424 return NULL((void*)0);
425 else
426 return set_architecture_string;
427}
428
429/* Called if the user enters ``show architecture'' without an
430 argument. */
431
432static void
433show_architecture (char *args, int from_tty)
434{
435 const char *arch;
436 arch = TARGET_ARCHITECTURE(gdbarch_bfd_arch_info (current_gdbarch))->printable_name;
437 if (target_architecture_auto)
438 printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
439 else
440 printf_filtered ("The target architecture is assumed to be %s\n", arch);
441}
442
443
444/* Called if the user enters ``set architecture'' with or without an
445 argument. */
446
447static void
448set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c)
449{
450 if (strcmp (set_architecture_string, "auto") == 0)
451 {
452 target_architecture_auto = 1;
453 }
454 else
455 {
456 struct gdbarch_info info;
457 gdbarch_info_init (&info);
458 info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
459 if (info.bfd_arch_info == NULL((void*)0))
460 internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/arch-utils.c", __LINE__460,
461 "set_architecture: bfd_scan_arch failed");
462 if (gdbarch_update_p (info))
463 target_architecture_auto = 0;
464 else
465 printf_unfiltered ("Architecture `%s' not recognized.\n",
466 set_architecture_string);
467 }
468 show_architecture (NULL((void*)0), from_tty);
469}
470
471/* Try to select a global architecture that matches "info". Return
472 non-zero if the attempt succeds. */
473int
474gdbarch_update_p (struct gdbarch_info info)
475{
476 struct gdbarch *new_gdbarch = gdbarch_find_by_info (info);
477
478 /* If there no architecture by that name, reject the request. */
479 if (new_gdbarch == NULL((void*)0))
480 {
481 if (gdbarch_debug)
482 fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
483 "Architecture not found\n");
484 return 0;
485 }
486
487 /* If it is the same old architecture, accept the request (but don't
488 swap anything). */
489 if (new_gdbarch == current_gdbarch)
490 {
491 if (gdbarch_debug)
492 fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
493 "Architecture 0x%08lx (%s) unchanged\n",
494 (long) new_gdbarch,
495 gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
496 return 1;
497 }
498
499 /* It's a new architecture, swap it in. */
500 if (gdbarch_debug)
501 fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
502 "New architecture 0x%08lx (%s) selected\n",
503 (long) new_gdbarch,
504 gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
505 deprecated_current_gdbarch_select_hack (new_gdbarch);
506
507 return 1;
508}
509
510/* Return the architecture for ABFD. If no suitable architecture
511 could be find, return NULL. */
512
513struct gdbarch *
514gdbarch_from_bfd (bfd *abfd)
515{
516 struct gdbarch *old_gdbarch = current_gdbarch;
Value stored to 'old_gdbarch' during its initialization is never read
517 struct gdbarch *new_gdbarch;
518 struct gdbarch_info info;
519
520 gdbarch_info_init (&info);
521 info.abfd = abfd;
522 return gdbarch_find_by_info (info);
523}
524
525/* Set the dynamic target-system-dependent parameters (architecture,
526 byte-order) using information found in the BFD */
527
528void
529set_gdbarch_from_file (bfd *abfd)
530{
531 struct gdbarch *gdbarch;
532
533 gdbarch = gdbarch_from_bfd (abfd);
534 if (gdbarch == NULL((void*)0))
535 error ("Architecture of file not recognized.\n");
536 deprecated_current_gdbarch_select_hack (gdbarch);
537}
538
539/* Initialize the current architecture. Update the ``set
540 architecture'' command so that it specifies a list of valid
541 architectures. */
542
543#ifdef DEFAULT_BFD_ARCHbfd_i386_arch
544extern const bfd_arch_info_type DEFAULT_BFD_ARCHbfd_i386_arch;
545static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCHbfd_i386_arch;
546#else
547static const bfd_arch_info_type *default_bfd_arch;
548#endif
549
550#ifdef DEFAULT_BFD_VECbfd_elf64_x86_64_vec
551extern const bfd_target DEFAULT_BFD_VECbfd_elf64_x86_64_vec;
552static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VECbfd_elf64_x86_64_vec;
553#else
554static const bfd_target *default_bfd_vec;
555#endif
556
557void
558initialize_current_architecture (void)
559{
560 const char **arches = gdbarch_printable_names ();
561
562 /* determine a default architecture and byte order. */
563 struct gdbarch_info info;
564 gdbarch_info_init (&info);
565
566 /* Find a default architecture. */
567 if (info.bfd_arch_info == NULL((void*)0)
568 && default_bfd_arch != NULL((void*)0))
569 info.bfd_arch_info = default_bfd_arch;
570 if (info.bfd_arch_info == NULL((void*)0))
571 {
572 /* Choose the architecture by taking the first one
573 alphabetically. */
574 const char *chosen = arches[0];
575 const char **arch;
576 for (arch = arches; *arch != NULL((void*)0); arch++)
577 {
578 if (strcmp (*arch, chosen) < 0)
579 chosen = *arch;
580 }
581 if (chosen == NULL((void*)0))
582 internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/arch-utils.c", __LINE__582,
583 "initialize_current_architecture: No arch");
584 info.bfd_arch_info = bfd_scan_arch (chosen);
585 if (info.bfd_arch_info == NULL((void*)0))
586 internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/arch-utils.c", __LINE__586,
587 "initialize_current_architecture: Arch not found");
588 }
589
590 /* Take several guesses at a byte order. */
591 if (info.byte_order == BFD_ENDIAN_UNKNOWN
592 && default_bfd_vec != NULL((void*)0))
593 {
594 /* Extract BFD's default vector's byte order. */
595 switch (default_bfd_vec->byteorder)
596 {
597 case BFD_ENDIAN_BIG:
598 info.byte_order = BFD_ENDIAN_BIG;
599 break;
600 case BFD_ENDIAN_LITTLE:
601 info.byte_order = BFD_ENDIAN_LITTLE;
602 break;
603 default:
604 break;
605 }
606 }
607 if (info.byte_order == BFD_ENDIAN_UNKNOWN)
608 {
609 /* look for ``*el-*'' in the target name. */
610 const char *chp;
611 chp = strchr (target_name, '-');
612 if (chp != NULL((void*)0)
613 && chp - 2 >= target_name
614 && strncmp (chp - 2, "el", 2) == 0)
615 info.byte_order = BFD_ENDIAN_LITTLE;
616 }
617 if (info.byte_order == BFD_ENDIAN_UNKNOWN)
618 {
619 /* Wire it to big-endian!!! */
620 info.byte_order = BFD_ENDIAN_BIG;
621 }
622
623 if (! gdbarch_update_p (info))
624 internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/arch-utils.c", __LINE__624,
625 "initialize_current_architecture: Selection of initial architecture failed");
626
627 /* Create the ``set architecture'' command appending ``auto'' to the
628 list of architectures. */
629 {
630 struct cmd_list_element *c;
631 /* Append ``auto''. */
632 int nr;
633 for (nr = 0; arches[nr] != NULL((void*)0); nr++);
634 arches = xrealloc (arches, sizeof (char*) * (nr + 2));
635 arches[nr + 0] = "auto";
636 arches[nr + 1] = NULL((void*)0);
637 /* FIXME: add_set_enum_cmd() uses an array of ``char *'' instead
638 of ``const char *''. We just happen to know that the casts are
639 safe. */
640 c = add_set_enum_cmd ("architecture", class_support,
641 arches, &set_architecture_string,
642 "Set architecture of target.",
643 &setlist);
644 set_cmd_sfunc (c, set_architecture);
645 add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
646 /* Don't use set_from_show - need to print both auto/manual and
647 current setting. */
648 add_cmd ("architecture", class_support, show_architecture,
649 "Show the current target architecture", &showlist);
650 }
651}
652
653
654/* Initialize a gdbarch info to values that will be automatically
655 overridden. Note: Originally, this ``struct info'' was initialized
656 using memset(0). Unfortunately, that ran into problems, namely
657 BFD_ENDIAN_BIG is zero. An explicit initialization function that
658 can explicitly set each field to a well defined value is used. */
659
660void
661gdbarch_info_init (struct gdbarch_info *info)
662{
663 memset (info, 0, sizeof (struct gdbarch_info));
664 info->byte_order = BFD_ENDIAN_UNKNOWN;
665 info->osabi = GDB_OSABI_UNINITIALIZED;
666}
667
668/* Similar to init, but this time fill in the blanks. Information is
669 obtained from the specified architecture, global "set ..." options,
670 and explicitly initialized INFO fields. */
671
672void
673gdbarch_info_fill (struct gdbarch *gdbarch, struct gdbarch_info *info)
674{
675 /* "(gdb) set architecture ...". */
676 if (info->bfd_arch_info == NULL((void*)0)
677 && !target_architecture_auto
678 && gdbarch != NULL((void*)0))
679 info->bfd_arch_info = gdbarch_bfd_arch_info (gdbarch);
680 if (info->bfd_arch_info == NULL((void*)0)
681 && info->abfd != NULL((void*)0)
682 && bfd_get_arch (info->abfd) != bfd_arch_unknown
683 && bfd_get_arch (info->abfd) != bfd_arch_obscure)
684 info->bfd_arch_info = bfd_get_arch_info (info->abfd);
685 if (info->bfd_arch_info == NULL((void*)0)
686 && gdbarch != NULL((void*)0))
687 info->bfd_arch_info = gdbarch_bfd_arch_info (gdbarch);
688
689 /* "(gdb) set byte-order ...". */
690 if (info->byte_order == BFD_ENDIAN_UNKNOWN
691 && !target_byte_order_auto
692 && gdbarch != NULL((void*)0))
693 info->byte_order = gdbarch_byte_order (gdbarch);
694 /* From the INFO struct. */
695 if (info->byte_order == BFD_ENDIAN_UNKNOWN
696 && info->abfd != NULL((void*)0))
697 info->byte_order = (bfd_big_endian (info->abfd)((info->abfd)->xvec->byteorder == BFD_ENDIAN_BIG) ? BFD_ENDIAN_BIG
698 : bfd_little_endian (info->abfd)((info->abfd)->xvec->byteorder == BFD_ENDIAN_LITTLE) ? BFD_ENDIAN_LITTLE
699 : BFD_ENDIAN_UNKNOWN);
700 /* From the current target. */
701 if (info->byte_order == BFD_ENDIAN_UNKNOWN
702 && gdbarch != NULL((void*)0))
703 info->byte_order = gdbarch_byte_order (gdbarch);
704
705 /* "(gdb) set osabi ...". Handled by gdbarch_lookup_osabi. */
706 if (info->osabi == GDB_OSABI_UNINITIALIZED)
707 info->osabi = gdbarch_lookup_osabi (info->abfd);
708 if (info->osabi == GDB_OSABI_UNINITIALIZED
709 && gdbarch != NULL((void*)0))
710 info->osabi = gdbarch_osabi (gdbarch);
711
712 /* Must have at least filled in the architecture. */
713 gdb_assert (info->bfd_arch_info != NULL)((void) ((info->bfd_arch_info != ((void*)0)) ? 0 : (internal_error
("/usr/src/gnu/usr.bin/binutils/gdb/arch-utils.c", 713, "%s: Assertion `%s' failed."
, __PRETTY_FUNCTION__, "info->bfd_arch_info != NULL"), 0))
);
714}
715
716/* */
717
718extern initialize_file_ftype _initialize_gdbarch_utils; /* -Wmissing-prototypes */
719
720void
721_initialize_gdbarch_utils (void)
722{
723 struct cmd_list_element *c;
724 c = add_set_enum_cmd ("endian", class_support,
725 endian_enum, &set_endian_string,
726 "Set endianness of target.",
727 &setlist);
728 set_cmd_sfunc (c, set_endian);
729 /* Don't use set_from_show - need to print both auto/manual and
730 current setting. */
731 add_cmd ("endian", class_support, show_endian,
732 "Show the current byte-order", &showlist);
733}