sdbout.c revision 117395
160107Sobrien/* Output sdb-format symbol table information from GNU compiler. 216877Ssos Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 316877Ssos 2000, 2001, 2002 Free Software Foundation, Inc. 416877Ssos 516877SsosThis file is part of GCC. 616877Ssos 716877SsosGCC is free software; you can redistribute it and/or modify it under 816877Ssosthe terms of the GNU General Public License as published by the Free 916877SsosSoftware Foundation; either version 2, or (at your option) any later 1016877Ssosversion. 1116877Ssos 1216877SsosGCC is distributed in the hope that it will be useful, but WITHOUT ANY 1316877SsosWARRANTY; without even the implied warranty of MERCHANTABILITY or 1416877SsosFITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 1516877Ssosfor more details. 1616877Ssos 1716877SsosYou should have received a copy of the GNU General Public License 1816877Ssosalong with GCC; see the file COPYING. If not, write to the Free 1916877SsosSoftware Foundation, 59 Temple Place - Suite 330, Boston, MA 2016877Ssos02111-1307, USA. */ 2116877Ssos 2216877Ssos/* mike@tredysvr.Tredydev.Unisys.COM says: 2316877SsosI modified the struct.c example and have a nm of a .o resulting from the 2416877SsosAT&T C compiler. From the example below I would conclude the following: 2516877Ssos 2616877Ssos1. All .defs from structures are emitted as scanned. The example below 2716877Ssos clearly shows the symbol table entries for BoxRec2 are after the first 2816877Ssos function. 2916877Ssos 3016877Ssos2. All functions and their locals (including statics) are emitted as scanned. 3116877Ssos 3216877Ssos3. All nested unnamed union and structure .defs must be emitted before 3316877Ssos the structure in which they are nested. The AT&T assembler is a 3416877Ssos one pass beast as far as symbolics are concerned. 3516877Ssos 3616877Ssos4. All structure .defs are emitted before the typedefs that refer to them. 3716877Ssos 3816877Ssos5. All top level static and external variable definitions are moved to the 3916877Ssos end of file with all top level statics occurring first before externs. 4016877Ssos 4116877Ssos6. All undefined references are at the end of the file. 4216877Ssos*/ 4316877Ssos 4416877Ssos#include "config.h" 4516877Ssos#include "system.h" 4616877Ssos#include "debug.h" 4716877Ssos#include "tree.h" 4816877Ssos#include "ggc.h" 4916877Ssos 5016877Ssosstatic GTY(()) tree anonymous_types; 5116877Ssos 5216877Ssos#ifdef SDB_DEBUGGING_INFO 5316877Ssos 5416877Ssos#include "rtl.h" 5516877Ssos#include "regs.h" 5616877Ssos#include "flags.h" 5716877Ssos#include "insn-config.h" 5816877Ssos#include "reload.h" 5938140Syokota#include "output.h" 6016877Ssos#include "toplev.h" 6116877Ssos#include "tm_p.h" 6216877Ssos#include "gsyms.h" 6332822Syokota#include "langhooks.h" 6416877Ssos 6516877Ssos/* 1 if PARM is passed to this function in memory. */ 6616877Ssos 6716877Ssos#define PARM_PASSED_IN_MEMORY(PARM) \ 6816877Ssos (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM) 6916877Ssos 7016877Ssos/* A C expression for the integer offset value of an automatic variable 7116877Ssos (C_AUTO) having address X (an RTX). */ 7216877Ssos#ifndef DEBUGGER_AUTO_OFFSET 7316877Ssos#define DEBUGGER_AUTO_OFFSET(X) \ 7416877Ssos (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0) 7516877Ssos#endif 7616877Ssos 7716877Ssos/* A C expression for the integer offset value of an argument (C_ARG) 7816877Ssos having address X (an RTX). The nominal offset is OFFSET. */ 7916877Ssos#ifndef DEBUGGER_ARG_OFFSET 8016877Ssos#define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET) 8116877Ssos#endif 8216877Ssos 8316877Ssos/* Line number of beginning of current function, minus one. 8416877Ssos Negative means not in a function or not using sdb. */ 8516877Ssos 8616877Ssosint sdb_begin_function_line = -1; 8716877Ssos 8816877Ssos/* Counter to generate unique "names" for nameless struct members. */ 8916877Ssos 9016877Ssosstatic int unnamed_struct_number = 0; 9116877Ssos 9216877Ssosextern FILE *asm_out_file; 9316877Ssos 9416877Ssosextern tree current_function_decl; 9518194Ssos 9616877Ssos#include "sdbout.h" 9716877Ssos 9874119Sachestatic void sdbout_init PARAMS ((const char *)); 9916877Ssosstatic void sdbout_finish PARAMS ((const char *)); 10016877Ssosstatic void sdbout_start_source_file PARAMS ((unsigned int, const char *)); 10116877Ssosstatic void sdbout_end_source_file PARAMS ((unsigned int)); 10216877Ssosstatic void sdbout_begin_block PARAMS ((unsigned int, unsigned int)); 10316877Ssosstatic void sdbout_end_block PARAMS ((unsigned int, unsigned int)); 10416877Ssosstatic void sdbout_source_line PARAMS ((unsigned int, const char *)); 10516877Ssosstatic void sdbout_end_epilogue PARAMS ((unsigned int, const char *)); 10616877Ssosstatic void sdbout_global_decl PARAMS ((tree)); 10716877Ssos#ifndef MIPS_DEBUGGING_INFO 10874119Sachestatic void sdbout_begin_prologue PARAMS ((unsigned int, const char *)); 10916877Ssos#endif 11043334Syokotastatic void sdbout_end_prologue PARAMS ((unsigned int, const char *)); 11143334Syokotastatic void sdbout_begin_function PARAMS ((tree)); 11243334Syokotastatic void sdbout_end_function PARAMS ((unsigned int)); 11343334Syokotastatic void sdbout_toplevel_data PARAMS ((tree)); 11443334Syokotastatic void sdbout_label PARAMS ((rtx)); 115static char *gen_fake_label PARAMS ((void)); 116static int plain_type PARAMS ((tree)); 117static int template_name_p PARAMS ((tree)); 118static void sdbout_record_type_name PARAMS ((tree)); 119static int plain_type_1 PARAMS ((tree, int)); 120static void sdbout_block PARAMS ((tree)); 121static void sdbout_syms PARAMS ((tree)); 122#ifdef SDB_ALLOW_FORWARD_REFERENCES 123static void sdbout_queue_anonymous_type PARAMS ((tree)); 124static void sdbout_dequeue_anonymous_types PARAMS ((void)); 125#endif 126static void sdbout_type PARAMS ((tree)); 127static void sdbout_field_types PARAMS ((tree)); 128static void sdbout_one_type PARAMS ((tree)); 129static void sdbout_parms PARAMS ((tree)); 130static void sdbout_reg_parms PARAMS ((tree)); 131static void sdbout_global_decl PARAMS ((tree)); 132 133/* Random macros describing parts of SDB data. */ 134 135/* Put something here if lines get too long */ 136#define CONTIN 137 138/* Default value of delimiter is ";". */ 139#ifndef SDB_DELIM 140#define SDB_DELIM ";" 141#endif 142 143/* Maximum number of dimensions the assembler will allow. */ 144#ifndef SDB_MAX_DIM 145#define SDB_MAX_DIM 4 146#endif 147 148#ifndef PUT_SDB_SCL 149#define PUT_SDB_SCL(a) fprintf(asm_out_file, "\t.scl\t%d%s", (a), SDB_DELIM) 150#endif 151 152#ifndef PUT_SDB_INT_VAL 153#define PUT_SDB_INT_VAL(a) \ 154 do { \ 155 fputs ("\t.val\t", asm_out_file); \ 156 fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC, (HOST_WIDE_INT) (a)); \ 157 fprintf (asm_out_file, "%s", SDB_DELIM); \ 158 } while (0) 159 160#endif 161 162#ifndef PUT_SDB_VAL 163#define PUT_SDB_VAL(a) \ 164( fputs ("\t.val\t", asm_out_file), \ 165 output_addr_const (asm_out_file, (a)), \ 166 fprintf (asm_out_file, SDB_DELIM)) 167#endif 168 169#ifndef PUT_SDB_DEF 170#define PUT_SDB_DEF(a) \ 171do { fprintf (asm_out_file, "\t.def\t"); \ 172 assemble_name (asm_out_file, a); \ 173 fprintf (asm_out_file, SDB_DELIM); } while (0) 174#endif 175 176#ifndef PUT_SDB_PLAIN_DEF 177#define PUT_SDB_PLAIN_DEF(a) fprintf(asm_out_file,"\t.def\t.%s%s",a, SDB_DELIM) 178#endif 179 180#ifndef PUT_SDB_ENDEF 181#define PUT_SDB_ENDEF fputs("\t.endef\n", asm_out_file) 182#endif 183 184#ifndef PUT_SDB_TYPE 185#define PUT_SDB_TYPE(a) fprintf(asm_out_file, "\t.type\t0%o%s", a, SDB_DELIM) 186#endif 187 188#ifndef PUT_SDB_SIZE 189#define PUT_SDB_SIZE(a) \ 190 do { \ 191 fputs ("\t.size\t", asm_out_file); \ 192 fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC, (HOST_WIDE_INT) (a)); \ 193 fprintf (asm_out_file, "%s", SDB_DELIM); \ 194 } while(0) 195#endif 196 197#ifndef PUT_SDB_START_DIM 198#define PUT_SDB_START_DIM fprintf(asm_out_file, "\t.dim\t") 199#endif 200 201#ifndef PUT_SDB_NEXT_DIM 202#define PUT_SDB_NEXT_DIM(a) fprintf(asm_out_file, "%d,", a) 203#endif 204 205#ifndef PUT_SDB_LAST_DIM 206#define PUT_SDB_LAST_DIM(a) fprintf(asm_out_file, "%d%s", a, SDB_DELIM) 207#endif 208 209#ifndef PUT_SDB_TAG 210#define PUT_SDB_TAG(a) \ 211do { fprintf (asm_out_file, "\t.tag\t"); \ 212 assemble_name (asm_out_file, a); \ 213 fprintf (asm_out_file, SDB_DELIM); } while (0) 214#endif 215 216#ifndef PUT_SDB_BLOCK_START 217#define PUT_SDB_BLOCK_START(LINE) \ 218 fprintf (asm_out_file, \ 219 "\t.def\t.bb%s\t.val\t.%s\t.scl\t100%s\t.line\t%d%s\t.endef\n", \ 220 SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM) 221#endif 222 223#ifndef PUT_SDB_BLOCK_END 224#define PUT_SDB_BLOCK_END(LINE) \ 225 fprintf (asm_out_file, \ 226 "\t.def\t.eb%s\t.val\t.%s\t.scl\t100%s\t.line\t%d%s\t.endef\n", \ 227 SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM) 228#endif 229 230#ifndef PUT_SDB_FUNCTION_START 231#define PUT_SDB_FUNCTION_START(LINE) \ 232 fprintf (asm_out_file, \ 233 "\t.def\t.bf%s\t.val\t.%s\t.scl\t101%s\t.line\t%d%s\t.endef\n", \ 234 SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM) 235#endif 236 237#ifndef PUT_SDB_FUNCTION_END 238#define PUT_SDB_FUNCTION_END(LINE) \ 239 fprintf (asm_out_file, \ 240 "\t.def\t.ef%s\t.val\t.%s\t.scl\t101%s\t.line\t%d%s\t.endef\n", \ 241 SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM) 242#endif 243 244#ifndef SDB_GENERATE_FAKE 245#define SDB_GENERATE_FAKE(BUFFER, NUMBER) \ 246 sprintf ((BUFFER), ".%dfake", (NUMBER)); 247#endif 248 249/* Return the sdb tag identifier string for TYPE 250 if TYPE has already been defined; otherwise return a null pointer. */ 251 252#define KNOWN_TYPE_TAG(type) TYPE_SYMTAB_POINTER (type) 253 254/* Set the sdb tag identifier string for TYPE to NAME. */ 255 256#define SET_KNOWN_TYPE_TAG(TYPE, NAME) \ 257 TYPE_SYMTAB_POINTER (TYPE) = (NAME) 258 259/* Return the name (a string) of the struct, union or enum tag 260 described by the TREE_LIST node LINK. This is 0 for an anonymous one. */ 261 262#define TAG_NAME(link) \ 263 (((link) && TREE_PURPOSE ((link)) \ 264 && IDENTIFIER_POINTER (TREE_PURPOSE ((link)))) \ 265 ? IDENTIFIER_POINTER (TREE_PURPOSE ((link))) : (char *) 0) 266 267/* Ensure we don't output a negative line number. */ 268#define MAKE_LINE_SAFE(line) \ 269 if ((int) line <= sdb_begin_function_line) \ 270 line = sdb_begin_function_line + 1 271 272/* Perform linker optimization of merging header file definitions together 273 for targets with MIPS_DEBUGGING_INFO defined. This won't work without a 274 post 960826 version of GAS. Nothing breaks with earlier versions of GAS, 275 the optimization just won't be done. The native assembler already has the 276 necessary support. */ 277 278#ifdef MIPS_DEBUGGING_INFO 279 280#ifndef PUT_SDB_SRC_FILE 281#define PUT_SDB_SRC_FILE(FILENAME) \ 282output_file_directive (asm_out_file, (FILENAME)) 283#endif 284 285/* ECOFF linkers have an optimization that does the same kind of thing as 286 N_BINCL/E_INCL in stabs: eliminate duplicate debug information in the 287 executable. To achieve this, GCC must output a .file for each file 288 name change. */ 289 290/* This is a stack of input files. */ 291 292struct sdb_file 293{ 294 struct sdb_file *next; 295 const char *name; 296}; 297 298/* This is the top of the stack. */ 299 300static struct sdb_file *current_file; 301 302#endif /* MIPS_DEBUGGING_INFO */ 303 304/* The debug hooks structure. */ 305const struct gcc_debug_hooks sdb_debug_hooks = 306{ 307 sdbout_init, /* init */ 308 sdbout_finish, /* finish */ 309 debug_nothing_int_charstar, /* define */ 310 debug_nothing_int_charstar, /* undef */ 311 sdbout_start_source_file, /* start_source_file */ 312 sdbout_end_source_file, /* end_source_file */ 313 sdbout_begin_block, /* begin_block */ 314 sdbout_end_block, /* end_block */ 315 debug_true_tree, /* ignore_block */ 316 sdbout_source_line, /* source_line */ 317#ifdef MIPS_DEBUGGING_INFO 318 /* Defer on MIPS systems so that parameter descriptions follow 319 function entry. */ 320 debug_nothing_int_charstar, /* begin_prologue */ 321 sdbout_end_prologue, /* end_prologue */ 322#else 323 sdbout_begin_prologue, /* begin_prologue */ 324 debug_nothing_int_charstar, /* end_prologue */ 325#endif 326 sdbout_end_epilogue, /* end_epilogue */ 327 sdbout_begin_function, /* begin_function */ 328 sdbout_end_function, /* end_function */ 329 debug_nothing_tree, /* function_decl */ 330 sdbout_global_decl, /* global_decl */ 331 debug_nothing_tree, /* deferred_inline_function */ 332 debug_nothing_tree, /* outlining_inline_function */ 333 sdbout_label 334}; 335 336#if 0 337 338/* return the tag identifier for type 339 */ 340 341char * 342tag_of_ru_type (type,link) 343 tree type,link; 344{ 345 if (TYPE_SYMTAB_ADDRESS (type)) 346 return TYPE_SYMTAB_ADDRESS (type); 347 if (link && TREE_PURPOSE (link) 348 && IDENTIFIER_POINTER (TREE_PURPOSE (link))) 349 TYPE_SYMTAB_ADDRESS (type) = IDENTIFIER_POINTER (TREE_PURPOSE (link)); 350 else 351 return (char *) TYPE_SYMTAB_ADDRESS (type); 352} 353#endif 354 355/* Return a unique string to name an anonymous type. */ 356 357static char * 358gen_fake_label () 359{ 360 char label[10]; 361 char *labelstr; 362 SDB_GENERATE_FAKE (label, unnamed_struct_number); 363 unnamed_struct_number++; 364 labelstr = xstrdup (label); 365 return labelstr; 366} 367 368/* Return the number which describes TYPE for SDB. 369 For pointers, etc., this function is recursive. 370 Each record, union or enumeral type must already have had a 371 tag number output. */ 372 373/* The number is given by d6d5d4d3d2d1bbbb 374 where bbbb is 4 bit basic type, and di indicate one of notype,ptr,fn,array. 375 Thus, char *foo () has bbbb=T_CHAR 376 d1=D_FCN 377 d2=D_PTR 378 N_BTMASK= 017 1111 basic type field. 379 N_TSHIFT= 2 derived type shift 380 N_BTSHFT= 4 Basic type shift */ 381 382/* Produce the number that describes a pointer, function or array type. 383 PREV is the number describing the target, value or element type. 384 DT_type describes how to transform that type. */ 385#define PUSH_DERIVED_LEVEL(DT_type,PREV) \ 386 ((((PREV) & ~(int) N_BTMASK) << (int) N_TSHIFT) \ 387 | ((int) DT_type << (int) N_BTSHFT) \ 388 | ((PREV) & (int) N_BTMASK)) 389 390/* Number of elements used in sdb_dims. */ 391static int sdb_n_dims = 0; 392 393/* Table of array dimensions of current type. */ 394static int sdb_dims[SDB_MAX_DIM]; 395 396/* Size of outermost array currently being processed. */ 397static int sdb_type_size = -1; 398 399static int 400plain_type (type) 401 tree type; 402{ 403 int val = plain_type_1 (type, 0); 404 405 /* If we have already saved up some array dimensions, print them now. */ 406 if (sdb_n_dims > 0) 407 { 408 int i; 409 PUT_SDB_START_DIM; 410 for (i = sdb_n_dims - 1; i > 0; i--) 411 PUT_SDB_NEXT_DIM (sdb_dims[i]); 412 PUT_SDB_LAST_DIM (sdb_dims[0]); 413 sdb_n_dims = 0; 414 415 sdb_type_size = int_size_in_bytes (type); 416 /* Don't kill sdb if type is not laid out or has variable size. */ 417 if (sdb_type_size < 0) 418 sdb_type_size = 0; 419 } 420 /* If we have computed the size of an array containing this type, 421 print it now. */ 422 if (sdb_type_size >= 0) 423 { 424 PUT_SDB_SIZE (sdb_type_size); 425 sdb_type_size = -1; 426 } 427 return val; 428} 429 430static int 431template_name_p (name) 432 tree name; 433{ 434 const char *ptr = IDENTIFIER_POINTER (name); 435 while (*ptr && *ptr != '<') 436 ptr++; 437 438 return *ptr != '\0'; 439} 440 441static void 442sdbout_record_type_name (type) 443 tree type; 444{ 445 const char *name = 0; 446 int no_name; 447 448 if (KNOWN_TYPE_TAG (type)) 449 return; 450 451 if (TYPE_NAME (type) != 0) 452 { 453 tree t = 0; 454 455 /* Find the IDENTIFIER_NODE for the type name. */ 456 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE) 457 t = TYPE_NAME (type); 458 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL) 459 { 460 t = DECL_NAME (TYPE_NAME (type)); 461 /* The DECL_NAME for templates includes "<>", which breaks 462 most assemblers. Use its assembler name instead, which 463 has been mangled into being safe. */ 464 if (t && template_name_p (t)) 465 t = DECL_ASSEMBLER_NAME (TYPE_NAME (type)); 466 } 467 468 /* Now get the name as a string, or invent one. */ 469 if (t != NULL_TREE) 470 name = IDENTIFIER_POINTER (t); 471 } 472 473 no_name = (name == 0 || *name == 0); 474 if (no_name) 475 name = gen_fake_label (); 476 477 SET_KNOWN_TYPE_TAG (type, name); 478#ifdef SDB_ALLOW_FORWARD_REFERENCES 479 if (no_name) 480 sdbout_queue_anonymous_type (type); 481#endif 482} 483 484/* Return the .type value for type TYPE. 485 486 LEVEL indicates how many levels deep we have recursed into the type. 487 The SDB debug format can only represent 6 derived levels of types. 488 After that, we must output inaccurate debug info. We deliberately 489 stop before the 7th level, so that ADA recursive types will not give an 490 infinite loop. */ 491 492static int 493plain_type_1 (type, level) 494 tree type; 495 int level; 496{ 497 if (type == 0) 498 type = void_type_node; 499 else if (type == error_mark_node) 500 type = integer_type_node; 501 else 502 type = TYPE_MAIN_VARIANT (type); 503 504 switch (TREE_CODE (type)) 505 { 506 case VOID_TYPE: 507 return T_VOID; 508 case BOOLEAN_TYPE: 509 case INTEGER_TYPE: 510 { 511 int size = int_size_in_bytes (type) * BITS_PER_UNIT; 512 513 /* Carefully distinguish all the standard types of C, 514 without messing up if the language is not C. 515 Note that we check only for the names that contain spaces; 516 other names might occur by coincidence in other languages. */ 517 if (TYPE_NAME (type) != 0 518 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 519 && DECL_NAME (TYPE_NAME (type)) != 0 520 && TREE_CODE (DECL_NAME (TYPE_NAME (type))) == IDENTIFIER_NODE) 521 { 522 const char *const name 523 = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))); 524 525 if (!strcmp (name, "char")) 526 return T_CHAR; 527 if (!strcmp (name, "unsigned char")) 528 return T_UCHAR; 529 if (!strcmp (name, "signed char")) 530 return T_CHAR; 531 if (!strcmp (name, "int")) 532 return T_INT; 533 if (!strcmp (name, "unsigned int")) 534 return T_UINT; 535 if (!strcmp (name, "short int")) 536 return T_SHORT; 537 if (!strcmp (name, "short unsigned int")) 538 return T_USHORT; 539 if (!strcmp (name, "long int")) 540 return T_LONG; 541 if (!strcmp (name, "long unsigned int")) 542 return T_ULONG; 543 } 544 545 if (size == INT_TYPE_SIZE) 546 return (TREE_UNSIGNED (type) ? T_UINT : T_INT); 547 if (size == CHAR_TYPE_SIZE) 548 return (TREE_UNSIGNED (type) ? T_UCHAR : T_CHAR); 549 if (size == SHORT_TYPE_SIZE) 550 return (TREE_UNSIGNED (type) ? T_USHORT : T_SHORT); 551 if (size == LONG_TYPE_SIZE) 552 return (TREE_UNSIGNED (type) ? T_ULONG : T_LONG); 553 if (size == LONG_LONG_TYPE_SIZE) /* better than nothing */ 554 return (TREE_UNSIGNED (type) ? T_ULONG : T_LONG); 555 return 0; 556 } 557 558 case REAL_TYPE: 559 { 560 int precision = TYPE_PRECISION (type); 561 if (precision == FLOAT_TYPE_SIZE) 562 return T_FLOAT; 563 if (precision == DOUBLE_TYPE_SIZE) 564 return T_DOUBLE; 565#ifdef EXTENDED_SDB_BASIC_TYPES 566 if (precision == LONG_DOUBLE_TYPE_SIZE) 567 return T_LNGDBL; 568#else 569 if (precision == LONG_DOUBLE_TYPE_SIZE) 570 return T_DOUBLE; /* better than nothing */ 571#endif 572 return 0; 573 } 574 575 case ARRAY_TYPE: 576 { 577 int m; 578 if (level >= 6) 579 return T_VOID; 580 else 581 m = plain_type_1 (TREE_TYPE (type), level+1); 582 if (sdb_n_dims < SDB_MAX_DIM) 583 sdb_dims[sdb_n_dims++] 584 = (TYPE_DOMAIN (type) 585 && TYPE_MIN_VALUE (TYPE_DOMAIN (type)) != 0 586 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != 0 587 && host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), 0) 588 && host_integerp (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0) 589 ? (tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), 0) 590 - tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0) + 1) 591 : 0); 592 593 return PUSH_DERIVED_LEVEL (DT_ARY, m); 594 } 595 596 case RECORD_TYPE: 597 case UNION_TYPE: 598 case QUAL_UNION_TYPE: 599 case ENUMERAL_TYPE: 600 { 601 char *tag; 602#ifdef SDB_ALLOW_FORWARD_REFERENCES 603 sdbout_record_type_name (type); 604#endif 605#ifndef SDB_ALLOW_UNKNOWN_REFERENCES 606 if ((TREE_ASM_WRITTEN (type) && KNOWN_TYPE_TAG (type) != 0) 607#ifdef SDB_ALLOW_FORWARD_REFERENCES 608 || TYPE_MODE (type) != VOIDmode 609#endif 610 ) 611#endif 612 { 613 /* Output the referenced structure tag name 614 only if the .def has already been finished. 615 At least on 386, the Unix assembler 616 cannot handle forward references to tags. */ 617 /* But the 88100, it requires them, sigh... */ 618 /* And the MIPS requires unknown refs as well... */ 619 tag = KNOWN_TYPE_TAG (type); 620 PUT_SDB_TAG (tag); 621 /* These 3 lines used to follow the close brace. 622 However, a size of 0 without a tag implies a tag of 0, 623 so if we don't know a tag, we can't mention the size. */ 624 sdb_type_size = int_size_in_bytes (type); 625 if (sdb_type_size < 0) 626 sdb_type_size = 0; 627 } 628 return ((TREE_CODE (type) == RECORD_TYPE) ? T_STRUCT 629 : (TREE_CODE (type) == UNION_TYPE) ? T_UNION 630 : (TREE_CODE (type) == QUAL_UNION_TYPE) ? T_UNION 631 : T_ENUM); 632 } 633 case POINTER_TYPE: 634 case REFERENCE_TYPE: 635 { 636 int m; 637 if (level >= 6) 638 return T_VOID; 639 else 640 m = plain_type_1 (TREE_TYPE (type), level+1); 641 return PUSH_DERIVED_LEVEL (DT_PTR, m); 642 } 643 case FUNCTION_TYPE: 644 case METHOD_TYPE: 645 { 646 int m; 647 if (level >= 6) 648 return T_VOID; 649 else 650 m = plain_type_1 (TREE_TYPE (type), level+1); 651 return PUSH_DERIVED_LEVEL (DT_FCN, m); 652 } 653 default: 654 return 0; 655 } 656} 657 658/* Output the symbols defined in block number DO_BLOCK. 659 660 This function works by walking the tree structure of blocks, 661 counting blocks until it finds the desired block. */ 662 663static int do_block = 0; 664 665static void 666sdbout_block (block) 667 tree block; 668{ 669 while (block) 670 { 671 /* Ignore blocks never expanded or otherwise marked as real. */ 672 if (TREE_USED (block)) 673 { 674 /* When we reach the specified block, output its symbols. */ 675 if (BLOCK_NUMBER (block) == do_block) 676 sdbout_syms (BLOCK_VARS (block)); 677 678 /* If we are past the specified block, stop the scan. */ 679 if (BLOCK_NUMBER (block) > do_block) 680 return; 681 682 /* Scan the blocks within this block. */ 683 sdbout_block (BLOCK_SUBBLOCKS (block)); 684 } 685 686 block = BLOCK_CHAIN (block); 687 } 688} 689 690/* Call sdbout_symbol on each decl in the chain SYMS. */ 691 692static void 693sdbout_syms (syms) 694 tree syms; 695{ 696 while (syms) 697 { 698 if (TREE_CODE (syms) != LABEL_DECL) 699 sdbout_symbol (syms, 1); 700 syms = TREE_CHAIN (syms); 701 } 702} 703 704/* Output SDB information for a symbol described by DECL. 705 LOCAL is nonzero if the symbol is not file-scope. */ 706 707void 708sdbout_symbol (decl, local) 709 tree decl; 710 int local; 711{ 712 tree type = TREE_TYPE (decl); 713 tree context = NULL_TREE; 714 rtx value; 715 int regno = -1; 716 const char *name; 717 718 sdbout_one_type (type); 719 720#if 0 /* This loses when functions are marked to be ignored, 721 which happens in the C++ front end. */ 722 if (DECL_IGNORED_P (decl)) 723 return; 724#endif 725 726 switch (TREE_CODE (decl)) 727 { 728 case CONST_DECL: 729 /* Enum values are defined by defining the enum type. */ 730 return; 731 732 case FUNCTION_DECL: 733 /* Don't mention a nested function under its parent. */ 734 context = decl_function_context (decl); 735 if (context == current_function_decl) 736 return; 737 /* Check DECL_INITIAL to distinguish declarations from definitions. 738 Don't output debug info here for declarations; they will have 739 a DECL_INITIAL value of 0. */ 740 if (! DECL_INITIAL (decl)) 741 return; 742 if (GET_CODE (DECL_RTL (decl)) != MEM 743 || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF) 744 return; 745 PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))); 746 PUT_SDB_VAL (XEXP (DECL_RTL (decl), 0)); 747 PUT_SDB_SCL (TREE_PUBLIC (decl) ? C_EXT : C_STAT); 748 break; 749 750 case TYPE_DECL: 751 /* Done with tagged types. */ 752 if (DECL_NAME (decl) == 0) 753 return; 754 if (DECL_IGNORED_P (decl)) 755 return; 756 757 /* Output typedef name. */ 758 if (template_name_p (DECL_NAME (decl))) 759 PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))); 760 else 761 PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_NAME (decl))); 762 PUT_SDB_SCL (C_TPDEF); 763 break; 764 765 case PARM_DECL: 766 /* Parm decls go in their own separate chains 767 and are output by sdbout_reg_parms and sdbout_parms. */ 768 abort (); 769 770 case VAR_DECL: 771 /* Don't mention a variable that is external. 772 Let the file that defines it describe it. */ 773 if (DECL_EXTERNAL (decl)) 774 return; 775 776 /* Ignore __FUNCTION__, etc. */ 777 if (DECL_IGNORED_P (decl)) 778 return; 779 780 /* If there was an error in the declaration, don't dump core 781 if there is no RTL associated with the variable doesn't 782 exist. */ 783 if (!DECL_RTL_SET_P (decl)) 784 return; 785 786 SET_DECL_RTL (decl, 787 eliminate_regs (DECL_RTL (decl), 0, NULL_RTX)); 788#ifdef LEAF_REG_REMAP 789 if (current_function_uses_only_leaf_regs) 790 leaf_renumber_regs_insn (DECL_RTL (decl)); 791#endif 792 value = DECL_RTL (decl); 793 794 /* Don't mention a variable at all 795 if it was completely optimized into nothingness. 796 797 If DECL was from an inline function, then its rtl 798 is not identically the rtl that was used in this 799 particular compilation. */ 800 if (GET_CODE (value) == REG) 801 { 802 regno = REGNO (value); 803 if (regno >= FIRST_PSEUDO_REGISTER) 804 return; 805 } 806 else if (GET_CODE (value) == SUBREG) 807 { 808 while (GET_CODE (value) == SUBREG) 809 value = SUBREG_REG (value); 810 if (GET_CODE (value) == REG) 811 { 812 if (REGNO (value) >= FIRST_PSEUDO_REGISTER) 813 return; 814 } 815 regno = REGNO (alter_subreg (&value)); 816 SET_DECL_RTL (decl, value); 817 } 818 /* Don't output anything if an auto variable 819 gets RTL that is static. 820 GAS version 2.2 can't handle such output. */ 821 else if (GET_CODE (value) == MEM && CONSTANT_P (XEXP (value, 0)) 822 && ! TREE_STATIC (decl)) 823 return; 824 825 /* Emit any structure, union, or enum type that has not been output. 826 This occurs for tag-less structs (et al) used to declare variables 827 within functions. */ 828 if (TREE_CODE (type) == ENUMERAL_TYPE 829 || TREE_CODE (type) == RECORD_TYPE 830 || TREE_CODE (type) == UNION_TYPE 831 || TREE_CODE (type) == QUAL_UNION_TYPE) 832 { 833 if (COMPLETE_TYPE_P (type) /* not a forward reference */ 834 && KNOWN_TYPE_TAG (type) == 0) /* not yet declared */ 835 sdbout_one_type (type); 836 } 837 838 /* Defer SDB information for top-level initialized variables! */ 839 if (! local 840 && GET_CODE (value) == MEM 841 && DECL_INITIAL (decl)) 842 return; 843 844 /* C++ in 2.3 makes nameless symbols. That will be fixed later. 845 For now, avoid crashing. */ 846 if (DECL_NAME (decl) == NULL_TREE) 847 return; 848 849 /* Record the name for, starting a symtab entry. */ 850 if (local) 851 name = IDENTIFIER_POINTER (DECL_NAME (decl)); 852 else 853 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); 854 855 if (GET_CODE (value) == MEM 856 && GET_CODE (XEXP (value, 0)) == SYMBOL_REF) 857 { 858 PUT_SDB_DEF (name); 859 if (TREE_PUBLIC (decl)) 860 { 861 PUT_SDB_VAL (XEXP (value, 0)); 862 PUT_SDB_SCL (C_EXT); 863 } 864 else 865 { 866 PUT_SDB_VAL (XEXP (value, 0)); 867 PUT_SDB_SCL (C_STAT); 868 } 869 } 870 else if (regno >= 0) 871 { 872 PUT_SDB_DEF (name); 873 PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (regno)); 874 PUT_SDB_SCL (C_REG); 875 } 876 else if (GET_CODE (value) == MEM 877 && (GET_CODE (XEXP (value, 0)) == MEM 878 || (GET_CODE (XEXP (value, 0)) == REG 879 && REGNO (XEXP (value, 0)) != HARD_FRAME_POINTER_REGNUM 880 && REGNO (XEXP (value, 0)) != STACK_POINTER_REGNUM))) 881 /* If the value is indirect by memory or by a register 882 that isn't the frame pointer 883 then it means the object is variable-sized and address through 884 that register or stack slot. COFF has no way to represent this 885 so all we can do is output the variable as a pointer. */ 886 { 887 PUT_SDB_DEF (name); 888 if (GET_CODE (XEXP (value, 0)) == REG) 889 { 890 PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (XEXP (value, 0)))); 891 PUT_SDB_SCL (C_REG); 892 } 893 else 894 { 895 /* DECL_RTL looks like (MEM (MEM (PLUS (REG...) 896 (CONST_INT...)))). 897 We want the value of that CONST_INT. */ 898 /* Encore compiler hates a newline in a macro arg, it seems. */ 899 PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET 900 (XEXP (XEXP (value, 0), 0))); 901 PUT_SDB_SCL (C_AUTO); 902 } 903 904 /* Effectively do build_pointer_type, but don't cache this type, 905 since it might be temporary whereas the type it points to 906 might have been saved for inlining. */ 907 /* Don't use REFERENCE_TYPE because dbx can't handle that. */ 908 type = make_node (POINTER_TYPE); 909 TREE_TYPE (type) = TREE_TYPE (decl); 910 } 911 else if (GET_CODE (value) == MEM 912 && ((GET_CODE (XEXP (value, 0)) == PLUS 913 && GET_CODE (XEXP (XEXP (value, 0), 0)) == REG 914 && GET_CODE (XEXP (XEXP (value, 0), 1)) == CONST_INT) 915 /* This is for variables which are at offset zero from 916 the frame pointer. This happens on the Alpha. 917 Non-frame pointer registers are excluded above. */ 918 || (GET_CODE (XEXP (value, 0)) == REG))) 919 { 920 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))) 921 or (MEM (REG...)). We want the value of that CONST_INT 922 or zero. */ 923 PUT_SDB_DEF (name); 924 PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET (XEXP (value, 0))); 925 PUT_SDB_SCL (C_AUTO); 926 } 927 else 928 { 929 /* It is something we don't know how to represent for SDB. */ 930 return; 931 } 932 break; 933 934 default: 935 break; 936 } 937 PUT_SDB_TYPE (plain_type (type)); 938 PUT_SDB_ENDEF; 939} 940 941/* Output SDB information for a top-level initialized variable 942 that has been delayed. */ 943 944static void 945sdbout_toplevel_data (decl) 946 tree decl; 947{ 948 tree type = TREE_TYPE (decl); 949 950 if (DECL_IGNORED_P (decl)) 951 return; 952 953 if (! (TREE_CODE (decl) == VAR_DECL 954 && GET_CODE (DECL_RTL (decl)) == MEM 955 && DECL_INITIAL (decl))) 956 abort (); 957 958 PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))); 959 PUT_SDB_VAL (XEXP (DECL_RTL (decl), 0)); 960 if (TREE_PUBLIC (decl)) 961 { 962 PUT_SDB_SCL (C_EXT); 963 } 964 else 965 { 966 PUT_SDB_SCL (C_STAT); 967 } 968 PUT_SDB_TYPE (plain_type (type)); 969 PUT_SDB_ENDEF; 970} 971 972#ifdef SDB_ALLOW_FORWARD_REFERENCES 973 974/* Machinery to record and output anonymous types. */ 975 976static void 977sdbout_queue_anonymous_type (type) 978 tree type; 979{ 980 anonymous_types = tree_cons (NULL_TREE, type, anonymous_types); 981} 982 983static void 984sdbout_dequeue_anonymous_types () 985{ 986 tree types, link; 987 988 while (anonymous_types) 989 { 990 types = nreverse (anonymous_types); 991 anonymous_types = NULL_TREE; 992 993 for (link = types; link; link = TREE_CHAIN (link)) 994 { 995 tree type = TREE_VALUE (link); 996 997 if (type && ! TREE_ASM_WRITTEN (type)) 998 sdbout_one_type (type); 999 } 1000 } 1001} 1002 1003#endif 1004 1005/* Given a chain of ..._TYPE nodes, all of which have names, 1006 output definitions of those names, as typedefs. */ 1007 1008void 1009sdbout_types (types) 1010 tree types; 1011{ 1012 tree link; 1013 1014 for (link = types; link; link = TREE_CHAIN (link)) 1015 sdbout_one_type (link); 1016 1017#ifdef SDB_ALLOW_FORWARD_REFERENCES 1018 sdbout_dequeue_anonymous_types (); 1019#endif 1020} 1021 1022static void 1023sdbout_type (type) 1024 tree type; 1025{ 1026 if (type == error_mark_node) 1027 type = integer_type_node; 1028 PUT_SDB_TYPE (plain_type (type)); 1029} 1030 1031/* Output types of the fields of type TYPE, if they are structs. 1032 1033 Formerly did not chase through pointer types, since that could be circular. 1034 They must come before TYPE, since forward refs are not allowed. 1035 Now james@bigtex.cactus.org says to try them. */ 1036 1037static void 1038sdbout_field_types (type) 1039 tree type; 1040{ 1041 tree tail; 1042 1043 for (tail = TYPE_FIELDS (type); tail; tail = TREE_CHAIN (tail)) 1044 /* This condition should match the one for emitting the actual 1045 members below. */ 1046 if (TREE_CODE (tail) == FIELD_DECL 1047 && DECL_NAME (tail) 1048 && DECL_SIZE (tail) 1049 && host_integerp (DECL_SIZE (tail), 1) 1050 && host_integerp (bit_position (tail), 0)) 1051 { 1052 if (POINTER_TYPE_P (TREE_TYPE (tail))) 1053 sdbout_one_type (TREE_TYPE (TREE_TYPE (tail))); 1054 else 1055 sdbout_one_type (TREE_TYPE (tail)); 1056 } 1057} 1058 1059/* Use this to put out the top level defined record and union types 1060 for later reference. If this is a struct with a name, then put that 1061 name out. Other unnamed structs will have .xxfake labels generated so 1062 that they may be referred to later. 1063 The label will be stored in the KNOWN_TYPE_TAG slot of a type. 1064 It may NOT be called recursively. */ 1065 1066static void 1067sdbout_one_type (type) 1068 tree type; 1069{ 1070 if (current_function_decl != NULL_TREE 1071 && DECL_SECTION_NAME (current_function_decl) != NULL_TREE) 1072 ; /* Don't change section amid function. */ 1073 else 1074 text_section (); 1075 1076 switch (TREE_CODE (type)) 1077 { 1078 case RECORD_TYPE: 1079 case UNION_TYPE: 1080 case QUAL_UNION_TYPE: 1081 case ENUMERAL_TYPE: 1082 type = TYPE_MAIN_VARIANT (type); 1083 /* Don't output a type twice. */ 1084 if (TREE_ASM_WRITTEN (type)) 1085 /* James said test TREE_ASM_BEING_WRITTEN here. */ 1086 return; 1087 1088 /* Output nothing if type is not yet defined. */ 1089 if (!COMPLETE_TYPE_P (type)) 1090 return; 1091 1092 TREE_ASM_WRITTEN (type) = 1; 1093#if 1 1094 /* This is reputed to cause trouble with the following case, 1095 but perhaps checking TYPE_SIZE above will fix it. */ 1096 1097 /* Here is a test case: 1098 1099 struct foo { 1100 struct badstr *bbb; 1101 } forwardref; 1102 1103 typedef struct intermediate { 1104 int aaaa; 1105 } intermediate_ref; 1106 1107 typedef struct badstr { 1108 int ccccc; 1109 } badtype; */ 1110 1111#if 0 1112 TREE_ASM_BEING_WRITTEN (type) = 1; 1113#endif 1114 /* This change, which ought to make better output, 1115 used to make the COFF assembler unhappy. 1116 Changes involving KNOWN_TYPE_TAG may fix the problem. */ 1117 /* Before really doing anything, output types we want to refer to. */ 1118 /* Note that in version 1 the following two lines 1119 are not used if forward references are in use. */ 1120 if (TREE_CODE (type) != ENUMERAL_TYPE) 1121 sdbout_field_types (type); 1122#if 0 1123 TREE_ASM_WRITTEN (type) = 1; 1124#endif 1125#endif 1126 1127 /* Output a structure type. */ 1128 { 1129 int size = int_size_in_bytes (type); 1130 int member_scl = 0; 1131 tree tem; 1132 int i, n_baseclasses = 0; 1133 1134 /* Record the type tag, but not in its permanent place just yet. */ 1135 sdbout_record_type_name (type); 1136 1137 PUT_SDB_DEF (KNOWN_TYPE_TAG (type)); 1138 1139 switch (TREE_CODE (type)) 1140 { 1141 case UNION_TYPE: 1142 case QUAL_UNION_TYPE: 1143 PUT_SDB_SCL (C_UNTAG); 1144 PUT_SDB_TYPE (T_UNION); 1145 member_scl = C_MOU; 1146 break; 1147 1148 case RECORD_TYPE: 1149 PUT_SDB_SCL (C_STRTAG); 1150 PUT_SDB_TYPE (T_STRUCT); 1151 member_scl = C_MOS; 1152 break; 1153 1154 case ENUMERAL_TYPE: 1155 PUT_SDB_SCL (C_ENTAG); 1156 PUT_SDB_TYPE (T_ENUM); 1157 member_scl = C_MOE; 1158 break; 1159 1160 default: 1161 break; 1162 } 1163 1164 PUT_SDB_SIZE (size); 1165 PUT_SDB_ENDEF; 1166 1167 /* Print out the base class information with fields 1168 named after the types they hold. */ 1169 /* This is only relevant to aggregate types. TYPE_BINFO is used 1170 for other purposes in an ENUMERAL_TYPE, so we must exclude that 1171 case. */ 1172 if (TREE_CODE (type) != ENUMERAL_TYPE) 1173 { 1174 if (TYPE_BINFO (type) 1175 && TYPE_BINFO_BASETYPES (type)) 1176 n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type)); 1177 for (i = 0; i < n_baseclasses; i++) 1178 { 1179 tree child = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type)), 1180 i); 1181 tree child_type = BINFO_TYPE (child); 1182 tree child_type_name; 1183 if (TYPE_NAME (child_type) == 0) 1184 continue; 1185 if (TREE_CODE (TYPE_NAME (child_type)) == IDENTIFIER_NODE) 1186 child_type_name = TYPE_NAME (child_type); 1187 else if (TREE_CODE (TYPE_NAME (child_type)) == TYPE_DECL) 1188 { 1189 child_type_name = DECL_NAME (TYPE_NAME (child_type)); 1190 if (child_type_name && template_name_p (child_type_name)) 1191 child_type_name 1192 = DECL_ASSEMBLER_NAME (TYPE_NAME (child_type)); 1193 } 1194 else 1195 continue; 1196 1197 CONTIN; 1198 PUT_SDB_DEF (IDENTIFIER_POINTER (child_type_name)); 1199 PUT_SDB_INT_VAL (tree_low_cst (BINFO_OFFSET (child), 0)); 1200 PUT_SDB_SCL (member_scl); 1201 sdbout_type (BINFO_TYPE (child)); 1202 PUT_SDB_ENDEF; 1203 } 1204 } 1205 1206 /* output the individual fields */ 1207 1208 if (TREE_CODE (type) == ENUMERAL_TYPE) 1209 { 1210 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem)) 1211 if (host_integerp (TREE_VALUE (tem), 0)) 1212 { 1213 PUT_SDB_DEF (IDENTIFIER_POINTER (TREE_PURPOSE (tem))); 1214 PUT_SDB_INT_VAL (tree_low_cst (TREE_VALUE (tem), 0)); 1215 PUT_SDB_SCL (C_MOE); 1216 PUT_SDB_TYPE (T_MOE); 1217 PUT_SDB_ENDEF; 1218 } 1219 } 1220 else /* record or union type */ 1221 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem)) 1222 /* Output the name, type, position (in bits), size (in bits) 1223 of each field. */ 1224 1225 /* Omit here the nameless fields that are used to skip bits. 1226 Also omit fields with variable size or position. 1227 Also omit non FIELD_DECL nodes that GNU C++ may put here. */ 1228 if (TREE_CODE (tem) == FIELD_DECL 1229 && DECL_NAME (tem) 1230 && DECL_SIZE (tem) 1231 && host_integerp (DECL_SIZE (tem), 1) 1232 && host_integerp (bit_position (tem), 0)) 1233 { 1234 const char *name; 1235 1236 CONTIN; 1237 name = IDENTIFIER_POINTER (DECL_NAME (tem)); 1238 PUT_SDB_DEF (name); 1239 if (DECL_BIT_FIELD_TYPE (tem)) 1240 { 1241 PUT_SDB_INT_VAL (int_bit_position (tem)); 1242 PUT_SDB_SCL (C_FIELD); 1243 sdbout_type (DECL_BIT_FIELD_TYPE (tem)); 1244 PUT_SDB_SIZE (tree_low_cst (DECL_SIZE (tem), 1)); 1245 } 1246 else 1247 { 1248 PUT_SDB_INT_VAL (int_bit_position (tem) / BITS_PER_UNIT); 1249 PUT_SDB_SCL (member_scl); 1250 sdbout_type (TREE_TYPE (tem)); 1251 } 1252 PUT_SDB_ENDEF; 1253 } 1254 /* output end of a structure,union, or enumeral definition */ 1255 1256 PUT_SDB_PLAIN_DEF ("eos"); 1257 PUT_SDB_INT_VAL (size); 1258 PUT_SDB_SCL (C_EOS); 1259 PUT_SDB_TAG (KNOWN_TYPE_TAG (type)); 1260 PUT_SDB_SIZE (size); 1261 PUT_SDB_ENDEF; 1262 break; 1263 1264 default: 1265 break; 1266 } 1267 } 1268} 1269 1270/* The following two functions output definitions of function parameters. 1271 Each parameter gets a definition locating it in the parameter list. 1272 Each parameter that is a register variable gets a second definition 1273 locating it in the register. 1274 1275 Printing or argument lists in gdb uses the definitions that 1276 locate in the parameter list. But reference to the variable in 1277 expressions uses preferentially the definition as a register. */ 1278 1279/* Output definitions, referring to storage in the parmlist, 1280 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */ 1281 1282static void 1283sdbout_parms (parms) 1284 tree parms; 1285{ 1286 for (; parms; parms = TREE_CHAIN (parms)) 1287 if (DECL_NAME (parms)) 1288 { 1289 int current_sym_value = 0; 1290 const char *name = IDENTIFIER_POINTER (DECL_NAME (parms)); 1291 1292 if (name == 0 || *name == 0) 1293 name = gen_fake_label (); 1294 1295 /* Perform any necessary register eliminations on the parameter's rtl, 1296 so that the debugging output will be accurate. */ 1297 DECL_INCOMING_RTL (parms) 1298 = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX); 1299 SET_DECL_RTL (parms, 1300 eliminate_regs (DECL_RTL (parms), 0, NULL_RTX)); 1301 1302 if (PARM_PASSED_IN_MEMORY (parms)) 1303 { 1304 rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0); 1305 tree type; 1306 1307 /* ??? Here we assume that the parm address is indexed 1308 off the frame pointer or arg pointer. 1309 If that is not true, we produce meaningless results, 1310 but do not crash. */ 1311 if (GET_CODE (addr) == PLUS 1312 && GET_CODE (XEXP (addr, 1)) == CONST_INT) 1313 current_sym_value = INTVAL (XEXP (addr, 1)); 1314 else 1315 current_sym_value = 0; 1316 1317 if (GET_CODE (DECL_RTL (parms)) == REG 1318 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER) 1319 type = DECL_ARG_TYPE (parms); 1320 else 1321 { 1322 int original_sym_value = current_sym_value; 1323 1324 /* This is the case where the parm is passed as an int or 1325 double and it is converted to a char, short or float 1326 and stored back in the parmlist. In this case, describe 1327 the parm with the variable's declared type, and adjust 1328 the address if the least significant bytes (which we are 1329 using) are not the first ones. */ 1330 if (BYTES_BIG_ENDIAN 1331 && TREE_TYPE (parms) != DECL_ARG_TYPE (parms)) 1332 current_sym_value += 1333 (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms))) 1334 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))); 1335 1336 if (GET_CODE (DECL_RTL (parms)) == MEM 1337 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS 1338 && (GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1)) 1339 == CONST_INT) 1340 && (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)) 1341 == current_sym_value)) 1342 type = TREE_TYPE (parms); 1343 else 1344 { 1345 current_sym_value = original_sym_value; 1346 type = DECL_ARG_TYPE (parms); 1347 } 1348 } 1349 1350 PUT_SDB_DEF (name); 1351 PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value, addr)); 1352 PUT_SDB_SCL (C_ARG); 1353 PUT_SDB_TYPE (plain_type (type)); 1354 PUT_SDB_ENDEF; 1355 } 1356 else if (GET_CODE (DECL_RTL (parms)) == REG) 1357 { 1358 rtx best_rtl; 1359 /* Parm passed in registers and lives in registers or nowhere. */ 1360 1361 /* If parm lives in a register, use that register; 1362 pretend the parm was passed there. It would be more consistent 1363 to describe the register where the parm was passed, 1364 but in practice that register usually holds something else. */ 1365 if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER) 1366 best_rtl = DECL_RTL (parms); 1367 /* If the parm lives nowhere, 1368 use the register where it was passed. */ 1369 else 1370 best_rtl = DECL_INCOMING_RTL (parms); 1371 1372 PUT_SDB_DEF (name); 1373 PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (best_rtl))); 1374 PUT_SDB_SCL (C_REGPARM); 1375 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms))); 1376 PUT_SDB_ENDEF; 1377 } 1378 else if (GET_CODE (DECL_RTL (parms)) == MEM 1379 && XEXP (DECL_RTL (parms), 0) != const0_rtx) 1380 { 1381 /* Parm was passed in registers but lives on the stack. */ 1382 1383 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))), 1384 in which case we want the value of that CONST_INT, 1385 or (MEM (REG ...)) or (MEM (MEM ...)), 1386 in which case we use a value of zero. */ 1387 if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG 1388 || GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM) 1389 current_sym_value = 0; 1390 else 1391 current_sym_value = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)); 1392 1393 /* Again, this assumes the offset is based on the arg pointer. */ 1394 PUT_SDB_DEF (name); 1395 PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value, 1396 XEXP (DECL_RTL (parms), 0))); 1397 PUT_SDB_SCL (C_ARG); 1398 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms))); 1399 PUT_SDB_ENDEF; 1400 } 1401 } 1402} 1403 1404/* Output definitions for the places where parms live during the function, 1405 when different from where they were passed, when the parms were passed 1406 in memory. 1407 1408 It is not useful to do this for parms passed in registers 1409 that live during the function in different registers, because it is 1410 impossible to look in the passed register for the passed value, 1411 so we use the within-the-function register to begin with. 1412 1413 PARMS is a chain of PARM_DECL nodes. */ 1414 1415static void 1416sdbout_reg_parms (parms) 1417 tree parms; 1418{ 1419 for (; parms; parms = TREE_CHAIN (parms)) 1420 if (DECL_NAME (parms)) 1421 { 1422 const char *name = IDENTIFIER_POINTER (DECL_NAME (parms)); 1423 1424 /* Report parms that live in registers during the function 1425 but were passed in memory. */ 1426 if (GET_CODE (DECL_RTL (parms)) == REG 1427 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER 1428 && PARM_PASSED_IN_MEMORY (parms)) 1429 { 1430 if (name == 0 || *name == 0) 1431 name = gen_fake_label (); 1432 PUT_SDB_DEF (name); 1433 PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (DECL_RTL (parms)))); 1434 PUT_SDB_SCL (C_REG); 1435 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms))); 1436 PUT_SDB_ENDEF; 1437 } 1438 /* Report parms that live in memory but not where they were passed. */ 1439 else if (GET_CODE (DECL_RTL (parms)) == MEM 1440 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS 1441 && GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == CONST_INT 1442 && PARM_PASSED_IN_MEMORY (parms) 1443 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms))) 1444 { 1445#if 0 /* ??? It is not clear yet what should replace this. */ 1446 int offset = DECL_OFFSET (parms) / BITS_PER_UNIT; 1447 /* A parm declared char is really passed as an int, 1448 so it occupies the least significant bytes. 1449 On a big-endian machine those are not the low-numbered ones. */ 1450 if (BYTES_BIG_ENDIAN 1451 && offset != -1 1452 && TREE_TYPE (parms) != DECL_ARG_TYPE (parms)) 1453 offset += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms))) 1454 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))); 1455 if (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)) != offset) {...} 1456#endif 1457 { 1458 if (name == 0 || *name == 0) 1459 name = gen_fake_label (); 1460 PUT_SDB_DEF (name); 1461 PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET 1462 (XEXP (DECL_RTL (parms), 0))); 1463 PUT_SDB_SCL (C_AUTO); 1464 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms))); 1465 PUT_SDB_ENDEF; 1466 } 1467 } 1468 } 1469} 1470 1471/* Output debug information for a global DECL. Called from toplev.c 1472 after compilation proper has finished. */ 1473 1474static void 1475sdbout_global_decl (decl) 1476 tree decl; 1477{ 1478 if (TREE_CODE (decl) == VAR_DECL 1479 && !DECL_EXTERNAL (decl) 1480 && DECL_RTL_SET_P (decl)) 1481 { 1482 /* The COFF linker can move initialized global vars to the end. 1483 And that can screw up the symbol ordering. Defer those for 1484 sdbout_finish (). */ 1485 if (!DECL_INITIAL (decl) || !TREE_PUBLIC (decl)) 1486 sdbout_symbol (decl, 0); 1487 1488 /* Output COFF information for non-global file-scope initialized 1489 variables. */ 1490 if (DECL_INITIAL (decl) && GET_CODE (DECL_RTL (decl)) == MEM) 1491 sdbout_toplevel_data (decl); 1492 } 1493} 1494 1495/* Output initialized global vars at the end, in the order of 1496 definition. See comment in sdbout_global_decl. */ 1497 1498static void 1499sdbout_finish (main_filename) 1500 const char *main_filename ATTRIBUTE_UNUSED; 1501{ 1502 tree decl = (*lang_hooks.decls.getdecls) (); 1503 unsigned int len = list_length (decl); 1504 tree *vec = (tree *) xmalloc (sizeof (tree) * len); 1505 unsigned int i; 1506 1507 /* Process the decls in reverse order--earliest first. Put them 1508 into VEC from back to front, then take out from front. */ 1509 1510 for (i = 0; i < len; i++, decl = TREE_CHAIN (decl)) 1511 vec[len - i - 1] = decl; 1512 1513 for (i = 0; i < len; i++) 1514 { 1515 decl = vec[i]; 1516 if (TREE_CODE (decl) == VAR_DECL 1517 && ! DECL_EXTERNAL (decl) 1518 && DECL_INITIAL (decl) 1519 && TREE_PUBLIC (decl) 1520 && DECL_RTL_SET_P (decl)) 1521 sdbout_symbol (decl, 0); 1522 } 1523 1524 free (vec); 1525} 1526 1527/* Describe the beginning of an internal block within a function. 1528 Also output descriptions of variables defined in this block. 1529 1530 N is the number of the block, by order of beginning, counting from 1, 1531 and not counting the outermost (function top-level) block. 1532 The blocks match the BLOCKs in DECL_INITIAL (current_function_decl), 1533 if the count starts at 0 for the outermost one. */ 1534 1535static void 1536sdbout_begin_block (line, n) 1537 unsigned int line; 1538 unsigned int n; 1539{ 1540 tree decl = current_function_decl; 1541 MAKE_LINE_SAFE (line); 1542 1543 /* The SCO compiler does not emit a separate block for the function level 1544 scope, so we avoid it here also. However, mips ECOFF compilers do emit 1545 a separate block, so we retain it when MIPS_DEBUGGING_INFO is defined. */ 1546#ifndef MIPS_DEBUGGING_INFO 1547 if (n != 1) 1548#endif 1549 PUT_SDB_BLOCK_START (line - sdb_begin_function_line); 1550 1551 if (n == 1) 1552 { 1553 /* Include the outermost BLOCK's variables in block 1. */ 1554 do_block = BLOCK_NUMBER (DECL_INITIAL (decl)); 1555 sdbout_block (DECL_INITIAL (decl)); 1556 } 1557 /* If -g1, suppress all the internal symbols of functions 1558 except for arguments. */ 1559 if (debug_info_level != DINFO_LEVEL_TERSE) 1560 { 1561 do_block = n; 1562 sdbout_block (DECL_INITIAL (decl)); 1563 } 1564 1565#ifdef SDB_ALLOW_FORWARD_REFERENCES 1566 sdbout_dequeue_anonymous_types (); 1567#endif 1568} 1569 1570/* Describe the end line-number of an internal block within a function. */ 1571 1572static void 1573sdbout_end_block (line, n) 1574 unsigned int line; 1575 unsigned int n ATTRIBUTE_UNUSED; 1576{ 1577 MAKE_LINE_SAFE (line); 1578 1579 /* The SCO compiler does not emit a separate block for the function level 1580 scope, so we avoid it here also. However, mips ECOFF compilers do emit 1581 a separate block, so we retain it when MIPS_DEBUGGING_INFO is defined. */ 1582#ifndef MIPS_DEBUGGING_INFO 1583 if (n != 1) 1584#endif 1585 PUT_SDB_BLOCK_END (line - sdb_begin_function_line); 1586} 1587 1588static void 1589sdbout_source_line (line, filename) 1590 unsigned int line; 1591 const char *filename ATTRIBUTE_UNUSED; 1592{ 1593 /* COFF relative line numbers must be positive. */ 1594 if ((int) line > sdb_begin_function_line) 1595 { 1596#ifdef ASM_OUTPUT_SOURCE_LINE 1597 ASM_OUTPUT_SOURCE_LINE (asm_out_file, line); 1598#else 1599 fprintf (asm_out_file, "\t.ln\t%d\n", 1600 ((sdb_begin_function_line > -1) 1601 ? line - sdb_begin_function_line : 1)); 1602#endif 1603 } 1604} 1605 1606/* Output sdb info for the current function name. 1607 Called from assemble_start_function. */ 1608 1609static void 1610sdbout_begin_function (decl) 1611 tree decl ATTRIBUTE_UNUSED; 1612{ 1613 sdbout_symbol (current_function_decl, 0); 1614} 1615 1616/* Called at beginning of function body (before or after prologue, 1617 depending on MIPS_DEBUGGING_INFO). Record the function's starting 1618 line number, so we can output relative line numbers for the other 1619 lines. Describe beginning of outermost block. Also describe the 1620 parameter list. */ 1621 1622#ifndef MIPS_DEBUGGING_INFO 1623static void 1624sdbout_begin_prologue (line, file) 1625 unsigned int line; 1626 const char *file ATTRIBUTE_UNUSED; 1627{ 1628 sdbout_end_prologue (line, file); 1629} 1630#endif 1631 1632static void 1633sdbout_end_prologue (line, file) 1634 unsigned int line; 1635 const char *file ATTRIBUTE_UNUSED; 1636{ 1637 sdb_begin_function_line = line - 1; 1638 PUT_SDB_FUNCTION_START (line); 1639 sdbout_parms (DECL_ARGUMENTS (current_function_decl)); 1640 sdbout_reg_parms (DECL_ARGUMENTS (current_function_decl)); 1641} 1642 1643/* Called at end of function (before epilogue). 1644 Describe end of outermost block. */ 1645 1646static void 1647sdbout_end_function (line) 1648 unsigned int line; 1649{ 1650#ifdef SDB_ALLOW_FORWARD_REFERENCES 1651 sdbout_dequeue_anonymous_types (); 1652#endif 1653 1654 MAKE_LINE_SAFE (line); 1655 PUT_SDB_FUNCTION_END (line - sdb_begin_function_line); 1656 1657 /* Indicate we are between functions, for line-number output. */ 1658 sdb_begin_function_line = -1; 1659} 1660 1661/* Output sdb info for the absolute end of a function. 1662 Called after the epilogue is output. */ 1663 1664static void 1665sdbout_end_epilogue (line, file) 1666 unsigned int line ATTRIBUTE_UNUSED; 1667 const char *file ATTRIBUTE_UNUSED; 1668{ 1669 const char *const name ATTRIBUTE_UNUSED 1670 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)); 1671 1672#ifdef PUT_SDB_EPILOGUE_END 1673 PUT_SDB_EPILOGUE_END (name); 1674#else 1675 fprintf (asm_out_file, "\t.def\t"); 1676 assemble_name (asm_out_file, name); 1677 fprintf (asm_out_file, "%s\t.val\t.%s\t.scl\t-1%s\t.endef\n", 1678 SDB_DELIM, SDB_DELIM, SDB_DELIM); 1679#endif 1680} 1681 1682/* Output sdb info for the given label. Called only if LABEL_NAME (insn) 1683 is present. */ 1684 1685static void 1686sdbout_label (insn) 1687 rtx insn; 1688{ 1689 PUT_SDB_DEF (LABEL_NAME (insn)); 1690 PUT_SDB_VAL (insn); 1691 PUT_SDB_SCL (C_LABEL); 1692 PUT_SDB_TYPE (T_NULL); 1693 PUT_SDB_ENDEF; 1694} 1695 1696/* Change to reading from a new source file. */ 1697 1698static void 1699sdbout_start_source_file (line, filename) 1700 unsigned int line ATTRIBUTE_UNUSED; 1701 const char *filename ATTRIBUTE_UNUSED; 1702{ 1703#ifdef MIPS_DEBUGGING_INFO 1704 struct sdb_file *n = (struct sdb_file *) xmalloc (sizeof *n); 1705 1706 n->next = current_file; 1707 n->name = filename; 1708 current_file = n; 1709 PUT_SDB_SRC_FILE (filename); 1710#endif 1711} 1712 1713/* Revert to reading a previous source file. */ 1714 1715static void 1716sdbout_end_source_file (line) 1717 unsigned int line ATTRIBUTE_UNUSED; 1718{ 1719#ifdef MIPS_DEBUGGING_INFO 1720 struct sdb_file *next; 1721 1722 next = current_file->next; 1723 free (current_file); 1724 current_file = next; 1725 PUT_SDB_SRC_FILE (current_file->name); 1726#endif 1727} 1728 1729/* Set up for SDB output at the start of compilation. */ 1730 1731static void 1732sdbout_init (input_file_name) 1733 const char *input_file_name ATTRIBUTE_UNUSED; 1734{ 1735#ifdef MIPS_DEBUGGING_INFO 1736 current_file = (struct sdb_file *) xmalloc (sizeof *current_file); 1737 current_file->next = NULL; 1738 current_file->name = input_file_name; 1739#endif 1740 1741#ifdef RMS_QUICK_HACK_1 1742 tree t; 1743 for (t = (*lang_hooks.decls.getdecls) (); t; t = TREE_CHAIN (t)) 1744 if (DECL_NAME (t) && IDENTIFIER_POINTER (DECL_NAME (t)) != 0 1745 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (t)), "__vtbl_ptr_type")) 1746 sdbout_symbol (t, 0); 1747#endif 1748} 1749 1750#else /* SDB_DEBUGGING_INFO */ 1751 1752/* This should never be used, but its address is needed for comparisons. */ 1753const struct gcc_debug_hooks sdb_debug_hooks; 1754 1755#endif /* SDB_DEBUGGING_INFO */ 1756 1757#include "gt-sdbout.h" 1758