OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gdb-7.2/] [gdb/] [arch-utils.c] - Blame information for rev 841

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 330 jeremybenn
/* Dynamic architecture support for GDB, the GNU debugger.
2
 
3
   Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
4
   2008, 2009, 2010 Free Software 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 3 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, see <http://www.gnu.org/licenses/>.  */
20
 
21
#include "defs.h"
22
 
23
#include "arch-utils.h"
24
#include "buildsym.h"
25
#include "gdbcmd.h"
26
#include "inferior.h"           /* enum CALL_DUMMY_LOCATION et.al. */
27
#include "gdb_string.h"
28
#include "regcache.h"
29
#include "gdb_assert.h"
30
#include "sim-regno.h"
31
#include "gdbcore.h"
32
#include "osabi.h"
33
#include "target-descriptions.h"
34
#include "objfiles.h"
35
 
36
#include "version.h"
37
 
38
#include "floatformat.h"
39
 
40
 
41
struct displaced_step_closure *
42
simple_displaced_step_copy_insn (struct gdbarch *gdbarch,
43
                                 CORE_ADDR from, CORE_ADDR to,
44
                                 struct regcache *regs)
45
{
46
  size_t len = gdbarch_max_insn_length (gdbarch);
47
  gdb_byte *buf = xmalloc (len);
48
 
49
  read_memory (from, buf, len);
50
  write_memory (to, buf, len);
51
 
52
  if (debug_displaced)
53
    {
54
      fprintf_unfiltered (gdb_stdlog, "displaced: copy %s->%s: ",
55
                          paddress (gdbarch, from), paddress (gdbarch, to));
56
      displaced_step_dump_bytes (gdb_stdlog, buf, len);
57
    }
58
 
59
  return (struct displaced_step_closure *) buf;
60
}
61
 
62
 
63
void
64
simple_displaced_step_free_closure (struct gdbarch *gdbarch,
65
                                    struct displaced_step_closure *closure)
66
{
67
  xfree (closure);
68
}
69
 
70
int
71
default_displaced_step_hw_singlestep (struct gdbarch *gdbarch,
72
                                      struct displaced_step_closure *closure)
73
{
74
  return !gdbarch_software_single_step_p (gdbarch);
75
}
76
 
77
CORE_ADDR
78
displaced_step_at_entry_point (struct gdbarch *gdbarch)
79
{
80
  CORE_ADDR addr;
81
  int bp_len;
82
 
83
  addr = entry_point_address ();
84
 
85
  /* Inferior calls also use the entry point as a breakpoint location.
86
     We don't want displaced stepping to interfere with those
87
     breakpoints, so leave space.  */
88
  gdbarch_breakpoint_from_pc (gdbarch, &addr, &bp_len);
89
  addr += bp_len * 2;
90
 
91
  return addr;
92
}
93
 
94
int
95
legacy_register_sim_regno (struct gdbarch *gdbarch, int regnum)
96
{
97
  /* Only makes sense to supply raw registers.  */
98
  gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch));
99
  /* NOTE: cagney/2002-05-13: The old code did it this way and it is
100
     suspected that some GDB/SIM combinations may rely on this
101
     behavour.  The default should be one2one_register_sim_regno
102
     (below).  */
103
  if (gdbarch_register_name (gdbarch, regnum) != NULL
104
      && gdbarch_register_name (gdbarch, regnum)[0] != '\0')
105
    return regnum;
106
  else
107
    return LEGACY_SIM_REGNO_IGNORE;
108
}
109
 
110
CORE_ADDR
111
generic_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
112
{
113
  return 0;
114
}
115
 
116
CORE_ADDR
117
generic_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
118
{
119
  return 0;
120
}
121
 
122
int
123
generic_in_solib_return_trampoline (struct gdbarch *gdbarch,
124
                                    CORE_ADDR pc, char *name)
125
{
126
  return 0;
127
}
128
 
129
int
130
generic_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
131
{
132
  return 0;
133
}
134
 
135
/* Helper functions for gdbarch_inner_than */
136
 
137
int
138
core_addr_lessthan (CORE_ADDR lhs, CORE_ADDR rhs)
139
{
140
  return (lhs < rhs);
141
}
142
 
143
int
144
core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs)
145
{
146
  return (lhs > rhs);
147
}
148
 
149
/* Misc helper functions for targets. */
150
 
151
CORE_ADDR
152
core_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr)
153
{
154
  return addr;
155
}
156
 
157
CORE_ADDR
158
convert_from_func_ptr_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr,
159
                                     struct target_ops *targ)
160
{
161
  return addr;
162
}
163
 
164
int
165
no_op_reg_to_regnum (struct gdbarch *gdbarch, int reg)
166
{
167
  return reg;
168
}
169
 
170
void
171
default_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
172
{
173
  return;
174
}
175
 
176
void
177
default_coff_make_msymbol_special (int val, struct minimal_symbol *msym)
178
{
179
  return;
180
}
181
 
182
int
183
cannot_register_not (struct gdbarch *gdbarch, int regnum)
184
{
185
  return 0;
186
}
187
 
188
/* Legacy version of target_virtual_frame_pointer().  Assumes that
189
   there is an gdbarch_deprecated_fp_regnum and that it is the same, cooked or
190
   raw.  */
191
 
192
void
193
legacy_virtual_frame_pointer (struct gdbarch *gdbarch,
194
                              CORE_ADDR pc,
195
                              int *frame_regnum,
196
                              LONGEST *frame_offset)
197
{
198
  /* FIXME: cagney/2002-09-13: This code is used when identifying the
199
     frame pointer of the current PC.  It is assuming that a single
200
     register and an offset can determine this.  I think it should
201
     instead generate a byte code expression as that would work better
202
     with things like Dwarf2's CFI.  */
203
  if (gdbarch_deprecated_fp_regnum (gdbarch) >= 0
204
      && gdbarch_deprecated_fp_regnum (gdbarch)
205
           < gdbarch_num_regs (gdbarch))
206
    *frame_regnum = gdbarch_deprecated_fp_regnum (gdbarch);
207
  else if (gdbarch_sp_regnum (gdbarch) >= 0
208
           && gdbarch_sp_regnum (gdbarch)
209
                < gdbarch_num_regs (gdbarch))
210
    *frame_regnum = gdbarch_sp_regnum (gdbarch);
211
  else
212
    /* Should this be an internal error?  I guess so, it is reflecting
213
       an architectural limitation in the current design.  */
214
    internal_error (__FILE__, __LINE__, _("No virtual frame pointer available"));
215
  *frame_offset = 0;
216
}
217
 
218
 
219
int
220
generic_convert_register_p (struct gdbarch *gdbarch, int regnum,
221
                            struct type *type)
222
{
223
  return 0;
224
}
225
 
226
int
227
default_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
228
{
229
  return 0;
230
}
231
 
232
int
233
generic_instruction_nullified (struct gdbarch *gdbarch,
234
                               struct regcache *regcache)
235
{
236
  return 0;
237
}
238
 
239
int
240
default_remote_register_number (struct gdbarch *gdbarch,
241
                                int regno)
242
{
243
  return regno;
244
}
245
 
246
 
247
/* Functions to manipulate the endianness of the target.  */
248
 
249
static int target_byte_order_user = BFD_ENDIAN_UNKNOWN;
250
 
251
static const char endian_big[] = "big";
252
static const char endian_little[] = "little";
253
static const char endian_auto[] = "auto";
254
static const char *endian_enum[] =
255
{
256
  endian_big,
257
  endian_little,
258
  endian_auto,
259
  NULL,
260
};
261
static const char *set_endian_string;
262
 
263
enum bfd_endian
264
selected_byte_order (void)
265
{
266
  return target_byte_order_user;
267
}
268
 
269
/* Called by ``show endian''.  */
270
 
271
static void
272
show_endian (struct ui_file *file, int from_tty, struct cmd_list_element *c,
273
             const char *value)
274
{
275
  if (target_byte_order_user == BFD_ENDIAN_UNKNOWN)
276
    if (gdbarch_byte_order (get_current_arch ()) == BFD_ENDIAN_BIG)
277
      fprintf_unfiltered (file, _("The target endianness is set automatically "
278
                                  "(currently big endian)\n"));
279
    else
280
      fprintf_unfiltered (file, _("The target endianness is set automatically "
281
                           "(currently little endian)\n"));
282
  else
283
    if (target_byte_order_user == BFD_ENDIAN_BIG)
284
      fprintf_unfiltered (file,
285
                          _("The target is assumed to be big endian\n"));
286
    else
287
      fprintf_unfiltered (file,
288
                          _("The target is assumed to be little endian\n"));
289
}
290
 
291
static void
292
set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c)
293
{
294
  struct gdbarch_info info;
295
 
296
  gdbarch_info_init (&info);
297
 
298
  if (set_endian_string == endian_auto)
299
    {
300
      target_byte_order_user = BFD_ENDIAN_UNKNOWN;
301
      if (! gdbarch_update_p (info))
302
        internal_error (__FILE__, __LINE__,
303
                        _("set_endian: architecture update failed"));
304
    }
305
  else if (set_endian_string == endian_little)
306
    {
307
      info.byte_order = BFD_ENDIAN_LITTLE;
308
      if (! gdbarch_update_p (info))
309
        printf_unfiltered (_("Little endian target not supported by GDB\n"));
310
      else
311
        target_byte_order_user = BFD_ENDIAN_LITTLE;
312
    }
313
  else if (set_endian_string == endian_big)
314
    {
315
      info.byte_order = BFD_ENDIAN_BIG;
316
      if (! gdbarch_update_p (info))
317
        printf_unfiltered (_("Big endian target not supported by GDB\n"));
318
      else
319
        target_byte_order_user = BFD_ENDIAN_BIG;
320
    }
321
  else
322
    internal_error (__FILE__, __LINE__,
323
                    _("set_endian: bad value"));
324
 
325
  show_endian (gdb_stdout, from_tty, NULL, NULL);
326
}
327
 
328
/* Given SELECTED, a currently selected BFD architecture, and
329
   TARGET_DESC, the current target description, return what
330
   architecture to use.
331
 
332
   SELECTED may be NULL, in which case we return the architecture
333
   associated with TARGET_DESC.  If SELECTED specifies a variant
334
   of the architecture associtated with TARGET_DESC, return the
335
   more specific of the two.
336
 
337
   If SELECTED is a different architecture, but it is accepted as
338
   compatible by the target, we can use the target architecture.
339
 
340
   If SELECTED is obviously incompatible, warn the user.  */
341
 
342
static const struct bfd_arch_info *
343
choose_architecture_for_target (const struct target_desc *target_desc,
344
                                const struct bfd_arch_info *selected)
345
{
346
  const struct bfd_arch_info *from_target = tdesc_architecture (target_desc);
347
  const struct bfd_arch_info *compat1, *compat2;
348
 
349
  if (selected == NULL)
350
    return from_target;
351
 
352
  if (from_target == NULL)
353
    return selected;
354
 
355
  /* struct bfd_arch_info objects are singletons: that is, there's
356
     supposed to be exactly one instance for a given machine.  So you
357
     can tell whether two are equivalent by comparing pointers.  */
358
  if (from_target == selected)
359
    return selected;
360
 
361
  /* BFD's 'A->compatible (A, B)' functions return zero if A and B are
362
     incompatible.  But if they are compatible, it returns the 'more
363
     featureful' of the two arches.  That is, if A can run code
364
     written for B, but B can't run code written for A, then it'll
365
     return A.
366
 
367
     Some targets (e.g. MIPS as of 2006-12-04) don't fully
368
     implement this, instead always returning NULL or the first
369
     argument.  We detect that case by checking both directions.  */
370
 
371
  compat1 = selected->compatible (selected, from_target);
372
  compat2 = from_target->compatible (from_target, selected);
373
 
374
  if (compat1 == NULL && compat2 == NULL)
375
    {
376
      /* BFD considers the architectures incompatible.  Check our target
377
         description whether it accepts SELECTED as compatible anyway.  */
378
      if (tdesc_compatible_p (target_desc, selected))
379
        return from_target;
380
 
381
      warning (_("Selected architecture %s is not compatible "
382
                 "with reported target architecture %s"),
383
               selected->printable_name, from_target->printable_name);
384
      return selected;
385
    }
386
 
387
  if (compat1 == NULL)
388
    return compat2;
389
  if (compat2 == NULL)
390
    return compat1;
391
  if (compat1 == compat2)
392
    return compat1;
393
 
394
  /* If the two didn't match, but one of them was a default architecture,
395
     assume the more specific one is correct.  This handles the case
396
     where an executable or target description just says "mips", but
397
     the other knows which MIPS variant.  */
398
  if (compat1->the_default)
399
    return compat2;
400
  if (compat2->the_default)
401
    return compat1;
402
 
403
  /* We have no idea which one is better.  This is a bug, but not
404
     a critical problem; warn the user.  */
405
  warning (_("Selected architecture %s is ambiguous with "
406
             "reported target architecture %s"),
407
           selected->printable_name, from_target->printable_name);
408
  return selected;
409
}
410
 
411
/* Functions to manipulate the architecture of the target */
412
 
413
enum set_arch { set_arch_auto, set_arch_manual };
414
 
415
static const struct bfd_arch_info *target_architecture_user;
416
 
417
static const char *set_architecture_string;
418
 
419
const char *
420
selected_architecture_name (void)
421
{
422
  if (target_architecture_user == NULL)
423
    return NULL;
424
  else
425
    return set_architecture_string;
426
}
427
 
428
/* Called if the user enters ``show architecture'' without an
429
   argument. */
430
 
431
static void
432
show_architecture (struct ui_file *file, int from_tty,
433
                   struct cmd_list_element *c, const char *value)
434
{
435
  if (target_architecture_user == NULL)
436
    fprintf_filtered (file, _("\
437
The target architecture is set automatically (currently %s)\n"),
438
                gdbarch_bfd_arch_info (get_current_arch ())->printable_name);
439
  else
440
    fprintf_filtered (file, _("\
441
The target architecture is assumed to be %s\n"), set_architecture_string);
442
}
443
 
444
 
445
/* Called if the user enters ``set architecture'' with or without an
446
   argument. */
447
 
448
static void
449
set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c)
450
{
451
  struct gdbarch_info info;
452
 
453
  gdbarch_info_init (&info);
454
 
455
  if (strcmp (set_architecture_string, "auto") == 0)
456
    {
457
      target_architecture_user = NULL;
458
      if (!gdbarch_update_p (info))
459
        internal_error (__FILE__, __LINE__,
460
                        _("could not select an architecture automatically"));
461
    }
462
  else
463
    {
464
      info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
465
      if (info.bfd_arch_info == NULL)
466
        internal_error (__FILE__, __LINE__,
467
                        _("set_architecture: bfd_scan_arch failed"));
468
      if (gdbarch_update_p (info))
469
        target_architecture_user = info.bfd_arch_info;
470
      else
471
        printf_unfiltered (_("Architecture `%s' not recognized.\n"),
472
                           set_architecture_string);
473
    }
474
  show_architecture (gdb_stdout, from_tty, NULL, NULL);
475
}
476
 
477
/* Try to select a global architecture that matches "info".  Return
478
   non-zero if the attempt succeds.  */
479
int
480
gdbarch_update_p (struct gdbarch_info info)
481
{
482
  struct gdbarch *new_gdbarch;
483
 
484
  /* Check for the current file.  */
485
  if (info.abfd == NULL)
486
    info.abfd = exec_bfd;
487
  if (info.abfd == NULL)
488
    info.abfd = core_bfd;
489
 
490
  /* Check for the current target description.  */
491
  if (info.target_desc == NULL)
492
    info.target_desc = target_current_description ();
493
 
494
  new_gdbarch = gdbarch_find_by_info (info);
495
 
496
  /* If there no architecture by that name, reject the request.  */
497
  if (new_gdbarch == NULL)
498
    {
499
      if (gdbarch_debug)
500
        fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
501
                            "Architecture not found\n");
502
      return 0;
503
    }
504
 
505
  /* If it is the same old architecture, accept the request (but don't
506
     swap anything).  */
507
  if (new_gdbarch == target_gdbarch)
508
    {
509
      if (gdbarch_debug)
510
        fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
511
                            "Architecture %s (%s) unchanged\n",
512
                            host_address_to_string (new_gdbarch),
513
                            gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
514
      return 1;
515
    }
516
 
517
  /* It's a new architecture, swap it in.  */
518
  if (gdbarch_debug)
519
    fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
520
                        "New architecture %s (%s) selected\n",
521
                        host_address_to_string (new_gdbarch),
522
                        gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
523
  deprecated_target_gdbarch_select_hack (new_gdbarch);
524
 
525
  return 1;
526
}
527
 
528
/* Return the architecture for ABFD.  If no suitable architecture
529
   could be find, return NULL.  */
530
 
531
struct gdbarch *
532
gdbarch_from_bfd (bfd *abfd)
533
{
534
  struct gdbarch_info info;
535
  gdbarch_info_init (&info);
536
 
537
  info.abfd = abfd;
538
  return gdbarch_find_by_info (info);
539
}
540
 
541
/* Set the dynamic target-system-dependent parameters (architecture,
542
   byte-order) using information found in the BFD */
543
 
544
void
545
set_gdbarch_from_file (bfd *abfd)
546
{
547
  struct gdbarch_info info;
548
  struct gdbarch *gdbarch;
549
 
550
  gdbarch_info_init (&info);
551
  info.abfd = abfd;
552
  info.target_desc = target_current_description ();
553
  gdbarch = gdbarch_find_by_info (info);
554
 
555
  if (gdbarch == NULL)
556
    error (_("Architecture of file not recognized."));
557
  deprecated_target_gdbarch_select_hack (gdbarch);
558
}
559
 
560
/* Initialize the current architecture.  Update the ``set
561
   architecture'' command so that it specifies a list of valid
562
   architectures.  */
563
 
564
#ifdef DEFAULT_BFD_ARCH
565
extern const bfd_arch_info_type DEFAULT_BFD_ARCH;
566
static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH;
567
#else
568
static const bfd_arch_info_type *default_bfd_arch;
569
#endif
570
 
571
#ifdef DEFAULT_BFD_VEC
572
extern const bfd_target DEFAULT_BFD_VEC;
573
static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC;
574
#else
575
static const bfd_target *default_bfd_vec;
576
#endif
577
 
578
static int default_byte_order = BFD_ENDIAN_UNKNOWN;
579
 
580
void
581
initialize_current_architecture (void)
582
{
583
  const char **arches = gdbarch_printable_names ();
584
  struct gdbarch_info info;
585
 
586
  /* determine a default architecture and byte order. */
587
  gdbarch_info_init (&info);
588
 
589
  /* Find a default architecture. */
590
  if (default_bfd_arch == NULL)
591
    {
592
      /* Choose the architecture by taking the first one
593
         alphabetically. */
594
      const char *chosen = arches[0];
595
      const char **arch;
596
      for (arch = arches; *arch != NULL; arch++)
597
        {
598
          if (strcmp (*arch, chosen) < 0)
599
            chosen = *arch;
600
        }
601
      if (chosen == NULL)
602
        internal_error (__FILE__, __LINE__,
603
                        _("initialize_current_architecture: No arch"));
604
      default_bfd_arch = bfd_scan_arch (chosen);
605
      if (default_bfd_arch == NULL)
606
        internal_error (__FILE__, __LINE__,
607
                        _("initialize_current_architecture: Arch not found"));
608
    }
609
 
610
  info.bfd_arch_info = default_bfd_arch;
611
 
612
  /* Take several guesses at a byte order.  */
613
  if (default_byte_order == BFD_ENDIAN_UNKNOWN
614
      && default_bfd_vec != NULL)
615
    {
616
      /* Extract BFD's default vector's byte order. */
617
      switch (default_bfd_vec->byteorder)
618
        {
619
        case BFD_ENDIAN_BIG:
620
          default_byte_order = BFD_ENDIAN_BIG;
621
          break;
622
        case BFD_ENDIAN_LITTLE:
623
          default_byte_order = BFD_ENDIAN_LITTLE;
624
          break;
625
        default:
626
          break;
627
        }
628
    }
629
  if (default_byte_order == BFD_ENDIAN_UNKNOWN)
630
    {
631
      /* look for ``*el-*'' in the target name. */
632
      const char *chp;
633
      chp = strchr (target_name, '-');
634
      if (chp != NULL
635
          && chp - 2 >= target_name
636
          && strncmp (chp - 2, "el", 2) == 0)
637
        default_byte_order = BFD_ENDIAN_LITTLE;
638
    }
639
  if (default_byte_order == BFD_ENDIAN_UNKNOWN)
640
    {
641
      /* Wire it to big-endian!!! */
642
      default_byte_order = BFD_ENDIAN_BIG;
643
    }
644
 
645
  info.byte_order = default_byte_order;
646
  info.byte_order_for_code = info.byte_order;
647
 
648
  if (! gdbarch_update_p (info))
649
    internal_error (__FILE__, __LINE__,
650
                    _("initialize_current_architecture: Selection of "
651
                      "initial architecture failed"));
652
 
653
  /* Create the ``set architecture'' command appending ``auto'' to the
654
     list of architectures. */
655
  {
656
    /* Append ``auto''. */
657
    int nr;
658
    for (nr = 0; arches[nr] != NULL; nr++);
659
    arches = xrealloc (arches, sizeof (char*) * (nr + 2));
660
    arches[nr + 0] = "auto";
661
    arches[nr + 1] = NULL;
662
    add_setshow_enum_cmd ("architecture", class_support,
663
                          arches, &set_architecture_string, _("\
664
Set architecture of target."), _("\
665
Show architecture of target."), NULL,
666
                          set_architecture, show_architecture,
667
                          &setlist, &showlist);
668
    add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
669
  }
670
}
671
 
672
 
673
/* Initialize a gdbarch info to values that will be automatically
674
   overridden.  Note: Originally, this ``struct info'' was initialized
675
   using memset(0).  Unfortunately, that ran into problems, namely
676
   BFD_ENDIAN_BIG is zero.  An explicit initialization function that
677
   can explicitly set each field to a well defined value is used.  */
678
 
679
void
680
gdbarch_info_init (struct gdbarch_info *info)
681
{
682
  memset (info, 0, sizeof (struct gdbarch_info));
683
  info->byte_order = BFD_ENDIAN_UNKNOWN;
684
  info->byte_order_for_code = info->byte_order;
685
  info->osabi = GDB_OSABI_UNINITIALIZED;
686
}
687
 
688
/* Similar to init, but this time fill in the blanks.  Information is
689
   obtained from the global "set ..." options and explicitly
690
   initialized INFO fields.  */
691
 
692
void
693
gdbarch_info_fill (struct gdbarch_info *info)
694
{
695
  /* "(gdb) set architecture ...".  */
696
  if (info->bfd_arch_info == NULL
697
      && target_architecture_user)
698
    info->bfd_arch_info = target_architecture_user;
699
  /* From the file.  */
700
  if (info->bfd_arch_info == NULL
701
      && info->abfd != NULL
702
      && bfd_get_arch (info->abfd) != bfd_arch_unknown
703
      && bfd_get_arch (info->abfd) != bfd_arch_obscure)
704
    info->bfd_arch_info = bfd_get_arch_info (info->abfd);
705
  /* From the target.  */
706
  if (info->target_desc != NULL)
707
    info->bfd_arch_info = choose_architecture_for_target
708
                           (info->target_desc, info->bfd_arch_info);
709
  /* From the default.  */
710
  if (info->bfd_arch_info == NULL)
711
    info->bfd_arch_info = default_bfd_arch;
712
 
713
  /* "(gdb) set byte-order ...".  */
714
  if (info->byte_order == BFD_ENDIAN_UNKNOWN
715
      && target_byte_order_user != BFD_ENDIAN_UNKNOWN)
716
    info->byte_order = target_byte_order_user;
717
  /* From the INFO struct.  */
718
  if (info->byte_order == BFD_ENDIAN_UNKNOWN
719
      && info->abfd != NULL)
720
    info->byte_order = (bfd_big_endian (info->abfd) ? BFD_ENDIAN_BIG
721
                        : bfd_little_endian (info->abfd) ? BFD_ENDIAN_LITTLE
722
                        : BFD_ENDIAN_UNKNOWN);
723
  /* From the default.  */
724
  if (info->byte_order == BFD_ENDIAN_UNKNOWN)
725
    info->byte_order = default_byte_order;
726
  info->byte_order_for_code = info->byte_order;
727
 
728
  /* "(gdb) set osabi ...".  Handled by gdbarch_lookup_osabi.  */
729
  /* From the manual override, or from file.  */
730
  if (info->osabi == GDB_OSABI_UNINITIALIZED)
731
    info->osabi = gdbarch_lookup_osabi (info->abfd);
732
  /* From the target.  */
733
  if (info->osabi == GDB_OSABI_UNKNOWN && info->target_desc != NULL)
734
    info->osabi = tdesc_osabi (info->target_desc);
735
  /* From the configured default.  */
736
#ifdef GDB_OSABI_DEFAULT
737
  if (info->osabi == GDB_OSABI_UNKNOWN)
738
    info->osabi = GDB_OSABI_DEFAULT;
739
#endif
740
 
741
  /* Must have at least filled in the architecture.  */
742
  gdb_assert (info->bfd_arch_info != NULL);
743
}
744
 
745
/* Return "current" architecture.  If the target is running, this is the
746
   architecture of the selected frame.  Otherwise, the "current" architecture
747
   defaults to the target architecture.
748
 
749
   This function should normally be called solely by the command interpreter
750
   routines to determine the architecture to execute a command in.  */
751
struct gdbarch *
752
get_current_arch (void)
753
{
754
  if (has_stack_frames ())
755
    return get_frame_arch (get_selected_frame (NULL));
756
  else
757
    return target_gdbarch;
758
}
759
 
760
int
761
default_has_shared_address_space (struct gdbarch *gdbarch)
762
{
763
  /* Simply say no.  In most unix-like targets each inferior/process
764
     has its own address space.  */
765
  return 0;
766
}
767
 
768
int
769
default_fast_tracepoint_valid_at (struct gdbarch *gdbarch,
770
                                  CORE_ADDR addr, int *isize, char **msg)
771
{
772
  /* We don't know if maybe the target has some way to do fast
773
     tracepoints that doesn't need gdbarch, so always say yes.  */
774
  if (msg)
775
    *msg = NULL;
776
  return 1;
777
}
778
 
779
void
780
default_remote_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
781
                                   int *kindptr)
782
{
783
  gdbarch_breakpoint_from_pc (gdbarch, pcptr, kindptr);
784
}
785
 
786
/* */
787
 
788
extern initialize_file_ftype _initialize_gdbarch_utils; /* -Wmissing-prototypes */
789
 
790
void
791
_initialize_gdbarch_utils (void)
792
{
793
  add_setshow_enum_cmd ("endian", class_support,
794
                        endian_enum, &set_endian_string, _("\
795
Set endianness of target."), _("\
796
Show endianness of target."), NULL,
797
                        set_endian, show_endian,
798
                        &setlist, &showlist);
799
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.