1/* Output dbx-format symbol table information from GNU compiler. 2 Copyright (C) 1987, 88, 92-97, 1998 Free Software Foundation, Inc. 3 4This file is part of GNU CC. 5 6GNU CC is free software; you can redistribute it and/or modify 7it under the terms of the GNU General Public License as published by 8the Free Software Foundation; either version 2, or (at your option) 9any later version. 10 11GNU CC is distributed in the hope that it will be useful, 12but WITHOUT ANY WARRANTY; without even the implied warranty of 13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14GNU General Public License for more details. 15 16You should have received a copy of the GNU General Public License 17along with GNU CC; see the file COPYING. If not, write to 18the Free Software Foundation, 59 Temple Place - Suite 330, 19Boston, MA 02111-1307, USA. */ 20 21 22/* Output dbx-format symbol table data. 23 This consists of many symbol table entries, each of them 24 a .stabs assembler pseudo-op with four operands: 25 a "name" which is really a description of one symbol and its type, 26 a "code", which is a symbol defined in stab.h whose name starts with N_, 27 an unused operand always 0, 28 and a "value" which is an address or an offset. 29 The name is enclosed in doublequote characters. 30 31 Each function, variable, typedef, and structure tag 32 has a symbol table entry to define it. 33 The beginning and end of each level of name scoping within 34 a function are also marked by special symbol table entries. 35 36 The "name" consists of the symbol name, a colon, a kind-of-symbol letter, 37 and a data type number. The data type number may be followed by 38 "=" and a type definition; normally this will happen the first time 39 the type number is mentioned. The type definition may refer to 40 other types by number, and those type numbers may be followed 41 by "=" and nested definitions. 42 43 This can make the "name" quite long. 44 When a name is more than 80 characters, we split the .stabs pseudo-op 45 into two .stabs pseudo-ops, both sharing the same "code" and "value". 46 The first one is marked as continued with a double-backslash at the 47 end of its "name". 48 49 The kind-of-symbol letter distinguished function names from global 50 variables from file-scope variables from parameters from auto 51 variables in memory from typedef names from register variables. 52 See `dbxout_symbol'. 53 54 The "code" is mostly redundant with the kind-of-symbol letter 55 that goes in the "name", but not entirely: for symbols located 56 in static storage, the "code" says which segment the address is in, 57 which controls how it is relocated. 58 59 The "value" for a symbol in static storage 60 is the core address of the symbol (actually, the assembler 61 label for the symbol). For a symbol located in a stack slot 62 it is the stack offset; for one in a register, the register number. 63 For a typedef symbol, it is zero. 64 65 If DEBUG_SYMS_TEXT is defined, all debugging symbols must be 66 output while in the text section. 67 68 For more on data type definitions, see `dbxout_type'. */ 69 70#include "config.h" 71#include "system.h" 72 73#include "tree.h" 74#include "rtl.h" 75#include "flags.h" 76#include "regs.h" 77#include "insn-config.h" 78#include "reload.h" 79#include "defaults.h" 80#include "output.h" /* ASM_OUTPUT_SOURCE_LINE may refer to sdb functions. */ 81#include "dbxout.h" 82#include "toplev.h" 83 84#ifdef XCOFF_DEBUGGING_INFO 85#include "xcoffout.h" 86#endif 87 88#ifndef ASM_STABS_OP 89#define ASM_STABS_OP ".stabs" 90#endif 91 92#ifndef ASM_STABN_OP 93#define ASM_STABN_OP ".stabn" 94#endif 95 96#ifndef DBX_TYPE_DECL_STABS_CODE 97#define DBX_TYPE_DECL_STABS_CODE N_LSYM 98#endif 99 100#ifndef DBX_STATIC_CONST_VAR_CODE 101#define DBX_STATIC_CONST_VAR_CODE N_FUN 102#endif 103 104#ifndef DBX_REGPARM_STABS_CODE 105#define DBX_REGPARM_STABS_CODE N_RSYM 106#endif 107 108#ifndef DBX_REGPARM_STABS_LETTER 109#define DBX_REGPARM_STABS_LETTER 'P' 110#endif 111 112/* This is used for parameters passed by invisible reference in a register. */ 113#ifndef GDB_INV_REF_REGPARM_STABS_LETTER 114#define GDB_INV_REF_REGPARM_STABS_LETTER 'a' 115#endif 116 117#ifndef DBX_MEMPARM_STABS_LETTER 118#define DBX_MEMPARM_STABS_LETTER 'p' 119#endif 120 121#ifndef FILE_NAME_JOINER 122#define FILE_NAME_JOINER "/" 123#endif 124 125/* Nonzero means if the type has methods, only output debugging 126 information if methods are actually written to the asm file. This 127 optimization only works if the debugger can detect the special C++ 128 marker. */ 129 130#define MINIMAL_DEBUG 1 131 132#ifdef NO_DOLLAR_IN_LABEL 133#ifdef NO_DOT_IN_LABEL 134#undef MINIMAL_DEBUG 135#define MINIMAL_DEBUG 0 136#endif 137#endif 138 139char *getpwd (); 140 141/* Typical USG systems don't have stab.h, and they also have 142 no use for DBX-format debugging info. */ 143 144#if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO) 145 146static int flag_minimal_debug = MINIMAL_DEBUG; 147 148/* Nonzero if we have actually used any of the GDB extensions 149 to the debugging format. The idea is that we use them for the 150 first time only if there's a strong reason, but once we have done that, 151 we use them whenever convenient. */ 152 153static int have_used_extensions = 0; 154 155/* Number for the next N_SOL filename stabs label. The number 0 is reserved 156 for the N_SO filename stabs label. */ 157 158static int source_label_number = 1; 159 160#ifdef DEBUG_SYMS_TEXT 161#define FORCE_TEXT text_section (); 162#else 163#define FORCE_TEXT 164#endif 165 166/* If there is a system stab.h, use it. Otherwise, use our own. */ 167/* ??? This is supposed to describe the target's stab format, so using 168 the host HAVE_STAB_H appears to be wrong. For now, we use our own file 169 when cross compiling. */ 170#if defined (USG) || !defined (HAVE_STAB_H) || defined (CROSS_COMPILE) 171#include "gstab.h" /* If doing DBX on sysV, use our own stab.h. */ 172#else 173#include <stab.h> 174 175/* This is a GNU extension we need to reference in this file. */ 176#ifndef N_CATCH 177#define N_CATCH 0x54 178#endif 179#endif 180 181#ifdef __GNU_STAB__ 182#define STAB_CODE_TYPE enum __stab_debug_code 183#else 184#define STAB_CODE_TYPE int 185#endif 186 187/* 1 if PARM is passed to this function in memory. */ 188 189#define PARM_PASSED_IN_MEMORY(PARM) \ 190 (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM) 191 192/* A C expression for the integer offset value of an automatic variable 193 (N_LSYM) having address X (an RTX). */ 194#ifndef DEBUGGER_AUTO_OFFSET 195#define DEBUGGER_AUTO_OFFSET(X) \ 196 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0) 197#endif 198 199/* A C expression for the integer offset value of an argument (N_PSYM) 200 having address X (an RTX). The nominal offset is OFFSET. */ 201#ifndef DEBUGGER_ARG_OFFSET 202#define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET) 203#endif 204 205/* Stream for writing to assembler file. */ 206 207static FILE *asmfile; 208 209/* Last source file name mentioned in a NOTE insn. */ 210 211static char *lastfile; 212 213/* Current working directory. */ 214 215static char *cwd; 216 217enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED}; 218 219/* Structure recording information about a C data type. 220 The status element says whether we have yet output 221 the definition of the type. TYPE_XREF says we have 222 output it as a cross-reference only. 223 The file_number and type_number elements are used if DBX_USE_BINCL 224 is defined. */ 225 226struct typeinfo 227{ 228 enum typestatus status; 229#ifdef DBX_USE_BINCL 230 int file_number; 231 int type_number; 232#endif 233}; 234 235/* Vector recording information about C data types. 236 When we first notice a data type (a tree node), 237 we assign it a number using next_type_number. 238 That is its index in this vector. */ 239 240struct typeinfo *typevec; 241 242/* Number of elements of space allocated in `typevec'. */ 243 244static int typevec_len; 245 246/* In dbx output, each type gets a unique number. 247 This is the number for the next type output. 248 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */ 249 250static int next_type_number; 251 252#ifdef DBX_USE_BINCL 253 254/* When using N_BINCL in dbx output, each type number is actually a 255 pair of the file number and the type number within the file. 256 This is a stack of input files. */ 257 258struct dbx_file 259{ 260 struct dbx_file *next; 261 int file_number; 262 int next_type_number; 263}; 264 265/* This is the top of the stack. */ 266 267static struct dbx_file *current_file; 268 269/* This is the next file number to use. */ 270 271static int next_file_number; 272 273#endif /* DBX_USE_BINCL */ 274 275/* In dbx output, we must assign symbol-blocks id numbers 276 in the order in which their beginnings are encountered. 277 We output debugging info that refers to the beginning and 278 end of the ranges of code in each block 279 with assembler labels LBBn and LBEn, where n is the block number. 280 The labels are generated in final, which assigns numbers to the 281 blocks in the same way. */ 282 283static int next_block_number; 284 285/* These variables are for dbxout_symbol to communicate to 286 dbxout_finish_symbol. 287 current_sym_code is the symbol-type-code, a symbol N_... define in stab.h. 288 current_sym_value and current_sym_addr are two ways to address the 289 value to store in the symtab entry. 290 current_sym_addr if nonzero represents the value as an rtx. 291 If that is zero, current_sym_value is used. This is used 292 when the value is an offset (such as for auto variables, 293 register variables and parms). */ 294 295static STAB_CODE_TYPE current_sym_code; 296static int current_sym_value; 297static rtx current_sym_addr; 298 299/* Number of chars of symbol-description generated so far for the 300 current symbol. Used by CHARS and CONTIN. */ 301 302static int current_sym_nchars; 303 304/* Report having output N chars of the current symbol-description. */ 305 306#define CHARS(N) (current_sym_nchars += (N)) 307 308/* Break the current symbol-description, generating a continuation, 309 if it has become long. */ 310 311#ifndef DBX_CONTIN_LENGTH 312#define DBX_CONTIN_LENGTH 80 313#endif 314 315#if DBX_CONTIN_LENGTH > 0 316#define CONTIN \ 317 do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0) 318#else 319#define CONTIN 320#endif 321 322void dbxout_types (); 323void dbxout_args (); 324void dbxout_symbol (); 325 326#if defined(ASM_OUTPUT_SECTION_NAME) 327static void dbxout_function_end PROTO((void)); 328#endif 329static void dbxout_typedefs PROTO((tree)); 330static void dbxout_type_index PROTO((tree)); 331#if DBX_CONTIN_LENGTH > 0 332static void dbxout_continue PROTO((void)); 333#endif 334static void dbxout_type_fields PROTO((tree)); 335static void dbxout_type_method_1 PROTO((tree, char *)); 336static void dbxout_type_methods PROTO((tree)); 337static void dbxout_range_type PROTO((tree)); 338static void dbxout_type PROTO((tree, int, int)); 339static void print_int_cst_octal PROTO((tree)); 340static void print_octal PROTO((unsigned HOST_WIDE_INT, int)); 341static void dbxout_type_name PROTO((tree)); 342static void dbxout_symbol_location PROTO((tree, tree, char *, rtx)); 343static void dbxout_symbol_name PROTO((tree, char *, int)); 344static void dbxout_prepare_symbol PROTO((tree)); 345static void dbxout_finish_symbol PROTO((tree)); 346static void dbxout_block PROTO((tree, int, tree)); 347static void dbxout_really_begin_function PROTO((tree)); 348 349#if defined(ASM_OUTPUT_SECTION_NAME) 350static void 351dbxout_function_end () 352{ 353 static int scope_labelno = 0; 354 char lscope_label_name[100]; 355 /* Convert Ltext into the appropriate format for local labels in case 356 the system doesn't insert underscores in front of user generated 357 labels. */ 358 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name, "Lscope", scope_labelno); 359 ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Lscope", scope_labelno); 360 scope_labelno++; 361 362 /* By convention, GCC will mark the end of a function with an N_FUN 363 symbol and an empty string. */ 364 fprintf (asmfile, "%s \"\",%d,0,0,", ASM_STABS_OP, N_FUN); 365 assemble_name (asmfile, lscope_label_name); 366 fputc ('-', asmfile); 367 assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0)); 368 fprintf (asmfile, "\n"); 369} 370#endif /* ! NO_DBX_FUNCTION_END */ 371 372/* At the beginning of compilation, start writing the symbol table. 373 Initialize `typevec' and output the standard data types of C. */ 374 375void 376dbxout_init (asm_file, input_file_name, syms) 377 FILE *asm_file; 378 char *input_file_name; 379 tree syms; 380{ 381 char ltext_label_name[100]; 382 383 asmfile = asm_file; 384 385 typevec_len = 100; 386 typevec = (struct typeinfo *) xmalloc (typevec_len * sizeof typevec[0]); 387 bzero ((char *) typevec, typevec_len * sizeof typevec[0]); 388 389 /* Convert Ltext into the appropriate format for local labels in case 390 the system doesn't insert underscores in front of user generated 391 labels. */ 392 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0); 393 394 /* Put the current working directory in an N_SO symbol. */ 395#ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this, 396 but GDB always does. */ 397 if (use_gnu_debug_info_extensions) 398#endif 399 { 400 if (!cwd && (cwd = getpwd ()) && (!*cwd || cwd[strlen (cwd) - 1] != '/')) 401 { 402 char *wdslash = xmalloc (strlen (cwd) + sizeof (FILE_NAME_JOINER)); 403 sprintf (wdslash, "%s%s", cwd, FILE_NAME_JOINER); 404 cwd = wdslash; 405 } 406 if (cwd) 407 { 408#ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY 409 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile, cwd); 410#else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */ 411 fprintf (asmfile, "%s ", ASM_STABS_OP); 412 output_quoted_string (asmfile, cwd); 413 fprintf (asmfile, ",%d,0,0,%s\n", N_SO, <ext_label_name[1]); 414#endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */ 415 } 416 } 417 418#ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME 419 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That 420 would give us an N_SOL, and we want an N_SO. */ 421 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile, input_file_name); 422#else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */ 423 /* We include outputting `Ltext:' here, 424 because that gives you a way to override it. */ 425 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */ 426 fprintf (asmfile, "%s ", ASM_STABS_OP); 427 output_quoted_string (asmfile, input_file_name); 428 fprintf (asmfile, ",%d,0,0,%s\n", 429 N_SO, <ext_label_name[1]); 430 text_section (); 431 ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Ltext", 0); 432#endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */ 433 434 /* Possibly output something to inform GDB that this compilation was by 435 GCC. It's easier for GDB to parse it when after the N_SO's. This 436 is used in Solaris 2. */ 437#ifdef ASM_IDENTIFY_GCC_AFTER_SOURCE 438 ASM_IDENTIFY_GCC_AFTER_SOURCE (asmfile); 439#endif 440 441 lastfile = input_file_name; 442 443 next_type_number = 1; 444 next_block_number = 2; 445 446#ifdef DBX_USE_BINCL 447 current_file = (struct dbx_file *) xmalloc (sizeof *current_file); 448 current_file->next = NULL; 449 current_file->file_number = 0; 450 current_file->next_type_number = 1; 451 next_file_number = 1; 452#endif 453 454 /* Make sure that types `int' and `char' have numbers 1 and 2. 455 Definitions of other integer types will refer to those numbers. 456 (Actually it should no longer matter what their numbers are. 457 Also, if any types with tags have been defined, dbxout_symbol 458 will output them first, so the numbers won't be 1 and 2. That 459 happens in C++. So it's a good thing it should no longer matter). */ 460 461#ifdef DBX_OUTPUT_STANDARD_TYPES 462 DBX_OUTPUT_STANDARD_TYPES (syms); 463#else 464 dbxout_symbol (TYPE_NAME (integer_type_node), 0); 465 dbxout_symbol (TYPE_NAME (char_type_node), 0); 466#endif 467 468 /* Get all permanent types that have typedef names, 469 and output them all, except for those already output. */ 470 471 dbxout_typedefs (syms); 472} 473 474/* Output any typedef names for types described by TYPE_DECLs in SYMS, 475 in the reverse order from that which is found in SYMS. */ 476 477static void 478dbxout_typedefs (syms) 479 tree syms; 480{ 481 if (syms) 482 { 483 dbxout_typedefs (TREE_CHAIN (syms)); 484 if (TREE_CODE (syms) == TYPE_DECL) 485 { 486 tree type = TREE_TYPE (syms); 487 if (TYPE_NAME (type) 488 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 489 && TYPE_SIZE (type) != NULL_TREE 490 && ! TREE_ASM_WRITTEN (TYPE_NAME (type))) 491 dbxout_symbol (TYPE_NAME (type), 0); 492 } 493 } 494} 495 496/* Change to reading from a new source file. Generate a N_BINCL stab. */ 497 498void 499dbxout_start_new_source_file (filename) 500 char *filename ATTRIBUTE_UNUSED; 501{ 502#ifdef DBX_USE_BINCL 503 struct dbx_file *n = (struct dbx_file *) xmalloc (sizeof *n); 504 505 n->next = current_file; 506 n->file_number = next_file_number++; 507 n->next_type_number = 1; 508 current_file = n; 509 fprintf (asmfile, "%s ", ASM_STABS_OP); 510 output_quoted_string (asmfile, filename); 511 fprintf (asmfile, ",%d,0,0,0\n", N_BINCL); 512#endif 513} 514 515/* Revert to reading a previous source file. Generate a N_EINCL stab. */ 516 517void 518dbxout_resume_previous_source_file () 519{ 520#ifdef DBX_USE_BINCL 521 struct dbx_file *next; 522 523 fprintf (asmfile, "%s %d,0,0,0\n", ASM_STABN_OP, N_EINCL); 524 next = current_file->next; 525 free (current_file); 526 current_file = next; 527#endif 528} 529 530/* Output debugging info to FILE to switch to sourcefile FILENAME. */ 531 532void 533dbxout_source_file (file, filename) 534 FILE *file; 535 char *filename; 536{ 537 char ltext_label_name[100]; 538 539 if (filename && (lastfile == 0 || strcmp (filename, lastfile))) 540 { 541#ifdef DBX_OUTPUT_SOURCE_FILENAME 542 DBX_OUTPUT_SOURCE_FILENAME (file, filename); 543#else 544 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 545 source_label_number); 546 fprintf (file, "%s ", ASM_STABS_OP); 547 output_quoted_string (file, filename); 548 fprintf (file, ",%d,0,0,%s\n", N_SOL, <ext_label_name[1]); 549 if (current_function_decl != NULL_TREE 550 && DECL_SECTION_NAME (current_function_decl) != NULL_TREE) 551 ; /* Don't change section amid function. */ 552 else 553 text_section (); 554 ASM_OUTPUT_INTERNAL_LABEL (file, "Ltext", source_label_number); 555 source_label_number++; 556#endif 557 lastfile = filename; 558 } 559} 560 561/* Output a line number symbol entry into output stream FILE, 562 for source file FILENAME and line number LINENO. */ 563 564void 565dbxout_source_line (file, filename, lineno) 566 FILE *file; 567 char *filename; 568 int lineno; 569{ 570 dbxout_source_file (file, filename); 571 572#ifdef ASM_OUTPUT_SOURCE_LINE 573 ASM_OUTPUT_SOURCE_LINE (file, lineno); 574#else 575 fprintf (file, "\t%s %d,0,%d\n", ASM_STABD_OP, N_SLINE, lineno); 576#endif 577} 578 579/* At the end of compilation, finish writing the symbol table. 580 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is 581 to do nothing. */ 582 583void 584dbxout_finish (file, filename) 585 FILE *file ATTRIBUTE_UNUSED; 586 char *filename ATTRIBUTE_UNUSED; 587{ 588#ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END 589 DBX_OUTPUT_MAIN_SOURCE_FILE_END (file, filename); 590#endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */ 591} 592 593/* Output the index of a type. */ 594 595static void 596dbxout_type_index (type) 597 tree type; 598{ 599#ifndef DBX_USE_BINCL 600 fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type)); 601 CHARS (3); 602#else 603 struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)]; 604 fprintf (asmfile, "(%d,%d)", t->file_number, t->type_number); 605 CHARS (7); 606#endif 607} 608 609#if DBX_CONTIN_LENGTH > 0 610/* Continue a symbol-description that gets too big. 611 End one symbol table entry with a double-backslash 612 and start a new one, eventually producing something like 613 .stabs "start......\\",code,0,value 614 .stabs "...rest",code,0,value */ 615 616static void 617dbxout_continue () 618{ 619#ifdef DBX_CONTIN_CHAR 620 fprintf (asmfile, "%c", DBX_CONTIN_CHAR); 621#else 622 fprintf (asmfile, "\\\\"); 623#endif 624 dbxout_finish_symbol (NULL_TREE); 625 fprintf (asmfile, "%s \"", ASM_STABS_OP); 626 current_sym_nchars = 0; 627} 628#endif /* DBX_CONTIN_LENGTH > 0 */ 629 630/* Subroutine of `dbxout_type'. Output the type fields of TYPE. 631 This must be a separate function because anonymous unions require 632 recursive calls. */ 633 634static void 635dbxout_type_fields (type) 636 tree type; 637{ 638 tree tem; 639 /* Output the name, type, position (in bits), size (in bits) of each 640 field. */ 641 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem)) 642 { 643 /* Omit here local type decls until we know how to support them. */ 644 if (TREE_CODE (tem) == TYPE_DECL) 645 continue; 646 /* Omit fields whose position or size are variable. */ 647 else if (TREE_CODE (tem) == FIELD_DECL 648 && (TREE_CODE (DECL_FIELD_BITPOS (tem)) != INTEGER_CST 649 || TREE_CODE (DECL_SIZE (tem)) != INTEGER_CST)) 650 continue; 651 /* Omit here the nameless fields that are used to skip bits. */ 652 else if (DECL_IGNORED_P (tem)) 653 continue; 654 else if (TREE_CODE (tem) != CONST_DECL) 655 { 656 /* Continue the line if necessary, 657 but not before the first field. */ 658 if (tem != TYPE_FIELDS (type)) 659 { 660 CONTIN; 661 } 662 663 if (use_gnu_debug_info_extensions 664 && flag_minimal_debug 665 && TREE_CODE (tem) == FIELD_DECL 666 && DECL_VIRTUAL_P (tem) 667 && DECL_ASSEMBLER_NAME (tem)) 668 { 669 have_used_extensions = 1; 670 CHARS (3 + IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (tem))); 671 fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem)), asmfile); 672 dbxout_type (DECL_FCONTEXT (tem), 0, 0); 673 fprintf (asmfile, ":"); 674 dbxout_type (TREE_TYPE (tem), 0, 0); 675 fputc (',', asmfile); 676 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, 677 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem))); 678 fputc (';', asmfile); 679 continue; 680 } 681 682 if (DECL_NAME (tem)) 683 { 684 fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem))); 685 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem))); 686 } 687 else 688 { 689 fprintf (asmfile, ":"); 690 CHARS (2); 691 } 692 693 if (use_gnu_debug_info_extensions 694 && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem) 695 || TREE_CODE (tem) != FIELD_DECL)) 696 { 697 have_used_extensions = 1; 698 putc ('/', asmfile); 699 putc ((TREE_PRIVATE (tem) ? '0' 700 : TREE_PROTECTED (tem) ? '1' : '2'), 701 asmfile); 702 CHARS (2); 703 } 704 705 dbxout_type ((TREE_CODE (tem) == FIELD_DECL 706 && DECL_BIT_FIELD_TYPE (tem)) 707 ? DECL_BIT_FIELD_TYPE (tem) 708 : TREE_TYPE (tem), 0, 0); 709 710 if (TREE_CODE (tem) == VAR_DECL) 711 { 712 if (TREE_STATIC (tem) && use_gnu_debug_info_extensions) 713 { 714 char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem)); 715 have_used_extensions = 1; 716 fprintf (asmfile, ":%s;", name); 717 CHARS (strlen (name)); 718 } 719 else 720 { 721 /* If TEM is non-static, GDB won't understand it. */ 722 fprintf (asmfile, ",0,0;"); 723 } 724 } 725 else if (TREE_CODE (DECL_FIELD_BITPOS (tem)) == INTEGER_CST) 726 { 727 fputc (',', asmfile); 728 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, 729 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem))); 730 fputc (',', asmfile); 731 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, 732 TREE_INT_CST_LOW (DECL_SIZE (tem))); 733 fputc (';', asmfile); 734 } 735 CHARS (23); 736 } 737 } 738} 739 740/* Subroutine of `dbxout_type_methods'. Output debug info about the 741 method described DECL. DEBUG_NAME is an encoding of the method's 742 type signature. ??? We may be able to do without DEBUG_NAME altogether 743 now. */ 744 745static void 746dbxout_type_method_1 (decl, debug_name) 747 tree decl; 748 char *debug_name; 749{ 750 char c1 = 'A', c2; 751 752 if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE) 753 c2 = '?'; 754 else /* it's a METHOD_TYPE. */ 755 { 756 tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl))); 757 /* A for normal functions. 758 B for `const' member functions. 759 C for `volatile' member functions. 760 D for `const volatile' member functions. */ 761 if (TYPE_READONLY (TREE_TYPE (firstarg))) 762 c1 += 1; 763 if (TYPE_VOLATILE (TREE_TYPE (firstarg))) 764 c1 += 2; 765 766 if (DECL_VINDEX (decl)) 767 c2 = '*'; 768 else 769 c2 = '.'; 770 } 771 772 fprintf (asmfile, ":%s;%c%c%c", debug_name, 773 TREE_PRIVATE (decl) ? '0' : TREE_PROTECTED (decl) ? '1' : '2', c1, c2); 774 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl)) + 6 775 - (debug_name - IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)))); 776 if (DECL_VINDEX (decl)) 777 { 778 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, 779 TREE_INT_CST_LOW (DECL_VINDEX (decl))); 780 fputc (';', asmfile); 781 dbxout_type (DECL_CONTEXT (decl), 0, 0); 782 fprintf (asmfile, ";"); 783 CHARS (8); 784 } 785} 786 787/* Subroutine of `dbxout_type'. Output debug info about the methods defined 788 in TYPE. */ 789 790static void 791dbxout_type_methods (type) 792 register tree type; 793{ 794 /* C++: put out the method names and their parameter lists */ 795 tree methods = TYPE_METHODS (type); 796 tree type_encoding; 797 register tree fndecl; 798 register tree last; 799 char formatted_type_identifier_length[16]; 800 register int type_identifier_length; 801 802 if (methods == NULL_TREE) 803 return; 804 805 type_encoding = DECL_NAME (TYPE_NAME (type)); 806 807#if 0 808 /* C++: Template classes break some assumptions made by this code about 809 the class names, constructor names, and encodings for assembler 810 label names. For now, disable output of dbx info for them. */ 811 { 812 char *ptr = IDENTIFIER_POINTER (type_encoding); 813 /* This should use index. (mrs) */ 814 while (*ptr && *ptr != '<') ptr++; 815 if (*ptr != 0) 816 { 817 static int warned; 818 if (!warned) 819 warned = 1; 820 return; 821 } 822 } 823#endif 824 825 type_identifier_length = IDENTIFIER_LENGTH (type_encoding); 826 827 sprintf(formatted_type_identifier_length, "%d", type_identifier_length); 828 829 if (TREE_CODE (methods) != TREE_VEC) 830 fndecl = methods; 831 else if (TREE_VEC_ELT (methods, 0) != NULL_TREE) 832 fndecl = TREE_VEC_ELT (methods, 0); 833 else 834 fndecl = TREE_VEC_ELT (methods, 1); 835 836 while (fndecl) 837 { 838 tree name = DECL_NAME (fndecl); 839 int need_prefix = 1; 840 841 /* Group together all the methods for the same operation. 842 These differ in the types of the arguments. */ 843 for (last = NULL_TREE; 844 fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last)); 845 fndecl = TREE_CHAIN (fndecl)) 846 /* Output the name of the field (after overloading), as 847 well as the name of the field before overloading, along 848 with its parameter list */ 849 { 850 /* This is the "mangled" name of the method. 851 It encodes the argument types. */ 852 char *debug_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)); 853 int show_arg_types = 0; 854 855 CONTIN; 856 857 last = fndecl; 858 859 if (DECL_IGNORED_P (fndecl)) 860 continue; 861 862 if (flag_minimal_debug) 863 { 864 char marker; 865 866 /* We can't optimize a method which uses an anonymous 867 class, because the debugger will not be able to 868 associate the arbitrary class name with the actual 869 class. */ 870#ifndef NO_DOLLAR_IN_LABEL 871 marker = '$'; 872#else 873 marker = '.'; 874#endif 875 if (strchr (debug_name, marker)) 876 show_arg_types = 1; 877 /* Detect ordinary methods because their mangled names 878 start with the operation name. */ 879 else if (!strncmp (IDENTIFIER_POINTER (name), debug_name, 880 IDENTIFIER_LENGTH (name))) 881 { 882 debug_name += IDENTIFIER_LENGTH (name); 883 if (debug_name[0] == '_' && debug_name[1] == '_') 884 { 885 char *method_name = debug_name + 2; 886 char *length_ptr = formatted_type_identifier_length; 887 /* Get past const and volatile qualifiers. */ 888 while (*method_name == 'C' || *method_name == 'V') 889 method_name++; 890 /* Skip digits for length of type_encoding. */ 891 while (*method_name == *length_ptr && *length_ptr) 892 length_ptr++, method_name++; 893 if (! strncmp (method_name, 894 IDENTIFIER_POINTER (type_encoding), 895 type_identifier_length)) 896 method_name += type_identifier_length; 897 debug_name = method_name; 898 } 899 } 900 /* Detect constructors by their style of name mangling. */ 901 else if (debug_name[0] == '_' && debug_name[1] == '_') 902 { 903 char *ctor_name = debug_name + 2; 904 char *length_ptr = formatted_type_identifier_length; 905 while (*ctor_name == 'C' || *ctor_name == 'V') 906 ctor_name++; 907 /* Skip digits for length of type_encoding. */ 908 while (*ctor_name == *length_ptr && *length_ptr) 909 length_ptr++, ctor_name++; 910 if (!strncmp (IDENTIFIER_POINTER (type_encoding), ctor_name, 911 type_identifier_length)) 912 debug_name = ctor_name + type_identifier_length; 913 } 914 /* The other alternative is a destructor. */ 915 else 916 show_arg_types = 1; 917 918 /* Output the operation name just once, for the first method 919 that we output. */ 920 if (need_prefix) 921 { 922 fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name)); 923 CHARS (IDENTIFIER_LENGTH (name) + 2); 924 need_prefix = 0; 925 } 926 } 927 928 dbxout_type (TREE_TYPE (fndecl), 0, show_arg_types); 929 930 dbxout_type_method_1 (fndecl, debug_name); 931 } 932 if (!need_prefix) 933 { 934 putc (';', asmfile); 935 CHARS (1); 936 } 937 } 938} 939 940/* Emit a "range" type specification, which has the form: 941 "r<index type>;<lower bound>;<upper bound>;". 942 TYPE is an INTEGER_TYPE. */ 943 944static void 945dbxout_range_type (type) 946 tree type; 947{ 948 fprintf (asmfile, "r"); 949 if (TREE_TYPE (type)) 950 dbxout_type (TREE_TYPE (type), 0, 0); 951 else if (TREE_CODE (type) != INTEGER_TYPE) 952 dbxout_type (type, 0, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */ 953 else 954 { 955 /* Traditionally, we made sure 'int' was type 1, and builtin types 956 were defined to be sub-ranges of int. Unfortunately, this 957 does not allow us to distinguish true sub-ranges from integer 958 types. So, instead we define integer (non-sub-range) types as 959 sub-ranges of themselves. This matters for Chill. If this isn't 960 a subrange type, then we want to define it in terms of itself. 961 However, in C, this may be an anonymous integer type, and we don't 962 want to emit debug info referring to it. Just calling 963 dbxout_type_index won't work anyways, because the type hasn't been 964 defined yet. We make this work for both cases by checked to see 965 whether this is a defined type, referring to it if it is, and using 966 'int' otherwise. */ 967 if (TYPE_SYMTAB_ADDRESS (type) != 0) 968 dbxout_type_index (type); 969 else 970 dbxout_type_index (integer_type_node); 971 } 972 if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST) 973 { 974 fputc (';', asmfile); 975 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, 976 TREE_INT_CST_LOW (TYPE_MIN_VALUE (type))); 977 } 978 else 979 fprintf (asmfile, ";0"); 980 if (TYPE_MAX_VALUE (type) 981 && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST) 982 { 983 fputc (';', asmfile); 984 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, 985 TREE_INT_CST_LOW (TYPE_MAX_VALUE (type))); 986 fputc (';', asmfile); 987 } 988 else 989 fprintf (asmfile, ";-1;"); 990} 991 992/* Output a reference to a type. If the type has not yet been 993 described in the dbx output, output its definition now. 994 For a type already defined, just refer to its definition 995 using the type number. 996 997 If FULL is nonzero, and the type has been described only with 998 a forward-reference, output the definition now. 999 If FULL is zero in this case, just refer to the forward-reference 1000 using the number previously allocated. 1001 1002 If SHOW_ARG_TYPES is nonzero, we output a description of the argument 1003 types for a METHOD_TYPE. */ 1004 1005static void 1006dbxout_type (type, full, show_arg_types) 1007 tree type; 1008 int full; 1009 int show_arg_types; 1010{ 1011 register tree tem; 1012 static int anonymous_type_number = 0; 1013 1014 /* If there was an input error and we don't really have a type, 1015 avoid crashing and write something that is at least valid 1016 by assuming `int'. */ 1017 if (type == error_mark_node) 1018 type = integer_type_node; 1019 else 1020 { 1021 /* Try to find the "main variant" with the same name but not const 1022 or volatile. (Since stabs does not distinguish const and volatile, 1023 there is no need to make them separate types. But types with 1024 different names are usefully distinguished.) */ 1025 1026 for (tem = TYPE_MAIN_VARIANT (type); tem; tem = TYPE_NEXT_VARIANT (tem)) 1027 if (!TYPE_READONLY (tem) && !TYPE_VOLATILE (tem) 1028 && TYPE_NAME (tem) == TYPE_NAME (type)) 1029 { 1030 type = tem; 1031 break; 1032 } 1033 if (TYPE_NAME (type) 1034 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 1035 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type))) 1036 full = 0; 1037 } 1038 1039 if (TYPE_SYMTAB_ADDRESS (type) == 0) 1040 { 1041 /* Type has no dbx number assigned. Assign next available number. */ 1042 TYPE_SYMTAB_ADDRESS (type) = next_type_number++; 1043 1044 /* Make sure type vector is long enough to record about this type. */ 1045 1046 if (next_type_number == typevec_len) 1047 { 1048 typevec 1049 = (struct typeinfo *) xrealloc (typevec, 1050 typevec_len * 2 * sizeof typevec[0]); 1051 bzero ((char *) (typevec + typevec_len), 1052 typevec_len * sizeof typevec[0]); 1053 typevec_len *= 2; 1054 } 1055 1056#ifdef DBX_USE_BINCL 1057 typevec[TYPE_SYMTAB_ADDRESS (type)].file_number 1058 = current_file->file_number; 1059 typevec[TYPE_SYMTAB_ADDRESS (type)].type_number 1060 = current_file->next_type_number++; 1061#endif 1062 } 1063 1064 /* Output the number of this type, to refer to it. */ 1065 dbxout_type_index (type); 1066 1067#ifdef DBX_TYPE_DEFINED 1068 if (DBX_TYPE_DEFINED (type)) 1069 return; 1070#endif 1071 1072 /* If this type's definition has been output or is now being output, 1073 that is all. */ 1074 1075 switch (typevec[TYPE_SYMTAB_ADDRESS (type)].status) 1076 { 1077 case TYPE_UNSEEN: 1078 break; 1079 case TYPE_XREF: 1080 /* If we have already had a cross reference, 1081 and either that's all we want or that's the best we could do, 1082 don't repeat the cross reference. 1083 Sun dbx crashes if we do. */ 1084 if (! full || TYPE_SIZE (type) == 0 1085 /* No way in DBX fmt to describe a variable size. */ 1086 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) 1087 return; 1088 break; 1089 case TYPE_DEFINED: 1090 return; 1091 } 1092 1093#ifdef DBX_NO_XREFS 1094 /* For systems where dbx output does not allow the `=xsNAME:' syntax, 1095 leave the type-number completely undefined rather than output 1096 a cross-reference. If we have already used GNU debug info extensions, 1097 then it is OK to output a cross reference. This is necessary to get 1098 proper C++ debug output. */ 1099 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE 1100 || TREE_CODE (type) == QUAL_UNION_TYPE 1101 || TREE_CODE (type) == ENUMERAL_TYPE) 1102 && ! use_gnu_debug_info_extensions) 1103 /* We must use the same test here as we use twice below when deciding 1104 whether to emit a cross-reference. */ 1105 if ((TYPE_NAME (type) != 0 1106 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 1107 && DECL_IGNORED_P (TYPE_NAME (type))) 1108 && !full) 1109 || TYPE_SIZE (type) == 0 1110 /* No way in DBX fmt to describe a variable size. */ 1111 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) 1112 { 1113 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF; 1114 return; 1115 } 1116#endif 1117 1118 /* Output a definition now. */ 1119 1120 fprintf (asmfile, "="); 1121 CHARS (1); 1122 1123 /* Mark it as defined, so that if it is self-referent 1124 we will not get into an infinite recursion of definitions. */ 1125 1126 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_DEFINED; 1127 1128 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 1129 && DECL_ORIGINAL_TYPE (TYPE_NAME (type))) 1130 { 1131 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type)), 0, 0); 1132 return; 1133 } 1134 1135 switch (TREE_CODE (type)) 1136 { 1137 case VOID_TYPE: 1138 case LANG_TYPE: 1139 /* For a void type, just define it as itself; ie, "5=5". 1140 This makes us consider it defined 1141 without saying what it is. The debugger will make it 1142 a void type when the reference is seen, and nothing will 1143 ever override that default. */ 1144 dbxout_type_index (type); 1145 break; 1146 1147 case INTEGER_TYPE: 1148 if (type == char_type_node && ! TREE_UNSIGNED (type)) 1149 { 1150 /* Output the type `char' as a subrange of itself! 1151 I don't understand this definition, just copied it 1152 from the output of pcc. 1153 This used to use `r2' explicitly and we used to 1154 take care to make sure that `char' was type number 2. */ 1155 fprintf (asmfile, "r"); 1156 dbxout_type_index (type); 1157 fprintf (asmfile, ";0;127;"); 1158 } 1159 /* This used to check if the type's precision was more than 1160 HOST_BITS_PER_WIDE_INT. That is wrong since gdb uses a 1161 long (it has no concept of HOST_BITS_PER_WIDE_INT). */ 1162 else if (use_gnu_debug_info_extensions 1163 && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node) 1164 || TYPE_PRECISION (type) >= HOST_BITS_PER_LONG)) 1165 { 1166 /* This used to say `r1' and we used to take care 1167 to make sure that `int' was type number 1. */ 1168 fprintf (asmfile, "r"); 1169 dbxout_type_index (integer_type_node); 1170 fprintf (asmfile, ";"); 1171 print_int_cst_octal (TYPE_MIN_VALUE (type)); 1172 fprintf (asmfile, ";"); 1173 print_int_cst_octal (TYPE_MAX_VALUE (type)); 1174 fprintf (asmfile, ";"); 1175 } 1176 else /* Output other integer types as subranges of `int'. */ 1177 dbxout_range_type (type); 1178 CHARS (22); 1179 break; 1180 1181 case REAL_TYPE: 1182 /* This used to say `r1' and we used to take care 1183 to make sure that `int' was type number 1. */ 1184 fprintf (asmfile, "r"); 1185 dbxout_type_index (integer_type_node); 1186 fputc (';', asmfile); 1187 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, int_size_in_bytes (type)); 1188 fputs (";0;", asmfile); 1189 CHARS (13); 1190 break; 1191 1192 case CHAR_TYPE: 1193 if (use_gnu_debug_info_extensions) 1194 { 1195 fputs ("@s", asmfile); 1196 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, 1197 BITS_PER_UNIT * int_size_in_bytes (type)); 1198 fputs (";-20;", asmfile); 1199 } 1200 else 1201 { 1202 /* Output the type `char' as a subrange of itself. 1203 That is what pcc seems to do. */ 1204 fprintf (asmfile, "r"); 1205 dbxout_type_index (char_type_node); 1206 fprintf (asmfile, ";0;%d;", TREE_UNSIGNED (type) ? 255 : 127); 1207 } 1208 CHARS (9); 1209 break; 1210 1211 case BOOLEAN_TYPE: 1212 if (use_gnu_debug_info_extensions) 1213 { 1214 fputs ("@s", asmfile); 1215 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, 1216 BITS_PER_UNIT * int_size_in_bytes (type)); 1217 fputs (";-16;", asmfile); 1218 } 1219 else /* Define as enumeral type (False, True) */ 1220 fprintf (asmfile, "eFalse:0,True:1,;"); 1221 CHARS (17); 1222 break; 1223 1224 case FILE_TYPE: 1225 putc ('d', asmfile); 1226 CHARS (1); 1227 dbxout_type (TREE_TYPE (type), 0, 0); 1228 break; 1229 1230 case COMPLEX_TYPE: 1231 /* Differs from the REAL_TYPE by its new data type number */ 1232 1233 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE) 1234 { 1235 fprintf (asmfile, "r"); 1236 dbxout_type_index (type); 1237 fputc (';', asmfile); 1238 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, 1239 int_size_in_bytes (TREE_TYPE (type))); 1240 fputs (";0;", asmfile); 1241 CHARS (12); /* The number is probably incorrect here. */ 1242 } 1243 else 1244 { 1245 /* Output a complex integer type as a structure, 1246 pending some other way to do it. */ 1247 fputc ('s', asmfile); 1248 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, int_size_in_bytes (type)); 1249 1250 fprintf (asmfile, "real:"); 1251 CHARS (10); 1252 dbxout_type (TREE_TYPE (type), 0, 0); 1253 fprintf (asmfile, ",%d,%d;", 1254 0, TYPE_PRECISION (TREE_TYPE (type))); 1255 CHARS (8); 1256 fprintf (asmfile, "imag:"); 1257 CHARS (5); 1258 dbxout_type (TREE_TYPE (type), 0, 0); 1259 fprintf (asmfile, ",%d,%d;;", 1260 TYPE_PRECISION (TREE_TYPE (type)), 1261 TYPE_PRECISION (TREE_TYPE (type))); 1262 CHARS (9); 1263 } 1264 break; 1265 1266 case SET_TYPE: 1267 if (use_gnu_debug_info_extensions) 1268 { 1269 have_used_extensions = 1; 1270 fputs ("@s", asmfile); 1271 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, 1272 BITS_PER_UNIT * int_size_in_bytes (type)); 1273 fputc (';', asmfile); 1274 /* Check if a bitstring type, which in Chill is 1275 different from a [power]set. */ 1276 if (TYPE_STRING_FLAG (type)) 1277 fprintf (asmfile, "@S;"); 1278 } 1279 putc ('S', asmfile); 1280 CHARS (1); 1281 dbxout_type (TYPE_DOMAIN (type), 0, 0); 1282 break; 1283 1284 case ARRAY_TYPE: 1285 /* Make arrays of packed bits look like bitstrings for chill. */ 1286 if (TYPE_PACKED (type) && use_gnu_debug_info_extensions) 1287 { 1288 have_used_extensions = 1; 1289 fputs ("@s", asmfile); 1290 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, 1291 BITS_PER_UNIT * int_size_in_bytes (type)); 1292 fputc (';', asmfile); 1293 fprintf (asmfile, "@S;"); 1294 putc ('S', asmfile); 1295 CHARS (1); 1296 dbxout_type (TYPE_DOMAIN (type), 0, 0); 1297 break; 1298 } 1299 /* Output "a" followed by a range type definition 1300 for the index type of the array 1301 followed by a reference to the target-type. 1302 ar1;0;N;M for a C array of type M and size N+1. */ 1303 /* Check if a character string type, which in Chill is 1304 different from an array of characters. */ 1305 if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions) 1306 { 1307 have_used_extensions = 1; 1308 fprintf (asmfile, "@S;"); 1309 } 1310 tem = TYPE_DOMAIN (type); 1311 if (tem == NULL) 1312 { 1313 fprintf (asmfile, "ar"); 1314 dbxout_type_index (integer_type_node); 1315 fprintf (asmfile, ";0;-1;"); 1316 } 1317 else 1318 { 1319 fprintf (asmfile, "a"); 1320 dbxout_range_type (tem); 1321 } 1322 CHARS (14); 1323 dbxout_type (TREE_TYPE (type), 0, 0); 1324 break; 1325 1326 case RECORD_TYPE: 1327 case UNION_TYPE: 1328 case QUAL_UNION_TYPE: 1329 { 1330 int i, n_baseclasses = 0; 1331 1332 if (TYPE_BINFO (type) != 0 1333 && TREE_CODE (TYPE_BINFO (type)) == TREE_VEC 1334 && TYPE_BINFO_BASETYPES (type) != 0) 1335 n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type)); 1336 1337 /* Output a structure type. We must use the same test here as we 1338 use in the DBX_NO_XREFS case above. */ 1339 if ((TYPE_NAME (type) != 0 1340 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 1341 && DECL_IGNORED_P (TYPE_NAME (type))) 1342 && !full) 1343 || TYPE_SIZE (type) == 0 1344 /* No way in DBX fmt to describe a variable size. */ 1345 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) 1346 { 1347 /* If the type is just a cross reference, output one 1348 and mark the type as partially described. 1349 If it later becomes defined, we will output 1350 its real definition. 1351 If the type has a name, don't nest its definition within 1352 another type's definition; instead, output an xref 1353 and let the definition come when the name is defined. */ 1354 fprintf (asmfile, (TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu"); 1355 CHARS (3); 1356#if 0 /* This assertion is legitimately false in C++. */ 1357 /* We shouldn't be outputting a reference to a type before its 1358 definition unless the type has a tag name. 1359 A typedef name without a tag name should be impossible. */ 1360 if (TREE_CODE (TYPE_NAME (type)) != IDENTIFIER_NODE) 1361 abort (); 1362#endif 1363 if (TYPE_NAME (type) != 0) 1364 dbxout_type_name (type); 1365 else 1366 fprintf (asmfile, "$$%d", anonymous_type_number++); 1367 fprintf (asmfile, ":"); 1368 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF; 1369 break; 1370 } 1371 1372 /* Identify record or union, and print its size. */ 1373 fputc (((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u'), asmfile); 1374 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, 1375 int_size_in_bytes (type)); 1376 1377 if (use_gnu_debug_info_extensions) 1378 { 1379 if (n_baseclasses) 1380 { 1381 have_used_extensions = 1; 1382 fprintf (asmfile, "!%d,", n_baseclasses); 1383 CHARS (8); 1384 } 1385 } 1386 for (i = 0; i < n_baseclasses; i++) 1387 { 1388 tree child = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type)), i); 1389 if (use_gnu_debug_info_extensions) 1390 { 1391 have_used_extensions = 1; 1392 putc (TREE_VIA_VIRTUAL (child) ? '1' 1393 : '0', 1394 asmfile); 1395 putc (TREE_VIA_PUBLIC (child) ? '2' 1396 : '0', 1397 asmfile); 1398 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, 1399 TREE_INT_CST_LOW (BINFO_OFFSET (child)) * BITS_PER_UNIT); 1400 fputc (',', asmfile); 1401 CHARS (15); 1402 dbxout_type (BINFO_TYPE (child), 0, 0); 1403 putc (';', asmfile); 1404 } 1405 else 1406 { 1407 /* Print out the base class information with fields 1408 which have the same names at the types they hold. */ 1409 dbxout_type_name (BINFO_TYPE (child)); 1410 putc (':', asmfile); 1411 dbxout_type (BINFO_TYPE (child), full, 0); 1412 fputc (',', asmfile); 1413 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, 1414 TREE_INT_CST_LOW (BINFO_OFFSET (child)) * BITS_PER_UNIT); 1415 fputc (',', asmfile); 1416 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, 1417 TREE_INT_CST_LOW (DECL_SIZE (TYPE_NAME (BINFO_TYPE (child)))) * BITS_PER_UNIT); 1418 fputc (';', asmfile); 1419 CHARS (20); 1420 } 1421 } 1422 } 1423 1424 CHARS (11); 1425 1426 /* Write out the field declarations. */ 1427 dbxout_type_fields (type); 1428 if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE) 1429 { 1430 have_used_extensions = 1; 1431 dbxout_type_methods (type); 1432 } 1433 putc (';', asmfile); 1434 1435 if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE 1436 /* Avoid the ~ if we don't really need it--it confuses dbx. */ 1437 && TYPE_VFIELD (type)) 1438 { 1439 have_used_extensions = 1; 1440 1441 /* Tell GDB+ that it may keep reading. */ 1442 putc ('~', asmfile); 1443 1444 /* We need to write out info about what field this class 1445 uses as its "main" vtable pointer field, because if this 1446 field is inherited from a base class, GDB cannot necessarily 1447 figure out which field it's using in time. */ 1448 if (TYPE_VFIELD (type)) 1449 { 1450 putc ('%', asmfile); 1451 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0, 0); 1452 } 1453 putc (';', asmfile); 1454 CHARS (3); 1455 } 1456 break; 1457 1458 case ENUMERAL_TYPE: 1459 /* We must use the same test here as we use in the DBX_NO_XREFS case 1460 above. We simplify it a bit since an enum will never have a variable 1461 size. */ 1462 if ((TYPE_NAME (type) != 0 1463 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 1464 && DECL_IGNORED_P (TYPE_NAME (type))) 1465 && !full) 1466 || TYPE_SIZE (type) == 0) 1467 { 1468 fprintf (asmfile, "xe"); 1469 CHARS (3); 1470 dbxout_type_name (type); 1471 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF; 1472 fprintf (asmfile, ":"); 1473 return; 1474 } 1475#ifdef DBX_OUTPUT_ENUM 1476 DBX_OUTPUT_ENUM (asmfile, type); 1477#else 1478 if (use_gnu_debug_info_extensions 1479 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node)) 1480 fprintf (asmfile, "@s%d;", TYPE_PRECISION (type)); 1481 putc ('e', asmfile); 1482 CHARS (1); 1483 for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem)) 1484 { 1485 fprintf (asmfile, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem))); 1486 if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0) 1487 fprintf (asmfile, HOST_WIDE_INT_PRINT_UNSIGNED, 1488 TREE_INT_CST_LOW (TREE_VALUE (tem))); 1489 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1 1490 && TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0) 1491 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, 1492 TREE_INT_CST_LOW (TREE_VALUE (tem))); 1493 else 1494 print_int_cst_octal (TREE_VALUE (tem)); 1495 fprintf (asmfile, ","); 1496 CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem))); 1497 if (TREE_CHAIN (tem) != 0) 1498 { 1499 CONTIN; 1500 } 1501 } 1502 putc (';', asmfile); 1503 CHARS (1); 1504#endif 1505 break; 1506 1507 case POINTER_TYPE: 1508 putc ('*', asmfile); 1509 CHARS (1); 1510 dbxout_type (TREE_TYPE (type), 0, 0); 1511 break; 1512 1513 case METHOD_TYPE: 1514 if (use_gnu_debug_info_extensions) 1515 { 1516 have_used_extensions = 1; 1517 putc ('#', asmfile); 1518 CHARS (1); 1519 if (flag_minimal_debug && !show_arg_types) 1520 { 1521 /* Normally, just output the return type. 1522 The argument types are encoded in the method name. */ 1523 putc ('#', asmfile); 1524 CHARS (1); 1525 dbxout_type (TREE_TYPE (type), 0, 0); 1526 putc (';', asmfile); 1527 CHARS (1); 1528 } 1529 else 1530 { 1531 /* When outputting destructors, we need to write 1532 the argument types out longhand. */ 1533 dbxout_type (TYPE_METHOD_BASETYPE (type), 0, 0); 1534 putc (',', asmfile); 1535 CHARS (1); 1536 dbxout_type (TREE_TYPE (type), 0, 0); 1537 dbxout_args (TYPE_ARG_TYPES (type)); 1538 putc (';', asmfile); 1539 CHARS (1); 1540 } 1541 } 1542 else 1543 { 1544 /* Treat it as a function type. */ 1545 dbxout_type (TREE_TYPE (type), 0, 0); 1546 } 1547 break; 1548 1549 case OFFSET_TYPE: 1550 if (use_gnu_debug_info_extensions) 1551 { 1552 have_used_extensions = 1; 1553 putc ('@', asmfile); 1554 CHARS (1); 1555 dbxout_type (TYPE_OFFSET_BASETYPE (type), 0, 0); 1556 putc (',', asmfile); 1557 CHARS (1); 1558 dbxout_type (TREE_TYPE (type), 0, 0); 1559 } 1560 else 1561 { 1562 /* Should print as an int, because it is really 1563 just an offset. */ 1564 dbxout_type (integer_type_node, 0, 0); 1565 } 1566 break; 1567 1568 case REFERENCE_TYPE: 1569 if (use_gnu_debug_info_extensions) 1570 have_used_extensions = 1; 1571 putc (use_gnu_debug_info_extensions ? '&' : '*', asmfile); 1572 CHARS (1); 1573 dbxout_type (TREE_TYPE (type), 0, 0); 1574 break; 1575 1576 case FUNCTION_TYPE: 1577 putc ('f', asmfile); 1578 CHARS (1); 1579 dbxout_type (TREE_TYPE (type), 0, 0); 1580 break; 1581 1582 default: 1583 abort (); 1584 } 1585} 1586 1587/* Print the value of integer constant C, in octal, 1588 handling double precision. */ 1589 1590static void 1591print_int_cst_octal (c) 1592 tree c; 1593{ 1594 unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (c); 1595 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (c); 1596 int excess = (3 - (HOST_BITS_PER_WIDE_INT % 3)); 1597 int width = TYPE_PRECISION (TREE_TYPE (c)); 1598 1599 /* GDB wants constants with no extra leading "1" bits, so 1600 we need to remove any sign-extension that might be 1601 present. */ 1602 if (width == HOST_BITS_PER_WIDE_INT * 2) 1603 ; 1604 else if (width > HOST_BITS_PER_WIDE_INT) 1605 high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1); 1606 else if (width == HOST_BITS_PER_WIDE_INT) 1607 high = 0; 1608 else 1609 high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1); 1610 1611 fprintf (asmfile, "0"); 1612 1613 if (excess == 3) 1614 { 1615 print_octal (high, HOST_BITS_PER_WIDE_INT / 3); 1616 print_octal (low, HOST_BITS_PER_WIDE_INT / 3); 1617 } 1618 else 1619 { 1620 unsigned HOST_WIDE_INT beg = high >> excess; 1621 unsigned HOST_WIDE_INT middle 1622 = ((high & (((HOST_WIDE_INT) 1 << excess) - 1)) << (3 - excess) 1623 | (low >> (HOST_BITS_PER_WIDE_INT / 3 * 3))); 1624 unsigned HOST_WIDE_INT end 1625 = low & (((unsigned HOST_WIDE_INT) 1 1626 << (HOST_BITS_PER_WIDE_INT / 3 * 3)) 1627 - 1); 1628 1629 fprintf (asmfile, "%o%01o", (int)beg, (int)middle); 1630 print_octal (end, HOST_BITS_PER_WIDE_INT / 3); 1631 } 1632} 1633 1634static void 1635print_octal (value, digits) 1636 unsigned HOST_WIDE_INT value; 1637 int digits; 1638{ 1639 int i; 1640 1641 for (i = digits - 1; i >= 0; i--) 1642 fprintf (asmfile, "%01o", (int)((value >> (3 * i)) & 7)); 1643} 1644 1645/* Output the name of type TYPE, with no punctuation. 1646 Such names can be set up either by typedef declarations 1647 or by struct, enum and union tags. */ 1648 1649static void 1650dbxout_type_name (type) 1651 register tree type; 1652{ 1653 tree t; 1654 if (TYPE_NAME (type) == 0) 1655 abort (); 1656 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE) 1657 { 1658 t = TYPE_NAME (type); 1659 } 1660 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL) 1661 { 1662 t = DECL_NAME (TYPE_NAME (type)); 1663 } 1664 else 1665 abort (); 1666 1667 fprintf (asmfile, "%s", IDENTIFIER_POINTER (t)); 1668 CHARS (IDENTIFIER_LENGTH (t)); 1669} 1670 1671/* Output a .stabs for the symbol defined by DECL, 1672 which must be a ..._DECL node in the normal namespace. 1673 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL. 1674 LOCAL is nonzero if the scope is less than the entire file. */ 1675 1676void 1677dbxout_symbol (decl, local) 1678 tree decl; 1679 int local; 1680{ 1681 tree type = TREE_TYPE (decl); 1682 tree context = NULL_TREE; 1683 1684 /* Cast avoids warning in old compilers. */ 1685 current_sym_code = (STAB_CODE_TYPE) 0; 1686 current_sym_value = 0; 1687 current_sym_addr = 0; 1688 1689 /* Ignore nameless syms, but don't ignore type tags. */ 1690 1691 if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL) 1692 || DECL_IGNORED_P (decl)) 1693 return; 1694 1695 dbxout_prepare_symbol (decl); 1696 1697 /* The output will always start with the symbol name, 1698 so always count that in the length-output-so-far. */ 1699 1700 if (DECL_NAME (decl) != 0) 1701 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (decl)); 1702 1703 switch (TREE_CODE (decl)) 1704 { 1705 case CONST_DECL: 1706 /* Enum values are defined by defining the enum type. */ 1707 break; 1708 1709 case FUNCTION_DECL: 1710 if (DECL_RTL (decl) == 0) 1711 return; 1712 if (DECL_EXTERNAL (decl)) 1713 break; 1714 /* Don't mention a nested function under its parent. */ 1715 context = decl_function_context (decl); 1716 if (context == current_function_decl) 1717 break; 1718 if (GET_CODE (DECL_RTL (decl)) != MEM 1719 || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF) 1720 break; 1721 FORCE_TEXT; 1722 1723 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP, 1724 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), 1725 TREE_PUBLIC (decl) ? 'F' : 'f'); 1726 1727 current_sym_code = N_FUN; 1728 current_sym_addr = XEXP (DECL_RTL (decl), 0); 1729 1730 if (TREE_TYPE (type)) 1731 dbxout_type (TREE_TYPE (type), 0, 0); 1732 else 1733 dbxout_type (void_type_node, 0, 0); 1734 1735 /* For a nested function, when that function is compiled, 1736 mention the containing function name 1737 as well as (since dbx wants it) our own assembler-name. */ 1738 if (context != 0) 1739 fprintf (asmfile, ",%s,%s", 1740 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), 1741 IDENTIFIER_POINTER (DECL_NAME (context))); 1742 1743 dbxout_finish_symbol (decl); 1744 break; 1745 1746 case TYPE_DECL: 1747#if 0 1748 /* This seems all wrong. Outputting most kinds of types gives no name 1749 at all. A true definition gives no name; a cross-ref for a 1750 structure can give the tag name, but not a type name. 1751 It seems that no typedef name is defined by outputting a type. */ 1752 1753 /* If this typedef name was defined by outputting the type, 1754 don't duplicate it. */ 1755 if (typevec[TYPE_SYMTAB_ADDRESS (type)].status == TYPE_DEFINED 1756 && TYPE_NAME (TREE_TYPE (decl)) == decl) 1757 return; 1758#endif 1759 /* Don't output the same typedef twice. 1760 And don't output what language-specific stuff doesn't want output. */ 1761 if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl)) 1762 return; 1763 1764 FORCE_TEXT; 1765 1766 { 1767 int tag_needed = 1; 1768 int did_output = 0; 1769 1770 if (DECL_NAME (decl)) 1771 { 1772 /* Nonzero means we must output a tag as well as a typedef. */ 1773 tag_needed = 0; 1774 1775 /* Handle the case of a C++ structure or union 1776 where the TYPE_NAME is a TYPE_DECL 1777 which gives both a typedef name and a tag. */ 1778 /* dbx requires the tag first and the typedef second. */ 1779 if ((TREE_CODE (type) == RECORD_TYPE 1780 || TREE_CODE (type) == UNION_TYPE 1781 || TREE_CODE (type) == QUAL_UNION_TYPE) 1782 && TYPE_NAME (type) == decl 1783 && !(use_gnu_debug_info_extensions && have_used_extensions) 1784 && !TREE_ASM_WRITTEN (TYPE_NAME (type)) 1785 /* Distinguish the implicit typedefs of C++ 1786 from explicit ones that might be found in C. */ 1787 && DECL_ARTIFICIAL (decl)) 1788 { 1789 tree name = TYPE_NAME (type); 1790 if (TREE_CODE (name) == TYPE_DECL) 1791 name = DECL_NAME (name); 1792 1793 current_sym_code = DBX_TYPE_DECL_STABS_CODE; 1794 current_sym_value = 0; 1795 current_sym_addr = 0; 1796 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name); 1797 1798 fprintf (asmfile, "%s \"%s:T", ASM_STABS_OP, 1799 IDENTIFIER_POINTER (name)); 1800 dbxout_type (type, 1, 0); 1801 dbxout_finish_symbol (NULL_TREE); 1802 } 1803 1804 /* Output typedef name. */ 1805 fprintf (asmfile, "%s \"%s:", ASM_STABS_OP, 1806 IDENTIFIER_POINTER (DECL_NAME (decl))); 1807 1808 /* Short cut way to output a tag also. */ 1809 if ((TREE_CODE (type) == RECORD_TYPE 1810 || TREE_CODE (type) == UNION_TYPE 1811 || TREE_CODE (type) == QUAL_UNION_TYPE) 1812 && TYPE_NAME (type) == decl 1813 /* Distinguish the implicit typedefs of C++ 1814 from explicit ones that might be found in C. */ 1815 && DECL_ARTIFICIAL (decl)) 1816 { 1817 if (use_gnu_debug_info_extensions && have_used_extensions) 1818 { 1819 putc ('T', asmfile); 1820 TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1; 1821 } 1822#if 0 /* Now we generate the tag for this case up above. */ 1823 else 1824 tag_needed = 1; 1825#endif 1826 } 1827 1828 putc ('t', asmfile); 1829 current_sym_code = DBX_TYPE_DECL_STABS_CODE; 1830 1831 dbxout_type (type, 1, 0); 1832 dbxout_finish_symbol (decl); 1833 did_output = 1; 1834 } 1835 1836 /* Don't output a tag if this is an incomplete type (TYPE_SIZE is 1837 zero). This prevents the sun4 Sun OS 4.x dbx from crashing. */ 1838 1839 if (tag_needed && TYPE_NAME (type) != 0 1840 && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE 1841 || (DECL_NAME (TYPE_NAME (type)) != 0)) 1842 && TYPE_SIZE (type) != 0 1843 && !TREE_ASM_WRITTEN (TYPE_NAME (type))) 1844 { 1845 /* For a TYPE_DECL with no name, but the type has a name, 1846 output a tag. 1847 This is what represents `struct foo' with no typedef. */ 1848 /* In C++, the name of a type is the corresponding typedef. 1849 In C, it is an IDENTIFIER_NODE. */ 1850 tree name = TYPE_NAME (type); 1851 if (TREE_CODE (name) == TYPE_DECL) 1852 name = DECL_NAME (name); 1853 1854 current_sym_code = DBX_TYPE_DECL_STABS_CODE; 1855 current_sym_value = 0; 1856 current_sym_addr = 0; 1857 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name); 1858 1859 fprintf (asmfile, "%s \"%s:T", ASM_STABS_OP, 1860 IDENTIFIER_POINTER (name)); 1861 dbxout_type (type, 1, 0); 1862 dbxout_finish_symbol (NULL_TREE); 1863 did_output = 1; 1864 } 1865 1866 /* If an enum type has no name, it cannot be referred to, 1867 but we must output it anyway, since the enumeration constants 1868 can be referred to. */ 1869 if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE) 1870 { 1871 current_sym_code = DBX_TYPE_DECL_STABS_CODE; 1872 current_sym_value = 0; 1873 current_sym_addr = 0; 1874 current_sym_nchars = 2; 1875 1876 /* Some debuggers fail when given NULL names, so give this a 1877 harmless name of ` '. */ 1878 fprintf (asmfile, "%s \" :T", ASM_STABS_OP); 1879 dbxout_type (type, 1, 0); 1880 dbxout_finish_symbol (NULL_TREE); 1881 } 1882 1883 /* Prevent duplicate output of a typedef. */ 1884 TREE_ASM_WRITTEN (decl) = 1; 1885 break; 1886 } 1887 1888 case PARM_DECL: 1889 /* Parm decls go in their own separate chains 1890 and are output by dbxout_reg_parms and dbxout_parms. */ 1891 abort (); 1892 1893 case RESULT_DECL: 1894 /* Named return value, treat like a VAR_DECL. */ 1895 case VAR_DECL: 1896 if (DECL_RTL (decl) == 0) 1897 return; 1898 /* Don't mention a variable that is external. 1899 Let the file that defines it describe it. */ 1900 if (DECL_EXTERNAL (decl)) 1901 break; 1902 1903 /* If the variable is really a constant 1904 and not written in memory, inform the debugger. */ 1905 if (TREE_STATIC (decl) && TREE_READONLY (decl) 1906 && DECL_INITIAL (decl) != 0 1907 && ! TREE_ASM_WRITTEN (decl) 1908 && (DECL_FIELD_CONTEXT (decl) == NULL_TREE 1909 || TREE_CODE (DECL_FIELD_CONTEXT (decl)) == BLOCK)) 1910 { 1911 if (TREE_PUBLIC (decl) == 0) 1912 { 1913 /* The sun4 assembler does not grok this. */ 1914 char *name = IDENTIFIER_POINTER (DECL_NAME (decl)); 1915 if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE 1916 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE) 1917 { 1918 HOST_WIDE_INT ival = TREE_INT_CST_LOW (DECL_INITIAL (decl)); 1919#ifdef DBX_OUTPUT_CONSTANT_SYMBOL 1920 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile, name, ival); 1921#else 1922 fprintf (asmfile, "%s \"%s:c=i", ASM_STABS_OP, name); 1923 1924 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, ival); 1925 fprintf (asmfile, "\",0x%x,0,0,0\n", N_LSYM); 1926#endif 1927 return; 1928 } 1929 else if (TREE_CODE (TREE_TYPE (decl)) == REAL_TYPE) 1930 { 1931 /* don't know how to do this yet. */ 1932 } 1933 break; 1934 } 1935 /* else it is something we handle like a normal variable. */ 1936 } 1937 1938 DECL_RTL (decl) = eliminate_regs (DECL_RTL (decl), 0, NULL_RTX); 1939#ifdef LEAF_REG_REMAP 1940 if (current_function_uses_only_leaf_regs) 1941 leaf_renumber_regs_insn (DECL_RTL (decl)); 1942#endif 1943 1944 dbxout_symbol_location (decl, type, 0, DECL_RTL (decl)); 1945 break; 1946 1947 default: 1948 break; 1949 } 1950} 1951 1952/* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL. 1953 Add SUFFIX to its name, if SUFFIX is not 0. 1954 Describe the variable as residing in HOME 1955 (usually HOME is DECL_RTL (DECL), but not always). */ 1956 1957static void 1958dbxout_symbol_location (decl, type, suffix, home) 1959 tree decl, type; 1960 char *suffix; 1961 rtx home; 1962{ 1963 int letter = 0; 1964 int regno = -1; 1965 1966 /* Don't mention a variable at all 1967 if it was completely optimized into nothingness. 1968 1969 If the decl was from an inline function, then its rtl 1970 is not identically the rtl that was used in this 1971 particular compilation. */ 1972 if (GET_CODE (home) == REG) 1973 { 1974 regno = REGNO (home); 1975 if (regno >= FIRST_PSEUDO_REGISTER) 1976 return; 1977 } 1978 else if (GET_CODE (home) == SUBREG) 1979 { 1980 rtx value = home; 1981 int offset = 0; 1982 while (GET_CODE (value) == SUBREG) 1983 { 1984 offset += SUBREG_WORD (value); 1985 value = SUBREG_REG (value); 1986 } 1987 if (GET_CODE (value) == REG) 1988 { 1989 regno = REGNO (value); 1990 if (regno >= FIRST_PSEUDO_REGISTER) 1991 return; 1992 regno += offset; 1993 } 1994 alter_subreg (home); 1995 } 1996 1997 /* The kind-of-variable letter depends on where 1998 the variable is and on the scope of its name: 1999 G and N_GSYM for static storage and global scope, 2000 S for static storage and file scope, 2001 V for static storage and local scope, 2002 for those two, use N_LCSYM if data is in bss segment, 2003 N_STSYM if in data segment, N_FUN otherwise. 2004 (We used N_FUN originally, then changed to N_STSYM 2005 to please GDB. However, it seems that confused ld. 2006 Now GDB has been fixed to like N_FUN, says Kingdon.) 2007 no letter at all, and N_LSYM, for auto variable, 2008 r and N_RSYM for register variable. */ 2009 2010 if (GET_CODE (home) == MEM 2011 && GET_CODE (XEXP (home, 0)) == SYMBOL_REF) 2012 { 2013 if (TREE_PUBLIC (decl)) 2014 { 2015 letter = 'G'; 2016 current_sym_code = N_GSYM; 2017 } 2018 else 2019 { 2020 current_sym_addr = XEXP (home, 0); 2021 2022 letter = decl_function_context (decl) ? 'V' : 'S'; 2023 2024 /* This should be the same condition as in assemble_variable, but 2025 we don't have access to dont_output_data here. So, instead, 2026 we rely on the fact that error_mark_node initializers always 2027 end up in bss for C++ and never end up in bss for C. */ 2028 if (DECL_INITIAL (decl) == 0 2029 || (!strcmp (lang_identify (), "cplusplus") 2030 && DECL_INITIAL (decl) == error_mark_node)) 2031 current_sym_code = N_LCSYM; 2032 else if (DECL_IN_TEXT_SECTION (decl)) 2033 /* This is not quite right, but it's the closest 2034 of all the codes that Unix defines. */ 2035 current_sym_code = DBX_STATIC_CONST_VAR_CODE; 2036 else 2037 { 2038 /* Ultrix `as' seems to need this. */ 2039#ifdef DBX_STATIC_STAB_DATA_SECTION 2040 data_section (); 2041#endif 2042 current_sym_code = N_STSYM; 2043 } 2044 } 2045 } 2046 else if (regno >= 0) 2047 { 2048 letter = 'r'; 2049 current_sym_code = N_RSYM; 2050 current_sym_value = DBX_REGISTER_NUMBER (regno); 2051 } 2052 else if (GET_CODE (home) == MEM 2053 && (GET_CODE (XEXP (home, 0)) == MEM 2054 || (GET_CODE (XEXP (home, 0)) == REG 2055 && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM 2056 && REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM 2057#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM 2058 && REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM 2059#endif 2060 ))) 2061 /* If the value is indirect by memory or by a register 2062 that isn't the frame pointer 2063 then it means the object is variable-sized and address through 2064 that register or stack slot. DBX has no way to represent this 2065 so all we can do is output the variable as a pointer. 2066 If it's not a parameter, ignore it. 2067 (VAR_DECLs like this can be made by integrate.c.) */ 2068 { 2069 if (GET_CODE (XEXP (home, 0)) == REG) 2070 { 2071 letter = 'r'; 2072 current_sym_code = N_RSYM; 2073 current_sym_value = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0))); 2074 } 2075 else 2076 { 2077 current_sym_code = N_LSYM; 2078 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))). 2079 We want the value of that CONST_INT. */ 2080 current_sym_value 2081 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0)); 2082 } 2083 2084 /* Effectively do build_pointer_type, but don't cache this type, 2085 since it might be temporary whereas the type it points to 2086 might have been saved for inlining. */ 2087 /* Don't use REFERENCE_TYPE because dbx can't handle that. */ 2088 type = make_node (POINTER_TYPE); 2089 TREE_TYPE (type) = TREE_TYPE (decl); 2090 } 2091 else if (GET_CODE (home) == MEM 2092 && GET_CODE (XEXP (home, 0)) == REG) 2093 { 2094 current_sym_code = N_LSYM; 2095 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0)); 2096 } 2097 else if (GET_CODE (home) == MEM 2098 && GET_CODE (XEXP (home, 0)) == PLUS 2099 && GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT) 2100 { 2101 current_sym_code = N_LSYM; 2102 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...))) 2103 We want the value of that CONST_INT. */ 2104 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0)); 2105 } 2106 else if (GET_CODE (home) == MEM 2107 && GET_CODE (XEXP (home, 0)) == CONST) 2108 { 2109 /* Handle an obscure case which can arise when optimizing and 2110 when there are few available registers. (This is *always* 2111 the case for i386/i486 targets). The RTL looks like 2112 (MEM (CONST ...)) even though this variable is a local `auto' 2113 or a local `register' variable. In effect, what has happened 2114 is that the reload pass has seen that all assignments and 2115 references for one such a local variable can be replaced by 2116 equivalent assignments and references to some static storage 2117 variable, thereby avoiding the need for a register. In such 2118 cases we're forced to lie to debuggers and tell them that 2119 this variable was itself `static'. */ 2120 current_sym_code = N_LCSYM; 2121 letter = 'V'; 2122 current_sym_addr = XEXP (XEXP (home, 0), 0); 2123 } 2124 else if (GET_CODE (home) == CONCAT) 2125 { 2126 tree subtype = TREE_TYPE (type); 2127 2128 /* If the variable's storage is in two parts, 2129 output each as a separate stab with a modified name. */ 2130 if (WORDS_BIG_ENDIAN) 2131 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0)); 2132 else 2133 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0)); 2134 2135 /* Cast avoids warning in old compilers. */ 2136 current_sym_code = (STAB_CODE_TYPE) 0; 2137 current_sym_value = 0; 2138 current_sym_addr = 0; 2139 dbxout_prepare_symbol (decl); 2140 2141 if (WORDS_BIG_ENDIAN) 2142 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1)); 2143 else 2144 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1)); 2145 return; 2146 } 2147 else 2148 /* Address might be a MEM, when DECL is a variable-sized object. 2149 Or it might be const0_rtx, meaning previous passes 2150 want us to ignore this variable. */ 2151 return; 2152 2153 /* Ok, start a symtab entry and output the variable name. */ 2154 FORCE_TEXT; 2155 2156#ifdef DBX_STATIC_BLOCK_START 2157 DBX_STATIC_BLOCK_START (asmfile, current_sym_code); 2158#endif 2159 2160 dbxout_symbol_name (decl, suffix, letter); 2161 dbxout_type (type, 0, 0); 2162 dbxout_finish_symbol (decl); 2163 2164#ifdef DBX_STATIC_BLOCK_END 2165 DBX_STATIC_BLOCK_END (asmfile, current_sym_code); 2166#endif 2167} 2168 2169/* Output the symbol name of DECL for a stabs, with suffix SUFFIX. 2170 Then output LETTER to indicate the kind of location the symbol has. */ 2171 2172static void 2173dbxout_symbol_name (decl, suffix, letter) 2174 tree decl; 2175 char *suffix; 2176 int letter; 2177{ 2178 /* One slight hitch: if this is a VAR_DECL which is a static 2179 class member, we must put out the mangled name instead of the 2180 DECL_NAME. Note also that static member (variable) names DO NOT begin 2181 with underscores in .stabs directives. */ 2182 char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); 2183 if (name == 0) 2184 name = "(anon)"; 2185 fprintf (asmfile, "%s \"%s%s:", ASM_STABS_OP, name, 2186 (suffix ? suffix : "")); 2187 2188 if (letter) putc (letter, asmfile); 2189} 2190 2191static void 2192dbxout_prepare_symbol (decl) 2193 tree decl ATTRIBUTE_UNUSED; 2194{ 2195#ifdef WINNING_GDB 2196 char *filename = DECL_SOURCE_FILE (decl); 2197 2198 dbxout_source_file (asmfile, filename); 2199#endif 2200} 2201 2202static void 2203dbxout_finish_symbol (sym) 2204 tree sym; 2205{ 2206#ifdef DBX_FINISH_SYMBOL 2207 DBX_FINISH_SYMBOL (sym); 2208#else 2209 int line = 0; 2210 if (use_gnu_debug_info_extensions && sym != 0) 2211 line = DECL_SOURCE_LINE (sym); 2212 2213 fprintf (asmfile, "\",%d,0,%d,", current_sym_code, line); 2214 if (current_sym_addr) 2215 output_addr_const (asmfile, current_sym_addr); 2216 else 2217 fprintf (asmfile, "%d", current_sym_value); 2218 putc ('\n', asmfile); 2219#endif 2220} 2221 2222/* Output definitions of all the decls in a chain. */ 2223 2224void 2225dbxout_syms (syms) 2226 tree syms; 2227{ 2228 while (syms) 2229 { 2230 dbxout_symbol (syms, 1); 2231 syms = TREE_CHAIN (syms); 2232 } 2233} 2234 2235/* The following two functions output definitions of function parameters. 2236 Each parameter gets a definition locating it in the parameter list. 2237 Each parameter that is a register variable gets a second definition 2238 locating it in the register. 2239 2240 Printing or argument lists in gdb uses the definitions that 2241 locate in the parameter list. But reference to the variable in 2242 expressions uses preferentially the definition as a register. */ 2243 2244/* Output definitions, referring to storage in the parmlist, 2245 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */ 2246 2247void 2248dbxout_parms (parms) 2249 tree parms; 2250{ 2251 for (; parms; parms = TREE_CHAIN (parms)) 2252 if (DECL_NAME (parms) && TREE_TYPE (parms) != error_mark_node) 2253 { 2254 dbxout_prepare_symbol (parms); 2255 2256 /* Perform any necessary register eliminations on the parameter's rtl, 2257 so that the debugging output will be accurate. */ 2258 DECL_INCOMING_RTL (parms) 2259 = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX); 2260 DECL_RTL (parms) = eliminate_regs (DECL_RTL (parms), 0, NULL_RTX); 2261#ifdef LEAF_REG_REMAP 2262 if (current_function_uses_only_leaf_regs) 2263 { 2264 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms)); 2265 leaf_renumber_regs_insn (DECL_RTL (parms)); 2266 } 2267#endif 2268 2269 if (PARM_PASSED_IN_MEMORY (parms)) 2270 { 2271 rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0); 2272 2273 /* ??? Here we assume that the parm address is indexed 2274 off the frame pointer or arg pointer. 2275 If that is not true, we produce meaningless results, 2276 but do not crash. */ 2277 if (GET_CODE (addr) == PLUS 2278 && GET_CODE (XEXP (addr, 1)) == CONST_INT) 2279 current_sym_value = INTVAL (XEXP (addr, 1)); 2280 else 2281 current_sym_value = 0; 2282 2283 current_sym_code = N_PSYM; 2284 current_sym_addr = 0; 2285 2286 FORCE_TEXT; 2287 if (DECL_NAME (parms)) 2288 { 2289 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms)); 2290 2291 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP, 2292 IDENTIFIER_POINTER (DECL_NAME (parms)), 2293 DBX_MEMPARM_STABS_LETTER); 2294 } 2295 else 2296 { 2297 current_sym_nchars = 8; 2298 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP, 2299 DBX_MEMPARM_STABS_LETTER); 2300 } 2301 2302 /* It is quite tempting to use: 2303 2304 dbxout_type (TREE_TYPE (parms), 0, 0); 2305 2306 as the next statement, rather than using DECL_ARG_TYPE(), so 2307 that gcc reports the actual type of the parameter, rather 2308 than the promoted type. This certainly makes GDB's life 2309 easier, at least for some ports. The change is a bad idea 2310 however, since GDB expects to be able access the type without 2311 performing any conversions. So for example, if we were 2312 passing a float to an unprototyped function, gcc will store a 2313 double on the stack, but if we emit a stab saying the type is a 2314 float, then gdb will only read in a single value, and this will 2315 produce an erropneous value. */ 2316 dbxout_type (DECL_ARG_TYPE (parms), 0, 0); 2317 current_sym_value = DEBUGGER_ARG_OFFSET (current_sym_value, addr); 2318 dbxout_finish_symbol (parms); 2319 } 2320 else if (GET_CODE (DECL_RTL (parms)) == REG) 2321 { 2322 rtx best_rtl; 2323 char regparm_letter; 2324 tree parm_type; 2325 /* Parm passed in registers and lives in registers or nowhere. */ 2326 2327 current_sym_code = DBX_REGPARM_STABS_CODE; 2328 regparm_letter = DBX_REGPARM_STABS_LETTER; 2329 current_sym_addr = 0; 2330 2331 /* If parm lives in a register, use that register; 2332 pretend the parm was passed there. It would be more consistent 2333 to describe the register where the parm was passed, 2334 but in practice that register usually holds something else. 2335 2336 If we use DECL_RTL, then we must use the declared type of 2337 the variable, not the type that it arrived in. */ 2338 if (REGNO (DECL_RTL (parms)) >= 0 2339 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER) 2340 { 2341 best_rtl = DECL_RTL (parms); 2342 parm_type = TREE_TYPE (parms); 2343 } 2344 /* If the parm lives nowhere, use the register where it was 2345 passed. It is also better to use the declared type here. */ 2346 else 2347 { 2348 best_rtl = DECL_INCOMING_RTL (parms); 2349 parm_type = TREE_TYPE (parms); 2350 } 2351 current_sym_value = DBX_REGISTER_NUMBER (REGNO (best_rtl)); 2352 2353 FORCE_TEXT; 2354 if (DECL_NAME (parms)) 2355 { 2356 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms)); 2357 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP, 2358 IDENTIFIER_POINTER (DECL_NAME (parms)), 2359 regparm_letter); 2360 } 2361 else 2362 { 2363 current_sym_nchars = 8; 2364 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP, 2365 regparm_letter); 2366 } 2367 2368 dbxout_type (parm_type, 0, 0); 2369 dbxout_finish_symbol (parms); 2370 } 2371 else if (GET_CODE (DECL_RTL (parms)) == MEM 2372 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG 2373 && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM 2374 && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM 2375#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM 2376 && REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM 2377#endif 2378 ) 2379 { 2380 /* Parm was passed via invisible reference. 2381 That is, its address was passed in a register. 2382 Output it as if it lived in that register. 2383 The debugger will know from the type 2384 that it was actually passed by invisible reference. */ 2385 2386 char regparm_letter; 2387 /* Parm passed in registers and lives in registers or nowhere. */ 2388 2389 current_sym_code = DBX_REGPARM_STABS_CODE; 2390 if (use_gnu_debug_info_extensions) 2391 regparm_letter = GDB_INV_REF_REGPARM_STABS_LETTER; 2392 else 2393 regparm_letter = DBX_REGPARM_STABS_LETTER; 2394 2395 /* DECL_RTL looks like (MEM (REG...). Get the register number. 2396 If it is an unallocated pseudo-reg, then use the register where 2397 it was passed instead. */ 2398 if (REGNO (XEXP (DECL_RTL (parms), 0)) >= 0 2399 && REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER) 2400 current_sym_value = REGNO (XEXP (DECL_RTL (parms), 0)); 2401 else 2402 current_sym_value = REGNO (DECL_INCOMING_RTL (parms)); 2403 2404 current_sym_addr = 0; 2405 2406 FORCE_TEXT; 2407 if (DECL_NAME (parms)) 2408 { 2409 current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms))); 2410 2411 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP, 2412 IDENTIFIER_POINTER (DECL_NAME (parms)), 2413 regparm_letter); 2414 } 2415 else 2416 { 2417 current_sym_nchars = 8; 2418 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP, 2419 regparm_letter); 2420 } 2421 2422 dbxout_type (TREE_TYPE (parms), 0, 0); 2423 dbxout_finish_symbol (parms); 2424 } 2425 else if (GET_CODE (DECL_RTL (parms)) == MEM 2426 && XEXP (DECL_RTL (parms), 0) != const0_rtx 2427 /* ??? A constant address for a parm can happen 2428 when the reg it lives in is equiv to a constant in memory. 2429 Should make this not happen, after 2.4. */ 2430 && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0))) 2431 { 2432 /* Parm was passed in registers but lives on the stack. */ 2433 2434 current_sym_code = N_PSYM; 2435 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))), 2436 in which case we want the value of that CONST_INT, 2437 or (MEM (REG ...)) or (MEM (MEM ...)), 2438 in which case we use a value of zero. */ 2439 if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG 2440 || GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM) 2441 current_sym_value = 0; 2442 else 2443 current_sym_value = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)); 2444 current_sym_addr = 0; 2445 2446 /* Make a big endian correction if the mode of the type of the 2447 parameter is not the same as the mode of the rtl. */ 2448 if (BYTES_BIG_ENDIAN 2449 && TYPE_MODE (TREE_TYPE (parms)) != GET_MODE (DECL_RTL (parms)) 2450 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))) < UNITS_PER_WORD) 2451 { 2452 current_sym_value += UNITS_PER_WORD - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))); 2453 } 2454 2455 FORCE_TEXT; 2456 if (DECL_NAME (parms)) 2457 { 2458 current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms))); 2459 2460 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP, 2461 IDENTIFIER_POINTER (DECL_NAME (parms)), 2462 DBX_MEMPARM_STABS_LETTER); 2463 } 2464 else 2465 { 2466 current_sym_nchars = 8; 2467 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP, 2468 DBX_MEMPARM_STABS_LETTER); 2469 } 2470 2471 current_sym_value 2472 = DEBUGGER_ARG_OFFSET (current_sym_value, 2473 XEXP (DECL_RTL (parms), 0)); 2474 dbxout_type (TREE_TYPE (parms), 0, 0); 2475 dbxout_finish_symbol (parms); 2476 } 2477 } 2478} 2479 2480/* Output definitions for the places where parms live during the function, 2481 when different from where they were passed, when the parms were passed 2482 in memory. 2483 2484 It is not useful to do this for parms passed in registers 2485 that live during the function in different registers, because it is 2486 impossible to look in the passed register for the passed value, 2487 so we use the within-the-function register to begin with. 2488 2489 PARMS is a chain of PARM_DECL nodes. */ 2490 2491void 2492dbxout_reg_parms (parms) 2493 tree parms; 2494{ 2495 for (; parms; parms = TREE_CHAIN (parms)) 2496 if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms)) 2497 { 2498 dbxout_prepare_symbol (parms); 2499 2500 /* Report parms that live in registers during the function 2501 but were passed in memory. */ 2502 if (GET_CODE (DECL_RTL (parms)) == REG 2503 && REGNO (DECL_RTL (parms)) >= 0 2504 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER) 2505 dbxout_symbol_location (parms, TREE_TYPE (parms), 2506 0, DECL_RTL (parms)); 2507 else if (GET_CODE (DECL_RTL (parms)) == CONCAT) 2508 dbxout_symbol_location (parms, TREE_TYPE (parms), 2509 0, DECL_RTL (parms)); 2510 /* Report parms that live in memory but not where they were passed. */ 2511 else if (GET_CODE (DECL_RTL (parms)) == MEM 2512 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms))) 2513 dbxout_symbol_location (parms, TREE_TYPE (parms), 2514 0, DECL_RTL (parms)); 2515 } 2516} 2517 2518/* Given a chain of ..._TYPE nodes (as come in a parameter list), 2519 output definitions of those names, in raw form */ 2520 2521void 2522dbxout_args (args) 2523 tree args; 2524{ 2525 while (args) 2526 { 2527 putc (',', asmfile); 2528 dbxout_type (TREE_VALUE (args), 0, 0); 2529 CHARS (1); 2530 args = TREE_CHAIN (args); 2531 } 2532} 2533 2534/* Given a chain of ..._TYPE nodes, 2535 find those which have typedef names and output those names. 2536 This is to ensure those types get output. */ 2537 2538void 2539dbxout_types (types) 2540 register tree types; 2541{ 2542 while (types) 2543 { 2544 if (TYPE_NAME (types) 2545 && TREE_CODE (TYPE_NAME (types)) == TYPE_DECL 2546 && ! TREE_ASM_WRITTEN (TYPE_NAME (types))) 2547 dbxout_symbol (TYPE_NAME (types), 1); 2548 types = TREE_CHAIN (types); 2549 } 2550} 2551 2552/* Output everything about a symbol block (a BLOCK node 2553 that represents a scope level), 2554 including recursive output of contained blocks. 2555 2556 BLOCK is the BLOCK node. 2557 DEPTH is its depth within containing symbol blocks. 2558 ARGS is usually zero; but for the outermost block of the 2559 body of a function, it is a chain of PARM_DECLs for the function parameters. 2560 We output definitions of all the register parms 2561 as if they were local variables of that block. 2562 2563 If -g1 was used, we count blocks just the same, but output nothing 2564 except for the outermost block. 2565 2566 Actually, BLOCK may be several blocks chained together. 2567 We handle them all in sequence. */ 2568 2569static void 2570dbxout_block (block, depth, args) 2571 register tree block; 2572 int depth; 2573 tree args; 2574{ 2575 int blocknum; 2576 2577 while (block) 2578 { 2579 /* Ignore blocks never expanded or otherwise marked as real. */ 2580 if (TREE_USED (block)) 2581 { 2582#ifndef DBX_LBRAC_FIRST 2583 /* In dbx format, the syms of a block come before the N_LBRAC. */ 2584 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0) 2585 dbxout_syms (BLOCK_VARS (block)); 2586 if (args) 2587 dbxout_reg_parms (args); 2588#endif 2589 2590 /* Now output an N_LBRAC symbol to represent the beginning of 2591 the block. Use the block's tree-walk order to generate 2592 the assembler symbols LBBn and LBEn 2593 that final will define around the code in this block. */ 2594 if (depth > 0 && debug_info_level != DINFO_LEVEL_TERSE) 2595 { 2596 char buf[20]; 2597 blocknum = next_block_number++; 2598 ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum); 2599 2600 if (BLOCK_HANDLER_BLOCK (block)) 2601 { 2602 /* A catch block. Must precede N_LBRAC. */ 2603 tree decl = BLOCK_VARS (block); 2604 while (decl) 2605 { 2606#ifdef DBX_OUTPUT_CATCH 2607 DBX_OUTPUT_CATCH (asmfile, decl, buf); 2608#else 2609 fprintf (asmfile, "%s \"%s:C1\",%d,0,0,", ASM_STABS_OP, 2610 IDENTIFIER_POINTER (DECL_NAME (decl)), N_CATCH); 2611 assemble_name (asmfile, buf); 2612 fprintf (asmfile, "\n"); 2613#endif 2614 decl = TREE_CHAIN (decl); 2615 } 2616 } 2617 2618#ifdef DBX_OUTPUT_LBRAC 2619 DBX_OUTPUT_LBRAC (asmfile, buf); 2620#else 2621 fprintf (asmfile, "%s %d,0,0,", ASM_STABN_OP, N_LBRAC); 2622 assemble_name (asmfile, buf); 2623#if DBX_BLOCKS_FUNCTION_RELATIVE 2624 fputc ('-', asmfile); 2625 assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0)); 2626#endif 2627 fprintf (asmfile, "\n"); 2628#endif 2629 } 2630 else if (depth > 0) 2631 /* Count blocks the same way regardless of debug_info_level. */ 2632 next_block_number++; 2633 2634#ifdef DBX_LBRAC_FIRST 2635 /* On some weird machines, the syms of a block 2636 come after the N_LBRAC. */ 2637 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0) 2638 dbxout_syms (BLOCK_VARS (block)); 2639 if (args) 2640 dbxout_reg_parms (args); 2641#endif 2642 2643 /* Output the subblocks. */ 2644 dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE); 2645 2646 /* Refer to the marker for the end of the block. */ 2647 if (depth > 0 && debug_info_level != DINFO_LEVEL_TERSE) 2648 { 2649 char buf[20]; 2650 ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum); 2651#ifdef DBX_OUTPUT_RBRAC 2652 DBX_OUTPUT_RBRAC (asmfile, buf); 2653#else 2654 fprintf (asmfile, "%s %d,0,0,", ASM_STABN_OP, N_RBRAC); 2655 assemble_name (asmfile, buf); 2656#if DBX_BLOCKS_FUNCTION_RELATIVE 2657 fputc ('-', asmfile); 2658 assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0)); 2659#endif 2660 fprintf (asmfile, "\n"); 2661#endif 2662 } 2663 } 2664 block = BLOCK_CHAIN (block); 2665 } 2666} 2667 2668/* Output the information about a function and its arguments and result. 2669 Usually this follows the function's code, 2670 but on some systems, it comes before. */ 2671 2672static void 2673dbxout_really_begin_function (decl) 2674 tree decl; 2675{ 2676 dbxout_symbol (decl, 0); 2677 dbxout_parms (DECL_ARGUMENTS (decl)); 2678 if (DECL_NAME (DECL_RESULT (decl)) != 0) 2679 dbxout_symbol (DECL_RESULT (decl), 1); 2680} 2681 2682/* Called at beginning of output of function definition. */ 2683 2684void 2685dbxout_begin_function (decl) 2686 tree decl ATTRIBUTE_UNUSED; 2687{ 2688#ifdef DBX_FUNCTION_FIRST 2689 dbxout_really_begin_function (decl); 2690#endif 2691} 2692 2693/* Output dbx data for a function definition. 2694 This includes a definition of the function name itself (a symbol), 2695 definitions of the parameters (locating them in the parameter list) 2696 and then output the block that makes up the function's body 2697 (including all the auto variables of the function). */ 2698 2699void 2700dbxout_function (decl) 2701 tree decl; 2702{ 2703#ifndef DBX_FUNCTION_FIRST 2704 dbxout_really_begin_function (decl); 2705#endif 2706 dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl)); 2707#ifdef DBX_OUTPUT_FUNCTION_END 2708 DBX_OUTPUT_FUNCTION_END (asmfile, decl); 2709#endif 2710#if defined(ASM_OUTPUT_SECTION_NAME) 2711 if (use_gnu_debug_info_extensions 2712#if defined(NO_DBX_FUNCTION_END) 2713 && ! NO_DBX_FUNCTION_END 2714#endif 2715 ) 2716 dbxout_function_end (); 2717#endif 2718} 2719#endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */ 2720