1/* *INDENT-OFF* */ /* ATTR_FORMAT confuses indent, avoid running it for now */ 2/* Basic, host-specific, and target-specific definitions for GDB. 3 Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 4 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 5 Free Software Foundation, Inc. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 2 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 59 Temple Place - Suite 330, 22 Boston, MA 02111-1307, USA. */ 23 24#ifndef DEFS_H 25#define DEFS_H 26 27#include "config.h" /* Generated by configure. */ 28 29#include <stdio.h> 30#include <errno.h> /* System call error return status. */ 31#include <limits.h> 32 33#ifdef HAVE_STDDEF_H 34#include <stddef.h> 35#else 36#include <sys/types.h> /* For size_t. */ 37#endif 38 39#ifdef HAVE_UNISTD_H 40#include <unistd.h> 41#endif 42 43/* First include ansidecl.h so we can use the various macro definitions 44 here and in all subsequent file inclusions. */ 45 46#include "ansidecl.h" 47 48#include "gdb_locale.h" 49 50/* For ``enum target_signal''. */ 51#include "gdb/signals.h" 52 53/* Just in case they're not defined in stdio.h. */ 54 55#ifndef SEEK_SET 56#define SEEK_SET 0 57#endif 58#ifndef SEEK_CUR 59#define SEEK_CUR 1 60#endif 61 62#include <stdarg.h> /* For va_list. */ 63 64#include "libiberty.h" 65 66/* For BFD64 and bfd_vma. */ 67#include "bfd.h" 68 69 70/* The target is partially multi-arched. Both "tm.h" and the 71 multi-arch vector provide definitions. "tm.h" normally overrides 72 the multi-arch vector (but there are a few exceptions). */ 73 74#define GDB_MULTI_ARCH_PARTIAL 1 75 76/* The target is partially multi-arched. Both the multi-arch vector 77 and "tm.h" provide definitions. "tm.h" cannot override a definition 78 provided by the multi-arch vector. It is detected as a compilation 79 error. 80 81 This setting is only useful during a multi-arch conversion. */ 82 83#define GDB_MULTI_ARCH_TM 2 84 85/* The target is pure multi-arch. The MULTI-ARCH vector provides all 86 definitions. "tm.h" is linked to an empty file. */ 87 88#define GDB_MULTI_ARCH_PURE 3 89 90 91 92/* An address in the program being debugged. Host byte order. Rather 93 than duplicate all the logic in BFD which figures out what type 94 this is (long, long long, etc.) and whether it needs to be 64 95 bits (the host/target interactions are subtle), we just use 96 bfd_vma. */ 97 98typedef bfd_vma CORE_ADDR; 99 100/* This is to make sure that LONGEST is at least as big as CORE_ADDR. */ 101 102#ifndef LONGEST 103 104#ifdef BFD64 105 106#define LONGEST BFD_HOST_64_BIT 107#define ULONGEST BFD_HOST_U_64_BIT 108 109#else /* No BFD64 */ 110 111#ifdef CC_HAS_LONG_LONG 112#define LONGEST long long 113#define ULONGEST unsigned long long 114#else 115#ifdef BFD_HOST_64_BIT 116/* BFD_HOST_64_BIT is defined for some hosts that don't have long long 117 (e.g. i386-windows) so try it. */ 118#define LONGEST BFD_HOST_64_BIT 119#define ULONGEST BFD_HOST_U_64_BIT 120#else 121#define LONGEST long 122#define ULONGEST unsigned long 123#endif 124#endif 125 126#endif /* No BFD64 */ 127 128#endif /* ! LONGEST */ 129 130#ifndef min 131#define min(a, b) ((a) < (b) ? (a) : (b)) 132#endif 133#ifndef max 134#define max(a, b) ((a) > (b) ? (a) : (b)) 135#endif 136 137/* Macros to do string compares. 138 139 NOTE: cagney/2000-03-14: 140 141 While old code can continue to refer to these macros, new code is 142 probably better off using strcmp() directly vis: ``strcmp() == 0'' 143 and ``strcmp() != 0''. 144 145 This is because modern compilers can directly inline strcmp() 146 making the original justification for these macros - avoid function 147 call overhead by pre-testing the first characters 148 (``*X==*Y?...:0'') - redundant. 149 150 ``Even if [...] testing the first character does have a modest 151 performance improvement, I'd rather that whenever a performance 152 issue is found that we spend the effort on algorithmic 153 optimizations than micro-optimizing.'' J.T. */ 154 155/* NOTE: cagney/2003-11-23: All instances of STREQ[N] covered by 156 testing GDB on a stabs system have been replaced by equivalent 157 str[n]cmp calls. To avoid the possability of introducing bugs when 158 making untested changes, the remaining references were deprecated 159 rather than replaced. */ 160 161/* DISCLAIMER: cagney/2003-11-23: Simplified definition of these 162 macros so that they just map directly onto strcmp equivalent. I'm 163 not responsible for any breakage due to code that relied on the old 164 underlying implementation. */ 165 166#define DEPRECATED_STREQ(a,b) (strcmp ((a), (b)) == 0) 167#define DEPRECATED_STREQN(a,b,c) (strncmp ((a), (b), (c)) == 0) 168 169/* Check if a character is one of the commonly used C++ marker characters. */ 170extern int is_cplus_marker (int); 171 172/* enable xdb commands if set */ 173extern int xdb_commands; 174 175/* enable dbx commands if set */ 176extern int dbx_commands; 177 178/* System root path, used to find libraries etc. */ 179extern char *gdb_sysroot; 180 181extern int quit_flag; 182extern int immediate_quit; 183extern int sevenbit_strings; 184 185extern void quit (void); 186 187/* FIXME: cagney/2000-03-13: It has been suggested that the peformance 188 benefits of having a ``QUIT'' macro rather than a function are 189 marginal. If the overhead of a QUIT function call is proving 190 significant then its calling frequency should probably be reduced 191 [kingdon]. A profile analyzing the current situtation is 192 needed. */ 193 194#ifdef QUIT 195/* do twice to force compiler warning */ 196#define QUIT_FIXME "FIXME" 197#define QUIT_FIXME "ignoring redefinition of QUIT" 198#else 199#define QUIT { \ 200 if (quit_flag) quit (); \ 201 if (interactive_hook) interactive_hook (); \ 202} 203#endif 204 205/* Languages represented in the symbol table and elsewhere. 206 This should probably be in language.h, but since enum's can't 207 be forward declared to satisfy opaque references before their 208 actual definition, needs to be here. */ 209 210enum language 211 { 212 language_unknown, /* Language not known */ 213 language_auto, /* Placeholder for automatic setting */ 214 language_c, /* C */ 215 language_cplus, /* C++ */ 216 language_objc, /* Objective-C */ 217 language_java, /* Java */ 218 language_fortran, /* Fortran */ 219 language_m2, /* Modula-2 */ 220 language_asm, /* Assembly language */ 221 language_scm, /* Scheme / Guile */ 222 language_pascal, /* Pascal */ 223 language_minimal /* All other languages, minimal support only */ 224 }; 225 226enum precision_type 227 { 228 single_precision, 229 double_precision, 230 unspecified_precision 231 }; 232 233/* A generic, not quite boolean, enumeration. */ 234enum auto_boolean 235{ 236 AUTO_BOOLEAN_TRUE, 237 AUTO_BOOLEAN_FALSE, 238 AUTO_BOOLEAN_AUTO 239}; 240 241/* Potential ways that a function can return a value of a given type. */ 242enum return_value_convention 243{ 244 /* Where the return value has been squeezed into one or more 245 registers. */ 246 RETURN_VALUE_REGISTER_CONVENTION, 247 /* Commonly known as the "struct return convention". The caller 248 passes an additional hidden first parameter to the caller. That 249 parameter contains the address at which the value being returned 250 should be stored. While typically, and historically, used for 251 large structs, this is convention is applied to values of many 252 different types. */ 253 RETURN_VALUE_STRUCT_CONVENTION 254}; 255 256/* the cleanup list records things that have to be undone 257 if an error happens (descriptors to be closed, memory to be freed, etc.) 258 Each link in the chain records a function to call and an 259 argument to give it. 260 261 Use make_cleanup to add an element to the cleanup chain. 262 Use do_cleanups to do all cleanup actions back to a given 263 point in the chain. Use discard_cleanups to remove cleanups 264 from the chain back to a given point, not doing them. */ 265 266struct cleanup 267 { 268 struct cleanup *next; 269 void (*function) (void *); 270 void *arg; 271 }; 272 273 274/* The ability to declare that a function never returns is useful, but 275 not really required to compile GDB successfully, so the NORETURN and 276 ATTR_NORETURN macros normally expand into nothing. */ 277 278/* If compiling with older versions of GCC, a function may be declared 279 "volatile" to indicate that it does not return. */ 280 281#ifndef NORETURN 282#if defined(__GNUC__) \ 283 && (__GNUC__ == 1 || (__GNUC__ == 2 && __GNUC_MINOR__ < 7)) 284#define NORETURN volatile 285#else 286#define NORETURN /* nothing */ 287#endif 288#endif 289 290/* GCC 2.5 and later versions define a function attribute "noreturn", 291 which is the preferred way to declare that a function never returns. 292 However GCC 2.7 appears to be the first version in which this fully 293 works everywhere we use it. */ 294 295#ifndef ATTR_NORETURN 296#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 7)) 297#define ATTR_NORETURN __attribute__ ((noreturn)) 298#else 299#define ATTR_NORETURN /* nothing */ 300#endif 301#endif 302 303#ifndef ATTR_FORMAT 304#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 4)) 305#define ATTR_FORMAT(type, x, y) __attribute__ ((format(type, x, y))) 306#else 307#define ATTR_FORMAT(type, x, y) /* nothing */ 308#endif 309#endif 310 311/* Be conservative and use enum bitfields only with GCC. 312 This is copied from gcc 3.3.1, system.h. */ 313 314#if defined(__GNUC__) && (__GNUC__ >= 2) 315#define ENUM_BITFIELD(TYPE) enum TYPE 316#else 317#define ENUM_BITFIELD(TYPE) unsigned int 318#endif 319 320/* Needed for various prototypes */ 321 322struct symtab; 323struct breakpoint; 324struct frame_info; 325 326/* From blockframe.c */ 327 328extern int inside_entry_func (struct frame_info *this_frame); 329 330extern int deprecated_inside_entry_file (CORE_ADDR addr); 331 332extern int inside_main_func (CORE_ADDR pc); 333 334/* From utils.c */ 335 336extern void initialize_utils (void); 337 338extern void notice_quit (void); 339 340extern int strcmp_iw (const char *, const char *); 341 342extern int strcmp_iw_ordered (const char *, const char *); 343 344extern int streq (const char *, const char *); 345 346extern int subset_compare (char *, char *); 347 348extern char *safe_strerror (int); 349 350extern void init_malloc (void *); 351 352extern void request_quit (int); 353 354extern void do_cleanups (struct cleanup *); 355extern void do_final_cleanups (struct cleanup *); 356extern void do_run_cleanups (struct cleanup *); 357extern void do_exec_cleanups (struct cleanup *); 358extern void do_exec_error_cleanups (struct cleanup *); 359 360extern void discard_cleanups (struct cleanup *); 361extern void discard_final_cleanups (struct cleanup *); 362extern void discard_exec_error_cleanups (struct cleanup *); 363extern void discard_my_cleanups (struct cleanup **, struct cleanup *); 364 365/* NOTE: cagney/2000-03-04: This typedef is strictly for the 366 make_cleanup function declarations below. Do not use this typedef 367 as a cast when passing functions into the make_cleanup() code. 368 Instead either use a bounce function or add a wrapper function. 369 Calling a f(char*) function with f(void*) is non-portable. */ 370typedef void (make_cleanup_ftype) (void *); 371 372extern struct cleanup *make_cleanup (make_cleanup_ftype *, void *); 373 374extern struct cleanup *make_cleanup_freeargv (char **); 375 376struct ui_file; 377extern struct cleanup *make_cleanup_ui_file_delete (struct ui_file *); 378 379extern struct cleanup *make_cleanup_close (int fd); 380 381extern struct cleanup *make_cleanup_bfd_close (bfd *abfd); 382 383extern struct cleanup *make_final_cleanup (make_cleanup_ftype *, void *); 384 385extern struct cleanup *make_my_cleanup (struct cleanup **, 386 make_cleanup_ftype *, void *); 387 388extern struct cleanup *make_run_cleanup (make_cleanup_ftype *, void *); 389 390extern struct cleanup *make_exec_cleanup (make_cleanup_ftype *, void *); 391extern struct cleanup *make_exec_error_cleanup (make_cleanup_ftype *, void *); 392 393extern struct cleanup *save_cleanups (void); 394extern struct cleanup *save_final_cleanups (void); 395extern struct cleanup *save_my_cleanups (struct cleanup **); 396 397extern void restore_cleanups (struct cleanup *); 398extern void restore_final_cleanups (struct cleanup *); 399extern void restore_my_cleanups (struct cleanup **, struct cleanup *); 400 401extern void free_current_contents (void *); 402 403extern void null_cleanup (void *); 404 405extern int myread (int, char *, int); 406 407extern int query (const char *, ...) ATTR_FORMAT (printf, 1, 2); 408extern int nquery (const char *, ...) ATTR_FORMAT (printf, 1, 2); 409extern int yquery (const char *, ...) ATTR_FORMAT (printf, 1, 2); 410 411extern void init_page_info (void); 412 413extern char *gdb_realpath (const char *); 414extern char *xfullpath (const char *); 415 416extern unsigned long gnu_debuglink_crc32 (unsigned long crc, 417 unsigned char *buf, size_t len); 418 419/* From demangle.c */ 420 421extern void set_demangling_style (char *); 422 423/* From tm.h */ 424 425struct type; 426typedef int (use_struct_convention_fn) (int gcc_p, struct type * value_type); 427extern use_struct_convention_fn generic_use_struct_convention; 428 429 430/* Annotation stuff. */ 431 432extern int annotation_level; /* in stack.c */ 433 434extern void begin_line (void); 435 436extern void wrap_here (char *); 437 438extern void reinitialize_more_filter (void); 439 440/* Normal results */ 441extern struct ui_file *gdb_stdout; 442/* Input stream */ 443extern struct ui_file *gdb_stdin; 444/* Serious error notifications */ 445extern struct ui_file *gdb_stderr; 446/* Log/debug/trace messages that should bypass normal stdout/stderr 447 filtering. For moment, always call this stream using 448 *_unfiltered. In the very near future that restriction shall be 449 removed - either call shall be unfiltered. (cagney 1999-06-13). */ 450extern struct ui_file *gdb_stdlog; 451/* Target output that should bypass normal stdout/stderr filtering. 452 For moment, always call this stream using *_unfiltered. In the 453 very near future that restriction shall be removed - either call 454 shall be unfiltered. (cagney 1999-07-02). */ 455extern struct ui_file *gdb_stdtarg; 456extern struct ui_file *gdb_stdtargerr; 457extern struct ui_file *gdb_stdtargin; 458 459#include "ui-file.h" 460 461/* More generic printf like operations. Filtered versions may return 462 non-locally on error. */ 463 464extern void fputs_filtered (const char *, struct ui_file *); 465 466extern void fputs_unfiltered (const char *, struct ui_file *); 467 468extern int fputc_filtered (int c, struct ui_file *); 469 470extern int fputc_unfiltered (int c, struct ui_file *); 471 472extern int putchar_filtered (int c); 473 474extern int putchar_unfiltered (int c); 475 476extern void puts_filtered (const char *); 477 478extern void puts_unfiltered (const char *); 479 480extern void puts_filtered_tabular (char *string, int width, int right); 481 482extern void puts_debug (char *prefix, char *string, char *suffix); 483 484extern void vprintf_filtered (const char *, va_list) ATTR_FORMAT (printf, 1, 0); 485 486extern void vfprintf_filtered (struct ui_file *, const char *, va_list) ATTR_FORMAT (printf, 2, 0); 487 488extern void fprintf_filtered (struct ui_file *, const char *, ...) ATTR_FORMAT (printf, 2, 3); 489 490extern void fprintfi_filtered (int, struct ui_file *, const char *, ...) ATTR_FORMAT (printf, 3, 4); 491 492extern void printf_filtered (const char *, ...) ATTR_FORMAT (printf, 1, 2); 493 494extern void printfi_filtered (int, const char *, ...) ATTR_FORMAT (printf, 2, 3); 495 496extern void vprintf_unfiltered (const char *, va_list) ATTR_FORMAT (printf, 1, 0); 497 498extern void vfprintf_unfiltered (struct ui_file *, const char *, va_list) ATTR_FORMAT (printf, 2, 0); 499 500extern void fprintf_unfiltered (struct ui_file *, const char *, ...) ATTR_FORMAT (printf, 2, 3); 501 502extern void printf_unfiltered (const char *, ...) ATTR_FORMAT (printf, 1, 2); 503 504extern void print_spaces (int, struct ui_file *); 505 506extern void print_spaces_filtered (int, struct ui_file *); 507 508extern char *n_spaces (int); 509 510extern void fputstr_filtered (const char *str, int quotr, struct ui_file * stream); 511 512extern void fputstr_unfiltered (const char *str, int quotr, struct ui_file * stream); 513 514extern void fputstrn_unfiltered (const char *str, int n, int quotr, struct ui_file * stream); 515 516/* Display the host ADDR on STREAM formatted as ``0x%x''. */ 517extern void gdb_print_host_address (const void *addr, struct ui_file *stream); 518 519/* Convert a CORE_ADDR into a HEX string. paddr() is like %08lx. 520 paddr_nz() is like %lx. paddr_u() is like %lu. paddr_width() is 521 for ``%*''. */ 522extern int strlen_paddr (void); 523extern char *paddr (CORE_ADDR addr); 524extern char *paddr_nz (CORE_ADDR addr); 525extern char *paddr_u (CORE_ADDR addr); 526extern char *paddr_d (LONGEST addr); 527 528extern char *phex (ULONGEST l, int sizeof_l); 529extern char *phex_nz (ULONGEST l, int sizeof_l); 530 531/* Like paddr() only print/scan raw CORE_ADDR. The output from 532 core_addr_to_string() can be passed direct to 533 string_to_core_addr(). */ 534extern const char *core_addr_to_string (const CORE_ADDR addr); 535extern const char *core_addr_to_string_nz (const CORE_ADDR addr); 536extern CORE_ADDR string_to_core_addr (const char *my_string); 537 538extern void fprintf_symbol_filtered (struct ui_file *, char *, 539 enum language, int); 540 541extern NORETURN void perror_with_name (const char *) ATTR_NORETURN; 542 543extern void print_sys_errmsg (const char *, int); 544 545/* From regex.c or libc. BSD 4.4 declares this with the argument type as 546 "const char *" in unistd.h, so we can't declare the argument 547 as "char *". */ 548 549extern char *re_comp (const char *); 550 551/* From symfile.c */ 552 553extern void symbol_file_command (char *, int); 554 555/* Remote targets may wish to use this as their load function. */ 556extern void generic_load (char *name, int from_tty); 557 558/* Summarise a download */ 559extern void print_transfer_performance (struct ui_file *stream, 560 unsigned long data_count, 561 unsigned long write_count, 562 unsigned long time_count); 563 564/* From top.c */ 565 566typedef void initialize_file_ftype (void); 567 568extern char *skip_quoted (char *); 569 570extern char *gdb_readline (char *); 571 572extern char *gdb_readline_wrapper (char *); 573 574extern char *command_line_input (char *, int, char *); 575 576extern void print_prompt (void); 577 578extern int input_from_terminal_p (void); 579 580extern int info_verbose; 581 582/* From printcmd.c */ 583 584extern void set_next_address (CORE_ADDR); 585 586extern void print_address_symbolic (CORE_ADDR, struct ui_file *, int, 587 char *); 588 589extern int build_address_symbolic (CORE_ADDR addr, 590 int do_demangle, 591 char **name, 592 int *offset, 593 char **filename, 594 int *line, 595 int *unmapped); 596 597extern void print_address_numeric (CORE_ADDR, int, struct ui_file *); 598 599extern void print_address (CORE_ADDR, struct ui_file *); 600 601/* From source.c */ 602 603extern int openp (const char *, int, const char *, int, int, char **); 604 605extern int source_full_path_of (char *, char **); 606 607extern void mod_path (char *, char **); 608 609extern void add_path (char *, char **, int); 610 611extern void directory_command (char *, int); 612 613extern char *source_path; 614 615extern void init_source_path (void); 616 617extern void init_last_source_visited (void); 618 619extern char *symtab_to_filename (struct symtab *); 620 621/* From exec.c */ 622 623extern void exec_set_section_offsets (bfd_signed_vma text_off, 624 bfd_signed_vma data_off, 625 bfd_signed_vma bss_off); 626 627/* Take over the 'find_mapped_memory' vector from exec.c. */ 628extern void exec_set_find_memory_regions (int (*) (int (*) (CORE_ADDR, 629 unsigned long, 630 int, int, int, 631 void *), 632 void *)); 633 634/* Possible lvalue types. Like enum language, this should be in 635 value.h, but needs to be here for the same reason. */ 636 637enum lval_type 638 { 639 /* Not an lval. */ 640 not_lval, 641 /* In memory. Could be a saved register. */ 642 lval_memory, 643 /* In a register. */ 644 lval_register, 645 /* In a gdb internal variable. */ 646 lval_internalvar, 647 /* Part of a gdb internal variable (structure field). */ 648 lval_internalvar_component, 649 /* In a register series in a frame not the current one, which may have been 650 partially saved or saved in different places (otherwise would be 651 lval_register or lval_memory). */ 652 lval_reg_frame_relative 653 }; 654 655/* Control types for commands */ 656 657enum misc_command_type 658 { 659 ok_command, 660 end_command, 661 else_command, 662 nop_command 663 }; 664 665enum command_control_type 666 { 667 simple_control, 668 break_control, 669 continue_control, 670 while_control, 671 if_control, 672 invalid_control 673 }; 674 675/* Structure for saved commands lines 676 (for breakpoints, defined commands, etc). */ 677 678struct command_line 679 { 680 struct command_line *next; 681 char *line; 682 enum command_control_type control_type; 683 int body_count; 684 struct command_line **body_list; 685 }; 686 687extern struct command_line *read_command_lines (char *, int); 688 689extern void free_command_lines (struct command_line **); 690 691/* To continue the execution commands when running gdb asynchronously. 692 A continuation structure contains a pointer to a function to be called 693 to finish the command, once the target has stopped. Such mechanism is 694 used bt the finish and until commands, and in the remote protocol 695 when opening an extended-remote connection. */ 696 697struct continuation_arg 698 { 699 struct continuation_arg *next; 700 union continuation_data { 701 void *pointer; 702 int integer; 703 long longint; 704 } data; 705 }; 706 707struct continuation 708 { 709 void (*continuation_hook) (struct continuation_arg *); 710 struct continuation_arg *arg_list; 711 struct continuation *next; 712 }; 713 714/* In infrun.c. */ 715extern struct continuation *cmd_continuation; 716/* Used only by the step_1 function. */ 717extern struct continuation *intermediate_continuation; 718 719/* From utils.c */ 720extern void add_continuation (void (*)(struct continuation_arg *), 721 struct continuation_arg *); 722extern void do_all_continuations (void); 723extern void discard_all_continuations (void); 724 725extern void add_intermediate_continuation (void (*)(struct continuation_arg *), 726 struct continuation_arg *); 727extern void do_all_intermediate_continuations (void); 728extern void discard_all_intermediate_continuations (void); 729 730/* String containing the current directory (what getwd would return). */ 731 732extern char *current_directory; 733 734/* Default radixes for input and output. Only some values supported. */ 735extern unsigned input_radix; 736extern unsigned output_radix; 737 738/* Possibilities for prettyprint parameters to routines which print 739 things. Like enum language, this should be in value.h, but needs 740 to be here for the same reason. FIXME: If we can eliminate this 741 as an arg to LA_VAL_PRINT, then we can probably move it back to 742 value.h. */ 743 744enum val_prettyprint 745 { 746 Val_no_prettyprint = 0, 747 Val_prettyprint, 748 /* Use the default setting which the user has specified. */ 749 Val_pretty_default 750 }; 751 752/* The ptid struct is a collection of the various "ids" necessary 753 for identifying the inferior. This consists of the process id 754 (pid), thread id (tid), and other fields necessary for uniquely 755 identifying the inferior process/thread being debugged. When 756 manipulating ptids, the constructors, accessors, and predicate 757 declared in inferior.h should be used. These are as follows: 758 759 ptid_build - Make a new ptid from a pid, lwp, and tid. 760 pid_to_ptid - Make a new ptid from just a pid. 761 ptid_get_pid - Fetch the pid component of a ptid. 762 ptid_get_lwp - Fetch the lwp component of a ptid. 763 ptid_get_tid - Fetch the tid component of a ptid. 764 ptid_equal - Test to see if two ptids are equal. 765 766 Please do NOT access the struct ptid members directly (except, of 767 course, in the implementation of the above ptid manipulation 768 functions). */ 769 770struct ptid 771 { 772 /* Process id */ 773 int pid; 774 775 /* Lightweight process id */ 776 long lwp; 777 778 /* Thread id */ 779 long tid; 780 }; 781 782typedef struct ptid ptid_t; 783 784 785 786/* Optional host machine definition. Pure autoconf targets will not 787 need a "xm.h" file. This will be a symlink to one of the xm-*.h 788 files, built by the `configure' script. */ 789 790#ifdef GDB_XM_FILE 791#include "xm.h" 792#endif 793 794/* Optional native machine support. Non-native (and possibly pure 795 multi-arch) targets do not need a "nm.h" file. This will be a 796 symlink to one of the nm-*.h files, built by the `configure' 797 script. */ 798 799#ifdef GDB_NM_FILE 800#include "nm.h" 801#endif 802 803/* Optional target machine definition. Pure multi-arch configurations 804 do not need a "tm.h" file. This will be a symlink to one of the 805 tm-*.h files, built by the `configure' script. */ 806 807#ifdef GDB_TM_FILE 808#include "tm.h" 809#endif 810 811/* If the xm.h file did not define the mode string used to open the 812 files, assume that binary files are opened the same way as text 813 files */ 814#ifndef FOPEN_RB 815#include "fopen-same.h" 816#endif 817 818/* Defaults for system-wide constants (if not defined by xm.h, we fake it). 819 FIXME: Assumes 2's complement arithmetic */ 820 821#if !defined (UINT_MAX) 822#define UINT_MAX ((unsigned int)(~0)) /* 0xFFFFFFFF for 32-bits */ 823#endif 824 825#if !defined (INT_MAX) 826#define INT_MAX ((int)(UINT_MAX >> 1)) /* 0x7FFFFFFF for 32-bits */ 827#endif 828 829#if !defined (INT_MIN) 830#define INT_MIN ((int)((int) ~0 ^ INT_MAX)) /* 0x80000000 for 32-bits */ 831#endif 832 833#if !defined (ULONG_MAX) 834#define ULONG_MAX ((unsigned long)(~0L)) /* 0xFFFFFFFF for 32-bits */ 835#endif 836 837#if !defined (LONG_MAX) 838#define LONG_MAX ((long)(ULONG_MAX >> 1)) /* 0x7FFFFFFF for 32-bits */ 839#endif 840 841#if !defined (ULONGEST_MAX) 842#define ULONGEST_MAX (~(ULONGEST)0) /* 0xFFFFFFFFFFFFFFFF for 64-bits */ 843#endif 844 845#if !defined (LONGEST_MAX) /* 0x7FFFFFFFFFFFFFFF for 64-bits */ 846#define LONGEST_MAX ((LONGEST)(ULONGEST_MAX >> 1)) 847#endif 848 849/* Convert a LONGEST to an int. This is used in contexts (e.g. number of 850 arguments to a function, number in a value history, register number, etc.) 851 where the value must not be larger than can fit in an int. */ 852 853extern int longest_to_int (LONGEST); 854 855/* Assorted functions we can declare, now that const and volatile are 856 defined. */ 857 858extern char *savestring (const char *, size_t); 859 860extern char *msavestring (void *, const char *, size_t); 861 862extern char *mstrsave (void *, const char *); 863 864/* Robust versions of same. Throw an internal error when no memory, 865 guard against stray NULL arguments. */ 866extern void *xmmalloc (void *md, size_t size); 867extern void *xmrealloc (void *md, void *ptr, size_t size); 868extern void *xmcalloc (void *md, size_t number, size_t size); 869extern void xmfree (void *md, void *ptr); 870 871/* xmalloc(), xrealloc() and xcalloc() have already been declared in 872 "libiberty.h". */ 873extern void xfree (void *); 874 875/* Utility macros to allocate typed memory. Avoids errors like: 876 struct foo *foo = xmalloc (sizeof struct bar); and memset (foo, 877 sizeof (struct foo), 0). */ 878#define XZALLOC(TYPE) ((TYPE*) memset (xmalloc (sizeof (TYPE)), 0, sizeof (TYPE))) 879#define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE))) 880#define XCALLOC(NMEMB, TYPE) ((TYPE*) xcalloc ((NMEMB), sizeof (TYPE))) 881 882/* Like asprintf/vasprintf but get an internal_error if the call 883 fails. */ 884extern void xasprintf (char **ret, const char *format, ...) ATTR_FORMAT (printf, 2, 3); 885extern void xvasprintf (char **ret, const char *format, va_list ap); 886 887/* Like asprintf, but return the string, throw an error if no memory. */ 888extern char *xstrprintf (const char *format, ...) ATTR_FORMAT (printf, 1, 2); 889 890extern int parse_escape (char **); 891 892/* Message to be printed before the error message, when an error occurs. */ 893 894extern char *error_pre_print; 895 896/* Message to be printed before the error message, when an error occurs. */ 897 898extern char *quit_pre_print; 899 900/* Message to be printed before the warning message, when a warning occurs. */ 901 902extern char *warning_pre_print; 903 904extern NORETURN void verror (const char *fmt, va_list ap) ATTR_NORETURN; 905 906extern NORETURN void error (const char *fmt, ...) ATTR_NORETURN ATTR_FORMAT (printf, 1, 2); 907 908extern NORETURN void error_silent (const char *fmt, ...) ATTR_NORETURN ATTR_FORMAT (printf, 1, 2); 909 910extern NORETURN void error_stream (struct ui_file *) ATTR_NORETURN; 911 912/* Initialize the error buffer. */ 913extern void error_init (void); 914 915/* Returns a freshly allocate buffer containing the last error 916 message. */ 917extern char *error_last_message (void); 918 919/* Output arbitrary error message. */ 920extern void error_output_message (char *pre_print, char *msg); 921 922extern NORETURN void internal_verror (const char *file, int line, 923 const char *, va_list ap) ATTR_NORETURN; 924 925extern NORETURN void internal_error (const char *file, int line, 926 const char *, ...) ATTR_NORETURN ATTR_FORMAT (printf, 3, 4); 927 928extern void internal_vwarning (const char *file, int line, 929 const char *, va_list ap); 930 931extern void internal_warning (const char *file, int line, 932 const char *, ...) ATTR_FORMAT (printf, 3, 4); 933 934extern NORETURN void nomem (long) ATTR_NORETURN; 935 936/* Reasons for calling throw_exception(). NOTE: all reason values 937 must be less than zero. enum value 0 is reserved for internal use 938 as the return value from an initial setjmp(). The function 939 catch_exceptions() reserves values >= 0 as legal results from its 940 wrapped function. */ 941 942enum return_reason 943 { 944 /* User interrupt. */ 945 RETURN_QUIT = -2, 946 /* Any other error. */ 947 RETURN_ERROR 948 }; 949 950#define ALL_CLEANUPS ((struct cleanup *)0) 951 952#define RETURN_MASK(reason) (1 << (int)(-reason)) 953#define RETURN_MASK_QUIT RETURN_MASK (RETURN_QUIT) 954#define RETURN_MASK_ERROR RETURN_MASK (RETURN_ERROR) 955#define RETURN_MASK_ALL (RETURN_MASK_QUIT | RETURN_MASK_ERROR) 956typedef int return_mask; 957 958/* Throw an exception of type RETURN_REASON. Will execute a LONG JUMP 959 to the inner most containing exception handler established using 960 catch_exceptions() (or the legacy catch_errors()). 961 962 Code normally throws an exception using error() et.al. For various 963 reaons, GDB also contains code that throws an exception directly. 964 For instance, the remote*.c targets contain CNTRL-C signal handlers 965 that propogate the QUIT event up the exception chain. ``This could 966 be a good thing or a dangerous thing.'' -- the Existential Wombat. */ 967 968extern NORETURN void throw_exception (enum return_reason) ATTR_NORETURN; 969 970/* Call FUNC(UIOUT, FUNC_ARGS) but wrapped within an exception 971 handler. If an exception (enum return_reason) is thrown using 972 throw_exception() than all cleanups installed since 973 catch_exceptions() was entered are invoked, the (-ve) exception 974 value is then returned by catch_exceptions. If FUNC() returns 975 normally (with a postive or zero return value) then that value is 976 returned by catch_exceptions(). It is an internal_error() for 977 FUNC() to return a negative value. 978 979 For the period of the FUNC() call: UIOUT is installed as the output 980 builder; ERRSTRING is installed as the error/quit message; and a 981 new cleanup_chain is established. The old values are restored 982 before catch_exceptions() returns. 983 984 The variant catch_exceptions_with_msg() is the same as 985 catch_exceptions() but adds the ability to return an allocated 986 copy of the gdb error message. This is used when a silent error is 987 issued and the caller wants to manually issue the error message. 988 989 FIXME; cagney/2001-08-13: The need to override the global UIOUT 990 builder variable should just go away. 991 992 This function superseeds catch_errors(). 993 994 This function uses SETJMP() and LONGJUMP(). */ 995 996struct ui_out; 997typedef int (catch_exceptions_ftype) (struct ui_out *ui_out, void *args); 998extern int catch_exceptions (struct ui_out *uiout, 999 catch_exceptions_ftype *func, void *func_args, 1000 char *errstring, return_mask mask); 1001extern int catch_exceptions_with_msg (struct ui_out *uiout, 1002 catch_exceptions_ftype *func, 1003 void *func_args, 1004 char *errstring, char **gdberrmsg, 1005 return_mask mask); 1006 1007/* If CATCH_ERRORS_FTYPE throws an error, catch_errors() returns zero 1008 otherwize the result from CATCH_ERRORS_FTYPE is returned. It is 1009 probably useful for CATCH_ERRORS_FTYPE to always return a non-zero 1010 value. It's unfortunate that, catch_errors() does not return an 1011 indication of the exact exception that it caught - quit_flag might 1012 help. 1013 1014 This function is superseeded by catch_exceptions(). */ 1015 1016typedef int (catch_errors_ftype) (void *); 1017extern int catch_errors (catch_errors_ftype *, void *, char *, return_mask); 1018 1019/* Template to catch_errors() that wraps calls to command 1020 functions. */ 1021 1022typedef void (catch_command_errors_ftype) (char *, int); 1023extern int catch_command_errors (catch_command_errors_ftype *func, char *command, int from_tty, return_mask); 1024 1025extern void warning (const char *, ...) ATTR_FORMAT (printf, 1, 2); 1026 1027extern void vwarning (const char *, va_list args); 1028 1029/* List of known OS ABIs. If you change this, make sure to update the 1030 table in osabi.c. */ 1031enum gdb_osabi 1032{ 1033 GDB_OSABI_UNINITIALIZED = -1, /* For struct gdbarch_info. */ 1034 1035 GDB_OSABI_UNKNOWN = 0, /* keep this zero */ 1036 1037 GDB_OSABI_SVR4, 1038 GDB_OSABI_HURD, 1039 GDB_OSABI_SOLARIS, 1040 GDB_OSABI_OSF1, 1041 GDB_OSABI_LINUX, 1042 GDB_OSABI_FREEBSD_AOUT, 1043 GDB_OSABI_FREEBSD_ELF, 1044 GDB_OSABI_NETBSD_AOUT, 1045 GDB_OSABI_NETBSD_ELF, 1046 GDB_OSABI_OPENBSD_ELF, 1047 GDB_OSABI_WINCE, 1048 GDB_OSABI_GO32, 1049 GDB_OSABI_NETWARE, 1050 GDB_OSABI_IRIX, 1051 GDB_OSABI_LYNXOS, 1052 GDB_OSABI_INTERIX, 1053 GDB_OSABI_HPUX_ELF, 1054 GDB_OSABI_HPUX_SOM, 1055 1056 GDB_OSABI_ARM_EABI_V1, 1057 GDB_OSABI_ARM_EABI_V2, 1058 GDB_OSABI_ARM_APCS, 1059 GDB_OSABI_QNXNTO, 1060 1061 GDB_OSABI_CYGWIN, 1062 1063 GDB_OSABI_INVALID /* keep this last */ 1064}; 1065 1066/* Global functions from other, non-gdb GNU thingies. 1067 Libiberty thingies are no longer declared here. We include libiberty.h 1068 above, instead. */ 1069 1070#ifndef GETENV_PROVIDED 1071extern char *getenv (const char *); 1072#endif 1073 1074/* From other system libraries */ 1075 1076#ifdef HAVE_STDDEF_H 1077#include <stddef.h> 1078#endif 1079 1080#ifdef HAVE_STDLIB_H 1081#include <stdlib.h> 1082#endif 1083#ifndef min 1084#define min(a, b) ((a) < (b) ? (a) : (b)) 1085#endif 1086#ifndef max 1087#define max(a, b) ((a) > (b) ? (a) : (b)) 1088#endif 1089 1090 1091/* We take the address of fclose later, but some stdio's forget 1092 to declare this. We can't always declare it since there's 1093 no way to declare the parameters without upsetting some compiler 1094 somewhere. */ 1095 1096#ifndef FCLOSE_PROVIDED 1097extern int fclose (FILE *); 1098#endif 1099 1100#ifndef atof 1101extern double atof (const char *); /* X3.159-1989 4.10.1.1 */ 1102#endif 1103 1104/* Various possibilities for alloca. */ 1105#ifndef alloca 1106#ifdef __GNUC__ 1107#define alloca __builtin_alloca 1108#else /* Not GNU C */ 1109#ifdef HAVE_ALLOCA_H 1110#include <alloca.h> 1111#else 1112#ifdef _AIX 1113#pragma alloca 1114#else 1115 1116/* We need to be careful not to declare this in a way which conflicts with 1117 bison. Bison never declares it as char *, but under various circumstances 1118 (like __hpux) we need to use void *. */ 1119extern void *alloca (); 1120#endif /* Not _AIX */ 1121#endif /* Not HAVE_ALLOCA_H */ 1122#endif /* Not GNU C */ 1123#endif /* alloca not defined */ 1124 1125/* Is GDB multi-arch? If there's a "tm.h" file, it is not. */ 1126#ifndef GDB_MULTI_ARCH 1127#ifdef GDB_TM_FILE 1128#define GDB_MULTI_ARCH GDB_MULTI_ARCH_PARTIAL 1129#else 1130#define GDB_MULTI_ARCH GDB_MULTI_ARCH_PURE 1131#endif 1132#endif 1133 1134/* Dynamic target-system-dependent parameters for GDB. */ 1135#include "gdbarch.h" 1136 1137/* Maximum size of a register. Something small, but large enough for 1138 all known ISAs. If it turns out to be too small, make it bigger. */ 1139 1140enum { MAX_REGISTER_SIZE = 16 }; 1141 1142/* Static target-system-dependent parameters for GDB. */ 1143 1144/* Number of bits in a char or unsigned char for the target machine. 1145 Just like CHAR_BIT in <limits.h> but describes the target machine. */ 1146#if !defined (TARGET_CHAR_BIT) 1147#define TARGET_CHAR_BIT 8 1148#endif 1149 1150/* If we picked up a copy of CHAR_BIT from a configuration file 1151 (which may get it by including <limits.h>) then use it to set 1152 the number of bits in a host char. If not, use the same size 1153 as the target. */ 1154 1155#if defined (CHAR_BIT) 1156#define HOST_CHAR_BIT CHAR_BIT 1157#else 1158#define HOST_CHAR_BIT TARGET_CHAR_BIT 1159#endif 1160 1161/* The bit byte-order has to do just with numbering of bits in 1162 debugging symbols and such. Conceptually, it's quite separate 1163 from byte/word byte order. */ 1164 1165#if !defined (BITS_BIG_ENDIAN) 1166#define BITS_BIG_ENDIAN (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) 1167#endif 1168 1169/* In findvar.c. */ 1170 1171extern LONGEST extract_signed_integer (const void *, int); 1172 1173extern ULONGEST extract_unsigned_integer (const void *, int); 1174 1175extern int extract_long_unsigned_integer (const void *, int, LONGEST *); 1176 1177extern CORE_ADDR extract_typed_address (const void *buf, struct type *type); 1178 1179extern void store_signed_integer (void *, int, LONGEST); 1180 1181extern void store_unsigned_integer (void *, int, ULONGEST); 1182 1183extern void store_typed_address (void *buf, struct type *type, CORE_ADDR addr); 1184 1185 1186/* From valops.c */ 1187 1188extern CORE_ADDR push_bytes (CORE_ADDR, char *, int); 1189 1190extern CORE_ADDR push_word (CORE_ADDR, ULONGEST); 1191 1192extern int watchdog; 1193 1194/* Hooks for alternate command interfaces. */ 1195 1196/* The name of the interpreter if specified on the command line. */ 1197extern char *interpreter_p; 1198 1199/* If a given interpreter matches INTERPRETER_P then it should update 1200 command_loop_hook and init_ui_hook with the per-interpreter 1201 implementation. */ 1202/* FIXME: command_loop_hook and init_ui_hook should be moved here. */ 1203 1204struct target_waitstatus; 1205struct cmd_list_element; 1206 1207/* Should the asynchronous variant of the interpreter (using the 1208 event-loop) be enabled? */ 1209extern int event_loop_p; 1210 1211extern void (*init_ui_hook) (char *argv0); 1212extern void (*command_loop_hook) (void); 1213extern void (*show_load_progress) (const char *section, 1214 unsigned long section_sent, 1215 unsigned long section_size, 1216 unsigned long total_sent, 1217 unsigned long total_size); 1218extern void (*print_frame_info_listing_hook) (struct symtab * s, 1219 int line, int stopline, 1220 int noerror); 1221extern struct frame_info *parse_frame_specification (char *frame_exp); 1222extern int (*query_hook) (const char *, va_list); 1223extern void (*warning_hook) (const char *, va_list); 1224extern void (*flush_hook) (struct ui_file * stream); 1225extern void (*create_breakpoint_hook) (struct breakpoint * b); 1226extern void (*delete_breakpoint_hook) (struct breakpoint * bpt); 1227extern void (*modify_breakpoint_hook) (struct breakpoint * bpt); 1228extern void (*interactive_hook) (void); 1229extern void (*registers_changed_hook) (void); 1230extern void (*readline_begin_hook) (char *,...); 1231extern char *(*readline_hook) (char *); 1232extern void (*readline_end_hook) (void); 1233extern void (*register_changed_hook) (int regno); 1234extern void (*memory_changed_hook) (CORE_ADDR addr, int len); 1235extern void (*context_hook) (int); 1236extern ptid_t (*target_wait_hook) (ptid_t ptid, 1237 struct target_waitstatus * status); 1238 1239extern void (*attach_hook) (void); 1240extern void (*detach_hook) (void); 1241extern void (*call_command_hook) (struct cmd_list_element * c, 1242 char *cmd, int from_tty); 1243 1244extern void (*set_hook) (struct cmd_list_element * c); 1245 1246extern NORETURN void (*error_hook) (void) ATTR_NORETURN; 1247 1248extern void (*error_begin_hook) (void); 1249 1250extern int (*ui_load_progress_hook) (const char *section, unsigned long num); 1251 1252 1253/* Inhibit window interface if non-zero. */ 1254 1255extern int use_windows; 1256 1257/* Symbolic definitions of filename-related things. */ 1258/* FIXME, this doesn't work very well if host and executable 1259 filesystems conventions are different. */ 1260 1261#ifndef DIRNAME_SEPARATOR 1262#define DIRNAME_SEPARATOR ':' 1263#endif 1264 1265#ifndef SLASH_STRING 1266#define SLASH_STRING "/" 1267#endif 1268 1269#ifdef __MSDOS__ 1270# define CANT_FORK 1271# define GLOBAL_CURDIR 1272#endif 1273 1274/* Provide default definitions of PIDGET, TIDGET, and MERGEPID. 1275 The name ``TIDGET'' is a historical accident. Many uses of TIDGET 1276 in the code actually refer to a lightweight process id, i.e, 1277 something that can be considered a process id in its own right for 1278 certain purposes. */ 1279 1280#ifndef PIDGET 1281#define PIDGET(PTID) (ptid_get_pid (PTID)) 1282#define TIDGET(PTID) (ptid_get_lwp (PTID)) 1283#define MERGEPID(PID, TID) ptid_build (PID, TID, 0) 1284#endif 1285 1286/* Define well known filenos if the system does not define them. */ 1287#ifndef STDIN_FILENO 1288#define STDIN_FILENO 0 1289#endif 1290#ifndef STDOUT_FILENO 1291#define STDOUT_FILENO 1 1292#endif 1293#ifndef STDERR_FILENO 1294#define STDERR_FILENO 2 1295#endif 1296 1297/* If this definition isn't overridden by the header files, assume 1298 that isatty and fileno exist on this system. */ 1299#ifndef ISATTY 1300#define ISATTY(FP) (isatty (fileno (FP))) 1301#endif 1302 1303/* Ensure that V is aligned to an N byte boundary (B's assumed to be a 1304 power of 2). Round up/down when necessary. Examples of correct 1305 use include: 1306 1307 addr = align_up (addr, 8); -- VALUE needs 8 byte alignment 1308 write_memory (addr, value, len); 1309 addr += len; 1310 1311 and: 1312 1313 sp = align_down (sp - len, 16); -- Keep SP 16 byte aligned 1314 write_memory (sp, value, len); 1315 1316 Note that uses such as: 1317 1318 write_memory (addr, value, len); 1319 addr += align_up (len, 8); 1320 1321 and: 1322 1323 sp -= align_up (len, 8); 1324 write_memory (sp, value, len); 1325 1326 are typically not correct as they don't ensure that the address (SP 1327 or ADDR) is correctly aligned (relying on previous alignment to 1328 keep things right). This is also why the methods are called 1329 "align_..." instead of "round_..." as the latter reads better with 1330 this incorrect coding style. */ 1331 1332extern ULONGEST align_up (ULONGEST v, int n); 1333extern ULONGEST align_down (ULONGEST v, int n); 1334 1335#endif /* #ifndef DEFS_H */ 1336