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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [gdb/] [arch-utils.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 578 markom
/* Dynamic architecture support for GDB, the GNU debugger.
2
   Copyright 1998, 1999, 2000, 2001 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,
19
   Boston, MA 02111-1307, USA.  */
20
 
21
#include "defs.h"
22
 
23
#if GDB_MULTI_ARCH
24
#include "gdbcmd.h"
25
#include "inferior.h"           /* enum CALL_DUMMY_LOCATION et.al. */
26
#else
27
/* Just include everything in sight so that the every old definition
28
   of macro is visible. */
29
#include "gdb_string.h"
30
#include "symtab.h"
31
#include "frame.h"
32
#include "inferior.h"
33
#include "breakpoint.h"
34
#include "gdb_wait.h"
35
#include "gdbcore.h"
36
#include "gdbcmd.h"
37
#include "target.h"
38
#include "annotate.h"
39
#endif
40
#include "regcache.h"
41
 
42
#include "version.h"
43
 
44
#include "floatformat.h"
45
 
46
/* Use the program counter to determine the contents and size
47
   of a breakpoint instruction.  If no target-dependent macro
48
   BREAKPOINT_FROM_PC has been defined to implement this function,
49
   assume that the breakpoint doesn't depend on the PC, and
50
   use the values of the BIG_BREAKPOINT and LITTLE_BREAKPOINT macros.
51
   Return a pointer to a string of bytes that encode a breakpoint
52
   instruction, stores the length of the string to *lenptr,
53
   and optionally adjust the pc to point to the correct memory location
54
   for inserting the breakpoint.  */
55
 
56
unsigned char *
57
legacy_breakpoint_from_pc (CORE_ADDR * pcptr, int *lenptr)
58
{
59
  /* {BIG_,LITTLE_}BREAKPOINT is the sequence of bytes we insert for a
60
     breakpoint.  On some machines, breakpoints are handled by the
61
     target environment and we don't have to worry about them here.  */
62
#ifdef BIG_BREAKPOINT
63
  if (TARGET_BYTE_ORDER == BIG_ENDIAN)
64
    {
65
      static unsigned char big_break_insn[] = BIG_BREAKPOINT;
66
      *lenptr = sizeof (big_break_insn);
67
      return big_break_insn;
68
    }
69
#endif
70
#ifdef LITTLE_BREAKPOINT
71
  if (TARGET_BYTE_ORDER != BIG_ENDIAN)
72
    {
73
      static unsigned char little_break_insn[] = LITTLE_BREAKPOINT;
74
      *lenptr = sizeof (little_break_insn);
75
      return little_break_insn;
76
    }
77
#endif
78
#ifdef BREAKPOINT
79
  {
80
    static unsigned char break_insn[] = BREAKPOINT;
81
    *lenptr = sizeof (break_insn);
82
    return break_insn;
83
  }
84
#endif
85
  *lenptr = 0;
86
  return NULL;
87
}
88
 
89
int
90
generic_frameless_function_invocation_not (struct frame_info *fi)
91
{
92
  return 0;
93
}
94
 
95
int
96
generic_return_value_on_stack_not (struct type *type)
97
{
98
  return 0;
99
}
100
 
101
char *
102
legacy_register_name (int i)
103
{
104
#ifdef REGISTER_NAMES
105
  static char *names[] = REGISTER_NAMES;
106
  if (i < 0 || i >= (sizeof (names) / sizeof (*names)))
107
    return NULL;
108
  else
109
    return names[i];
110
#else
111
  internal_error (__FILE__, __LINE__,
112
                  "legacy_register_name: called.");
113
  return NULL;
114
#endif
115
}
116
 
117
#if defined (CALL_DUMMY)
118
LONGEST legacy_call_dummy_words[] = CALL_DUMMY;
119
#else
120
LONGEST legacy_call_dummy_words[1];
121
#endif
122
int legacy_sizeof_call_dummy_words = sizeof (legacy_call_dummy_words);
123
 
124
void
125
generic_remote_translate_xfer_address (CORE_ADDR gdb_addr, int gdb_len,
126
                                       CORE_ADDR * rem_addr, int *rem_len)
127
{
128
  *rem_addr = gdb_addr;
129
  *rem_len = gdb_len;
130
}
131
 
132
int
133
generic_prologue_frameless_p (CORE_ADDR ip)
134
{
135
#ifdef SKIP_PROLOGUE_FRAMELESS_P
136
  return ip == SKIP_PROLOGUE_FRAMELESS_P (ip);
137
#else
138
  return ip == SKIP_PROLOGUE (ip);
139
#endif
140
}
141
 
142
 
143
/* Helper functions for INNER_THAN */
144
 
145
int
146
core_addr_lessthan (CORE_ADDR lhs, CORE_ADDR rhs)
147
{
148
  return (lhs < rhs);
149
}
150
 
151
int
152
core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs)
153
{
154
  return (lhs > rhs);
155
}
156
 
157
 
158
/* Helper functions for TARGET_{FLOAT,DOUBLE}_FORMAT */
159
 
160
const struct floatformat *
161
default_float_format (struct gdbarch *gdbarch)
162
{
163
#if GDB_MULTI_ARCH
164
  int byte_order = gdbarch_byte_order (gdbarch);
165
#else
166
  int byte_order = TARGET_BYTE_ORDER;
167
#endif
168
  switch (byte_order)
169
    {
170
    case BIG_ENDIAN:
171
      return &floatformat_ieee_single_big;
172
    case LITTLE_ENDIAN:
173
      return &floatformat_ieee_single_little;
174
    default:
175
      internal_error (__FILE__, __LINE__,
176
                      "default_float_format: bad byte order");
177
    }
178
}
179
 
180
 
181
const struct floatformat *
182
default_double_format (struct gdbarch *gdbarch)
183
{
184
#if GDB_MULTI_ARCH
185
  int byte_order = gdbarch_byte_order (gdbarch);
186
#else
187
  int byte_order = TARGET_BYTE_ORDER;
188
#endif
189
  switch (byte_order)
190
    {
191
    case BIG_ENDIAN:
192
      return &floatformat_ieee_double_big;
193
    case LITTLE_ENDIAN:
194
      return &floatformat_ieee_double_little;
195
    default:
196
      internal_error (__FILE__, __LINE__,
197
                      "default_double_format: bad byte order");
198
    }
199
}
200
 
201
/* Misc helper functions for targets. */
202
 
203
int
204
frame_num_args_unknown (struct frame_info *fi)
205
{
206
  return -1;
207
}
208
 
209
 
210
int
211
generic_register_convertible_not (int num)
212
{
213
  return 0;
214
}
215
 
216
 
217
int
218
default_register_sim_regno (int num)
219
{
220
  return num;
221
}
222
 
223
 
224
CORE_ADDR
225
core_addr_identity (CORE_ADDR addr)
226
{
227
  return addr;
228
}
229
 
230
int
231
no_op_reg_to_regnum (int reg)
232
{
233
  return reg;
234
}
235
 
236
/* For use by frame_args_address and frame_locals_address.  */
237
CORE_ADDR
238
default_frame_address (struct frame_info *fi)
239
{
240
  return fi->frame;
241
}
242
 
243
/* Default prepare_to_procced().  */
244
int
245
default_prepare_to_proceed (int select_it)
246
{
247
  return 0;
248
}
249
 
250
/* Generic prepare_to_proceed().  This one should be suitable for most
251
   targets that support threads. */
252
int
253
generic_prepare_to_proceed (int select_it)
254
{
255
  ptid_t wait_ptid;
256
  struct target_waitstatus wait_status;
257
 
258
  /* Get the last target status returned by target_wait().  */
259
  get_last_target_status (&wait_ptid, &wait_status);
260
 
261
  /* Make sure we were stopped either at a breakpoint, or because
262
     of a Ctrl-C.  */
263
  if (wait_status.kind != TARGET_WAITKIND_STOPPED
264
      || (wait_status.value.sig != TARGET_SIGNAL_TRAP &&
265
          wait_status.value.sig != TARGET_SIGNAL_INT))
266
    {
267
      return 0;
268
    }
269
 
270
  if (!ptid_equal (wait_ptid, minus_one_ptid)
271
      && !ptid_equal (inferior_ptid, wait_ptid))
272
    {
273
      /* Switched over from WAIT_PID.  */
274
      CORE_ADDR wait_pc = read_pc_pid (wait_ptid);
275
 
276
      if (wait_pc != read_pc ())
277
        {
278
          if (select_it)
279
            {
280
              /* Switch back to WAIT_PID thread.  */
281
              inferior_ptid = wait_ptid;
282
 
283
              /* FIXME: This stuff came from switch_to_thread() in
284
                 thread.c (which should probably be a public function).  */
285
              flush_cached_frames ();
286
              registers_changed ();
287
              stop_pc = wait_pc;
288
              select_frame (get_current_frame (), 0);
289
            }
290
          /* We return 1 to indicate that there is a breakpoint here,
291
             so we need to step over it before continuing to avoid
292
             hitting it straight away. */
293
          if (breakpoint_here_p (wait_pc))
294
            {
295
              return 1;
296
            }
297
        }
298
    }
299
  return 0;
300
 
301
}
302
 
303
void
304
init_frame_pc_noop (int fromleaf, struct frame_info *prev)
305
{
306
  return;
307
}
308
 
309
void
310
init_frame_pc_default (int fromleaf, struct frame_info *prev)
311
{
312
  if (fromleaf)
313
    prev->pc = SAVED_PC_AFTER_CALL (prev->next);
314
  else if (prev->next != NULL)
315
    prev->pc = FRAME_SAVED_PC (prev->next);
316
  else
317
    prev->pc = read_pc ();
318
}
319
 
320
int
321
cannot_register_not (int regnum)
322
{
323
  return 0;
324
}
325
 
326
/* Functions to manipulate the endianness of the target.  */
327
 
328
#ifdef TARGET_BYTE_ORDER_SELECTABLE
329
/* compat - Catch old targets that expect a selectable byte-order to
330
   default to BIG_ENDIAN */
331
#ifndef TARGET_BYTE_ORDER_DEFAULT
332
#define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN
333
#endif
334
#endif
335
#if !TARGET_BYTE_ORDER_SELECTABLE_P
336
#ifndef TARGET_BYTE_ORDER_DEFAULT
337
/* compat - Catch old non byte-order selectable targets that do not
338
   define TARGET_BYTE_ORDER_DEFAULT and instead expect
339
   TARGET_BYTE_ORDER to be used as the default.  For targets that
340
   defined neither TARGET_BYTE_ORDER nor TARGET_BYTE_ORDER_DEFAULT the
341
   below will get a strange compiler warning. */
342
#define TARGET_BYTE_ORDER_DEFAULT TARGET_BYTE_ORDER
343
#endif
344
#endif
345
#ifndef TARGET_BYTE_ORDER_DEFAULT
346
#define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN /* arbitrary */
347
#endif
348
/* ``target_byte_order'' is only used when non- multi-arch.
349
   Multi-arch targets obtain the current byte order using
350
   TARGET_BYTE_ORDER which is controlled by gdbarch.*. */
351
int target_byte_order = TARGET_BYTE_ORDER_DEFAULT;
352
int target_byte_order_auto = 1;
353
 
354
static const char endian_big[] = "big";
355
static const char endian_little[] = "little";
356
static const char endian_auto[] = "auto";
357
static const char *endian_enum[] =
358
{
359
  endian_big,
360
  endian_little,
361
  endian_auto,
362
  NULL,
363
};
364
static const char *set_endian_string;
365
 
366
/* Called by ``show endian''.  */
367
 
368
static void
369
show_endian (char *args, int from_tty)
370
{
371
  if (TARGET_BYTE_ORDER_AUTO)
372
    printf_unfiltered ("The target endianness is set automatically (currently %s endian)\n",
373
                       (TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little"));
374
  else
375
    printf_unfiltered ("The target is assumed to be %s endian\n",
376
                       (TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little"));
377
}
378
 
379
static void
380
set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c)
381
{
382
  if (!TARGET_BYTE_ORDER_SELECTABLE_P)
383
    {
384
      printf_unfiltered ("Byte order is not selectable.");
385
    }
386
  else if (set_endian_string == endian_auto)
387
    {
388
      target_byte_order_auto = 1;
389
    }
390
  else if (set_endian_string == endian_little)
391
    {
392
      target_byte_order_auto = 0;
393
      if (GDB_MULTI_ARCH)
394
        {
395
          struct gdbarch_info info;
396
          memset (&info, 0, sizeof info);
397
          info.byte_order = LITTLE_ENDIAN;
398
          if (! gdbarch_update_p (info))
399
            {
400
              printf_unfiltered ("Little endian target not supported by GDB\n");
401
            }
402
        }
403
      else
404
        {
405
          target_byte_order = LITTLE_ENDIAN;
406
        }
407
    }
408
  else if (set_endian_string == endian_big)
409
    {
410
      target_byte_order_auto = 0;
411
      if (GDB_MULTI_ARCH)
412
        {
413
          struct gdbarch_info info;
414
          memset (&info, 0, sizeof info);
415
          info.byte_order = BIG_ENDIAN;
416
          if (! gdbarch_update_p (info))
417
            {
418
              printf_unfiltered ("Big endian target not supported by GDB\n");
419
            }
420
        }
421
      else
422
        {
423
          target_byte_order = BIG_ENDIAN;
424
        }
425
    }
426
  else
427
    internal_error (__FILE__, __LINE__,
428
                    "set_endian: bad value");
429
  show_endian (NULL, from_tty);
430
}
431
 
432
/* Set the endianness from a BFD.  */
433
 
434
static void
435
set_endian_from_file (bfd *abfd)
436
{
437
  if (GDB_MULTI_ARCH)
438
    internal_error (__FILE__, __LINE__,
439
                    "set_endian_from_file: not for multi-arch");
440
  if (TARGET_BYTE_ORDER_SELECTABLE_P)
441
    {
442
      int want;
443
 
444
      if (bfd_big_endian (abfd))
445
        want = BIG_ENDIAN;
446
      else
447
        want = LITTLE_ENDIAN;
448
      if (TARGET_BYTE_ORDER_AUTO)
449
        target_byte_order = want;
450
      else if (TARGET_BYTE_ORDER != want)
451
        warning ("%s endian file does not match %s endian target.",
452
                 want == BIG_ENDIAN ? "big" : "little",
453
                 TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
454
    }
455
  else
456
    {
457
      if (bfd_big_endian (abfd)
458
          ? TARGET_BYTE_ORDER != BIG_ENDIAN
459
          : TARGET_BYTE_ORDER == BIG_ENDIAN)
460
        warning ("%s endian file does not match %s endian target.",
461
                 bfd_big_endian (abfd) ? "big" : "little",
462
                 TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
463
    }
464
}
465
 
466
 
467
/* Functions to manipulate the architecture of the target */
468
 
469
enum set_arch { set_arch_auto, set_arch_manual };
470
 
471
int target_architecture_auto = 1;
472
 
473
const char *set_architecture_string;
474
 
475
/* Old way of changing the current architecture. */
476
 
477
extern const struct bfd_arch_info bfd_default_arch_struct;
478
const struct bfd_arch_info *target_architecture = &bfd_default_arch_struct;
479
int (*target_architecture_hook) (const struct bfd_arch_info *ap);
480
 
481
static int
482
arch_ok (const struct bfd_arch_info *arch)
483
{
484
  if (GDB_MULTI_ARCH)
485
    internal_error (__FILE__, __LINE__,
486
                    "arch_ok: not multi-arched");
487
  /* Should be performing the more basic check that the binary is
488
     compatible with GDB. */
489
  /* Check with the target that the architecture is valid. */
490
  return (target_architecture_hook == NULL
491
          || target_architecture_hook (arch));
492
}
493
 
494
static void
495
set_arch (const struct bfd_arch_info *arch,
496
          enum set_arch type)
497
{
498
  if (GDB_MULTI_ARCH)
499
    internal_error (__FILE__, __LINE__,
500
                    "set_arch: not multi-arched");
501
  switch (type)
502
    {
503
    case set_arch_auto:
504
      if (!arch_ok (arch))
505
        warning ("Target may not support %s architecture",
506
                 arch->printable_name);
507
      target_architecture = arch;
508
      break;
509
    case set_arch_manual:
510
      if (!arch_ok (arch))
511
        {
512
          printf_unfiltered ("Target does not support `%s' architecture.\n",
513
                             arch->printable_name);
514
        }
515
      else
516
        {
517
          target_architecture_auto = 0;
518
          target_architecture = arch;
519
        }
520
      break;
521
    }
522
  if (gdbarch_debug)
523
    gdbarch_dump (current_gdbarch, gdb_stdlog);
524
}
525
 
526
/* Set the architecture from arch/machine (deprecated) */
527
 
528
void
529
set_architecture_from_arch_mach (enum bfd_architecture arch,
530
                                 unsigned long mach)
531
{
532
  const struct bfd_arch_info *wanted = bfd_lookup_arch (arch, mach);
533
  if (GDB_MULTI_ARCH)
534
    internal_error (__FILE__, __LINE__,
535
                    "set_architecture_from_arch_mach: not multi-arched");
536
  if (wanted != NULL)
537
    set_arch (wanted, set_arch_manual);
538
  else
539
    internal_error (__FILE__, __LINE__,
540
                    "gdbarch: hardwired architecture/machine not recognized");
541
}
542
 
543
/* Set the architecture from a BFD (deprecated) */
544
 
545
static void
546
set_architecture_from_file (bfd *abfd)
547
{
548
  const struct bfd_arch_info *wanted = bfd_get_arch_info (abfd);
549
  if (GDB_MULTI_ARCH)
550
    internal_error (__FILE__, __LINE__,
551
                    "set_architecture_from_file: not multi-arched");
552
  if (target_architecture_auto)
553
    {
554
      set_arch (wanted, set_arch_auto);
555
    }
556
  else if (wanted != target_architecture)
557
    {
558
      warning ("%s architecture file may be incompatible with %s target.",
559
               wanted->printable_name,
560
               target_architecture->printable_name);
561
    }
562
}
563
 
564
 
565
/* Called if the user enters ``show architecture'' without an
566
   argument. */
567
 
568
static void
569
show_architecture (char *args, int from_tty)
570
{
571
  const char *arch;
572
  arch = TARGET_ARCHITECTURE->printable_name;
573
  if (target_architecture_auto)
574
    printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
575
  else
576
    printf_filtered ("The target architecture is assumed to be %s\n", arch);
577
}
578
 
579
 
580
/* Called if the user enters ``set architecture'' with or without an
581
   argument. */
582
 
583
static void
584
set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c)
585
{
586
  if (strcmp (set_architecture_string, "auto") == 0)
587
    {
588
      target_architecture_auto = 1;
589
    }
590
  else if (GDB_MULTI_ARCH)
591
    {
592
      struct gdbarch_info info;
593
      memset (&info, 0, sizeof info);
594
      info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
595
      if (info.bfd_arch_info == NULL)
596
        internal_error (__FILE__, __LINE__,
597
                        "set_architecture: bfd_scan_arch failed");
598
      if (gdbarch_update_p (info))
599
        target_architecture_auto = 0;
600
      else
601
        printf_unfiltered ("Architecture `%s' not recognized.\n",
602
                           set_architecture_string);
603
    }
604
  else
605
    {
606
      const struct bfd_arch_info *arch
607
        = bfd_scan_arch (set_architecture_string);
608
      if (arch == NULL)
609
        internal_error (__FILE__, __LINE__,
610
                        "set_architecture: bfd_scan_arch failed");
611
      set_arch (arch, set_arch_manual);
612
    }
613
  show_architecture (NULL, from_tty);
614
}
615
 
616
/* Set the dynamic target-system-dependent parameters (architecture,
617
   byte-order) using information found in the BFD */
618
 
619
void
620
set_gdbarch_from_file (bfd *abfd)
621
{
622
  if (GDB_MULTI_ARCH)
623
    {
624
      struct gdbarch_info info;
625
      memset (&info, 0, sizeof info);
626
      info.abfd = abfd;
627
      if (! gdbarch_update_p (info))
628
        error ("Architecture of file not recognized.\n");
629
    }
630
  else
631
    {
632
      set_architecture_from_file (abfd);
633
      set_endian_from_file (abfd);
634
    }
635
}
636
 
637
/* Initialize the current architecture.  Update the ``set
638
   architecture'' command so that it specifies a list of valid
639
   architectures.  */
640
 
641
#ifdef DEFAULT_BFD_ARCH
642
extern const bfd_arch_info_type DEFAULT_BFD_ARCH;
643
static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH;
644
#else
645
static const bfd_arch_info_type *default_bfd_arch;
646
#endif
647
 
648
#ifdef DEFAULT_BFD_VEC
649
extern const bfd_target DEFAULT_BFD_VEC;
650
static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC;
651
#else
652
static const bfd_target *default_bfd_vec;
653
#endif
654
 
655
void
656
initialize_current_architecture (void)
657
{
658
  const char **arches = gdbarch_printable_names ();
659
 
660
  /* determine a default architecture and byte order. */
661
  struct gdbarch_info info;
662
  memset (&info, 0, sizeof (info));
663
 
664
  /* Find a default architecture. */
665
  if (info.bfd_arch_info == NULL
666
      && default_bfd_arch != NULL)
667
    info.bfd_arch_info = default_bfd_arch;
668
  if (info.bfd_arch_info == NULL)
669
    {
670
      /* Choose the architecture by taking the first one
671
         alphabetically. */
672
      const char *chosen = arches[0];
673
      const char **arch;
674
      for (arch = arches; *arch != NULL; arch++)
675
        {
676
          if (strcmp (*arch, chosen) < 0)
677
            chosen = *arch;
678
        }
679
      if (chosen == NULL)
680
        internal_error (__FILE__, __LINE__,
681
                        "initialize_current_architecture: No arch");
682
      info.bfd_arch_info = bfd_scan_arch (chosen);
683
      if (info.bfd_arch_info == NULL)
684
        internal_error (__FILE__, __LINE__,
685
                        "initialize_current_architecture: Arch not found");
686
    }
687
 
688
  /* take several guesses at a byte order. */
689
  /* NB: can't use TARGET_BYTE_ORDER_DEFAULT as its definition is
690
     forced above. */
691
  if (info.byte_order == 0
692
      && default_bfd_vec != NULL)
693
    {
694
      /* Extract BFD's default vector's byte order. */
695
      switch (default_bfd_vec->byteorder)
696
        {
697
        case BFD_ENDIAN_BIG:
698
          info.byte_order = BIG_ENDIAN;
699
          break;
700
        case BFD_ENDIAN_LITTLE:
701
          info.byte_order = LITTLE_ENDIAN;
702
          break;
703
        default:
704
          break;
705
        }
706
    }
707
  if (info.byte_order == 0)
708
    {
709
      /* look for ``*el-*'' in the target name. */
710
      const char *chp;
711
      chp = strchr (target_name, '-');
712
      if (chp != NULL
713
          && chp - 2 >= target_name
714
          && strncmp (chp - 2, "el", 2) == 0)
715
        info.byte_order = LITTLE_ENDIAN;
716
    }
717
  if (info.byte_order == 0)
718
    {
719
      /* Wire it to big-endian!!! */
720
      info.byte_order = BIG_ENDIAN;
721
    }
722
 
723
  if (GDB_MULTI_ARCH)
724
    {
725
      if (! gdbarch_update_p (info))
726
        {
727
          internal_error (__FILE__, __LINE__,
728
                          "initialize_current_architecture: Selection of initial architecture failed");
729
        }
730
    }
731
  else
732
    initialize_non_multiarch ();
733
 
734
  /* Create the ``set architecture'' command appending ``auto'' to the
735
     list of architectures. */
736
  {
737
    struct cmd_list_element *c;
738
    /* Append ``auto''. */
739
    int nr;
740
    for (nr = 0; arches[nr] != NULL; nr++);
741
    arches = xrealloc (arches, sizeof (char*) * (nr + 2));
742
    arches[nr + 0] = "auto";
743
    arches[nr + 1] = NULL;
744
    /* FIXME: add_set_enum_cmd() uses an array of ``char *'' instead
745
       of ``const char *''.  We just happen to know that the casts are
746
       safe. */
747
    c = add_set_enum_cmd ("architecture", class_support,
748
                          arches, &set_architecture_string,
749
                          "Set architecture of target.",
750
                          &setlist);
751
    c->function.sfunc = set_architecture;
752
    add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
753
    /* Don't use set_from_show - need to print both auto/manual and
754
       current setting. */
755
    add_cmd ("architecture", class_support, show_architecture,
756
             "Show the current target architecture", &showlist);
757
  }
758
}
759
 
760
 
761
/* */
762
 
763
extern initialize_file_ftype _initialize_gdbarch_utils;
764
 
765
void
766
_initialize_gdbarch_utils (void)
767
{
768
  struct cmd_list_element *c;
769
  c = add_set_enum_cmd ("endian", class_support,
770
                        endian_enum, &set_endian_string,
771
                        "Set endianness of target.",
772
                        &setlist);
773
  c->function.sfunc = set_endian;
774
  /* Don't use set_from_show - need to print both auto/manual and
775
     current setting. */
776
  add_cmd ("endian", class_support, show_endian,
777
           "Show the current byte-order", &showlist);
778
}

powered by: WebSVN 2.1.0

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