gdb/defs.h

   1 /* Basic, host-specific, and target-specific definitions for GDB.
   2    Copyright (C) 1986, 1989, 1991 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #if !defined (DEFS_H)
  21 #define DEFS_H 1
  22
  23 #include <stdio.h>
  24
  25 /* First include ansidecl.h so we can use the various macro definitions
  26    here and in all subsequent file inclusions.  */
  27
  28 #include "ansidecl.h"
  29
  30 /* An address in the program being debugged.  Host byte order.  */
  31 #ifndef CORE_ADDR_TYPE
  32 typedef unsigned int CORE_ADDR;
  33 #else
  34 typedef CORE_ADDR_TYPE CORE_ADDR;
  35 #endif
  36
  37 #define min(a, b) ((a) < (b) ? (a) : (b))
  38 #define max(a, b) ((a) > (b) ? (a) : (b))
  39
  40 /* Gdb does *lots* of string compares.  Use macros to speed them up by
  41    avoiding function calls if the first characters are not the same. */
  42
  43 #define STRCMP(a,b) (*(a) == *(b) ? strcmp ((a), (b)) : (int)*(a) - (int)*(b))
  44 #define STREQ(a,b) (*(a) == *(b) ? !strcmp ((a), (b)) : 0)
  45 #define STREQN(a,b,c) (*(a) == *(b) ? !strncmp ((a), (b), (c)) : 0)
  46
  47 /* The character GNU C++ uses to build identifiers that must be unique from
  48    the program's identifiers (such as $this and $$vptr).  */
  49 #define CPLUS_MARKER '$'        /* May be overridden to '.' for SysV */
  50
  51 #include <errno.h>              /* System call error return status */
  52
  53 extern int quit_flag;
  54 extern int immediate_quit;
  55 extern int sevenbit_strings;
  56
  57 extern void
  58 quit PARAMS ((void));
  59
  60 #define QUIT { if (quit_flag) quit (); }
  61
  62 /* Command classes are top-level categories into which commands are broken
  63    down for "help" purposes.
  64    Notes on classes: class_alias is for alias commands which are not
  65    abbreviations of the original command.  class-pseudo is for commands
  66    which are not really commands nor help topics ("stop").  */
  67
  68 enum command_class
  69 {
  70   /* Special args to help_list */
  71   all_classes = -2, all_commands = -1,
  72   /* Classes of commands */
  73   no_class = -1, class_run = 0, class_vars, class_stack,
  74   class_files, class_support, class_info, class_breakpoint,
  75   class_alias, class_obscure, class_user, class_maintenance,
  76   class_pseudo
  77 };
  78
  79 /* Languages represented in the symbol table and elsewhere.
  80    This should probably be in language.h, but since enum's can't
  81    be forward declared to satisfy opaque references before their
  82    actual definition, needs to be here. */
  83
  84 enum language
  85 {
  86    language_unknown,            /* Language not known */
  87    language_auto,               /* Placeholder for automatic setting */
  88    language_c,                  /* C */
  89    language_cplus,              /* C++ */
  90    language_chill,              /* Chill */
  91    language_m2                  /* Modula-2 */
  92 };
  93
  94 /* the cleanup list records things that have to be undone
  95    if an error happens (descriptors to be closed, memory to be freed, etc.)
  96    Each link in the chain records a function to call and an
  97    argument to give it.
  98
  99    Use make_cleanup to add an element to the cleanup chain.
 100    Use do_cleanups to do all cleanup actions back to a given
 101    point in the chain.  Use discard_cleanups to remove cleanups
 102    from the chain back to a given point, not doing them.  */
 103
 104 struct cleanup
 105 {
 106   struct cleanup *next;
 107   void (*function) PARAMS ((PTR));
 108   PTR arg;
 109 };
 110
 111 /* From blockframe.c */
 112
 113 extern int
 114 inside_entry_func PARAMS ((CORE_ADDR));
 115
 116 extern int
 117 inside_entry_file PARAMS ((CORE_ADDR addr));
 118
 119 extern int
 120 inside_main_func PARAMS ((CORE_ADDR pc));
 121
 122 /* From ch-lang.c, for the moment. (FIXME) */
 123
 124 extern char *
 125 chill_demangle PARAMS ((const char *));
 126
 127 /* From libiberty.a */
 128
 129 extern char *
 130 cplus_demangle PARAMS ((const char *, int));
 131
 132 extern char *
 133 cplus_mangle_opname PARAMS ((char *, int));
 134
 135 /* From libmmalloc.a (memory mapped malloc library) */
 136
 137 extern PTR
 138 mmalloc_attach PARAMS ((int, PTR));
 139
 140 extern PTR
 141 mmalloc_detach PARAMS ((PTR));
 142
 143 extern PTR
 144 mmalloc PARAMS ((PTR, long));
 145
 146 extern PTR
 147 mrealloc PARAMS ((PTR, PTR, long));
 148
 149 extern void
 150 mfree PARAMS ((PTR, PTR));
 151
 152 extern int
 153 mmalloc_setkey PARAMS ((PTR, int, PTR));
 154
 155 extern PTR
 156 mmalloc_getkey PARAMS ((PTR, int));
 157
 158 /* From utils.c */
 159
 160 extern int
 161 strcmp_iw PARAMS ((const char *, const char *));
 162
 163 extern char *
 164 safe_strerror PARAMS ((int));
 165
 166 extern char *
 167 safe_strsignal PARAMS ((int));
 168
 169 extern void
 170 init_malloc PARAMS ((void *));
 171
 172 extern void
 173 request_quit PARAMS ((int));
 174
 175 extern void
 176 do_cleanups PARAMS ((struct cleanup *));
 177
 178 extern void
 179 discard_cleanups PARAMS ((struct cleanup *));
 180
 181 /* The bare make_cleanup function is one of those rare beasts that
 182    takes almost any type of function as the first arg and anything that
 183    will fit in a "void *" as the second arg.
 184
 185    Should be, once all calls and called-functions are cleaned up:
 186 extern struct cleanup *
 187 make_cleanup PARAMS ((void (*function) (void *), void *));
 188
 189    Until then, lint and/or various type-checking compiler options will
 190    complain about make_cleanup calls.  It'd be wrong to just cast things,
 191    since the type actually passed when the function is called would be
 192    wrong.  */
 193
 194 extern struct cleanup *
 195 make_cleanup ();
 196
 197 extern struct cleanup *
 198 save_cleanups PARAMS ((void));
 199
 200 extern void
 201 restore_cleanups PARAMS ((struct cleanup *));
 202
 203 extern void
 204 free_current_contents PARAMS ((char **));
 205
 206 extern void
 207 null_cleanup PARAMS ((char **));
 208
 209 extern int
 210 myread PARAMS ((int, char *, int));
 211
 212 extern int
 213 query ();
 214
 215 extern void
 216 begin_line PARAMS ((void));
 217
 218 extern void
 219 wrap_here PARAMS ((char *));
 220
 221 extern void
 222 reinitialize_more_filter PARAMS ((void));
 223
 224 typedef FILE GDB_FILE;
 225 #define gdb_stdout stdout
 226 #define gdb_stderr stderr
 227
 228 extern int
 229 print_insn PARAMS ((CORE_ADDR, GDB_FILE *));
 230
 231 extern void
 232 gdb_flush PARAMS ((GDB_FILE *));
 233
 234 extern GDB_FILE *
 235 gdb_fopen PARAMS ((char * name, char * mode));
 236
 237 extern void
 238 fputs_filtered PARAMS ((const char *, GDB_FILE *));
 239
 240 extern void
 241 fputs_unfiltered PARAMS ((const char *, GDB_FILE *));
 242
 243 extern void
 244 fputc_unfiltered PARAMS ((int, GDB_FILE *));
 245
 246 extern void
 247 putc_unfiltered PARAMS ((int));
 248
 249 #define putchar_unfiltered(C)  putc_unfiltered(C)
 250
 251 extern void
 252 puts_filtered PARAMS ((char *));
 253
 254 extern void
 255 puts_unfiltered PARAMS ((char *));
 256
 257 extern void
 258 vprintf_filtered ();
 259
 260 extern void
 261 vfprintf_filtered ();
 262
 263 extern void
 264 fprintf_filtered ();
 265
 266 extern void
 267 fprintfi_filtered ();
 268
 269 extern void
 270 printf_filtered ();
 271
 272 extern void
 273 printfi_filtered ();
 274
 275 extern void
 276 vprintf_unfiltered ();
 277
 278 extern void
 279 vfprintf_unfiltered ();
 280
 281 extern void
 282 fprintf_unfiltered ();
 283
 284 extern void
 285 printf_unfiltered ();
 286
 287 extern void
 288 print_spaces PARAMS ((int, GDB_FILE *));
 289
 290 extern void
 291 print_spaces_filtered PARAMS ((int, GDB_FILE *));
 292
 293 extern char *
 294 n_spaces PARAMS ((int));
 295
 296 extern void
 297 gdb_printchar PARAMS ((int, GDB_FILE *, int));
 298
 299 extern void
 300 fprintf_symbol_filtered PARAMS ((GDB_FILE *, char *, enum language, int));
 301
 302 extern void
 303 perror_with_name PARAMS ((char *));
 304
 305 extern void
 306 print_sys_errmsg PARAMS ((char *, int));
 307
 308 /* From regex.c or libc.  BSD 4.4 declares this with the argument type as
 309    "const char *" in unistd.h, so we can't declare the argument
 310    as "char *".  */
 311
 312 extern char *
 313 re_comp PARAMS ((const char *));
 314
 315 /* From symfile.c */
 316
 317 extern void
 318 symbol_file_command PARAMS ((char *, int));
 319
 320 /* From main.c */
 321
 322 extern char *
 323 skip_quoted PARAMS ((char *));
 324
 325 extern char *
 326 gdb_readline PARAMS ((char *));
 327
 328 extern char *
 329 command_line_input PARAMS ((char *, int));
 330
 331 extern void
 332 print_prompt PARAMS ((void));
 333
 334 extern int
 335 batch_mode PARAMS ((void));
 336
 337 extern int
 338 input_from_terminal_p PARAMS ((void));
 339
 340 /* From printcmd.c */
 341
 342 extern void
 343 set_next_address PARAMS ((CORE_ADDR));
 344
 345 extern void
 346 print_address_symbolic PARAMS ((CORE_ADDR, GDB_FILE *, int, char *));
 347
 348 extern void
 349 print_address PARAMS ((CORE_ADDR, GDB_FILE *));
 350
 351 /* From source.c */
 352
 353 extern int
 354 openp PARAMS ((char *, int, char *, int, int, char **));
 355
 356 extern void
 357 mod_path PARAMS ((char *, char **));
 358
 359 extern void
 360 directory_command PARAMS ((char *, int));
 361
 362 extern void
 363 init_source_path PARAMS ((void));
 364
 365 /* From findvar.c */
 366
 367 extern int
 368 read_relative_register_raw_bytes PARAMS ((int, char *));
 369
 370 /* From readline (but not in any readline .h files).  */
 371
 372 extern char *
 373 tilde_expand PARAMS ((char *));
 374
 375 /* Structure for saved commands lines
 376    (for breakpoints, defined commands, etc).  */
 377
 378 struct command_line
 379 {
 380   struct command_line *next;
 381   char *line;
 382 };
 383
 384 extern struct command_line *
 385 read_command_lines PARAMS ((void));
 386
 387 extern void
 388 free_command_lines PARAMS ((struct command_line **));
 389
 390 /* String containing the current directory (what getwd would return).  */
 391
 392 extern char *current_directory;
 393
 394 /* Default radixes for input and output.  Only some values supported.  */
 395 extern unsigned input_radix;
 396 extern unsigned output_radix;
 397
 398 /* Possibilities for prettyprint parameters to routines which print
 399    things.  Like enum language, this should be in value.h, but needs
 400    to be here for the same reason.  FIXME:  If we can eliminate this
 401    as an arg to LA_VAL_PRINT, then we can probably move it back to
 402    value.h. */
 403
 404 enum val_prettyprint
 405 {
 406   Val_no_prettyprint = 0,
 407   Val_prettyprint,
 408   /* Use the default setting which the user has specified.  */
 409   Val_pretty_default
 410 };
 411
 412 \f
 413 /* Host machine definition.  This will be a symlink to one of the
 414    xm-*.h files, built by the `configure' script.  */
 415
 416 #include "xm.h"
 417
 418 /* Native machine support.  This will be a symlink to one of the
 419    nm-*.h files, built by the `configure' script.  */
 420
 421 #include "nm.h"
 422
 423 /* If the xm.h file did not define the mode string used to open the
 424    files, assume that binary files are opened the same way as text
 425    files */
 426 #ifndef FOPEN_RB
 427 #include "fopen-same.h"
 428 #endif
 429
 430 /*
 431  * Allow things in gdb to be declared "const".  If compiling ANSI, it
 432  * just works.  If compiling with gcc but non-ansi, redefine to __const__.
 433  * If non-ansi, non-gcc, then eliminate "const" entirely, making those
 434  * objects be read-write rather than read-only.
 435  */
 436
 437 #ifndef const
 438 #ifndef __STDC__
 439 # ifdef __GNUC__
 440 #  define const __const__
 441 # else
 442 #  define const /*nothing*/
 443 # endif /* GNUC */
 444 #endif /* STDC */
 445 #endif /* const */
 446
 447 #ifndef volatile
 448 #ifndef __STDC__
 449 # ifdef __GNUC__
 450 #  define volatile __volatile__
 451 # else
 452 #  define volatile /*nothing*/
 453 # endif /* GNUC */
 454 #endif /* STDC */
 455 #endif /* volatile */
 456
 457 #if 1
 458 #define NORETURN /*nothing*/
 459 #else /* not 1 */
 460 /* FIXME: This is bogus.  Having "volatile void" mean a function doesn't
 461    return is a gcc extension and should be based on #ifdef __GNUC__.
 462    Also, as of Sep 93 I'm told gcc is changing the syntax for ansi
 463    reasons (so declaring exit here as "volatile void" and as "void" in
 464    a system header loses).  Using the new "__attributes__ ((noreturn));"
 465    syntax would lose for old versions of gcc; using
 466      typedef void exit_fn_type PARAMS ((int));
 467      volatile exit_fn_type exit;
 468    would win.  */
 469 /* Some compilers (many AT&T SVR4 compilers for instance), do not accept
 470    declarations of functions that never return (exit for instance) as
 471    "volatile void".  For such compilers "NORETURN" can be defined away
 472    to keep them happy */
 473
 474 #ifndef NORETURN
 475 # ifdef __lucid
 476 #   define NORETURN /*nothing*/
 477 # else
 478 #   define NORETURN volatile
 479 # endif
 480 #endif
 481 #endif /* not 1 */
 482
 483 /* Defaults for system-wide constants (if not defined by xm.h, we fake it).  */
 484
 485 #if !defined (UINT_MAX)
 486 #define UINT_MAX ((unsigned int)(~0))           /* 0xFFFFFFFF for 32-bits */
 487 #endif
 488
 489 #if !defined (INT_MAX)
 490 #define INT_MAX ((int)(UINT_MAX >> 1))          /* 0x7FFFFFFF for 32-bits */
 491 #endif
 492
 493 #if !defined (INT_MIN)
 494 #define INT_MIN (-INT_MAX - 1)                  /* 0x80000000 for 32-bits */
 495 #endif
 496
 497 #if !defined (ULONG_MAX)
 498 #define ULONG_MAX ((unsigned long)(~0L))        /* 0xFFFFFFFF for 32-bits */
 499 #endif
 500
 501 #if !defined (LONG_MAX)
 502 #define LONG_MAX ((long)(ULONG_MAX >> 1))       /* 0x7FFFFFFF for 32-bits */
 503 #endif
 504
 505 /* Default to support for "long long" if the host compiler being used is gcc.
 506    Config files must define CC_HAS_LONG_LONG to use other host compilers
 507    that are capable of supporting "long long", and to cause gdb to use that
 508    support.  Not defining CC_HAS_LONG_LONG will suppress use of "long long"
 509    regardless of what compiler is used.
 510
 511    FIXME: For now, automatic selection of "long long" as the default when
 512    gcc is used is disabled, pending further testing.  Concerns include the
 513    impact on gdb performance and the universality of bugfree long long
 514    support on platforms that do have gcc.  Compiling with FORCE_LONG_LONG
 515    will select "long long" use for testing purposes.  -fnf */
 516
 517 #ifndef CC_HAS_LONG_LONG
 518 #  if defined (__GNUC__) && defined (FORCE_LONG_LONG) /* See FIXME above */
 519 #    define CC_HAS_LONG_LONG 1
 520 #  endif
 521 #endif
 522
 523 /* LONGEST should not be a typedef, because "unsigned LONGEST" needs to work.
 524    CC_HAS_LONG_LONG is defined if the host compiler supports "long long"
 525    variables and we wish to make use of that support.  */
 526
 527 #ifndef LONGEST
 528 #  ifdef CC_HAS_LONG_LONG
 529 #    define LONGEST long long
 530 #  else
 531 #    define LONGEST long
 532 #  endif
 533 #endif
 534
 535 /* Convert a LONGEST to an int.  This is used in contexts (e.g. number of
 536    arguments to a function, number in a value history, register number, etc.)
 537    where the value must not be larger than can fit in an int.  */
 538
 539 #ifndef longest_to_int
 540 #  ifdef CC_HAS_LONG_LONG
 541 #    define longest_to_int(x) (((x) > INT_MAX || (x) < INT_MIN) \
 542                                ? (error ("Value out of range."),0) : (int) (x))
 543 #  else
 544      /* Assume sizeof (int) == sizeof (long).  */
 545 #    define longest_to_int(x) ((int) (x))
 546 #  endif
 547 #endif
 548
 549 /* Assorted functions we can declare, now that const and volatile are
 550    defined.  */
 551
 552 extern char *
 553 savestring PARAMS ((const char *, int));
 554
 555 extern char *
 556 msavestring PARAMS ((void *, const char *, int));
 557
 558 extern char *
 559 strsave PARAMS ((const char *));
 560
 561 extern char *
 562 mstrsave PARAMS ((void *, const char *));
 563
 564 extern char *
 565 concat PARAMS ((char *, ...));
 566
 567 extern PTR
 568 xmalloc PARAMS ((long));
 569
 570 extern PTR
 571 xrealloc PARAMS ((PTR, long));
 572
 573 extern PTR
 574 xmmalloc PARAMS ((PTR, long));
 575
 576 extern PTR
 577 xmrealloc PARAMS ((PTR, PTR, long));
 578
 579 extern PTR
 580 mmalloc PARAMS ((PTR, long));
 581
 582 extern PTR
 583 mrealloc PARAMS ((PTR, PTR, long));
 584
 585 extern void
 586 mfree PARAMS ((PTR, PTR));
 587
 588 extern int
 589 mmcheck PARAMS ((PTR, void (*) (void)));
 590
 591 extern int
 592 mmtrace PARAMS ((void));
 593
 594 extern int
 595 parse_escape PARAMS ((char **));
 596
 597 extern const char * const reg_names[];
 598
 599 extern NORETURN void                    /* Does not return to the caller.  */
 600 error ();
 601
 602 extern NORETURN void                    /* Does not return to the caller.  */
 603 fatal ();
 604
 605 extern NORETURN void                    /* Not specified as volatile in ... */
 606 exit PARAMS ((int));                    /* 4.10.4.3 */
 607
 608 extern NORETURN void                    /* Does not return to the caller.  */
 609 nomem PARAMS ((long));
 610
 611 /* Reasons for calling return_to_top_level.  */
 612 enum return_reason {
 613   /* User interrupt.  */
 614   RETURN_QUIT,
 615
 616   /* Any other error.  */
 617   RETURN_ERROR
 618 };
 619
 620 #define RETURN_MASK_QUIT (1 << (int)RETURN_QUIT)
 621 #define RETURN_MASK_ERROR (1 << (int)RETURN_ERROR)
 622 #define RETURN_MASK_ALL (RETURN_MASK_QUIT | RETURN_MASK_ERROR)
 623 typedef int return_mask;
 624
 625 extern NORETURN void                    /* Does not return to the caller.  */
 626 return_to_top_level PARAMS ((enum return_reason));
 627
 628 extern int catch_errors PARAMS ((int (*) (char *), void *, char *,
 629                                  return_mask));
 630
 631 extern void
 632 warning_setup PARAMS ((void));
 633
 634 extern void
 635 warning ();
 636
 637 /* Global functions from other, non-gdb GNU thingies (libiberty for
 638    instance) */
 639
 640 extern char *
 641 basename PARAMS ((char *));
 642
 643 extern char *
 644 getenv PARAMS ((const char *));
 645
 646 extern char **
 647 buildargv PARAMS ((char *));
 648
 649 extern void
 650 freeargv PARAMS ((char **));
 651
 652 extern char *
 653 strerrno PARAMS ((int));
 654
 655 extern char *
 656 strsigno PARAMS ((int));
 657
 658 extern int
 659 errno_max PARAMS ((void));
 660
 661 extern int
 662 signo_max PARAMS ((void));
 663
 664 extern int
 665 strtoerrno PARAMS ((char *));
 666
 667 extern int
 668 strtosigno PARAMS ((char *));
 669
 670 extern char *
 671 strsignal PARAMS ((int));
 672
 673 /* From other system libraries */
 674
 675 #ifndef PSIGNAL_IN_SIGNAL_H
 676 extern void
 677 psignal PARAMS ((unsigned, const char *));
 678 #endif
 679
 680 /* For now, we can't include <stdlib.h> because it conflicts with
 681    "../include/getopt.h".  (FIXME)
 682
 683    However, if a function is defined in the ANSI C standard and a prototype
 684    for that function is defined and visible in any header file in an ANSI
 685    conforming environment, then that prototype must match the definition in
 686    the ANSI standard.  So we can just duplicate them here without conflict,
 687    since they must be the same in all conforming ANSI environments.  If
 688    these cause problems, then the environment is not ANSI conformant. */
 689
 690 #ifdef __STDC__
 691 #include <stddef.h>
 692 #endif
 693
 694 extern int
 695 fclose PARAMS ((GDB_FILE *stream));                             /* 4.9.5.1 */
 696
 697 extern void
 698 perror PARAMS ((const char *));                         /* 4.9.10.4 */
 699
 700 extern double
 701 atof PARAMS ((const char *nptr));                       /* 4.10.1.1 */
 702
 703 extern int
 704 atoi PARAMS ((const char *));                           /* 4.10.1.2 */
 705
 706 #ifndef MALLOC_INCOMPATIBLE
 707
 708 extern PTR
 709 malloc PARAMS ((size_t size));                          /* 4.10.3.3 */
 710
 711 extern PTR
 712 realloc PARAMS ((void *ptr, size_t size));              /* 4.10.3.4 */
 713
 714 extern void
 715 free PARAMS ((void *));                                 /* 4.10.3.2 */
 716
 717 #endif  /* MALLOC_INCOMPATIBLE */
 718
 719 extern void
 720 qsort PARAMS ((void *base, size_t nmemb,                /* 4.10.5.2 */
 721                size_t size,
 722                int (*comp)(const void *, const void *)));
 723
 724 #ifndef MEM_FNS_DECLARED        /* Some non-ANSI use void *, not char *.  */
 725 extern PTR
 726 memcpy PARAMS ((void *, const void *, size_t));         /* 4.11.2.1 */
 727
 728 extern int
 729 memcmp PARAMS ((const void *, const void *, size_t));   /* 4.11.4.1 */
 730 #endif
 731
 732 extern char *
 733 strchr PARAMS ((const char *, int));                    /* 4.11.5.2 */
 734
 735 extern char *
 736 strrchr PARAMS ((const char *, int));                   /* 4.11.5.5 */
 737
 738 extern char *
 739 strstr PARAMS ((const char *, const char *));           /* 4.11.5.7 */
 740
 741 extern char *
 742 strtok PARAMS ((char *, const char *));                 /* 4.11.5.8 */
 743
 744 #ifndef MEM_FNS_DECLARED        /* Some non-ANSI use void *, not char *.  */
 745 extern PTR
 746 memset PARAMS ((void *, int, size_t));                  /* 4.11.6.1 */
 747 #endif
 748
 749 extern char *
 750 strerror PARAMS ((int));                                /* 4.11.6.2 */
 751
 752 /* Various possibilities for alloca.  */
 753 #ifndef alloca
 754 # ifdef __GNUC__
 755 #  define alloca __builtin_alloca
 756 # else
 757 #  ifdef sparc
 758 #   include <alloca.h>          /* NOTE:  Doesn't declare alloca() */
 759 #  endif
 760 #  ifdef __STDC__
 761    extern void *alloca (size_t);
 762 #  else /* __STDC__ */
 763    extern char *alloca ();
 764 #  endif
 765 # endif
 766 #endif
 767
 768 /* TARGET_BYTE_ORDER and HOST_BYTE_ORDER must be defined to one of these.  */
 769
 770 #if !defined (BIG_ENDIAN)
 771 #define BIG_ENDIAN 4321
 772 #endif
 773
 774 #if !defined (LITTLE_ENDIAN)
 775 #define LITTLE_ENDIAN 1234
 776 #endif
 777
 778 /* Target-system-dependent parameters for GDB. */
 779
 780 /* Target machine definition.  This will be a symlink to one of the
 781    tm-*.h files, built by the `configure' script.  */
 782
 783 #include "tm.h"
 784
 785 /* Number of bits in a char or unsigned char for the target machine.
 786    Just like CHAR_BIT in <limits.h> but describes the target machine.  */
 787 #if !defined (TARGET_CHAR_BIT)
 788 #define TARGET_CHAR_BIT 8
 789 #endif
 790
 791 /* Number of bits in a short or unsigned short for the target machine. */
 792 #if !defined (TARGET_SHORT_BIT)
 793 #define TARGET_SHORT_BIT (2 * TARGET_CHAR_BIT)
 794 #endif
 795
 796 /* Number of bits in an int or unsigned int for the target machine. */
 797 #if !defined (TARGET_INT_BIT)
 798 #define TARGET_INT_BIT (4 * TARGET_CHAR_BIT)
 799 #endif
 800
 801 /* Number of bits in a long or unsigned long for the target machine. */
 802 #if !defined (TARGET_LONG_BIT)
 803 #define TARGET_LONG_BIT (4 * TARGET_CHAR_BIT)
 804 #endif
 805
 806 /* Number of bits in a long long or unsigned long long for the target machine. */
 807 #if !defined (TARGET_LONG_LONG_BIT)
 808 #define TARGET_LONG_LONG_BIT (2 * TARGET_LONG_BIT)
 809 #endif
 810
 811 /* Number of bits in a float for the target machine. */
 812 #if !defined (TARGET_FLOAT_BIT)
 813 #define TARGET_FLOAT_BIT (4 * TARGET_CHAR_BIT)
 814 #endif
 815
 816 /* Number of bits in a double for the target machine. */
 817 #if !defined (TARGET_DOUBLE_BIT)
 818 #define TARGET_DOUBLE_BIT (8 * TARGET_CHAR_BIT)
 819 #endif
 820
 821 /* Number of bits in a long double for the target machine.  */
 822 #if !defined (TARGET_LONG_DOUBLE_BIT)
 823 #define TARGET_LONG_DOUBLE_BIT (2 * TARGET_DOUBLE_BIT)
 824 #endif
 825
 826 /* Number of bits in a "complex" for the target machine. */
 827 #if !defined (TARGET_COMPLEX_BIT)
 828 #define TARGET_COMPLEX_BIT (2 * TARGET_FLOAT_BIT)
 829 #endif
 830
 831 /* Number of bits in a "double complex" for the target machine. */
 832 #if !defined (TARGET_DOUBLE_COMPLEX_BIT)
 833 #define TARGET_DOUBLE_COMPLEX_BIT (2 * TARGET_DOUBLE_BIT)
 834 #endif
 835
 836 /* Number of bits in a pointer for the target machine */
 837 #if !defined (TARGET_PTR_BIT)
 838 #define TARGET_PTR_BIT TARGET_INT_BIT
 839 #endif
 840
 841 /* If we picked up a copy of CHAR_BIT from a configuration file
 842    (which may get it by including <limits.h>) then use it to set
 843    the number of bits in a host char.  If not, use the same size
 844    as the target. */
 845
 846 #if defined (CHAR_BIT)
 847 #define HOST_CHAR_BIT CHAR_BIT
 848 #else
 849 #define HOST_CHAR_BIT TARGET_CHAR_BIT
 850 #endif
 851
 852 /* The bit byte-order has to do just with numbering of bits in
 853    debugging symbols and such.  Conceptually, it's quite separate
 854    from byte/word byte order.  */
 855
 856 #if !defined (BITS_BIG_ENDIAN)
 857 #if TARGET_BYTE_ORDER == BIG_ENDIAN
 858 #define BITS_BIG_ENDIAN 1
 859 #endif /* Big endian.  */
 860
 861 #if TARGET_BYTE_ORDER == LITTLE_ENDIAN
 862 #define BITS_BIG_ENDIAN 0
 863 #endif /* Little endian.  */
 864 #endif /* BITS_BIG_ENDIAN not defined.  */
 865
 866 /* In findvar.c.  */
 867 LONGEST extract_signed_integer PARAMS ((void *, int));
 868 unsigned LONGEST extract_unsigned_integer PARAMS ((void *, int));
 869 CORE_ADDR extract_address PARAMS ((void *, int));
 870
 871 void store_signed_integer PARAMS ((void *, int, LONGEST));
 872 void store_unsigned_integer PARAMS ((void *, int, unsigned LONGEST));
 873 void store_address PARAMS ((void *, int, CORE_ADDR));
 874
 875 double extract_floating PARAMS ((void *, int));
 876 void store_floating PARAMS ((void *, int, double));
 877 \f
 878 /* On some machines there are bits in addresses which are not really
 879    part of the address, but are used by the kernel, the hardware, etc.
 880    for special purposes.  ADDR_BITS_REMOVE takes out any such bits
 881    so we get a "real" address such as one would find in a symbol
 882    table.  This is used only for addresses of instructions, and even then
 883    I'm not sure it's used in all contexts.  It exists to deal with there
 884    being a few stray bits in the PC which would mislead us, not as some sort
 885    of generic thing to handle alignment or segmentation (it's possible it
 886    should be in TARGET_READ_PC instead).  */
 887 #if !defined (ADDR_BITS_REMOVE)
 888 #define ADDR_BITS_REMOVE(addr) (addr)
 889 #endif /* No ADDR_BITS_REMOVE.  */
 890
 891 /* From valops.c */
 892
 893 extern CORE_ADDR
 894 push_bytes PARAMS ((CORE_ADDR, char *, int));
 895
 896 extern CORE_ADDR
 897 push_word PARAMS ((CORE_ADDR, unsigned LONGEST));
 898
 899 /* Some parts of gdb might be considered optional, in the sense that they
 900    are not essential for being able to build a working, usable debugger
 901    for a specific environment.  For example, the maintenance commands
 902    are there for the benefit of gdb maintainers.  As another example,
 903    some environments really don't need gdb's that are able to read N
 904    different object file formats.  In order to make it possible (but
 905    not necessarily recommended) to build "stripped down" versions of
 906    gdb, the following defines control selective compilation of those
 907    parts of gdb which can be safely left out when necessary.  Note that
 908    the default is to include everything. */
 909
 910 #ifndef MAINTENANCE_CMDS
 911 #define MAINTENANCE_CMDS 1
 912 #endif
 913
 914 #endif /* !defined (DEFS_H) */