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 PTR xmalloc PARAMS ((long));
 211
 212 extern PTR xrealloc PARAMS ((PTR, long));
 213
 214 extern void notice_quit PARAMS ((void));
 215
 216 extern int strcmp_iw PARAMS ((const char *, const char *));
 217
 218 extern char *safe_strerror PARAMS ((int));
 219
 220 extern char *safe_strsignal PARAMS ((int));
 221
 222 extern void init_malloc PARAMS ((void *));
 223
 224 extern void request_quit PARAMS ((int));
 225
 226 extern void do_cleanups PARAMS ((struct cleanup *));
 227
 228 extern void discard_cleanups PARAMS ((struct cleanup *));
 229
 230 /* The bare make_cleanup function is one of those rare beasts that
 231    takes almost any type of function as the first arg and anything that
 232    will fit in a "void *" as the second arg.
 233
 234    Should be, once all calls and called-functions are cleaned up:
 235 extern struct cleanup *
 236 make_cleanup PARAMS ((void (*function) (void *), void *));
 237
 238    Until then, lint and/or various type-checking compiler options will
 239    complain about make_cleanup calls.  It'd be wrong to just cast things,
 240    since the type actually passed when the function is called would be
 241    wrong.  */
 242
 243 extern struct cleanup *make_cleanup ();
 244
 245 extern struct cleanup *save_cleanups PARAMS ((void));
 246
 247 extern void restore_cleanups PARAMS ((struct cleanup *));
 248
 249 extern void free_current_contents PARAMS ((char **));
 250
 251 extern void null_cleanup PARAMS ((PTR));
 252
 253 extern int myread PARAMS ((int, char *, int));
 254
 255 extern int query PARAMS((char *, ...))
 256      ATTR_FORMAT(printf, 1, 2);
 257
 258 /* From demangle.c */
 259
 260 extern void set_demangling_style PARAMS ((char *));
 261
 262 \f
 263 /* Annotation stuff.  */
 264
 265 extern int annotation_level; /* in stack.c */
 266 \f
 267 extern void begin_line PARAMS ((void));
 268
 269 extern void wrap_here PARAMS ((char *));
 270
 271 extern void reinitialize_more_filter PARAMS ((void));
 272
 273 typedef FILE GDB_FILE;
 274 #define gdb_stdout stdout
 275 #define gdb_stderr stderr
 276
 277 extern void gdb_flush PARAMS ((GDB_FILE *));
 278
 279 extern GDB_FILE *gdb_fopen PARAMS ((char * name, char * mode));
 280
 281 extern void fputs_filtered PARAMS ((const char *, GDB_FILE *));
 282
 283 extern void fputs_unfiltered PARAMS ((const char *, GDB_FILE *));
 284
 285 extern int fputc_unfiltered PARAMS ((int c, GDB_FILE *));
 286
 287 extern int putchar_unfiltered PARAMS ((int c));
 288
 289 extern void puts_filtered PARAMS ((const char *));
 290
 291 extern void puts_unfiltered PARAMS ((const char *));
 292
 293 extern void vprintf_filtered PARAMS ((const char *, va_list))
 294      ATTR_FORMAT(printf, 1, 0);
 295
 296 extern void vfprintf_filtered PARAMS ((FILE *, const char *, va_list))
 297      ATTR_FORMAT(printf, 2, 0);
 298
 299 extern void fprintf_filtered PARAMS ((FILE *, const char *, ...))
 300      ATTR_FORMAT(printf, 2, 3);
 301
 302 extern void fprintfi_filtered PARAMS ((int, FILE *, const char *, ...))
 303      ATTR_FORMAT(printf, 3, 4);
 304
 305 extern void printf_filtered PARAMS ((const char *, ...))
 306      ATTR_FORMAT(printf, 1, 2);
 307
 308 extern void printfi_filtered PARAMS ((int, const char *, ...))
 309      ATTR_FORMAT(printf, 2, 3);
 310
 311 extern void vprintf_unfiltered PARAMS ((const char *, va_list))
 312      ATTR_FORMAT(printf, 1, 0);
 313
 314 extern void vfprintf_unfiltered PARAMS ((FILE *, const char *, va_list))
 315      ATTR_FORMAT(printf, 2, 0);
 316
 317 extern void fprintf_unfiltered PARAMS ((FILE *, const char *, ...))
 318      ATTR_FORMAT(printf, 2, 3);
 319
 320 extern void printf_unfiltered PARAMS ((const char *, ...))
 321      ATTR_FORMAT(printf, 1, 2);
 322
 323 extern void print_spaces PARAMS ((int, GDB_FILE *));
 324
 325 extern void print_spaces_filtered PARAMS ((int, GDB_FILE *));
 326
 327 extern char *n_spaces PARAMS ((int));
 328
 329 extern void gdb_printchar PARAMS ((int, GDB_FILE *, int));
 330
 331 extern void gdb_print_address PARAMS ((void *, GDB_FILE *));
 332
 333 extern void fprintf_symbol_filtered PARAMS ((GDB_FILE *, char *,
 334                                              enum language, int));
 335
 336 extern void perror_with_name PARAMS ((char *));
 337
 338 extern void print_sys_errmsg PARAMS ((char *, int));
 339
 340 /* From regex.c or libc.  BSD 4.4 declares this with the argument type as
 341    "const char *" in unistd.h, so we can't declare the argument
 342    as "char *".  */
 343
 344 extern char *re_comp PARAMS ((const char *));
 345
 346 /* From symfile.c */
 347
 348 extern void symbol_file_command PARAMS ((char *, int));
 349
 350 /* From top.c */
 351
 352 extern char *skip_quoted PARAMS ((char *));
 353
 354 extern char *gdb_readline PARAMS ((char *));
 355
 356 extern char *command_line_input PARAMS ((char *, int, char *));
 357
 358 extern void print_prompt PARAMS ((void));
 359
 360 extern int input_from_terminal_p PARAMS ((void));
 361
 362 extern int info_verbose;
 363
 364 /* From printcmd.c */
 365
 366 extern void set_next_address PARAMS ((CORE_ADDR));
 367
 368 extern void print_address_symbolic PARAMS ((CORE_ADDR, GDB_FILE *, int,
 369                                             char *));
 370
 371 extern void print_address_numeric PARAMS ((CORE_ADDR, int, GDB_FILE *));
 372
 373 extern void print_address PARAMS ((CORE_ADDR, GDB_FILE *));
 374
 375 /* From source.c */
 376
 377 extern int openp PARAMS ((char *, int, char *, int, int, char **));
 378
 379 extern void mod_path PARAMS ((char *, char **));
 380
 381 extern void directory_command PARAMS ((char *, int));
 382
 383 extern void init_source_path PARAMS ((void));
 384
 385 extern char *symtab_to_filename PARAMS ((struct symtab *));
 386
 387 /* From findvar.c */
 388
 389 extern int read_relative_register_raw_bytes PARAMS ((int, char *));
 390
 391 /* From readline (but not in any readline .h files).  */
 392
 393 extern char *tilde_expand PARAMS ((char *));
 394
 395 /* Control types for commands */
 396
 397 enum misc_command_type
 398 {
 399   ok_command,
 400   end_command,
 401   else_command,
 402   nop_command
 403 };
 404
 405 enum command_control_type
 406 {
 407   simple_control,
 408   break_control,
 409   continue_control,
 410   while_control,
 411   if_control,
 412   invalid_control
 413 };
 414
 415 /* Structure for saved commands lines
 416    (for breakpoints, defined commands, etc).  */
 417
 418 struct command_line
 419 {
 420   struct command_line *next;
 421   char *line;
 422   enum command_control_type control_type;
 423   int body_count;
 424   struct command_line **body_list;
 425 };
 426
 427 extern struct command_line *read_command_lines PARAMS ((char *, int));
 428
 429 extern void free_command_lines PARAMS ((struct command_line **));
 430
 431 /* String containing the current directory (what getwd would return).  */
 432
 433 extern char *current_directory;
 434
 435 /* Default radixes for input and output.  Only some values supported.  */
 436 extern unsigned input_radix;
 437 extern unsigned output_radix;
 438
 439 /* Possibilities for prettyprint parameters to routines which print
 440    things.  Like enum language, this should be in value.h, but needs
 441    to be here for the same reason.  FIXME:  If we can eliminate this
 442    as an arg to LA_VAL_PRINT, then we can probably move it back to
 443    value.h. */
 444
 445 enum val_prettyprint
 446 {
 447   Val_no_prettyprint = 0,
 448   Val_prettyprint,
 449   /* Use the default setting which the user has specified.  */
 450   Val_pretty_default
 451 };
 452
 453 \f
 454 /* Host machine definition.  This will be a symlink to one of the
 455    xm-*.h files, built by the `configure' script.  */
 456
 457 #include "xm.h"
 458
 459 /* Native machine support.  This will be a symlink to one of the
 460    nm-*.h files, built by the `configure' script.  */
 461
 462 #include "nm.h"
 463
 464 /* Target machine definition.  This will be a symlink to one of the
 465    tm-*.h files, built by the `configure' script.  */
 466
 467 #include "tm.h"
 468
 469 /* If the xm.h file did not define the mode string used to open the
 470    files, assume that binary files are opened the same way as text
 471    files */
 472 #ifndef FOPEN_RB
 473 #include "fopen-same.h"
 474 #endif
 475
 476 /* Microsoft C can't deal with const pointers */
 477
 478 #ifdef _MSC_VER
 479 #define CONST_PTR
 480 #else
 481 #define CONST_PTR const
 482 #endif
 483
 484 /*
 485  * Allow things in gdb to be declared "volatile".  If compiling ANSI, it
 486  * just works.  If compiling with gcc but non-ansi, redefine to __volatile__.
 487  * If non-ansi, non-gcc, then eliminate "volatile" entirely, making those
 488  * objects be read-write rather than read-only.
 489  */
 490
 491 #ifndef volatile
 492 #ifndef __STDC__
 493 # ifdef __GNUC__
 494 #  define volatile __volatile__
 495 # else
 496 #  define volatile /*nothing*/
 497 # endif /* GNUC */
 498 #endif /* STDC */
 499 #endif /* volatile */
 500
 501 /* Defaults for system-wide constants (if not defined by xm.h, we fake it).
 502    FIXME: Assumes 2's complement arithmetic */
 503
 504 #if !defined (UINT_MAX)
 505 #define UINT_MAX ((unsigned int)(~0))           /* 0xFFFFFFFF for 32-bits */
 506 #endif
 507
 508 #if !defined (INT_MAX)
 509 #define INT_MAX ((int)(UINT_MAX >> 1))          /* 0x7FFFFFFF for 32-bits */
 510 #endif
 511
 512 #if !defined (INT_MIN)
 513 #define INT_MIN ((int)((int) ~0 ^ INT_MAX))     /* 0x80000000 for 32-bits */
 514 #endif
 515
 516 #if !defined (ULONG_MAX)
 517 #define ULONG_MAX ((unsigned long)(~0L))        /* 0xFFFFFFFF for 32-bits */
 518 #endif
 519
 520 #if !defined (LONG_MAX)
 521 #define LONG_MAX ((long)(ULONG_MAX >> 1))       /* 0x7FFFFFFF for 32-bits */
 522 #endif
 523
 524 #ifdef BFD64
 525
 526 /* This is to make sure that LONGEST is at least as big as CORE_ADDR.  */
 527
 528 #define LONGEST BFD_HOST_64_BIT
 529
 530 #else /* No BFD64 */
 531
 532 /* LONGEST should not be a typedef, because "unsigned LONGEST" needs to work.
 533    CC_HAS_LONG_LONG is defined if the host compiler supports "long long" */
 534
 535 #ifndef LONGEST
 536 #  ifdef CC_HAS_LONG_LONG
 537 #    define LONGEST long long
 538 #  else
 539 #    define LONGEST long
 540 #  endif
 541 #endif
 542
 543 #endif /* No BFD64 */
 544
 545 /* Convert a LONGEST to an int.  This is used in contexts (e.g. number of
 546    arguments to a function, number in a value history, register number, etc.)
 547    where the value must not be larger than can fit in an int.  */
 548
 549 extern int longest_to_int PARAMS ((LONGEST));
 550
 551 /* Assorted functions we can declare, now that const and volatile are
 552    defined.  */
 553
 554 extern char *savestring PARAMS ((const char *, int));
 555
 556 extern char *msavestring PARAMS ((void *, const char *, int));
 557
 558 extern char *strsave PARAMS ((const char *));
 559
 560 extern char *mstrsave PARAMS ((void *, const char *));
 561
 562 extern PTR xmmalloc PARAMS ((PTR, long));
 563
 564 extern PTR xmrealloc PARAMS ((PTR, PTR, long));
 565
 566 extern int parse_escape PARAMS ((char **));
 567
 568 extern char *reg_names[];
 569
 570 /* Message to be printed before the error message, when an error occurs.  */
 571
 572 extern char *error_pre_print;
 573
 574 /* Message to be printed before the error message, when an error occurs.  */
 575
 576 extern char *quit_pre_print;
 577
 578 /* Message to be printed before the warning message, when a warning occurs.  */
 579
 580 extern char *warning_pre_print;
 581
 582 extern NORETURN void error PARAMS((char *, ...)) ATTR_NORETURN;
 583
 584 extern void error_begin PARAMS ((void));
 585
 586 extern NORETURN void fatal PARAMS((char *, ...)) ATTR_NORETURN;
 587
 588 extern NORETURN void nomem PARAMS ((long)) ATTR_NORETURN;
 589
 590 /* Reasons for calling return_to_top_level.  */
 591 enum return_reason {
 592   /* User interrupt.  */
 593   RETURN_QUIT,
 594
 595   /* Any other error.  */
 596   RETURN_ERROR
 597 };
 598
 599 #define RETURN_MASK_QUIT (1 << (int)RETURN_QUIT)
 600 #define RETURN_MASK_ERROR (1 << (int)RETURN_ERROR)
 601 #define RETURN_MASK_ALL (RETURN_MASK_QUIT | RETURN_MASK_ERROR)
 602 typedef int return_mask;
 603
 604 extern NORETURN void
 605 return_to_top_level PARAMS ((enum return_reason)) ATTR_NORETURN;
 606
 607 extern int
 608 catch_errors PARAMS ((int (*) (char *), void *, char *, return_mask));
 609
 610 extern void warning_begin PARAMS ((void));
 611
 612 extern void warning PARAMS ((char *, ...))
 613      ATTR_FORMAT(printf, 1, 2);
 614
 615 /* Global functions from other, non-gdb GNU thingies.
 616    Libiberty thingies are no longer declared here.  We include libiberty.h
 617    above, instead.  */
 618
 619 #ifndef GETENV_PROVIDED
 620 extern char *getenv PARAMS ((const char *));
 621 #endif
 622
 623 /* From other system libraries */
 624
 625 #ifdef HAVE_STDDEF_H
 626 #include <stddef.h>
 627 #endif
 628
 629 #ifdef HAVE_STDLIB_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 #ifdef NEED_DECLARATION_MALLOC
 650 extern PTR malloc ();
 651 #endif
 652
 653 #ifdef NEED_DECLARATION_REALLOC
 654 extern PTR realloc ();
 655 #endif
 656
 657 #ifdef NEED_DECLARATION_FREE
 658 extern void free ();
 659 #endif
 660
 661 #endif /* MALLOC_INCOMPATIBLE */
 662
 663 /* Various possibilities for alloca.  */
 664 #ifndef alloca
 665 # ifdef __GNUC__
 666 #  define alloca __builtin_alloca
 667 # else /* Not GNU C */
 668 #  ifdef sparc
 669 #   include <alloca.h>          /* NOTE:  Doesn't declare alloca() */
 670 #  endif
 671
 672 /* We need to be careful not to declare this in a way which conflicts with
 673    bison.  Bison never declares it as char *, but under various circumstances
 674    (like __hpux) we need to use void *.  */
 675 #  if defined (__STDC__) || defined (__hpux)
 676    extern void *alloca ();
 677 #  else /* Don't use void *.  */
 678    extern char *alloca ();
 679 #  endif /* Don't use void *.  */
 680 # endif /* Not GNU C */
 681 #endif /* alloca not defined */
 682
 683 /* HOST_BYTE_ORDER must be defined to one of these.  */
 684
 685 #ifdef HAVE_ENDIAN_H
 686 #include <endian.h>
 687 #endif
 688
 689 #if !defined (BIG_ENDIAN)
 690 #define BIG_ENDIAN 4321
 691 #endif
 692
 693 #if !defined (LITTLE_ENDIAN)
 694 #define LITTLE_ENDIAN 1234
 695 #endif
 696
 697 /* Target-system-dependent parameters for GDB. */
 698
 699 #ifdef TARGET_BYTE_ORDER_SELECTABLE
 700 /* The target endianness is selectable at runtime.  Define
 701    TARGET_BYTE_ORDER to be a variable.  The user can use the `set
 702    endian' command to change it.  */
 703 #undef TARGET_BYTE_ORDER
 704 #define TARGET_BYTE_ORDER target_byte_order
 705 extern int target_byte_order;
 706 #endif
 707
 708 extern void set_endian_from_file PARAMS ((bfd *));
 709
 710 /* Number of bits in a char or unsigned char for the target machine.
 711    Just like CHAR_BIT in <limits.h> but describes the target machine.  */
 712 #if !defined (TARGET_CHAR_BIT)
 713 #define TARGET_CHAR_BIT 8
 714 #endif
 715
 716 /* Number of bits in a short or unsigned short for the target machine. */
 717 #if !defined (TARGET_SHORT_BIT)
 718 #define TARGET_SHORT_BIT (2 * TARGET_CHAR_BIT)
 719 #endif
 720
 721 /* Number of bits in an int or unsigned int for the target machine. */
 722 #if !defined (TARGET_INT_BIT)
 723 #define TARGET_INT_BIT (4 * TARGET_CHAR_BIT)
 724 #endif
 725
 726 /* Number of bits in a long or unsigned long for the target machine. */
 727 #if !defined (TARGET_LONG_BIT)
 728 #define TARGET_LONG_BIT (4 * TARGET_CHAR_BIT)
 729 #endif
 730
 731 /* Number of bits in a long long or unsigned long long for the target machine. */
 732 #if !defined (TARGET_LONG_LONG_BIT)
 733 #define TARGET_LONG_LONG_BIT (2 * TARGET_LONG_BIT)
 734 #endif
 735
 736 /* Number of bits in a float for the target machine. */
 737 #if !defined (TARGET_FLOAT_BIT)
 738 #define TARGET_FLOAT_BIT (4 * TARGET_CHAR_BIT)
 739 #endif
 740
 741 /* Number of bits in a double for the target machine. */
 742 #if !defined (TARGET_DOUBLE_BIT)
 743 #define TARGET_DOUBLE_BIT (8 * TARGET_CHAR_BIT)
 744 #endif
 745
 746 /* Number of bits in a long double for the target machine.  */
 747 #if !defined (TARGET_LONG_DOUBLE_BIT)
 748 #define TARGET_LONG_DOUBLE_BIT (2 * TARGET_DOUBLE_BIT)
 749 #endif
 750
 751 /* Number of bits in a pointer for the target machine */
 752 #if !defined (TARGET_PTR_BIT)
 753 #define TARGET_PTR_BIT TARGET_INT_BIT
 754 #endif
 755
 756 /* If we picked up a copy of CHAR_BIT from a configuration file
 757    (which may get it by including <limits.h>) then use it to set
 758    the number of bits in a host char.  If not, use the same size
 759    as the target. */
 760
 761 #if defined (CHAR_BIT)
 762 #define HOST_CHAR_BIT CHAR_BIT
 763 #else
 764 #define HOST_CHAR_BIT TARGET_CHAR_BIT
 765 #endif
 766
 767 /* The bit byte-order has to do just with numbering of bits in
 768    debugging symbols and such.  Conceptually, it's quite separate
 769    from byte/word byte order.  */
 770
 771 #if !defined (BITS_BIG_ENDIAN)
 772 #ifndef TARGET_BYTE_ORDER_SELECTABLE
 773
 774 #if TARGET_BYTE_ORDER == BIG_ENDIAN
 775 #define BITS_BIG_ENDIAN 1
 776 #endif /* Big endian.  */
 777
 778 #if TARGET_BYTE_ORDER == LITTLE_ENDIAN
 779 #define BITS_BIG_ENDIAN 0
 780 #endif /* Little endian.  */
 781
 782 #else /* defined (TARGET_BYTE_ORDER_SELECTABLE) */
 783
 784 #define BITS_BIG_ENDIAN (TARGET_BYTE_ORDER == BIG_ENDIAN)
 785
 786 #endif /* defined (TARGET_BYTE_ORDER_SELECTABLE) */
 787 #endif /* BITS_BIG_ENDIAN not defined.  */
 788
 789 /* In findvar.c.  */
 790
 791 extern LONGEST extract_signed_integer PARAMS ((void *, int));
 792
 793 extern unsigned LONGEST extract_unsigned_integer PARAMS ((void *, int));
 794
 795 extern int extract_long_unsigned_integer PARAMS ((void *, int, LONGEST *));
 796
 797 extern CORE_ADDR extract_address PARAMS ((void *, int));
 798
 799 extern void store_signed_integer PARAMS ((void *, int, LONGEST));
 800
 801 extern void store_unsigned_integer PARAMS ((void *, int, unsigned LONGEST));
 802
 803 extern void store_address PARAMS ((void *, int, CORE_ADDR));
 804
 805 /* Setup definitions for host and target floating point formats.  We need to
 806    consider the format for `float', `double', and `long double' for both target
 807    and host.  We need to do this so that we know what kind of conversions need
 808    to be done when converting target numbers to and from the hosts DOUBLEST
 809    data type.  */
 810
 811 /* This is used to indicate that we don't know the format of the floating point
 812    number.  Typically, this is useful for native ports, where the actual format
 813    is irrelevant, since no conversions will be taking place.  */
 814
 815 extern const struct floatformat floatformat_unknown;
 816
 817 #if HOST_BYTE_ORDER == BIG_ENDIAN
 818 #  ifndef HOST_FLOAT_FORMAT
 819 #    define HOST_FLOAT_FORMAT &floatformat_ieee_single_big
 820 #  endif
 821 #  ifndef HOST_DOUBLE_FORMAT
 822 #    define HOST_DOUBLE_FORMAT &floatformat_ieee_double_big
 823 #  endif
 824 #else                           /* LITTLE_ENDIAN */
 825 #  ifndef HOST_FLOAT_FORMAT
 826 #    define HOST_FLOAT_FORMAT &floatformat_ieee_single_little
 827 #  endif
 828 #  ifndef HOST_DOUBLE_FORMAT
 829 #    define HOST_DOUBLE_FORMAT &floatformat_ieee_double_little
 830 #  endif
 831 #endif
 832
 833 #ifndef HOST_LONG_DOUBLE_FORMAT
 834 #define HOST_LONG_DOUBLE_FORMAT &floatformat_unknown
 835 #endif
 836
 837 #ifndef TARGET_BYTE_ORDER_SELECTABLE
 838 #  if TARGET_BYTE_ORDER == BIG_ENDIAN
 839 #    ifndef TARGET_FLOAT_FORMAT
 840 #      define TARGET_FLOAT_FORMAT &floatformat_ieee_single_big
 841 #    endif
 842 #    ifndef TARGET_DOUBLE_FORMAT
 843 #      define TARGET_DOUBLE_FORMAT &floatformat_ieee_double_big
 844 #    endif
 845 #  else /* LITTLE_ENDIAN */
 846 #    ifndef TARGET_FLOAT_FORMAT
 847 #      define TARGET_FLOAT_FORMAT &floatformat_ieee_single_little
 848 #    endif
 849 #    ifndef TARGET_DOUBLE_FORMAT
 850 #      define TARGET_DOUBLE_FORMAT &floatformat_ieee_double_little
 851 #    endif
 852 #  endif
 853 #else                           /* TARGET_BYTE_ORDER_SELECTABLE */
 854 #  ifndef TARGET_FLOAT_FORMAT
 855 #    define TARGET_FLOAT_FORMAT (target_byte_order == BIG_ENDIAN \
 856                                  ? &floatformat_ieee_single_big \
 857                                  : &floatformat_ieee_single_little)
 858 #  endif
 859 #  ifndef TARGET_DOUBLE_FORMAT
 860 #    define TARGET_DOUBLE_FORMAT (target_byte_order == BIG_ENDIAN \
 861                                   ? &floatformat_ieee_double_big \
 862                                   : &floatformat_ieee_double_little)
 863 #  endif
 864 #endif
 865
 866 #ifndef TARGET_LONG_DOUBLE_FORMAT
 867 #  define TARGET_LONG_DOUBLE_FORMAT &floatformat_unknown
 868 #endif
 869
 870 /* Use `long double' if the host compiler supports it.  (Note that this is not
 871    necessarily any longer than `double'.  On SunOS/gcc, it's the same as
 872    double.)  This is necessary because GDB internally converts all floating
 873    point values to the widest type supported by the host.
 874
 875    There are problems however, when the target `long double' is longer than the
 876    host's `long double'.  In general, we'll probably reduce the precision of
 877    any such values and print a warning.  */
 878
 879 #ifdef HAVE_LONG_DOUBLE
 880 typedef long double DOUBLEST;
 881 #else
 882 typedef double DOUBLEST;
 883 #endif
 884
 885 extern void floatformat_to_doublest PARAMS ((const struct floatformat *,
 886                                              char *, DOUBLEST *));
 887 extern void floatformat_from_doublest PARAMS ((const struct floatformat *,
 888                                                DOUBLEST *, char *));
 889 extern DOUBLEST extract_floating PARAMS ((void *, int));
 890
 891 extern void store_floating PARAMS ((void *, int, DOUBLEST));
 892 \f
 893 /* On some machines there are bits in addresses which are not really
 894    part of the address, but are used by the kernel, the hardware, etc.
 895    for special purposes.  ADDR_BITS_REMOVE takes out any such bits
 896    so we get a "real" address such as one would find in a symbol
 897    table.  This is used only for addresses of instructions, and even then
 898    I'm not sure it's used in all contexts.  It exists to deal with there
 899    being a few stray bits in the PC which would mislead us, not as some sort
 900    of generic thing to handle alignment or segmentation (it's possible it
 901    should be in TARGET_READ_PC instead).  */
 902 #if !defined (ADDR_BITS_REMOVE)
 903 #define ADDR_BITS_REMOVE(addr) (addr)
 904 #endif /* No ADDR_BITS_REMOVE.  */
 905
 906 /* From valops.c */
 907
 908 extern CORE_ADDR push_bytes PARAMS ((CORE_ADDR, char *, int));
 909
 910 extern CORE_ADDR push_word PARAMS ((CORE_ADDR, unsigned LONGEST));
 911
 912 /* Some parts of gdb might be considered optional, in the sense that they
 913    are not essential for being able to build a working, usable debugger
 914    for a specific environment.  For example, the maintenance commands
 915    are there for the benefit of gdb maintainers.  As another example,
 916    some environments really don't need gdb's that are able to read N
 917    different object file formats.  In order to make it possible (but
 918    not necessarily recommended) to build "stripped down" versions of
 919    gdb, the following defines control selective compilation of those
 920    parts of gdb which can be safely left out when necessary.  Note that
 921    the default is to include everything. */
 922
 923 #ifndef MAINTENANCE_CMDS
 924 #define MAINTENANCE_CMDS 1
 925 #endif
 926
 927 #ifdef MAINTENANCE_CMDS
 928 extern int watchdog;
 929 #endif
 930
 931 #include "dis-asm.h"            /* Get defs for disassemble_info */
 932
 933 extern int dis_asm_read_memory PARAMS ((bfd_vma memaddr, bfd_byte *myaddr,
 934                                         int len, disassemble_info *info));
 935
 936 extern void dis_asm_memory_error PARAMS ((int status, bfd_vma memaddr,
 937                                           disassemble_info *info));
 938
 939 extern void dis_asm_print_address PARAMS ((bfd_vma addr,
 940                                            disassemble_info *info));
 941
 942 extern int (*tm_print_insn) PARAMS ((bfd_vma, disassemble_info*));
 943 extern disassemble_info tm_print_insn_info;
 944
 945 /* Hooks for alternate command interfaces.  */
 946
 947 #ifdef __STDC__
 948 struct target_waitstatus;
 949 struct cmd_list_element;
 950 #endif
 951
 952 extern void (*init_ui_hook) PARAMS ((void));
 953 extern void (*command_loop_hook) PARAMS ((void));
 954 extern void (*fputs_unfiltered_hook) PARAMS ((const char *linebuffer,
 955                                               FILE *stream));
 956 extern void (*print_frame_info_listing_hook) PARAMS ((struct symtab *s,
 957                                                       int line, int stopline,
 958                                                       int noerror));
 959 extern int (*query_hook) PARAMS ((const char *, va_list));
 960 extern void (*flush_hook) PARAMS ((FILE *stream));
 961 extern void (*create_breakpoint_hook) PARAMS ((struct breakpoint *b));
 962 extern void (*delete_breakpoint_hook) PARAMS ((struct breakpoint *bpt));
 963 extern void (*modify_breakpoint_hook) PARAMS ((struct breakpoint *bpt));
 964 extern void (*target_output_hook) PARAMS ((char *));
 965 extern void (*interactive_hook) PARAMS ((void));
 966 extern void (*registers_changed_hook) PARAMS ((void));
 967 extern void (*readline_begin_hook) PARAMS ((char *, ...));
 968 extern char * (*readline_hook) PARAMS ((char *));
 969 extern void (*readline_end_hook) PARAMS ((void));
 970
 971 extern int (*target_wait_hook) PARAMS ((int pid,
 972                                         struct target_waitstatus *status));
 973
 974 extern void (*call_command_hook) PARAMS ((struct cmd_list_element *c,
 975                                           char *cmd, int from_tty));
 976
 977 extern NORETURN void (*error_hook) PARAMS ((void)) ATTR_NORETURN;
 978
 979
 980
 981 /* Inhibit window interface if non-zero. */
 982
 983 extern int use_windows;
 984
 985 /* Symbolic definitions of filename-related things.  */
 986 /* FIXME, this doesn't work very well if host and executable
 987    filesystems conventions are different.  */
 988
 989 #ifndef DIRNAME_SEPARATOR
 990 #define DIRNAME_SEPARATOR ':'
 991 #endif
 992
 993 #ifndef SLASH_P
 994 #if defined(__GO32__)||defined(_WIN32)
 995 #define SLASH_P(X) ((X)=='\\')
 996 #else
 997 #define SLASH_P(X) ((X)=='/')
 998 #endif
 999 #endif
1000
1001 #ifndef SLASH_CHAR
1002 #if defined(__GO32__)||defined(_WIN32)
1003 #define SLASH_CHAR '\\'
1004 #else
1005 #define SLASH_CHAR '/'
1006 #endif
1007 #endif
1008
1009 #ifndef SLASH_STRING
1010 #if defined(__GO32__)||defined(_WIN32)
1011 #define SLASH_STRING "\\"
1012 #else
1013 #define SLASH_STRING "/"
1014 #endif
1015 #endif
1016
1017 #ifndef ROOTED_P
1018 #define ROOTED_P(X) (SLASH_P((X)[0]))
1019 #endif
1020
1021 #endif /* #ifndef DEFS_H */