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