gdb/defs.h

   1 /* Basic, host-specific, and target-specific definitions for GDB.
   2    Copyright (C) 1986, 1989, 1991, 1992, 1993, 1994, 1995, 1996
   3    Free Software Foundation, Inc.
   4
   5 This file is part of GDB.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #ifndef DEFS_H
  22 #define DEFS_H
  23
  24 #include "config.h"             /* Generated by configure */
  25 #include <stdio.h>
  26 #include <errno.h>              /* System call error return status */
  27
  28 /* Just in case they're not defined in stdio.h. */
  29
  30 #ifndef SEEK_SET
  31 #define SEEK_SET 0
  32 #endif
  33 #ifndef SEEK_CUR
  34 #define SEEK_CUR 1
  35 #endif
  36
  37 /* First include ansidecl.h so we can use the various macro definitions
  38    here and in all subsequent file inclusions.  */
  39
  40 #include "ansidecl.h"
  41
  42 #ifdef ANSI_PROTOTYPES
  43 #include <stdarg.h>
  44 #else
  45 #include <varargs.h>
  46 #endif
  47
  48 #define PRIVATE_XMALLOC 1       /* Suppress libiberty decls for xmalloc/xrealloc */
  49 #include "libiberty.h"
  50
  51 /* libiberty.h can't declare this one, but evidently we can.  */
  52 extern char *strsignal PARAMS ((int));
  53
  54 #include "progress.h"
  55
  56 #ifndef NO_MMALLOC
  57 #include "mmalloc.h"
  58 #endif
  59
  60 /* For BFD64 and bfd_vma.  */
  61 #include "bfd.h"
  62
  63 /* An address in the program being debugged.  Host byte order.  Rather
  64    than duplicate all the logic in BFD which figures out what type
  65    this is (long, long long, etc.) and whether it needs to be 64
  66    bits (the host/target interactions are subtle), we just use
  67    bfd_vma.  */
  68
  69 typedef bfd_vma CORE_ADDR;
  70
  71 #define min(a, b) ((a) < (b) ? (a) : (b))
  72 #define max(a, b) ((a) > (b) ? (a) : (b))
  73
  74 /* Gdb does *lots* of string compares.  Use macros to speed them up by
  75    avoiding function calls if the first characters are not the same. */
  76
  77 #define STRCMP(a,b) (*(a) == *(b) ? strcmp ((a), (b)) : (int)*(a) - (int)*(b))
  78 #define STREQ(a,b) (*(a) == *(b) ? !strcmp ((a), (b)) : 0)
  79 #define STREQN(a,b,c) (*(a) == *(b) ? !strncmp ((a), (b), (c)) : 0)
  80
  81 /* The character GNU C++ uses to build identifiers that must be unique from
  82    the program's identifiers (such as $this and $$vptr).  */
  83 #define CPLUS_MARKER '$'        /* May be overridden to '.' for SysV */
  84
  85 /* Check if a character is one of the commonly used C++ marker characters.  */
  86 extern int is_cplus_marker PARAMS ((int));
  87
  88 extern int quit_flag;
  89 extern int immediate_quit;
  90 extern int sevenbit_strings;
  91
  92 extern void quit PARAMS ((void));
  93
  94 #define QUIT { \
  95   if (quit_flag) quit (); \
  96   if (interactive_hook) interactive_hook (); \
  97   PROGRESS (1); \
  98 }
  99
 100 /* Command classes are top-level categories into which commands are broken
 101    down for "help" purposes.
 102    Notes on classes: class_alias is for alias commands which are not
 103    abbreviations of the original command.  class-pseudo is for commands
 104    which are not really commands nor help topics ("stop").  */
 105
 106 enum command_class
 107 {
 108   /* Special args to help_list */
 109   all_classes = -2, all_commands = -1,
 110   /* Classes of commands */
 111   no_class = -1, class_run = 0, class_vars, class_stack,
 112   class_files, class_support, class_info, class_breakpoint,
 113   class_alias, class_obscure, class_user, class_maintenance,
 114   class_pseudo
 115 };
 116
 117 /* Languages represented in the symbol table and elsewhere.
 118    This should probably be in language.h, but since enum's can't
 119    be forward declared to satisfy opaque references before their
 120    actual definition, needs to be here. */
 121
 122 enum language
 123 {
 124    language_unknown,            /* Language not known */
 125    language_auto,               /* Placeholder for automatic setting */
 126    language_c,                  /* C */
 127    language_cplus,              /* C++ */
 128    language_chill,              /* Chill */
 129    language_fortran,            /* Fortran */
 130    language_m2,                 /* Modula-2 */
 131    language_asm,                /* Assembly language */
 132    language_scm                 /* Scheme / Guile */
 133 };
 134
 135 /* the cleanup list records things that have to be undone
 136    if an error happens (descriptors to be closed, memory to be freed, etc.)
 137    Each link in the chain records a function to call and an
 138    argument to give it.
 139
 140    Use make_cleanup to add an element to the cleanup chain.
 141    Use do_cleanups to do all cleanup actions back to a given
 142    point in the chain.  Use discard_cleanups to remove cleanups
 143    from the chain back to a given point, not doing them.  */
 144
 145 struct cleanup
 146 {
 147   struct cleanup *next;
 148   void (*function) PARAMS ((PTR));
 149   PTR arg;
 150 };
 151
 152
 153 /* The ability to declare that a function never returns is useful, but
 154    not really required to compile GDB successfully, so the NORETURN and
 155    ATTR_NORETURN macros normally expand into nothing.  */
 156
 157 /* If compiling with older versions of GCC, a function may be declared
 158    "volatile" to indicate that it does not return.  */
 159
 160 #ifndef NORETURN
 161 # if defined(__GNUC__) \
 162      && (__GNUC__ == 1 || (__GNUC__ == 2 && __GNUC_MINOR__ < 7))
 163 #  define NORETURN volatile
 164 # else
 165 #  define NORETURN /* nothing */
 166 # endif
 167 #endif
 168
 169 /* GCC 2.5 and later versions define a function attribute "noreturn",
 170    which is the preferred way to declare that a function never returns.
 171    However GCC 2.7 appears to be the first version in which this fully
 172    works everywhere we use it. */
 173
 174 #ifndef ATTR_NORETURN
 175 # if defined(__GNUC__) && __GNUC__ >= 2 && __GNUC_MINOR__ >= 7
 176 #  define ATTR_NORETURN __attribute__ ((noreturn))
 177 # else
 178 #  define ATTR_NORETURN /* nothing */
 179 # endif
 180 #endif
 181
 182 #ifndef ATTR_FORMAT
 183 # if defined(__GNUC__) && __GNUC__ >= 2 && __GNUC_MINOR__ >= 4 && defined (__ANSI_PROTOTYPES)
 184 #  define ATTR_FORMAT(type, x, y) __attribute__ ((format(type, x, y)))
 185 # else
 186 #  define ATTR_FORMAT(type, x, y) /* nothing */
 187 # endif
 188 #endif
 189
 190 /* Needed for various prototypes */
 191
 192 #ifdef __STDC__
 193 struct symtab;
 194 struct breakpoint;
 195 #endif
 196
 197 /* From blockframe.c */
 198
 199 extern int inside_entry_func PARAMS ((CORE_ADDR));
 200
 201 extern int inside_entry_file PARAMS ((CORE_ADDR addr));
 202
 203 extern int inside_main_func PARAMS ((CORE_ADDR pc));
 204
 205 /* From ch-lang.c, for the moment. (FIXME) */
 206
 207 extern char *chill_demangle PARAMS ((const char *));
 208
 209 /* From utils.c */
 210
 211 extern PTR xmalloc PARAMS ((long));
 212
 213 extern PTR xrealloc PARAMS ((PTR, long));
 214
 215 extern void notice_quit PARAMS ((void));
 216
 217 extern int strcmp_iw PARAMS ((const char *, const char *));
 218
 219 extern char *safe_strerror PARAMS ((int));
 220
 221 extern char *safe_strsignal PARAMS ((int));
 222
 223 extern void init_malloc PARAMS ((void *));
 224
 225 extern void request_quit PARAMS ((int));
 226
 227 extern void do_cleanups PARAMS ((struct cleanup *));
 228
 229 extern void discard_cleanups PARAMS ((struct cleanup *));
 230
 231 /* The bare make_cleanup function is one of those rare beasts that
 232    takes almost any type of function as the first arg and anything that
 233    will fit in a "void *" as the second arg.
 234
 235    Should be, once all calls and called-functions are cleaned up:
 236 extern struct cleanup *
 237 make_cleanup PARAMS ((void (*function) (void *), void *));
 238
 239    Until then, lint and/or various type-checking compiler options will
 240    complain about make_cleanup calls.  It'd be wrong to just cast things,
 241    since the type actually passed when the function is called would be
 242    wrong.  */
 243
 244 extern struct cleanup *make_cleanup ();
 245
 246 extern struct cleanup *save_cleanups PARAMS ((void));
 247
 248 extern void restore_cleanups PARAMS ((struct cleanup *));
 249
 250 extern void free_current_contents PARAMS ((char **));
 251
 252 extern void null_cleanup PARAMS ((PTR));
 253
 254 extern int myread PARAMS ((int, char *, int));
 255
 256 extern int query PARAMS((char *, ...))
 257      ATTR_FORMAT(printf, 1, 2);
 258
 259 /* From demangle.c */
 260
 261 extern void set_demangling_style PARAMS ((char *));
 262
 263 \f
 264 /* Annotation stuff.  */
 265
 266 extern int annotation_level; /* in stack.c */
 267 \f
 268 extern void begin_line PARAMS ((void));
 269
 270 extern void wrap_here PARAMS ((char *));
 271
 272 extern void reinitialize_more_filter PARAMS ((void));
 273
 274 typedef FILE GDB_FILE;
 275 #define gdb_stdout stdout
 276 #define gdb_stderr stderr
 277
 278 extern void gdb_flush PARAMS ((GDB_FILE *));
 279
 280 extern GDB_FILE *gdb_fopen PARAMS ((char * name, char * mode));
 281
 282 extern void fputs_filtered PARAMS ((const char *, GDB_FILE *));
 283
 284 extern void fputs_unfiltered PARAMS ((const char *, GDB_FILE *));
 285
 286 extern int fputc_unfiltered PARAMS ((int c, GDB_FILE *));
 287
 288 extern int putchar_unfiltered PARAMS ((int c));
 289
 290 extern void puts_filtered PARAMS ((const char *));
 291
 292 extern void puts_unfiltered PARAMS ((const char *));
 293
 294 extern void vprintf_filtered PARAMS ((const char *, va_list))
 295      ATTR_FORMAT(printf, 1, 0);
 296
 297 extern void vfprintf_filtered PARAMS ((FILE *, const char *, va_list))
 298      ATTR_FORMAT(printf, 2, 0);
 299
 300 extern void fprintf_filtered PARAMS ((FILE *, const char *, ...))
 301      ATTR_FORMAT(printf, 2, 3);
 302
 303 extern void fprintfi_filtered PARAMS ((int, FILE *, const char *, ...))
 304      ATTR_FORMAT(printf, 3, 4);
 305
 306 extern void printf_filtered PARAMS ((const char *, ...))
 307      ATTR_FORMAT(printf, 1, 2);
 308
 309 extern void printfi_filtered PARAMS ((int, const char *, ...))
 310      ATTR_FORMAT(printf, 2, 3);
 311
 312 extern void vprintf_unfiltered PARAMS ((const char *, va_list))
 313      ATTR_FORMAT(printf, 1, 0);
 314
 315 extern void vfprintf_unfiltered PARAMS ((FILE *, const char *, va_list))
 316      ATTR_FORMAT(printf, 2, 0);
 317
 318 extern void fprintf_unfiltered PARAMS ((FILE *, const char *, ...))
 319      ATTR_FORMAT(printf, 2, 3);
 320
 321 extern void printf_unfiltered PARAMS ((const char *, ...))
 322      ATTR_FORMAT(printf, 1, 2);
 323
 324 extern void print_spaces PARAMS ((int, GDB_FILE *));
 325
 326 extern void print_spaces_filtered PARAMS ((int, GDB_FILE *));
 327
 328 extern char *n_spaces PARAMS ((int));
 329
 330 extern void gdb_printchar PARAMS ((int, GDB_FILE *, int));
 331
 332 extern void gdb_print_address PARAMS ((void *, GDB_FILE *));
 333
 334 extern void fprintf_symbol_filtered PARAMS ((GDB_FILE *, char *,
 335                                              enum language, int));
 336
 337 extern void perror_with_name PARAMS ((char *));
 338
 339 extern void print_sys_errmsg PARAMS ((char *, int));
 340
 341 /* From regex.c or libc.  BSD 4.4 declares this with the argument type as
 342    "const char *" in unistd.h, so we can't declare the argument
 343    as "char *".  */
 344
 345 extern char *re_comp PARAMS ((const char *));
 346
 347 /* From symfile.c */
 348
 349 extern void symbol_file_command PARAMS ((char *, int));
 350
 351 /* From top.c */
 352
 353 extern char *skip_quoted PARAMS ((char *));
 354
 355 extern char *gdb_readline PARAMS ((char *));
 356
 357 extern char *command_line_input PARAMS ((char *, int, char *));
 358
 359 extern void print_prompt PARAMS ((void));
 360
 361 extern int input_from_terminal_p PARAMS ((void));
 362
 363 extern int info_verbose;
 364
 365 /* From printcmd.c */
 366
 367 extern void set_next_address PARAMS ((CORE_ADDR));
 368
 369 extern void print_address_symbolic PARAMS ((CORE_ADDR, GDB_FILE *, int,
 370                                             char *));
 371
 372 extern void print_address_numeric PARAMS ((CORE_ADDR, int, GDB_FILE *));
 373
 374 extern void print_address PARAMS ((CORE_ADDR, GDB_FILE *));
 375
 376 /* From source.c */
 377
 378 extern int openp PARAMS ((char *, int, char *, int, int, char **));
 379
 380 extern void mod_path PARAMS ((char *, char **));
 381
 382 extern void directory_command PARAMS ((char *, int));
 383
 384 extern void init_source_path PARAMS ((void));
 385
 386 extern char *symtab_to_filename PARAMS ((struct symtab *));
 387
 388 /* From findvar.c */
 389
 390 extern int read_relative_register_raw_bytes PARAMS ((int, char *));
 391
 392 /* From readline (but not in any readline .h files).  */
 393
 394 extern char *tilde_expand PARAMS ((char *));
 395
 396 /* Control types for commands */
 397
 398 enum misc_command_type
 399 {
 400   ok_command,
 401   end_command,
 402   else_command,
 403   nop_command
 404 };
 405
 406 enum command_control_type
 407 {
 408   simple_control,
 409   break_control,
 410   continue_control,
 411   while_control,
 412   if_control,
 413   invalid_control
 414 };
 415
 416 /* Structure for saved commands lines
 417    (for breakpoints, defined commands, etc).  */
 418
 419 struct command_line
 420 {
 421   struct command_line *next;
 422   char *line;
 423   enum command_control_type control_type;
 424   int body_count;
 425   struct command_line **body_list;
 426 };
 427
 428 extern struct command_line *read_command_lines PARAMS ((char *, int));
 429
 430 extern void free_command_lines PARAMS ((struct command_line **));
 431
 432 /* String containing the current directory (what getwd would return).  */
 433
 434 extern char *current_directory;
 435
 436 /* Default radixes for input and output.  Only some values supported.  */
 437 extern unsigned input_radix;
 438 extern unsigned output_radix;
 439
 440 /* Possibilities for prettyprint parameters to routines which print
 441    things.  Like enum language, this should be in value.h, but needs
 442    to be here for the same reason.  FIXME:  If we can eliminate this
 443    as an arg to LA_VAL_PRINT, then we can probably move it back to
 444    value.h. */
 445
 446 enum val_prettyprint
 447 {
 448   Val_no_prettyprint = 0,
 449   Val_prettyprint,
 450   /* Use the default setting which the user has specified.  */
 451   Val_pretty_default
 452 };
 453
 454 \f
 455 /* Host machine definition.  This will be a symlink to one of the
 456    xm-*.h files, built by the `configure' script.  */
 457
 458 #include "xm.h"
 459
 460 /* Native machine support.  This will be a symlink to one of the
 461    nm-*.h files, built by the `configure' script.  */
 462
 463 #include "nm.h"
 464
 465 /* Target machine definition.  This will be a symlink to one of the
 466    tm-*.h files, built by the `configure' script.  */
 467
 468 #include "tm.h"
 469
 470 /* If the xm.h file did not define the mode string used to open the
 471    files, assume that binary files are opened the same way as text
 472    files */
 473 #ifndef FOPEN_RB
 474 #include "fopen-same.h"
 475 #endif
 476
 477 /*
 478  * Allow things in gdb to be declared "const".  If compiling ANSI, it
 479  * just works.  If compiling with gcc but non-ansi, redefine to __const__.
 480  * If non-ansi, non-gcc, then eliminate "const" entirely, making those
 481  * objects be read-write rather than read-only.
 482  */
 483
 484 #ifndef const
 485 #ifndef __STDC__
 486 # ifdef __GNUC__
 487 #  define const __const__
 488 # else
 489 #  define const /*nothing*/
 490 # endif /* GNUC */
 491 #endif /* STDC */
 492 #endif /* const */
 493
 494 #ifndef volatile
 495 #ifndef __STDC__
 496 # ifdef __GNUC__
 497 #  define volatile __volatile__
 498 # else
 499 #  define volatile /*nothing*/
 500 # endif /* GNUC */
 501 #endif /* STDC */
 502 #endif /* volatile */
 503
 504 /* Defaults for system-wide constants (if not defined by xm.h, we fake it).
 505    FIXME: Assumes 2's complement arithmetic */
 506
 507 #if !defined (UINT_MAX)
 508 #define UINT_MAX ((unsigned int)(~0))           /* 0xFFFFFFFF for 32-bits */
 509 #endif
 510
 511 #if !defined (INT_MAX)
 512 #define INT_MAX ((int)(UINT_MAX >> 1))          /* 0x7FFFFFFF for 32-bits */
 513 #endif
 514
 515 #if !defined (INT_MIN)
 516 #define INT_MIN ((int)((int) ~0 ^ INT_MAX))     /* 0x80000000 for 32-bits */
 517 #endif
 518
 519 #if !defined (ULONG_MAX)
 520 #define ULONG_MAX ((unsigned long)(~0L))        /* 0xFFFFFFFF for 32-bits */
 521 #endif
 522
 523 #if !defined (LONG_MAX)
 524 #define LONG_MAX ((long)(ULONG_MAX >> 1))       /* 0x7FFFFFFF for 32-bits */
 525 #endif
 526
 527 #ifdef BFD64
 528
 529 /* This is to make sure that LONGEST is at least as big as CORE_ADDR.  */
 530
 531 #define LONGEST BFD_HOST_64_BIT
 532
 533 #else /* No BFD64 */
 534
 535 /* LONGEST should not be a typedef, because "unsigned LONGEST" needs to work.
 536    CC_HAS_LONG_LONG is defined if the host compiler supports "long long" */
 537
 538 #ifndef LONGEST
 539 #  ifdef CC_HAS_LONG_LONG
 540 #    define LONGEST long long
 541 #  else
 542 #    define LONGEST long
 543 #  endif
 544 #endif
 545
 546 #endif /* No BFD64 */
 547
 548 /* Convert a LONGEST to an int.  This is used in contexts (e.g. number of
 549    arguments to a function, number in a value history, register number, etc.)
 550    where the value must not be larger than can fit in an int.  */
 551
 552 extern int longest_to_int PARAMS ((LONGEST));
 553
 554 /* Assorted functions we can declare, now that const and volatile are
 555    defined.  */
 556
 557 extern char *savestring PARAMS ((const char *, int));
 558
 559 extern char *msavestring PARAMS ((void *, const char *, int));
 560
 561 extern char *strsave PARAMS ((const char *));
 562
 563 extern char *mstrsave PARAMS ((void *, const char *));
 564
 565 extern PTR xmmalloc PARAMS ((PTR, long));
 566
 567 extern PTR xmrealloc PARAMS ((PTR, PTR, long));
 568
 569 extern int parse_escape PARAMS ((char **));
 570
 571 extern char *reg_names[];
 572
 573 /* Message to be printed before the error message, when an error occurs.  */
 574
 575 extern char *error_pre_print;
 576
 577 /* Message to be printed before the error message, when an error occurs.  */
 578
 579 extern char *quit_pre_print;
 580
 581 /* Message to be printed before the warning message, when a warning occurs.  */
 582
 583 extern char *warning_pre_print;
 584
 585 extern NORETURN void error PARAMS((char *, ...)) ATTR_NORETURN;
 586
 587 extern void error_begin PARAMS ((void));
 588
 589 extern NORETURN void fatal PARAMS((char *, ...)) ATTR_NORETURN;
 590
 591 extern NORETURN void nomem PARAMS ((long)) ATTR_NORETURN;
 592
 593 /* Reasons for calling return_to_top_level.  */
 594 enum return_reason {
 595   /* User interrupt.  */
 596   RETURN_QUIT,
 597
 598   /* Any other error.  */
 599   RETURN_ERROR
 600 };
 601
 602 #define RETURN_MASK_QUIT (1 << (int)RETURN_QUIT)
 603 #define RETURN_MASK_ERROR (1 << (int)RETURN_ERROR)
 604 #define RETURN_MASK_ALL (RETURN_MASK_QUIT | RETURN_MASK_ERROR)
 605 typedef int return_mask;
 606
 607 extern NORETURN void
 608 return_to_top_level PARAMS ((enum return_reason)) ATTR_NORETURN;
 609
 610 extern int
 611 catch_errors PARAMS ((int (*) (char *), void *, char *, return_mask));
 612
 613 extern void warning_begin PARAMS ((void));
 614
 615 extern void warning PARAMS ((char *, ...))
 616      ATTR_FORMAT(printf, 1, 2);
 617
 618 /* Global functions from other, non-gdb GNU thingies.
 619    Libiberty thingies are no longer declared here.  We include libiberty.h
 620    above, instead.  */
 621
 622 #ifndef GETENV_PROVIDED
 623 extern char *getenv PARAMS ((const char *));
 624 #endif
 625
 626 /* From other system libraries */
 627
 628 #ifdef __STDC__
 629 #include <stddef.h>
 630 #include <stdlib.h>
 631 #endif
 632
 633
 634 /* We take the address of fclose later, but some stdio's forget
 635    to declare this.  We can't always declare it since there's
 636    no way to declare the parameters without upsetting some compiler
 637    somewhere. */
 638
 639 #ifndef FCLOSE_PROVIDED
 640 extern int fclose PARAMS ((FILE *));
 641 #endif
 642
 643 #ifndef atof
 644 extern double atof PARAMS ((const char *));     /* X3.159-1989  4.10.1.1 */
 645 #endif
 646
 647 #ifndef MALLOC_INCOMPATIBLE
 648
 649 extern PTR malloc ();
 650
 651 extern PTR realloc ();
 652
 653 extern void free ();
 654
 655 #endif /* MALLOC_INCOMPATIBLE */
 656
 657 /* Various possibilities for alloca.  */
 658 #ifndef alloca
 659 # ifdef __GNUC__
 660 #  define alloca __builtin_alloca
 661 # else /* Not GNU C */
 662 #  ifdef sparc
 663 #   include <alloca.h>          /* NOTE:  Doesn't declare alloca() */
 664 #  endif
 665
 666 /* We need to be careful not to declare this in a way which conflicts with
 667    bison.  Bison never declares it as char *, but under various circumstances
 668    (like __hpux) we need to use void *.  */
 669 #  if defined (__STDC__) || defined (__hpux)
 670    extern void *alloca ();
 671 #  else /* Don't use void *.  */
 672    extern char *alloca ();
 673 #  endif /* Don't use void *.  */
 674 # endif /* Not GNU C */
 675 #endif /* alloca not defined */
 676
 677 /* HOST_BYTE_ORDER must be defined to one of these.  */
 678
 679 #ifdef HAVE_ENDIAN_H
 680 #include <endian.h>
 681 #endif
 682
 683 #if !defined (BIG_ENDIAN)
 684 #define BIG_ENDIAN 4321
 685 #endif
 686
 687 #if !defined (LITTLE_ENDIAN)
 688 #define LITTLE_ENDIAN 1234
 689 #endif
 690
 691 /* Target-system-dependent parameters for GDB. */
 692
 693 #ifdef TARGET_BYTE_ORDER_SELECTABLE
 694 /* The target endianness is selectable at runtime.  Define
 695    TARGET_BYTE_ORDER to be a variable.  The user can use the `set
 696    endian' command to change it.  */
 697 #undef TARGET_BYTE_ORDER
 698 #define TARGET_BYTE_ORDER target_byte_order
 699 extern int target_byte_order;
 700 #endif
 701
 702 extern void set_endian_from_file PARAMS ((bfd *));
 703
 704 /* Number of bits in a char or unsigned char for the target machine.
 705    Just like CHAR_BIT in <limits.h> but describes the target machine.  */
 706 #if !defined (TARGET_CHAR_BIT)
 707 #define TARGET_CHAR_BIT 8
 708 #endif
 709
 710 /* Number of bits in a short or unsigned short for the target machine. */
 711 #if !defined (TARGET_SHORT_BIT)
 712 #define TARGET_SHORT_BIT (2 * TARGET_CHAR_BIT)
 713 #endif
 714
 715 /* Number of bits in an int or unsigned int for the target machine. */
 716 #if !defined (TARGET_INT_BIT)
 717 #define TARGET_INT_BIT (4 * TARGET_CHAR_BIT)
 718 #endif
 719
 720 /* Number of bits in a long or unsigned long for the target machine. */
 721 #if !defined (TARGET_LONG_BIT)
 722 #define TARGET_LONG_BIT (4 * TARGET_CHAR_BIT)
 723 #endif
 724
 725 /* Number of bits in a long long or unsigned long long for the target machine. */
 726 #if !defined (TARGET_LONG_LONG_BIT)
 727 #define TARGET_LONG_LONG_BIT (2 * TARGET_LONG_BIT)
 728 #endif
 729
 730 /* Number of bits in a float for the target machine. */
 731 #if !defined (TARGET_FLOAT_BIT)
 732 #define TARGET_FLOAT_BIT (4 * TARGET_CHAR_BIT)
 733 #endif
 734
 735 /* Number of bits in a double for the target machine. */
 736 #if !defined (TARGET_DOUBLE_BIT)
 737 #define TARGET_DOUBLE_BIT (8 * TARGET_CHAR_BIT)
 738 #endif
 739
 740 /* Number of bits in a long double for the target machine.  */
 741 #if !defined (TARGET_LONG_DOUBLE_BIT)
 742 #define TARGET_LONG_DOUBLE_BIT (2 * TARGET_DOUBLE_BIT)
 743 #endif
 744
 745 /* Number of bits in a pointer for the target machine */
 746 #if !defined (TARGET_PTR_BIT)
 747 #define TARGET_PTR_BIT TARGET_INT_BIT
 748 #endif
 749
 750 /* If we picked up a copy of CHAR_BIT from a configuration file
 751    (which may get it by including <limits.h>) then use it to set
 752    the number of bits in a host char.  If not, use the same size
 753    as the target. */
 754
 755 #if defined (CHAR_BIT)
 756 #define HOST_CHAR_BIT CHAR_BIT
 757 #else
 758 #define HOST_CHAR_BIT TARGET_CHAR_BIT
 759 #endif
 760
 761 /* The bit byte-order has to do just with numbering of bits in
 762    debugging symbols and such.  Conceptually, it's quite separate
 763    from byte/word byte order.  */
 764
 765 #if !defined (BITS_BIG_ENDIAN)
 766 #ifndef TARGET_BYTE_ORDER_SELECTABLE
 767
 768 #if TARGET_BYTE_ORDER == BIG_ENDIAN
 769 #define BITS_BIG_ENDIAN 1
 770 #endif /* Big endian.  */
 771
 772 #if TARGET_BYTE_ORDER == LITTLE_ENDIAN
 773 #define BITS_BIG_ENDIAN 0
 774 #endif /* Little endian.  */
 775
 776 #else /* defined (TARGET_BYTE_ORDER_SELECTABLE) */
 777
 778 #define BITS_BIG_ENDIAN (TARGET_BYTE_ORDER == BIG_ENDIAN)
 779
 780 #endif /* defined (TARGET_BYTE_ORDER_SELECTABLE) */
 781 #endif /* BITS_BIG_ENDIAN not defined.  */
 782
 783 /* In findvar.c.  */
 784
 785 extern LONGEST extract_signed_integer PARAMS ((void *, int));
 786
 787 extern unsigned LONGEST extract_unsigned_integer PARAMS ((void *, int));
 788
 789 extern int extract_long_unsigned_integer PARAMS ((void *, int, LONGEST *));
 790
 791 extern CORE_ADDR extract_address PARAMS ((void *, int));
 792
 793 extern void store_signed_integer PARAMS ((void *, int, LONGEST));
 794
 795 extern void store_unsigned_integer PARAMS ((void *, int, unsigned LONGEST));
 796
 797 extern void store_address PARAMS ((void *, int, CORE_ADDR));
 798
 799 /* Setup definitions for host and target floating point formats.  We need to
 800    consider the format for `float', `double', and `long double' for both target
 801    and host.  We need to do this so that we know what kind of conversions need
 802    to be done when converting target numbers to and from the hosts DOUBLEST
 803    data type.  */
 804
 805 /* This is used to indicate that we don't know the format of the floating point
 806    number.  Typically, this is useful for native ports, where the actual format
 807    is irrelevant, since no conversions will be taking place.  */
 808
 809 extern const struct floatformat floatformat_unknown;
 810
 811 #if HOST_BYTE_ORDER == BIG_ENDIAN
 812 #  ifndef HOST_FLOAT_FORMAT
 813 #    define HOST_FLOAT_FORMAT &floatformat_ieee_single_big
 814 #  endif
 815 #  ifndef HOST_DOUBLE_FORMAT
 816 #    define HOST_DOUBLE_FORMAT &floatformat_ieee_double_big
 817 #  endif
 818 #else                           /* LITTLE_ENDIAN */
 819 #  ifndef HOST_FLOAT_FORMAT
 820 #    define HOST_FLOAT_FORMAT &floatformat_ieee_single_little
 821 #  endif
 822 #  ifndef HOST_DOUBLE_FORMAT
 823 #    define HOST_DOUBLE_FORMAT &floatformat_ieee_double_little
 824 #  endif
 825 #endif
 826
 827 #ifndef HOST_LONG_DOUBLE_FORMAT
 828 #define HOST_LONG_DOUBLE_FORMAT &floatformat_unknown
 829 #endif
 830
 831 #ifndef TARGET_BYTE_ORDER_SELECTABLE
 832 #  if TARGET_BYTE_ORDER == BIG_ENDIAN
 833 #    ifndef TARGET_FLOAT_FORMAT
 834 #      define TARGET_FLOAT_FORMAT &floatformat_ieee_single_big
 835 #    endif
 836 #    ifndef TARGET_DOUBLE_FORMAT
 837 #      define TARGET_DOUBLE_FORMAT &floatformat_ieee_double_big
 838 #    endif
 839 #  else /* LITTLE_ENDIAN */
 840 #    ifndef TARGET_FLOAT_FORMAT
 841 #      define TARGET_FLOAT_FORMAT &floatformat_ieee_single_little
 842 #    endif
 843 #    ifndef TARGET_DOUBLE_FORMAT
 844 #      define TARGET_DOUBLE_FORMAT &floatformat_ieee_double_little
 845 #    endif
 846 #  endif
 847 #else                           /* TARGET_BYTE_ORDER_SELECTABLE */
 848 #  ifndef TARGET_FLOAT_FORMAT
 849 #    define TARGET_FLOAT_FORMAT (target_byte_order == BIG_ENDIAN \
 850                                  ? &floatformat_ieee_single_big \
 851                                  : &floatformat_ieee_single_little)
 852 #  endif
 853 #  ifndef TARGET_DOUBLE_FORMAT
 854 #    define TARGET_DOUBLE_FORMAT (target_byte_order == BIG_ENDIAN \
 855                                   ? &floatformat_ieee_double_big \
 856                                   : &floatformat_ieee_double_little)
 857 #  endif
 858 #endif
 859
 860 #ifndef TARGET_LONG_DOUBLE_FORMAT
 861 #  define TARGET_LONG_DOUBLE_FORMAT &floatformat_unknown
 862 #endif
 863
 864 /* Use `long double' if the host compiler supports it.  (Note that this is not
 865    necessarily any longer than `double'.  On SunOS/gcc, it's the same as
 866    double.)  This is necessary because GDB internally converts all floating
 867    point values to the widest type supported by the host.
 868
 869    There are problems however, when the target `long double' is longer than the
 870    host's `long double'.  In general, we'll probably reduce the precision of
 871    any such values and print a warning.  */
 872
 873 #ifdef HAVE_LONG_DOUBLE
 874 typedef long double DOUBLEST;
 875 #else
 876 typedef double DOUBLEST;
 877 #endif
 878
 879 extern void floatformat_to_doublest PARAMS ((const struct floatformat *,
 880                                              char *, DOUBLEST *));
 881 extern void floatformat_from_doublest PARAMS ((const struct floatformat *,
 882                                                DOUBLEST *, char *));
 883 extern DOUBLEST extract_floating PARAMS ((void *, int));
 884
 885 extern void store_floating PARAMS ((void *, int, DOUBLEST));
 886 \f
 887 /* On some machines there are bits in addresses which are not really
 888    part of the address, but are used by the kernel, the hardware, etc.
 889    for special purposes.  ADDR_BITS_REMOVE takes out any such bits
 890    so we get a "real" address such as one would find in a symbol
 891    table.  This is used only for addresses of instructions, and even then
 892    I'm not sure it's used in all contexts.  It exists to deal with there
 893    being a few stray bits in the PC which would mislead us, not as some sort
 894    of generic thing to handle alignment or segmentation (it's possible it
 895    should be in TARGET_READ_PC instead).  */
 896 #if !defined (ADDR_BITS_REMOVE)
 897 #define ADDR_BITS_REMOVE(addr) (addr)
 898 #endif /* No ADDR_BITS_REMOVE.  */
 899
 900 /* From valops.c */
 901
 902 extern CORE_ADDR push_bytes PARAMS ((CORE_ADDR, char *, int));
 903
 904 extern CORE_ADDR push_word PARAMS ((CORE_ADDR, unsigned LONGEST));
 905
 906 /* Some parts of gdb might be considered optional, in the sense that they
 907    are not essential for being able to build a working, usable debugger
 908    for a specific environment.  For example, the maintenance commands
 909    are there for the benefit of gdb maintainers.  As another example,
 910    some environments really don't need gdb's that are able to read N
 911    different object file formats.  In order to make it possible (but
 912    not necessarily recommended) to build "stripped down" versions of
 913    gdb, the following defines control selective compilation of those
 914    parts of gdb which can be safely left out when necessary.  Note that
 915    the default is to include everything. */
 916
 917 #ifndef MAINTENANCE_CMDS
 918 #define MAINTENANCE_CMDS 1
 919 #endif
 920
 921 #ifdef MAINTENANCE_CMDS
 922 extern int watchdog;
 923 #endif
 924
 925 #include "dis-asm.h"            /* Get defs for disassemble_info */
 926
 927 extern int dis_asm_read_memory PARAMS ((bfd_vma memaddr, bfd_byte *myaddr,
 928                                         int len, disassemble_info *info));
 929
 930 extern void dis_asm_memory_error PARAMS ((int status, bfd_vma memaddr,
 931                                           disassemble_info *info));
 932
 933 extern void dis_asm_print_address PARAMS ((bfd_vma addr,
 934                                            disassemble_info *info));
 935
 936 extern int (*tm_print_insn) PARAMS ((bfd_vma, disassemble_info*));
 937 extern disassemble_info tm_print_insn_info;
 938
 939 /* Hooks for alternate command interfaces.  */
 940
 941 #ifdef __STDC__
 942 struct target_waitstatus;
 943 struct cmd_list_element;
 944 #endif
 945
 946 extern void (*init_ui_hook) PARAMS ((void));
 947 extern void (*command_loop_hook) PARAMS ((void));
 948 extern void (*fputs_unfiltered_hook) PARAMS ((const char *linebuffer,
 949                                               FILE *stream));
 950 extern void (*print_frame_info_listing_hook) PARAMS ((struct symtab *s,
 951                                                       int line, int stopline,
 952                                                       int noerror));
 953 extern int (*query_hook) PARAMS ((const char *, va_list));
 954 extern void (*flush_hook) PARAMS ((FILE *stream));
 955 extern void (*create_breakpoint_hook) PARAMS ((struct breakpoint *b));
 956 extern void (*delete_breakpoint_hook) PARAMS ((struct breakpoint *bpt));
 957 extern void (*modify_breakpoint_hook) PARAMS ((struct breakpoint *bpt));
 958 extern void (*target_output_hook) PARAMS ((char *));
 959 extern void (*interactive_hook) PARAMS ((void));
 960 extern void (*registers_changed_hook) PARAMS ((void));
 961 extern void (*readline_begin_hook) PARAMS ((char *, ...));
 962 extern char * (*readline_hook) PARAMS ((char *));
 963 extern void (*readline_end_hook) PARAMS ((void));
 964
 965 extern int (*target_wait_hook) PARAMS ((int pid,
 966                                         struct target_waitstatus *status));
 967
 968 extern void (*call_command_hook) PARAMS ((struct cmd_list_element *c,
 969                                           char *cmd, int from_tty));
 970
 971 extern NORETURN void (*error_hook) PARAMS ((void)) ATTR_NORETURN;
 972
 973
 974
 975 /* Inhibit window interface if non-zero. */
 976
 977 extern int use_windows;
 978
 979 /* Symbolic definitions of filename-related things.  */
 980 /* FIXME, this doesn't work very well if host and executable
 981    filesystems conventions are different.  */
 982
 983 #ifndef DIRNAME_SEPARATOR
 984 #define DIRNAME_SEPARATOR ':'
 985 #endif
 986
 987 #ifndef SLASH_P
 988 #if defined(__GO32__)||defined(__WIN32__)
 989 #define SLASH_P(X) ((X)=='\\')
 990 #else
 991 #define SLASH_P(X) ((X)=='/')
 992 #endif
 993 #endif
 994
 995 #ifndef SLASH_CHAR
 996 #if defined(__GO32__)||defined(__WIN32__)
 997 #define SLASH_CHAR '\\'
 998 #else
 999 #define SLASH_CHAR '/'
1000 #endif
1001 #endif
1002
1003 #ifndef SLASH_STRING
1004 #if defined(__GO32__)||defined(__WIN32__)
1005 #define SLASH_STRING "\\"
1006 #else
1007 #define SLASH_STRING "/"
1008 #endif
1009 #endif
1010
1011 #ifndef ROOTED_P
1012 #define ROOTED_P(X) (SLASH_P((X)[0]))
1013 #endif
1014
1015 #endif /* #ifndef DEFS_H */