dwarf2out.c revision 70635
1/* Output Dwarf2 format symbol table information from the GNU C compiler. 2 Copyright (C) 1992, 93, 95-98, 1999 Free Software Foundation, Inc. 3 Contributed by Gary Funck (gary@intrepid.com). 4 Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com). 5 Extensively modified by Jason Merrill (jason@cygnus.com). 6 7This file is part of GNU CC. 8 9GNU CC is free software; you can redistribute it and/or modify 10it under the terms of the GNU General Public License as published by 11the Free Software Foundation; either version 2, or (at your option) 12any later version. 13 14GNU CC is distributed in the hope that it will be useful, 15but WITHOUT ANY WARRANTY; without even the implied warranty of 16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17GNU General Public License for more details. 18 19You should have received a copy of the GNU General Public License 20along with GNU CC; see the file COPYING. If not, write to 21the Free Software Foundation, 59 Temple Place - Suite 330, 22Boston, MA 02111-1307, USA. */ 23 24/* The first part of this file deals with the DWARF 2 frame unwind 25 information, which is also used by the GCC efficient exception handling 26 mechanism. The second part, controlled only by an #ifdef 27 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging 28 information. */ 29 30#include "config.h" 31#include "system.h" 32#include "defaults.h" 33#include "tree.h" 34#include "flags.h" 35#include "rtl.h" 36#include "hard-reg-set.h" 37#include "regs.h" 38#include "insn-config.h" 39#include "reload.h" 40#include "output.h" 41#include "expr.h" 42#include "except.h" 43#include "dwarf2.h" 44#include "dwarf2out.h" 45#include "toplev.h" 46#include "dyn-string.h" 47 48/* We cannot use <assert.h> in GCC source, since that would include 49 GCC's assert.h, which may not be compatible with the host compiler. */ 50#undef assert 51#ifdef NDEBUG 52# define assert(e) 53#else 54# define assert(e) do { if (! (e)) abort (); } while (0) 55#endif 56 57/* Decide whether we want to emit frame unwind information for the current 58 translation unit. */ 59 60int 61dwarf2out_do_frame () 62{ 63 return (write_symbols == DWARF2_DEBUG 64#ifdef DWARF2_FRAME_INFO 65 || DWARF2_FRAME_INFO 66#endif 67#ifdef DWARF2_UNWIND_INFO 68 || (flag_exceptions && ! exceptions_via_longjmp) 69#endif 70 ); 71} 72 73#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO) 74 75/* How to start an assembler comment. */ 76#ifndef ASM_COMMENT_START 77#define ASM_COMMENT_START ";#" 78#endif 79 80typedef struct dw_cfi_struct *dw_cfi_ref; 81typedef struct dw_fde_struct *dw_fde_ref; 82typedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref; 83 84/* Call frames are described using a sequence of Call Frame 85 Information instructions. The register number, offset 86 and address fields are provided as possible operands; 87 their use is selected by the opcode field. */ 88 89typedef union dw_cfi_oprnd_struct 90{ 91 unsigned long dw_cfi_reg_num; 92 long int dw_cfi_offset; 93 char *dw_cfi_addr; 94} 95dw_cfi_oprnd; 96 97typedef struct dw_cfi_struct 98{ 99 dw_cfi_ref dw_cfi_next; 100 enum dwarf_call_frame_info dw_cfi_opc; 101 dw_cfi_oprnd dw_cfi_oprnd1; 102 dw_cfi_oprnd dw_cfi_oprnd2; 103} 104dw_cfi_node; 105 106/* All call frame descriptions (FDE's) in the GCC generated DWARF 107 refer to a single Common Information Entry (CIE), defined at 108 the beginning of the .debug_frame section. This used of a single 109 CIE obviates the need to keep track of multiple CIE's 110 in the DWARF generation routines below. */ 111 112typedef struct dw_fde_struct 113{ 114 char *dw_fde_begin; 115 char *dw_fde_current_label; 116 char *dw_fde_end; 117 dw_cfi_ref dw_fde_cfi; 118} 119dw_fde_node; 120 121/* Maximum size (in bytes) of an artificially generated label. */ 122#define MAX_ARTIFICIAL_LABEL_BYTES 30 123 124/* Make sure we know the sizes of the various types dwarf can describe. These 125 are only defaults. If the sizes are different for your target, you should 126 override these values by defining the appropriate symbols in your tm.h 127 file. */ 128 129#ifndef CHAR_TYPE_SIZE 130#define CHAR_TYPE_SIZE BITS_PER_UNIT 131#endif 132#ifndef PTR_SIZE 133#define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT) 134#endif 135 136/* The size in bytes of a DWARF field indicating an offset or length 137 relative to a debug info section, specified to be 4 bytes in the DWARF-2 138 specification. The SGI/MIPS ABI defines it to be the same as PTR_SIZE. */ 139 140#ifndef DWARF_OFFSET_SIZE 141#define DWARF_OFFSET_SIZE 4 142#endif 143 144#define DWARF_VERSION 2 145 146/* Round SIZE up to the nearest BOUNDARY. */ 147#define DWARF_ROUND(SIZE,BOUNDARY) \ 148 (((SIZE) + (BOUNDARY) - 1) & ~((BOUNDARY) - 1)) 149 150/* Offsets recorded in opcodes are a multiple of this alignment factor. */ 151#ifdef STACK_GROWS_DOWNWARD 152#define DWARF_CIE_DATA_ALIGNMENT (-UNITS_PER_WORD) 153#else 154#define DWARF_CIE_DATA_ALIGNMENT UNITS_PER_WORD 155#endif 156 157/* A pointer to the base of a table that contains frame description 158 information for each routine. */ 159static dw_fde_ref fde_table; 160 161/* Number of elements currently allocated for fde_table. */ 162static unsigned fde_table_allocated; 163 164/* Number of elements in fde_table currently in use. */ 165static unsigned fde_table_in_use; 166 167/* Size (in elements) of increments by which we may expand the 168 fde_table. */ 169#define FDE_TABLE_INCREMENT 256 170 171/* A list of call frame insns for the CIE. */ 172static dw_cfi_ref cie_cfi_head; 173 174/* The number of the current function definition for which debugging 175 information is being generated. These numbers range from 1 up to the 176 maximum number of function definitions contained within the current 177 compilation unit. These numbers are used to create unique label id's 178 unique to each function definition. */ 179static unsigned current_funcdef_number = 0; 180 181/* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram 182 attribute that accelerates the lookup of the FDE associated 183 with the subprogram. This variable holds the table index of the FDE 184 associated with the current function (body) definition. */ 185static unsigned current_funcdef_fde; 186 187/* Forward declarations for functions defined in this file. */ 188 189static char *stripattributes PROTO((char *)); 190static char *dwarf_cfi_name PROTO((unsigned)); 191static dw_cfi_ref new_cfi PROTO((void)); 192static void add_cfi PROTO((dw_cfi_ref *, dw_cfi_ref)); 193static unsigned long size_of_uleb128 PROTO((unsigned long)); 194static unsigned long size_of_sleb128 PROTO((long)); 195static void output_uleb128 PROTO((unsigned long)); 196static void output_sleb128 PROTO((long)); 197static void add_fde_cfi PROTO((char *, dw_cfi_ref)); 198static void lookup_cfa_1 PROTO((dw_cfi_ref, unsigned long *, 199 long *)); 200static void lookup_cfa PROTO((unsigned long *, long *)); 201static void reg_save PROTO((char *, unsigned, unsigned, 202 long)); 203static void initial_return_save PROTO((rtx)); 204static void output_cfi PROTO((dw_cfi_ref, dw_fde_ref)); 205static void output_call_frame_info PROTO((int)); 206static unsigned reg_number PROTO((rtx)); 207static void dwarf2out_stack_adjust PROTO((rtx)); 208 209/* Definitions of defaults for assembler-dependent names of various 210 pseudo-ops and section names. 211 Theses may be overridden in the tm.h file (if necessary) for a particular 212 assembler. */ 213 214#ifdef OBJECT_FORMAT_ELF 215#ifndef UNALIGNED_SHORT_ASM_OP 216#define UNALIGNED_SHORT_ASM_OP ".2byte" 217#endif 218#ifndef UNALIGNED_INT_ASM_OP 219#define UNALIGNED_INT_ASM_OP ".4byte" 220#endif 221#ifndef UNALIGNED_DOUBLE_INT_ASM_OP 222#define UNALIGNED_DOUBLE_INT_ASM_OP ".8byte" 223#endif 224#endif /* OBJECT_FORMAT_ELF */ 225 226#ifndef ASM_BYTE_OP 227#define ASM_BYTE_OP ".byte" 228#endif 229 230/* Data and reference forms for relocatable data. */ 231#define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4) 232#define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4) 233 234/* Pseudo-op for defining a new section. */ 235#ifndef SECTION_ASM_OP 236#define SECTION_ASM_OP ".section" 237#endif 238 239/* The default format used by the ASM_OUTPUT_SECTION macro (see below) to 240 print the SECTION_ASM_OP and the section name. The default here works for 241 almost all svr4 assemblers, except for the sparc, where the section name 242 must be enclosed in double quotes. (See sparcv4.h). */ 243#ifndef SECTION_FORMAT 244#ifdef PUSHSECTION_FORMAT 245#define SECTION_FORMAT PUSHSECTION_FORMAT 246#else 247#define SECTION_FORMAT "\t%s\t%s\n" 248#endif 249#endif 250 251#ifndef FRAME_SECTION 252#define FRAME_SECTION ".debug_frame" 253#endif 254 255#ifndef FUNC_BEGIN_LABEL 256#define FUNC_BEGIN_LABEL "LFB" 257#endif 258#ifndef FUNC_END_LABEL 259#define FUNC_END_LABEL "LFE" 260#endif 261#define CIE_AFTER_SIZE_LABEL "LSCIE" 262#define CIE_END_LABEL "LECIE" 263#define CIE_LENGTH_LABEL "LLCIE" 264#define FDE_AFTER_SIZE_LABEL "LSFDE" 265#define FDE_END_LABEL "LEFDE" 266#define FDE_LENGTH_LABEL "LLFDE" 267 268/* Definitions of defaults for various types of primitive assembly language 269 output operations. These may be overridden from within the tm.h file, 270 but typically, that is unnecessary. */ 271 272#ifndef ASM_OUTPUT_SECTION 273#define ASM_OUTPUT_SECTION(FILE, SECTION) \ 274 fprintf ((FILE), SECTION_FORMAT, SECTION_ASM_OP, SECTION) 275#endif 276 277#ifndef ASM_OUTPUT_DWARF_DATA1 278#define ASM_OUTPUT_DWARF_DATA1(FILE,VALUE) \ 279 fprintf ((FILE), "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) (VALUE)) 280#endif 281 282#ifndef ASM_OUTPUT_DWARF_DELTA1 283#define ASM_OUTPUT_DWARF_DELTA1(FILE,LABEL1,LABEL2) \ 284 do { fprintf ((FILE), "\t%s\t", ASM_BYTE_OP); \ 285 assemble_name (FILE, LABEL1); \ 286 fprintf (FILE, "-"); \ 287 assemble_name (FILE, LABEL2); \ 288 } while (0) 289#endif 290 291#ifdef UNALIGNED_INT_ASM_OP 292 293#ifndef UNALIGNED_OFFSET_ASM_OP 294#define UNALIGNED_OFFSET_ASM_OP \ 295 (DWARF_OFFSET_SIZE == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP : UNALIGNED_INT_ASM_OP) 296#endif 297 298#ifndef UNALIGNED_WORD_ASM_OP 299#define UNALIGNED_WORD_ASM_OP \ 300 (PTR_SIZE == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP : UNALIGNED_INT_ASM_OP) 301#endif 302 303#ifndef ASM_OUTPUT_DWARF_DELTA2 304#define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \ 305 do { fprintf ((FILE), "\t%s\t", UNALIGNED_SHORT_ASM_OP); \ 306 assemble_name (FILE, LABEL1); \ 307 fprintf (FILE, "-"); \ 308 assemble_name (FILE, LABEL2); \ 309 } while (0) 310#endif 311 312#ifndef ASM_OUTPUT_DWARF_DELTA4 313#define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \ 314 do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \ 315 assemble_name (FILE, LABEL1); \ 316 fprintf (FILE, "-"); \ 317 assemble_name (FILE, LABEL2); \ 318 } while (0) 319#endif 320 321#ifndef ASM_OUTPUT_DWARF_DELTA 322#define ASM_OUTPUT_DWARF_DELTA(FILE,LABEL1,LABEL2) \ 323 do { fprintf ((FILE), "\t%s\t", UNALIGNED_OFFSET_ASM_OP); \ 324 assemble_name (FILE, LABEL1); \ 325 fprintf (FILE, "-"); \ 326 assemble_name (FILE, LABEL2); \ 327 } while (0) 328#endif 329 330#ifndef ASM_OUTPUT_DWARF_ADDR_DELTA 331#define ASM_OUTPUT_DWARF_ADDR_DELTA(FILE,LABEL1,LABEL2) \ 332 do { fprintf ((FILE), "\t%s\t", UNALIGNED_WORD_ASM_OP); \ 333 assemble_name (FILE, LABEL1); \ 334 fprintf (FILE, "-"); \ 335 assemble_name (FILE, LABEL2); \ 336 } while (0) 337#endif 338 339#ifndef ASM_OUTPUT_DWARF_ADDR 340#define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \ 341 do { fprintf ((FILE), "\t%s\t", UNALIGNED_WORD_ASM_OP); \ 342 assemble_name (FILE, LABEL); \ 343 } while (0) 344#endif 345 346/* ??? This macro takes an RTX in dwarfout.c and a string in dwarf2out.c. 347 We resolve the conflict by creating a new macro ASM_OUTPUT_DWARF2_ADDR_CONST 348 for ports that want to support both DWARF1 and DWARF2. This needs a better 349 solution. See also the comments in sparc/sp64-elf.h. */ 350#ifdef ASM_OUTPUT_DWARF2_ADDR_CONST 351#undef ASM_OUTPUT_DWARF_ADDR_CONST 352#define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,ADDR) \ 353 ASM_OUTPUT_DWARF2_ADDR_CONST (FILE, ADDR) 354#endif 355 356#ifndef ASM_OUTPUT_DWARF_ADDR_CONST 357#define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,ADDR) \ 358 fprintf ((FILE), "\t%s\t%s", UNALIGNED_WORD_ASM_OP, (ADDR)) 359#endif 360 361#ifndef ASM_OUTPUT_DWARF_OFFSET4 362#define ASM_OUTPUT_DWARF_OFFSET4(FILE,LABEL) \ 363 do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \ 364 assemble_name (FILE, LABEL); \ 365 } while (0) 366#endif 367 368#ifndef ASM_OUTPUT_DWARF_OFFSET 369#define ASM_OUTPUT_DWARF_OFFSET(FILE,LABEL) \ 370 do { fprintf ((FILE), "\t%s\t", UNALIGNED_OFFSET_ASM_OP); \ 371 assemble_name (FILE, LABEL); \ 372 } while (0) 373#endif 374 375#ifndef ASM_OUTPUT_DWARF_DATA2 376#define ASM_OUTPUT_DWARF_DATA2(FILE,VALUE) \ 377 fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_SHORT_ASM_OP, (unsigned) (VALUE)) 378#endif 379 380#ifndef ASM_OUTPUT_DWARF_DATA4 381#define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \ 382 fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_INT_ASM_OP, (unsigned) (VALUE)) 383#endif 384 385#ifndef ASM_OUTPUT_DWARF_DATA 386#define ASM_OUTPUT_DWARF_DATA(FILE,VALUE) \ 387 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_OFFSET_ASM_OP, \ 388 (unsigned long) (VALUE)) 389#endif 390 391#ifndef ASM_OUTPUT_DWARF_ADDR_DATA 392#define ASM_OUTPUT_DWARF_ADDR_DATA(FILE,VALUE) \ 393 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_WORD_ASM_OP, \ 394 (unsigned long) (VALUE)) 395#endif 396 397#ifndef ASM_OUTPUT_DWARF_DATA8 398#define ASM_OUTPUT_DWARF_DATA8(FILE,HIGH_VALUE,LOW_VALUE) \ 399 do { \ 400 if (WORDS_BIG_ENDIAN) \ 401 { \ 402 fprintf ((FILE), "\t%s\t0x%lx\n", UNALIGNED_INT_ASM_OP, (HIGH_VALUE));\ 403 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_INT_ASM_OP, (LOW_VALUE));\ 404 } \ 405 else \ 406 { \ 407 fprintf ((FILE), "\t%s\t0x%lx\n", UNALIGNED_INT_ASM_OP, (LOW_VALUE)); \ 408 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_INT_ASM_OP, (HIGH_VALUE)); \ 409 } \ 410 } while (0) 411#endif 412 413#else /* UNALIGNED_INT_ASM_OP */ 414 415/* We don't have unaligned support, let's hope the normal output works for 416 .debug_frame. */ 417 418#define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \ 419 assemble_integer (gen_rtx_SYMBOL_REF (Pmode, LABEL), PTR_SIZE, 1) 420 421#define ASM_OUTPUT_DWARF_OFFSET4(FILE,LABEL) \ 422 assemble_integer (gen_rtx_SYMBOL_REF (SImode, LABEL), 4, 1) 423 424#define ASM_OUTPUT_DWARF_OFFSET(FILE,LABEL) \ 425 assemble_integer (gen_rtx_SYMBOL_REF (SImode, LABEL), 4, 1) 426 427#define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \ 428 assemble_integer (gen_rtx_MINUS (HImode, \ 429 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \ 430 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \ 431 2, 1) 432 433#define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \ 434 assemble_integer (gen_rtx_MINUS (SImode, \ 435 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \ 436 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \ 437 4, 1) 438 439#define ASM_OUTPUT_DWARF_ADDR_DELTA(FILE,LABEL1,LABEL2) \ 440 assemble_integer (gen_rtx_MINUS (Pmode, \ 441 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \ 442 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \ 443 PTR_SIZE, 1) 444 445#define ASM_OUTPUT_DWARF_DELTA(FILE,LABEL1,LABEL2) \ 446 ASM_OUTPUT_DWARF_DELTA4 (FILE,LABEL1,LABEL2) 447 448#define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \ 449 assemble_integer (GEN_INT (VALUE), 4, 1) 450 451#endif /* UNALIGNED_INT_ASM_OP */ 452 453#ifdef SET_ASM_OP 454#ifndef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL 455#define ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL(FILE, SY, HI, LO) \ 456 do { \ 457 fprintf (FILE, "\t%s\t", SET_ASM_OP); \ 458 assemble_name (FILE, SY); \ 459 fputc (',', FILE); \ 460 assemble_name (FILE, HI); \ 461 fputc ('-', FILE); \ 462 assemble_name (FILE, LO); \ 463 } while (0) 464#endif 465#endif /* SET_ASM_OP */ 466 467/* This is similar to the default ASM_OUTPUT_ASCII, except that no trailing 468 newline is produced. When flag_debug_asm is asserted, we add commentary 469 at the end of the line, so we must avoid output of a newline here. */ 470#ifndef ASM_OUTPUT_DWARF_STRING 471#define ASM_OUTPUT_DWARF_STRING(FILE,P) \ 472 do { \ 473 register int slen = strlen(P); \ 474 register char *p = (P); \ 475 register int i; \ 476 fprintf (FILE, "\t.ascii \""); \ 477 for (i = 0; i < slen; i++) \ 478 { \ 479 register int c = p[i]; \ 480 if (c == '\"' || c == '\\') \ 481 putc ('\\', FILE); \ 482 if (c >= ' ' && c < 0177) \ 483 putc (c, FILE); \ 484 else \ 485 { \ 486 fprintf (FILE, "\\%o", c); \ 487 } \ 488 } \ 489 fprintf (FILE, "\\0\""); \ 490 } \ 491 while (0) 492#endif 493 494/* The DWARF 2 CFA column which tracks the return address. Normally this 495 is the column for PC, or the first column after all of the hard 496 registers. */ 497#ifndef DWARF_FRAME_RETURN_COLUMN 498#ifdef PC_REGNUM 499#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM) 500#else 501#define DWARF_FRAME_RETURN_COLUMN FIRST_PSEUDO_REGISTER 502#endif 503#endif 504 505/* The mapping from gcc register number to DWARF 2 CFA column number. By 506 default, we just provide columns for all registers. */ 507#ifndef DWARF_FRAME_REGNUM 508#define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG) 509#endif 510 511/* Hook used by __throw. */ 512 513rtx 514expand_builtin_dwarf_fp_regnum () 515{ 516 return GEN_INT (DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM)); 517} 518 519/* The offset from the incoming value of %sp to the top of the stack frame 520 for the current function. */ 521#ifndef INCOMING_FRAME_SP_OFFSET 522#define INCOMING_FRAME_SP_OFFSET 0 523#endif 524 525/* Return a pointer to a copy of the section string name S with all 526 attributes stripped off, and an asterisk prepended (for assemble_name). */ 527 528static inline char * 529stripattributes (s) 530 char *s; 531{ 532 char *stripped = xmalloc (strlen (s) + 2); 533 char *p = stripped; 534 535 *p++ = '*'; 536 537 while (*s && *s != ',') 538 *p++ = *s++; 539 540 *p = '\0'; 541 return stripped; 542} 543 544/* Return the register number described by a given RTL node. */ 545 546static unsigned 547reg_number (rtl) 548 register rtx rtl; 549{ 550 register unsigned regno = REGNO (rtl); 551 552 if (regno >= FIRST_PSEUDO_REGISTER) 553 { 554 warning ("internal regno botch: regno = %d\n", regno); 555 regno = 0; 556 } 557 558 regno = DBX_REGISTER_NUMBER (regno); 559 return regno; 560} 561 562struct reg_size_range 563{ 564 int beg; 565 int end; 566 int size; 567}; 568 569/* Given a register number in REG_TREE, return an rtx for its size in bytes. 570 We do this in kind of a roundabout way, by building up a list of 571 register size ranges and seeing where our register falls in one of those 572 ranges. We need to do it this way because REG_TREE is not a constant, 573 and the target macros were not designed to make this task easy. */ 574 575rtx 576expand_builtin_dwarf_reg_size (reg_tree, target) 577 tree reg_tree; 578 rtx target; 579{ 580 enum machine_mode mode; 581 int size; 582 struct reg_size_range ranges[5]; 583 tree t, t2; 584 585 int i = 0; 586 int n_ranges = 0; 587 int last_size = -1; 588 589 for (; i < FIRST_PSEUDO_REGISTER; ++i) 590 { 591 /* The return address is out of order on the MIPS, and we don't use 592 copy_reg for it anyway, so we don't care here how large it is. */ 593 if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN) 594 continue; 595 596 mode = reg_raw_mode[i]; 597 598 /* CCmode is arbitrarily given a size of 4 bytes. It is more useful 599 to use the same size as word_mode, since that reduces the number 600 of ranges we need. It should not matter, since the result should 601 never be used for a condition code register anyways. */ 602 if (GET_MODE_CLASS (mode) == MODE_CC) 603 mode = word_mode; 604 605 size = GET_MODE_SIZE (mode); 606 607 /* If this register is not valid in the specified mode and 608 we have a previous size, use that for the size of this 609 register to avoid making junk tiny ranges. */ 610 if (! HARD_REGNO_MODE_OK (i, mode) && last_size != -1) 611 size = last_size; 612 613 if (size != last_size) 614 { 615 ranges[n_ranges].beg = i; 616 ranges[n_ranges].size = last_size = size; 617 ++n_ranges; 618 if (n_ranges >= 5) 619 abort (); 620 } 621 ranges[n_ranges-1].end = i; 622 } 623 624 /* The usual case: fp regs surrounded by general regs. */ 625 if (n_ranges == 3 && ranges[0].size == ranges[2].size) 626 { 627 if ((DWARF_FRAME_REGNUM (ranges[1].end) 628 - DWARF_FRAME_REGNUM (ranges[1].beg)) 629 != ranges[1].end - ranges[1].beg) 630 abort (); 631 t = fold (build (GE_EXPR, integer_type_node, reg_tree, 632 build_int_2 (DWARF_FRAME_REGNUM (ranges[1].beg), 0))); 633 t2 = fold (build (LE_EXPR, integer_type_node, reg_tree, 634 build_int_2 (DWARF_FRAME_REGNUM (ranges[1].end), 0))); 635 t = fold (build (TRUTH_ANDIF_EXPR, integer_type_node, t, t2)); 636 t = fold (build (COND_EXPR, integer_type_node, t, 637 build_int_2 (ranges[1].size, 0), 638 build_int_2 (ranges[0].size, 0))); 639 } 640 else 641 { 642 /* Initialize last_end to be larger than any possible 643 DWARF_FRAME_REGNUM. */ 644 int last_end = 0x7fffffff; 645 --n_ranges; 646 t = build_int_2 (ranges[n_ranges].size, 0); 647 do 648 { 649 int beg = DWARF_FRAME_REGNUM (ranges[n_ranges].beg); 650 int end = DWARF_FRAME_REGNUM (ranges[n_ranges].end); 651 if (beg < 0) 652 continue; 653 if (end >= last_end) 654 abort (); 655 last_end = end; 656 if (end - beg != ranges[n_ranges].end - ranges[n_ranges].beg) 657 abort (); 658 t2 = fold (build (LE_EXPR, integer_type_node, reg_tree, 659 build_int_2 (end, 0))); 660 t = fold (build (COND_EXPR, integer_type_node, t2, 661 build_int_2 (ranges[n_ranges].size, 0), t)); 662 } 663 while (--n_ranges >= 0); 664 } 665 return expand_expr (t, target, Pmode, 0); 666} 667 668/* Convert a DWARF call frame info. operation to its string name */ 669 670static char * 671dwarf_cfi_name (cfi_opc) 672 register unsigned cfi_opc; 673{ 674 switch (cfi_opc) 675 { 676 case DW_CFA_advance_loc: 677 return "DW_CFA_advance_loc"; 678 case DW_CFA_offset: 679 return "DW_CFA_offset"; 680 case DW_CFA_restore: 681 return "DW_CFA_restore"; 682 case DW_CFA_nop: 683 return "DW_CFA_nop"; 684 case DW_CFA_set_loc: 685 return "DW_CFA_set_loc"; 686 case DW_CFA_advance_loc1: 687 return "DW_CFA_advance_loc1"; 688 case DW_CFA_advance_loc2: 689 return "DW_CFA_advance_loc2"; 690 case DW_CFA_advance_loc4: 691 return "DW_CFA_advance_loc4"; 692 case DW_CFA_offset_extended: 693 return "DW_CFA_offset_extended"; 694 case DW_CFA_restore_extended: 695 return "DW_CFA_restore_extended"; 696 case DW_CFA_undefined: 697 return "DW_CFA_undefined"; 698 case DW_CFA_same_value: 699 return "DW_CFA_same_value"; 700 case DW_CFA_register: 701 return "DW_CFA_register"; 702 case DW_CFA_remember_state: 703 return "DW_CFA_remember_state"; 704 case DW_CFA_restore_state: 705 return "DW_CFA_restore_state"; 706 case DW_CFA_def_cfa: 707 return "DW_CFA_def_cfa"; 708 case DW_CFA_def_cfa_register: 709 return "DW_CFA_def_cfa_register"; 710 case DW_CFA_def_cfa_offset: 711 return "DW_CFA_def_cfa_offset"; 712 713 /* SGI/MIPS specific */ 714 case DW_CFA_MIPS_advance_loc8: 715 return "DW_CFA_MIPS_advance_loc8"; 716 717 /* GNU extensions */ 718 case DW_CFA_GNU_window_save: 719 return "DW_CFA_GNU_window_save"; 720 case DW_CFA_GNU_args_size: 721 return "DW_CFA_GNU_args_size"; 722 case DW_CFA_GNU_negative_offset_extended: 723 return "DW_CFA_GNU_negative_offset_extended"; 724 725 default: 726 return "DW_CFA_<unknown>"; 727 } 728} 729 730/* Return a pointer to a newly allocated Call Frame Instruction. */ 731 732static inline dw_cfi_ref 733new_cfi () 734{ 735 register dw_cfi_ref cfi = (dw_cfi_ref) xmalloc (sizeof (dw_cfi_node)); 736 737 cfi->dw_cfi_next = NULL; 738 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0; 739 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0; 740 741 return cfi; 742} 743 744/* Add a Call Frame Instruction to list of instructions. */ 745 746static inline void 747add_cfi (list_head, cfi) 748 register dw_cfi_ref *list_head; 749 register dw_cfi_ref cfi; 750{ 751 register dw_cfi_ref *p; 752 753 /* Find the end of the chain. */ 754 for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next) 755 ; 756 757 *p = cfi; 758} 759 760/* Generate a new label for the CFI info to refer to. */ 761 762char * 763dwarf2out_cfi_label () 764{ 765 static char label[20]; 766 static unsigned long label_num = 0; 767 768 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", label_num++); 769 ASM_OUTPUT_LABEL (asm_out_file, label); 770 771 return label; 772} 773 774/* Add CFI to the current fde at the PC value indicated by LABEL if specified, 775 or to the CIE if LABEL is NULL. */ 776 777static void 778add_fde_cfi (label, cfi) 779 register char *label; 780 register dw_cfi_ref cfi; 781{ 782 if (label) 783 { 784 register dw_fde_ref fde = &fde_table[fde_table_in_use - 1]; 785 786 if (*label == 0) 787 label = dwarf2out_cfi_label (); 788 789 if (fde->dw_fde_current_label == NULL 790 || strcmp (label, fde->dw_fde_current_label) != 0) 791 { 792 register dw_cfi_ref xcfi; 793 794 fde->dw_fde_current_label = label = xstrdup (label); 795 796 /* Set the location counter to the new label. */ 797 xcfi = new_cfi (); 798 xcfi->dw_cfi_opc = DW_CFA_advance_loc4; 799 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label; 800 add_cfi (&fde->dw_fde_cfi, xcfi); 801 } 802 803 add_cfi (&fde->dw_fde_cfi, cfi); 804 } 805 806 else 807 add_cfi (&cie_cfi_head, cfi); 808} 809 810/* Subroutine of lookup_cfa. */ 811 812static inline void 813lookup_cfa_1 (cfi, regp, offsetp) 814 register dw_cfi_ref cfi; 815 register unsigned long *regp; 816 register long *offsetp; 817{ 818 switch (cfi->dw_cfi_opc) 819 { 820 case DW_CFA_def_cfa_offset: 821 *offsetp = cfi->dw_cfi_oprnd1.dw_cfi_offset; 822 break; 823 case DW_CFA_def_cfa_register: 824 *regp = cfi->dw_cfi_oprnd1.dw_cfi_reg_num; 825 break; 826 case DW_CFA_def_cfa: 827 *regp = cfi->dw_cfi_oprnd1.dw_cfi_reg_num; 828 *offsetp = cfi->dw_cfi_oprnd2.dw_cfi_offset; 829 break; 830 default: 831 break; 832 } 833} 834 835/* Find the previous value for the CFA. */ 836 837static void 838lookup_cfa (regp, offsetp) 839 register unsigned long *regp; 840 register long *offsetp; 841{ 842 register dw_cfi_ref cfi; 843 844 *regp = (unsigned long) -1; 845 *offsetp = 0; 846 847 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next) 848 lookup_cfa_1 (cfi, regp, offsetp); 849 850 if (fde_table_in_use) 851 { 852 register dw_fde_ref fde = &fde_table[fde_table_in_use - 1]; 853 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next) 854 lookup_cfa_1 (cfi, regp, offsetp); 855 } 856} 857 858/* The current rule for calculating the DWARF2 canonical frame address. */ 859static unsigned long cfa_reg; 860static long cfa_offset; 861 862/* The register used for saving registers to the stack, and its offset 863 from the CFA. */ 864static unsigned cfa_store_reg; 865static long cfa_store_offset; 866 867/* The running total of the size of arguments pushed onto the stack. */ 868static long args_size; 869 870/* The last args_size we actually output. */ 871static long old_args_size; 872 873/* Entry point to update the canonical frame address (CFA). 874 LABEL is passed to add_fde_cfi. The value of CFA is now to be 875 calculated from REG+OFFSET. */ 876 877void 878dwarf2out_def_cfa (label, reg, offset) 879 register char *label; 880 register unsigned reg; 881 register long offset; 882{ 883 register dw_cfi_ref cfi; 884 unsigned long old_reg; 885 long old_offset; 886 887 cfa_reg = reg; 888 cfa_offset = offset; 889 if (cfa_store_reg == reg) 890 cfa_store_offset = offset; 891 892 reg = DWARF_FRAME_REGNUM (reg); 893 lookup_cfa (&old_reg, &old_offset); 894 895 if (reg == old_reg && offset == old_offset) 896 return; 897 898 cfi = new_cfi (); 899 900 if (reg == old_reg) 901 { 902 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset; 903 cfi->dw_cfi_oprnd1.dw_cfi_offset = offset; 904 } 905 906#ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */ 907 else if (offset == old_offset && old_reg != (unsigned long) -1) 908 { 909 cfi->dw_cfi_opc = DW_CFA_def_cfa_register; 910 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg; 911 } 912#endif 913 914 else 915 { 916 cfi->dw_cfi_opc = DW_CFA_def_cfa; 917 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg; 918 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset; 919 } 920 921 add_fde_cfi (label, cfi); 922} 923 924/* Add the CFI for saving a register. REG is the CFA column number. 925 LABEL is passed to add_fde_cfi. 926 If SREG is -1, the register is saved at OFFSET from the CFA; 927 otherwise it is saved in SREG. */ 928 929static void 930reg_save (label, reg, sreg, offset) 931 register char * label; 932 register unsigned reg; 933 register unsigned sreg; 934 register long offset; 935{ 936 register dw_cfi_ref cfi = new_cfi (); 937 938 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg; 939 940 /* The following comparison is correct. -1 is used to indicate that 941 the value isn't a register number. */ 942 if (sreg == (unsigned int) -1) 943 { 944 if (reg & ~0x3f) 945 /* The register number won't fit in 6 bits, so we have to use 946 the long form. */ 947 cfi->dw_cfi_opc = DW_CFA_offset_extended; 948 else 949 cfi->dw_cfi_opc = DW_CFA_offset; 950 951 offset /= DWARF_CIE_DATA_ALIGNMENT; 952 if (offset < 0) 953 { 954 cfi->dw_cfi_opc = DW_CFA_GNU_negative_offset_extended; 955 offset = -offset; 956 } 957 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset; 958 } 959 else 960 { 961 cfi->dw_cfi_opc = DW_CFA_register; 962 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg; 963 } 964 965 add_fde_cfi (label, cfi); 966} 967 968/* Add the CFI for saving a register window. LABEL is passed to reg_save. 969 This CFI tells the unwinder that it needs to restore the window registers 970 from the previous frame's window save area. 971 972 ??? Perhaps we should note in the CIE where windows are saved (instead of 973 assuming 0(cfa)) and what registers are in the window. */ 974 975void 976dwarf2out_window_save (label) 977 register char * label; 978{ 979 register dw_cfi_ref cfi = new_cfi (); 980 cfi->dw_cfi_opc = DW_CFA_GNU_window_save; 981 add_fde_cfi (label, cfi); 982} 983 984/* Add a CFI to update the running total of the size of arguments 985 pushed onto the stack. */ 986 987void 988dwarf2out_args_size (label, size) 989 char *label; 990 long size; 991{ 992 register dw_cfi_ref cfi; 993 994 if (size == old_args_size) 995 return; 996 old_args_size = size; 997 998 cfi = new_cfi (); 999 cfi->dw_cfi_opc = DW_CFA_GNU_args_size; 1000 cfi->dw_cfi_oprnd1.dw_cfi_offset = size; 1001 add_fde_cfi (label, cfi); 1002} 1003 1004/* Entry point for saving a register to the stack. REG is the GCC register 1005 number. LABEL and OFFSET are passed to reg_save. */ 1006 1007void 1008dwarf2out_reg_save (label, reg, offset) 1009 register char * label; 1010 register unsigned reg; 1011 register long offset; 1012{ 1013 reg_save (label, DWARF_FRAME_REGNUM (reg), -1, offset); 1014} 1015 1016/* Entry point for saving the return address in the stack. 1017 LABEL and OFFSET are passed to reg_save. */ 1018 1019void 1020dwarf2out_return_save (label, offset) 1021 register char * label; 1022 register long offset; 1023{ 1024 reg_save (label, DWARF_FRAME_RETURN_COLUMN, -1, offset); 1025} 1026 1027/* Entry point for saving the return address in a register. 1028 LABEL and SREG are passed to reg_save. */ 1029 1030void 1031dwarf2out_return_reg (label, sreg) 1032 register char * label; 1033 register unsigned sreg; 1034{ 1035 reg_save (label, DWARF_FRAME_RETURN_COLUMN, sreg, 0); 1036} 1037 1038/* Record the initial position of the return address. RTL is 1039 INCOMING_RETURN_ADDR_RTX. */ 1040 1041static void 1042initial_return_save (rtl) 1043 register rtx rtl; 1044{ 1045 unsigned int reg = (unsigned int) -1; 1046 long offset = 0; 1047 1048 switch (GET_CODE (rtl)) 1049 { 1050 case REG: 1051 /* RA is in a register. */ 1052 reg = reg_number (rtl); 1053 break; 1054 case MEM: 1055 /* RA is on the stack. */ 1056 rtl = XEXP (rtl, 0); 1057 switch (GET_CODE (rtl)) 1058 { 1059 case REG: 1060 if (REGNO (rtl) != STACK_POINTER_REGNUM) 1061 abort (); 1062 offset = 0; 1063 break; 1064 case PLUS: 1065 if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM) 1066 abort (); 1067 offset = INTVAL (XEXP (rtl, 1)); 1068 break; 1069 case MINUS: 1070 if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM) 1071 abort (); 1072 offset = -INTVAL (XEXP (rtl, 1)); 1073 break; 1074 default: 1075 abort (); 1076 } 1077 break; 1078 case PLUS: 1079 /* The return address is at some offset from any value we can 1080 actually load. For instance, on the SPARC it is in %i7+8. Just 1081 ignore the offset for now; it doesn't matter for unwinding frames. */ 1082 if (GET_CODE (XEXP (rtl, 1)) != CONST_INT) 1083 abort (); 1084 initial_return_save (XEXP (rtl, 0)); 1085 return; 1086 default: 1087 abort (); 1088 } 1089 1090 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa_offset); 1091} 1092 1093/* Check INSN to see if it looks like a push or a stack adjustment, and 1094 make a note of it if it does. EH uses this information to find out how 1095 much extra space it needs to pop off the stack. */ 1096 1097static void 1098dwarf2out_stack_adjust (insn) 1099 rtx insn; 1100{ 1101 long offset; 1102 char *label; 1103 1104 if (! asynchronous_exceptions && GET_CODE (insn) == CALL_INSN) 1105 { 1106 /* Extract the size of the args from the CALL rtx itself. */ 1107 1108 insn = PATTERN (insn); 1109 if (GET_CODE (insn) == PARALLEL) 1110 insn = XVECEXP (insn, 0, 0); 1111 if (GET_CODE (insn) == SET) 1112 insn = SET_SRC (insn); 1113 assert (GET_CODE (insn) == CALL); 1114 dwarf2out_args_size ("", INTVAL (XEXP (insn, 1))); 1115 return; 1116 } 1117 1118 /* If only calls can throw, and we have a frame pointer, 1119 save up adjustments until we see the CALL_INSN. */ 1120 else if (! asynchronous_exceptions 1121 && cfa_reg != STACK_POINTER_REGNUM) 1122 return; 1123 1124 if (GET_CODE (insn) == BARRIER) 1125 { 1126 /* When we see a BARRIER, we know to reset args_size to 0. Usually 1127 the compiler will have already emitted a stack adjustment, but 1128 doesn't bother for calls to noreturn functions. */ 1129#ifdef STACK_GROWS_DOWNWARD 1130 offset = -args_size; 1131#else 1132 offset = args_size; 1133#endif 1134 } 1135 else if (GET_CODE (PATTERN (insn)) == SET) 1136 { 1137 rtx src, dest; 1138 enum rtx_code code; 1139 1140 insn = PATTERN (insn); 1141 src = SET_SRC (insn); 1142 dest = SET_DEST (insn); 1143 1144 if (dest == stack_pointer_rtx) 1145 { 1146 /* (set (reg sp) (plus (reg sp) (const_int))) */ 1147 code = GET_CODE (src); 1148 if (! (code == PLUS || code == MINUS) 1149 || XEXP (src, 0) != stack_pointer_rtx 1150 || GET_CODE (XEXP (src, 1)) != CONST_INT) 1151 return; 1152 1153 offset = INTVAL (XEXP (src, 1)); 1154 } 1155 else if (GET_CODE (dest) == MEM) 1156 { 1157 /* (set (mem (pre_dec (reg sp))) (foo)) */ 1158 src = XEXP (dest, 0); 1159 code = GET_CODE (src); 1160 1161 if (! (code == PRE_DEC || code == PRE_INC) 1162 || XEXP (src, 0) != stack_pointer_rtx) 1163 return; 1164 1165 offset = GET_MODE_SIZE (GET_MODE (dest)); 1166 } 1167 else 1168 return; 1169 1170 if (code == PLUS || code == PRE_INC) 1171 offset = -offset; 1172 } 1173 else 1174 return; 1175 1176 if (offset == 0) 1177 return; 1178 1179 if (cfa_reg == STACK_POINTER_REGNUM) 1180 cfa_offset += offset; 1181 1182#ifndef STACK_GROWS_DOWNWARD 1183 offset = -offset; 1184#endif 1185 args_size += offset; 1186 if (args_size < 0) 1187 args_size = 0; 1188 1189 label = dwarf2out_cfi_label (); 1190 dwarf2out_def_cfa (label, cfa_reg, cfa_offset); 1191 dwarf2out_args_size (label, args_size); 1192} 1193 1194/* A temporary register used in adjusting SP or setting up the store_reg. */ 1195static unsigned cfa_temp_reg; 1196 1197/* A temporary value used in adjusting SP or setting up the store_reg. */ 1198static long cfa_temp_value; 1199 1200/* Record call frame debugging information for an expression, which either 1201 sets SP or FP (adjusting how we calculate the frame address) or saves a 1202 register to the stack. */ 1203 1204static void 1205dwarf2out_frame_debug_expr (expr, label) 1206 rtx expr; 1207 char *label; 1208{ 1209 rtx src, dest; 1210 long offset; 1211 1212 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of 1213 the PARALLEL independantly. The first element is always processed if 1214 it is a SET. This is for backward compatability. Other elements 1215 are processed only if they are SETs and the RTX_FRAME_RELATED_P 1216 flag is set in them. */ 1217 1218 if (GET_CODE (expr) == PARALLEL) 1219 { 1220 int par_index; 1221 int limit = XVECLEN (expr, 0); 1222 1223 for (par_index = 0; par_index < limit; par_index++) 1224 { 1225 rtx x = XVECEXP (expr, 0, par_index); 1226 1227 if (GET_CODE (x) == SET && 1228 (RTX_FRAME_RELATED_P (x) || par_index == 0)) 1229 dwarf2out_frame_debug_expr (x, label); 1230 } 1231 return; 1232 } 1233 1234 if (GET_CODE (expr) != SET) 1235 abort (); 1236 1237 src = SET_SRC (expr); 1238 dest = SET_DEST (expr); 1239 1240 switch (GET_CODE (dest)) 1241 { 1242 case REG: 1243 /* Update the CFA rule wrt SP or FP. Make sure src is 1244 relative to the current CFA register. */ 1245 switch (GET_CODE (src)) 1246 { 1247 /* Setting FP from SP. */ 1248 case REG: 1249 if (cfa_reg != (unsigned) REGNO (src)) 1250 abort (); 1251 if (REGNO (dest) != STACK_POINTER_REGNUM 1252 && !(frame_pointer_needed 1253 && REGNO (dest) == HARD_FRAME_POINTER_REGNUM)) 1254 abort (); 1255 cfa_reg = REGNO (dest); 1256 break; 1257 1258 case PLUS: 1259 case MINUS: 1260 if (dest == stack_pointer_rtx) 1261 { 1262 /* Adjusting SP. */ 1263 switch (GET_CODE (XEXP (src, 1))) 1264 { 1265 case CONST_INT: 1266 offset = INTVAL (XEXP (src, 1)); 1267 break; 1268 case REG: 1269 if ((unsigned) REGNO (XEXP (src, 1)) != cfa_temp_reg) 1270 abort (); 1271 offset = cfa_temp_value; 1272 break; 1273 default: 1274 abort (); 1275 } 1276 1277 if (XEXP (src, 0) == hard_frame_pointer_rtx) 1278 { 1279 /* Restoring SP from FP in the epilogue. */ 1280 if (cfa_reg != (unsigned) HARD_FRAME_POINTER_REGNUM) 1281 abort (); 1282 cfa_reg = STACK_POINTER_REGNUM; 1283 } 1284 else if (XEXP (src, 0) != stack_pointer_rtx) 1285 abort (); 1286 1287 if (GET_CODE (src) == PLUS) 1288 offset = -offset; 1289 if (cfa_reg == STACK_POINTER_REGNUM) 1290 cfa_offset += offset; 1291 if (cfa_store_reg == STACK_POINTER_REGNUM) 1292 cfa_store_offset += offset; 1293 } 1294 else if (dest == hard_frame_pointer_rtx) 1295 { 1296 /* Either setting the FP from an offset of the SP, 1297 or adjusting the FP */ 1298 if (! frame_pointer_needed 1299 || REGNO (dest) != HARD_FRAME_POINTER_REGNUM) 1300 abort (); 1301 1302 if (XEXP (src, 0) == stack_pointer_rtx 1303 && GET_CODE (XEXP (src, 1)) == CONST_INT) 1304 { 1305 if (cfa_reg != STACK_POINTER_REGNUM) 1306 abort (); 1307 offset = INTVAL (XEXP (src, 1)); 1308 if (GET_CODE (src) == PLUS) 1309 offset = -offset; 1310 cfa_offset += offset; 1311 cfa_reg = HARD_FRAME_POINTER_REGNUM; 1312 } 1313 else if (XEXP (src, 0) == hard_frame_pointer_rtx 1314 && GET_CODE (XEXP (src, 1)) == CONST_INT) 1315 { 1316 if (cfa_reg != (unsigned) HARD_FRAME_POINTER_REGNUM) 1317 abort (); 1318 offset = INTVAL (XEXP (src, 1)); 1319 if (GET_CODE (src) == PLUS) 1320 offset = -offset; 1321 cfa_offset += offset; 1322 } 1323 1324 else 1325 abort(); 1326 } 1327 else 1328 { 1329 if (GET_CODE (src) != PLUS 1330 || XEXP (src, 1) != stack_pointer_rtx) 1331 abort (); 1332 if (GET_CODE (XEXP (src, 0)) != REG 1333 || (unsigned) REGNO (XEXP (src, 0)) != cfa_temp_reg) 1334 abort (); 1335 if (cfa_reg != STACK_POINTER_REGNUM) 1336 abort (); 1337 cfa_store_reg = REGNO (dest); 1338 cfa_store_offset = cfa_offset - cfa_temp_value; 1339 } 1340 break; 1341 1342 case CONST_INT: 1343 cfa_temp_reg = REGNO (dest); 1344 cfa_temp_value = INTVAL (src); 1345 break; 1346 1347 case IOR: 1348 if (GET_CODE (XEXP (src, 0)) != REG 1349 || (unsigned) REGNO (XEXP (src, 0)) != cfa_temp_reg 1350 || (unsigned) REGNO (dest) != cfa_temp_reg 1351 || GET_CODE (XEXP (src, 1)) != CONST_INT) 1352 abort (); 1353 cfa_temp_value |= INTVAL (XEXP (src, 1)); 1354 break; 1355 1356 default: 1357 abort (); 1358 } 1359 dwarf2out_def_cfa (label, cfa_reg, cfa_offset); 1360 break; 1361 1362 case MEM: 1363 /* Saving a register to the stack. Make sure dest is relative to the 1364 CFA register. */ 1365 if (GET_CODE (src) != REG) 1366 abort (); 1367 switch (GET_CODE (XEXP (dest, 0))) 1368 { 1369 /* With a push. */ 1370 case PRE_INC: 1371 case PRE_DEC: 1372 offset = GET_MODE_SIZE (GET_MODE (dest)); 1373 if (GET_CODE (XEXP (dest, 0)) == PRE_INC) 1374 offset = -offset; 1375 1376 if (REGNO (XEXP (XEXP (dest, 0), 0)) != STACK_POINTER_REGNUM 1377 || cfa_store_reg != STACK_POINTER_REGNUM) 1378 abort (); 1379 cfa_store_offset += offset; 1380 if (cfa_reg == STACK_POINTER_REGNUM) 1381 cfa_offset = cfa_store_offset; 1382 1383 offset = -cfa_store_offset; 1384 break; 1385 1386 /* With an offset. */ 1387 case PLUS: 1388 case MINUS: 1389 offset = INTVAL (XEXP (XEXP (dest, 0), 1)); 1390 if (GET_CODE (XEXP (dest, 0)) == MINUS) 1391 offset = -offset; 1392 1393 if (cfa_store_reg != (unsigned) REGNO (XEXP (XEXP (dest, 0), 0))) 1394 abort (); 1395 offset -= cfa_store_offset; 1396 break; 1397 1398 /* Without an offset. */ 1399 case REG: 1400 if (cfa_store_reg != (unsigned) REGNO (XEXP (dest, 0))) 1401 abort(); 1402 offset = -cfa_store_offset; 1403 break; 1404 1405 default: 1406 abort (); 1407 } 1408 dwarf2out_def_cfa (label, cfa_reg, cfa_offset); 1409 dwarf2out_reg_save (label, REGNO (src), offset); 1410 break; 1411 1412 default: 1413 abort (); 1414 } 1415} 1416 1417 1418/* Record call frame debugging information for INSN, which either 1419 sets SP or FP (adjusting how we calculate the frame address) or saves a 1420 register to the stack. If INSN is NULL_RTX, initialize our state. */ 1421 1422void 1423dwarf2out_frame_debug (insn) 1424 rtx insn; 1425{ 1426 char *label; 1427 rtx src; 1428 1429 if (insn == NULL_RTX) 1430 { 1431 /* Set up state for generating call frame debug info. */ 1432 lookup_cfa (&cfa_reg, &cfa_offset); 1433 if (cfa_reg != DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM)) 1434 abort (); 1435 cfa_reg = STACK_POINTER_REGNUM; 1436 cfa_store_reg = cfa_reg; 1437 cfa_store_offset = cfa_offset; 1438 cfa_temp_reg = -1; 1439 cfa_temp_value = 0; 1440 return; 1441 } 1442 1443 if (! RTX_FRAME_RELATED_P (insn)) 1444 { 1445 dwarf2out_stack_adjust (insn); 1446 return; 1447 } 1448 1449 label = dwarf2out_cfi_label (); 1450 1451 src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX); 1452 if (src) 1453 insn = XEXP (src, 0); 1454 else 1455 insn = PATTERN (insn); 1456 1457 dwarf2out_frame_debug_expr (insn, label); 1458} 1459 1460/* Return the size of an unsigned LEB128 quantity. */ 1461 1462static inline unsigned long 1463size_of_uleb128 (value) 1464 register unsigned long value; 1465{ 1466 register unsigned long size = 0; 1467 register unsigned byte; 1468 1469 do 1470 { 1471 byte = (value & 0x7f); 1472 value >>= 7; 1473 size += 1; 1474 } 1475 while (value != 0); 1476 1477 return size; 1478} 1479 1480/* Return the size of a signed LEB128 quantity. */ 1481 1482static inline unsigned long 1483size_of_sleb128 (value) 1484 register long value; 1485{ 1486 register unsigned long size = 0; 1487 register unsigned byte; 1488 1489 do 1490 { 1491 byte = (value & 0x7f); 1492 value >>= 7; 1493 size += 1; 1494 } 1495 while (!(((value == 0) && ((byte & 0x40) == 0)) 1496 || ((value == -1) && ((byte & 0x40) != 0)))); 1497 1498 return size; 1499} 1500 1501/* Output an unsigned LEB128 quantity. */ 1502 1503static void 1504output_uleb128 (value) 1505 register unsigned long value; 1506{ 1507 unsigned long save_value = value; 1508 1509 fprintf (asm_out_file, "\t%s\t", ASM_BYTE_OP); 1510 do 1511 { 1512 register unsigned byte = (value & 0x7f); 1513 value >>= 7; 1514 if (value != 0) 1515 /* More bytes to follow. */ 1516 byte |= 0x80; 1517 1518 fprintf (asm_out_file, "0x%x", byte); 1519 if (value != 0) 1520 fprintf (asm_out_file, ","); 1521 } 1522 while (value != 0); 1523 1524 if (flag_debug_asm) 1525 fprintf (asm_out_file, "\t%s ULEB128 0x%lx", ASM_COMMENT_START, save_value); 1526} 1527 1528/* Output an signed LEB128 quantity. */ 1529 1530static void 1531output_sleb128 (value) 1532 register long value; 1533{ 1534 register int more; 1535 register unsigned byte; 1536 long save_value = value; 1537 1538 fprintf (asm_out_file, "\t%s\t", ASM_BYTE_OP); 1539 do 1540 { 1541 byte = (value & 0x7f); 1542 /* arithmetic shift */ 1543 value >>= 7; 1544 more = !((((value == 0) && ((byte & 0x40) == 0)) 1545 || ((value == -1) && ((byte & 0x40) != 0)))); 1546 if (more) 1547 byte |= 0x80; 1548 1549 fprintf (asm_out_file, "0x%x", byte); 1550 if (more) 1551 fprintf (asm_out_file, ","); 1552 } 1553 1554 while (more); 1555 if (flag_debug_asm) 1556 fprintf (asm_out_file, "\t%s SLEB128 %ld", ASM_COMMENT_START, save_value); 1557} 1558 1559/* Output a Call Frame Information opcode and its operand(s). */ 1560 1561static void 1562output_cfi (cfi, fde) 1563 register dw_cfi_ref cfi; 1564 register dw_fde_ref fde; 1565{ 1566 if (cfi->dw_cfi_opc == DW_CFA_advance_loc) 1567 { 1568 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 1569 cfi->dw_cfi_opc 1570 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)); 1571 if (flag_debug_asm) 1572 fprintf (asm_out_file, "\t%s DW_CFA_advance_loc 0x%lx", 1573 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_offset); 1574 fputc ('\n', asm_out_file); 1575 } 1576 1577 else if (cfi->dw_cfi_opc == DW_CFA_offset) 1578 { 1579 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 1580 cfi->dw_cfi_opc 1581 | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f)); 1582 if (flag_debug_asm) 1583 fprintf (asm_out_file, "\t%s DW_CFA_offset, column 0x%lx", 1584 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_reg_num); 1585 1586 fputc ('\n', asm_out_file); 1587 output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset); 1588 fputc ('\n', asm_out_file); 1589 } 1590 else if (cfi->dw_cfi_opc == DW_CFA_restore) 1591 { 1592 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 1593 cfi->dw_cfi_opc 1594 | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f)); 1595 if (flag_debug_asm) 1596 fprintf (asm_out_file, "\t%s DW_CFA_restore, column 0x%lx", 1597 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_reg_num); 1598 1599 fputc ('\n', asm_out_file); 1600 } 1601 else 1602 { 1603 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, cfi->dw_cfi_opc); 1604 if (flag_debug_asm) 1605 fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START, 1606 dwarf_cfi_name (cfi->dw_cfi_opc)); 1607 1608 fputc ('\n', asm_out_file); 1609 switch (cfi->dw_cfi_opc) 1610 { 1611 case DW_CFA_set_loc: 1612 ASM_OUTPUT_DWARF_ADDR (asm_out_file, cfi->dw_cfi_oprnd1.dw_cfi_addr); 1613 fputc ('\n', asm_out_file); 1614 break; 1615 case DW_CFA_advance_loc1: 1616 ASM_OUTPUT_DWARF_DELTA1 (asm_out_file, 1617 cfi->dw_cfi_oprnd1.dw_cfi_addr, 1618 fde->dw_fde_current_label); 1619 fputc ('\n', asm_out_file); 1620 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 1621 break; 1622 case DW_CFA_advance_loc2: 1623 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, 1624 cfi->dw_cfi_oprnd1.dw_cfi_addr, 1625 fde->dw_fde_current_label); 1626 fputc ('\n', asm_out_file); 1627 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 1628 break; 1629 case DW_CFA_advance_loc4: 1630 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, 1631 cfi->dw_cfi_oprnd1.dw_cfi_addr, 1632 fde->dw_fde_current_label); 1633 fputc ('\n', asm_out_file); 1634 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 1635 break; 1636#ifdef MIPS_DEBUGGING_INFO 1637 case DW_CFA_MIPS_advance_loc8: 1638 /* TODO: not currently implemented. */ 1639 abort (); 1640 break; 1641#endif 1642 case DW_CFA_offset_extended: 1643 case DW_CFA_GNU_negative_offset_extended: 1644 case DW_CFA_def_cfa: 1645 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num); 1646 fputc ('\n', asm_out_file); 1647 output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset); 1648 fputc ('\n', asm_out_file); 1649 break; 1650 case DW_CFA_restore_extended: 1651 case DW_CFA_undefined: 1652 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num); 1653 fputc ('\n', asm_out_file); 1654 break; 1655 case DW_CFA_same_value: 1656 case DW_CFA_def_cfa_register: 1657 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num); 1658 fputc ('\n', asm_out_file); 1659 break; 1660 case DW_CFA_register: 1661 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num); 1662 fputc ('\n', asm_out_file); 1663 output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_reg_num); 1664 fputc ('\n', asm_out_file); 1665 break; 1666 case DW_CFA_def_cfa_offset: 1667 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset); 1668 fputc ('\n', asm_out_file); 1669 break; 1670 case DW_CFA_GNU_window_save: 1671 break; 1672 case DW_CFA_GNU_args_size: 1673 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset); 1674 fputc ('\n', asm_out_file); 1675 break; 1676 default: 1677 break; 1678 } 1679 } 1680} 1681 1682#if !defined (EH_FRAME_SECTION) 1683#if defined (EH_FRAME_SECTION_ASM_OP) 1684#define EH_FRAME_SECTION() eh_frame_section(); 1685#else 1686#if defined (ASM_OUTPUT_SECTION_NAME) 1687#define EH_FRAME_SECTION() \ 1688 do { \ 1689 named_section (NULL_TREE, ".eh_frame", 0); \ 1690 } while (0) 1691#endif 1692#endif 1693#endif 1694 1695/* If we aren't using crtstuff to run ctors, don't use it for EH. */ 1696#if !defined (HAS_INIT_SECTION) && !defined (INIT_SECTION_ASM_OP) 1697#undef EH_FRAME_SECTION 1698#endif 1699 1700/* Output the call frame information used to used to record information 1701 that relates to calculating the frame pointer, and records the 1702 location of saved registers. */ 1703 1704static void 1705output_call_frame_info (for_eh) 1706 int for_eh; 1707{ 1708 register unsigned long i; 1709 register dw_fde_ref fde; 1710 register dw_cfi_ref cfi; 1711 char l1[20], l2[20]; 1712#ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL 1713 char ld[20]; 1714#endif 1715 1716 /* Do we want to include a pointer to the exception table? */ 1717 int eh_ptr = for_eh && exception_table_p (); 1718 1719 fputc ('\n', asm_out_file); 1720 1721 /* We're going to be generating comments, so turn on app. */ 1722 if (flag_debug_asm) 1723 app_enable (); 1724 1725 if (for_eh) 1726 { 1727#ifdef EH_FRAME_SECTION 1728 EH_FRAME_SECTION (); 1729#else 1730 tree label = get_file_function_name ('F'); 1731 1732 force_data_section (); 1733 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE)); 1734 ASM_GLOBALIZE_LABEL (asm_out_file, IDENTIFIER_POINTER (label)); 1735 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label)); 1736#endif 1737 assemble_label ("__FRAME_BEGIN__"); 1738 } 1739 else 1740 ASM_OUTPUT_SECTION (asm_out_file, FRAME_SECTION); 1741 1742 /* Output the CIE. */ 1743 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh); 1744 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh); 1745#ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL 1746 ASM_GENERATE_INTERNAL_LABEL (ld, CIE_LENGTH_LABEL, for_eh); 1747 if (for_eh) 1748 ASM_OUTPUT_DWARF_OFFSET4 (asm_out_file, ld); 1749 else 1750 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, ld); 1751#else 1752 if (for_eh) 1753 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l2, l1); 1754 else 1755 ASM_OUTPUT_DWARF_DELTA (asm_out_file, l2, l1); 1756#endif 1757 if (flag_debug_asm) 1758 fprintf (asm_out_file, "\t%s Length of Common Information Entry", 1759 ASM_COMMENT_START); 1760 1761 fputc ('\n', asm_out_file); 1762 ASM_OUTPUT_LABEL (asm_out_file, l1); 1763 1764 if (for_eh) 1765 /* Now that the CIE pointer is PC-relative for EH, 1766 use 0 to identify the CIE. */ 1767 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0); 1768 else 1769 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, DW_CIE_ID); 1770 1771 if (flag_debug_asm) 1772 fprintf (asm_out_file, "\t%s CIE Identifier Tag", ASM_COMMENT_START); 1773 1774 fputc ('\n', asm_out_file); 1775 if (! for_eh && DWARF_OFFSET_SIZE == 8) 1776 { 1777 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, DW_CIE_ID); 1778 fputc ('\n', asm_out_file); 1779 } 1780 1781 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_CIE_VERSION); 1782 if (flag_debug_asm) 1783 fprintf (asm_out_file, "\t%s CIE Version", ASM_COMMENT_START); 1784 1785 fputc ('\n', asm_out_file); 1786 if (eh_ptr) 1787 { 1788 /* The CIE contains a pointer to the exception region info for the 1789 frame. Make the augmentation string three bytes (including the 1790 trailing null) so the pointer is 4-byte aligned. The Solaris ld 1791 can't handle unaligned relocs. */ 1792 if (flag_debug_asm) 1793 { 1794 ASM_OUTPUT_DWARF_STRING (asm_out_file, "eh"); 1795 fprintf (asm_out_file, "\t%s CIE Augmentation", ASM_COMMENT_START); 1796 } 1797 else 1798 { 1799 ASM_OUTPUT_ASCII (asm_out_file, "eh", 3); 1800 } 1801 fputc ('\n', asm_out_file); 1802 1803 ASM_OUTPUT_DWARF_ADDR (asm_out_file, "__EXCEPTION_TABLE__"); 1804 if (flag_debug_asm) 1805 fprintf (asm_out_file, "\t%s pointer to exception region info", 1806 ASM_COMMENT_START); 1807 } 1808 else 1809 { 1810 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); 1811 if (flag_debug_asm) 1812 fprintf (asm_out_file, "\t%s CIE Augmentation (none)", 1813 ASM_COMMENT_START); 1814 } 1815 1816 fputc ('\n', asm_out_file); 1817 output_uleb128 (1); 1818 if (flag_debug_asm) 1819 fprintf (asm_out_file, " (CIE Code Alignment Factor)"); 1820 1821 fputc ('\n', asm_out_file); 1822 output_sleb128 (DWARF_CIE_DATA_ALIGNMENT); 1823 if (flag_debug_asm) 1824 fprintf (asm_out_file, " (CIE Data Alignment Factor)"); 1825 1826 fputc ('\n', asm_out_file); 1827 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_FRAME_RETURN_COLUMN); 1828 if (flag_debug_asm) 1829 fprintf (asm_out_file, "\t%s CIE RA Column", ASM_COMMENT_START); 1830 1831 fputc ('\n', asm_out_file); 1832 1833 for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next) 1834 output_cfi (cfi, NULL); 1835 1836 /* Pad the CIE out to an address sized boundary. */ 1837 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE)); 1838 ASM_OUTPUT_LABEL (asm_out_file, l2); 1839#ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL 1840 ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL (asm_out_file, ld, l2, l1); 1841 if (flag_debug_asm) 1842 fprintf (asm_out_file, "\t%s CIE Length Symbol", ASM_COMMENT_START); 1843 fputc ('\n', asm_out_file); 1844#endif 1845 1846 /* Loop through all of the FDE's. */ 1847 for (i = 0; i < fde_table_in_use; ++i) 1848 { 1849 fde = &fde_table[i]; 1850 1851 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i*2); 1852 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i*2); 1853#ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL 1854 ASM_GENERATE_INTERNAL_LABEL (ld, FDE_LENGTH_LABEL, for_eh + i*2); 1855 if (for_eh) 1856 ASM_OUTPUT_DWARF_OFFSET4 (asm_out_file, ld); 1857 else 1858 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, ld); 1859#else 1860 if (for_eh) 1861 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l2, l1); 1862 else 1863 ASM_OUTPUT_DWARF_DELTA (asm_out_file, l2, l1); 1864#endif 1865 if (flag_debug_asm) 1866 fprintf (asm_out_file, "\t%s FDE Length", ASM_COMMENT_START); 1867 fputc ('\n', asm_out_file); 1868 ASM_OUTPUT_LABEL (asm_out_file, l1); 1869 1870 /* ??? This always emits a 4 byte offset when for_eh is true, but it 1871 emits a target dependent sized offset when for_eh is not true. 1872 This inconsistency may confuse gdb. The only case where we need a 1873 non-4 byte offset is for the Irix6 N64 ABI, so we may lose SGI 1874 compatibility if we emit a 4 byte offset. We need a 4 byte offset 1875 though in order to be compatible with the dwarf_fde struct in frame.c. 1876 If the for_eh case is changed, then the struct in frame.c has 1877 to be adjusted appropriately. */ 1878 if (for_eh) 1879 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l1, "__FRAME_BEGIN__"); 1880 else 1881 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, stripattributes (FRAME_SECTION)); 1882 if (flag_debug_asm) 1883 fprintf (asm_out_file, "\t%s FDE CIE offset", ASM_COMMENT_START); 1884 1885 fputc ('\n', asm_out_file); 1886 ASM_OUTPUT_DWARF_ADDR (asm_out_file, fde->dw_fde_begin); 1887 if (flag_debug_asm) 1888 fprintf (asm_out_file, "\t%s FDE initial location", ASM_COMMENT_START); 1889 1890 fputc ('\n', asm_out_file); 1891 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, 1892 fde->dw_fde_end, fde->dw_fde_begin); 1893 if (flag_debug_asm) 1894 fprintf (asm_out_file, "\t%s FDE address range", ASM_COMMENT_START); 1895 1896 fputc ('\n', asm_out_file); 1897 1898 /* Loop through the Call Frame Instructions associated with 1899 this FDE. */ 1900 fde->dw_fde_current_label = fde->dw_fde_begin; 1901 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next) 1902 output_cfi (cfi, fde); 1903 1904 /* Pad the FDE out to an address sized boundary. */ 1905 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE)); 1906 ASM_OUTPUT_LABEL (asm_out_file, l2); 1907#ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL 1908 ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL (asm_out_file, ld, l2, l1); 1909 if (flag_debug_asm) 1910 fprintf (asm_out_file, "\t%s FDE Length Symbol", ASM_COMMENT_START); 1911 fputc ('\n', asm_out_file); 1912#endif 1913 } 1914#ifndef EH_FRAME_SECTION 1915 if (for_eh) 1916 { 1917 /* Emit terminating zero for table. */ 1918 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0); 1919 fputc ('\n', asm_out_file); 1920 } 1921#endif 1922#ifdef MIPS_DEBUGGING_INFO 1923 /* Work around Irix 6 assembler bug whereby labels at the end of a section 1924 get a value of 0. Putting .align 0 after the label fixes it. */ 1925 ASM_OUTPUT_ALIGN (asm_out_file, 0); 1926#endif 1927 1928 /* Turn off app to make assembly quicker. */ 1929 if (flag_debug_asm) 1930 app_disable (); 1931} 1932 1933/* Output a marker (i.e. a label) for the beginning of a function, before 1934 the prologue. */ 1935 1936void 1937dwarf2out_begin_prologue () 1938{ 1939 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 1940 register dw_fde_ref fde; 1941 1942 ++current_funcdef_number; 1943 1944 function_section (current_function_decl); 1945 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL, 1946 current_funcdef_number); 1947 ASM_OUTPUT_LABEL (asm_out_file, label); 1948 1949 /* Expand the fde table if necessary. */ 1950 if (fde_table_in_use == fde_table_allocated) 1951 { 1952 fde_table_allocated += FDE_TABLE_INCREMENT; 1953 fde_table 1954 = (dw_fde_ref) xrealloc (fde_table, 1955 fde_table_allocated * sizeof (dw_fde_node)); 1956 } 1957 1958 /* Record the FDE associated with this function. */ 1959 current_funcdef_fde = fde_table_in_use; 1960 1961 /* Add the new FDE at the end of the fde_table. */ 1962 fde = &fde_table[fde_table_in_use++]; 1963 fde->dw_fde_begin = xstrdup (label); 1964 fde->dw_fde_current_label = NULL; 1965 fde->dw_fde_end = NULL; 1966 fde->dw_fde_cfi = NULL; 1967 1968 args_size = old_args_size = 0; 1969} 1970 1971/* Output a marker (i.e. a label) for the absolute end of the generated code 1972 for a function definition. This gets called *after* the epilogue code has 1973 been generated. */ 1974 1975void 1976dwarf2out_end_epilogue () 1977{ 1978 dw_fde_ref fde; 1979 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 1980 1981 /* Output a label to mark the endpoint of the code generated for this 1982 function. */ 1983 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL, current_funcdef_number); 1984 ASM_OUTPUT_LABEL (asm_out_file, label); 1985 fde = &fde_table[fde_table_in_use - 1]; 1986 fde->dw_fde_end = xstrdup (label); 1987} 1988 1989void 1990dwarf2out_frame_init () 1991{ 1992 /* Allocate the initial hunk of the fde_table. */ 1993 fde_table 1994 = (dw_fde_ref) xmalloc (FDE_TABLE_INCREMENT * sizeof (dw_fde_node)); 1995 bzero ((char *) fde_table, FDE_TABLE_INCREMENT * sizeof (dw_fde_node)); 1996 fde_table_allocated = FDE_TABLE_INCREMENT; 1997 fde_table_in_use = 0; 1998 1999 /* Generate the CFA instructions common to all FDE's. Do it now for the 2000 sake of lookup_cfa. */ 2001 2002#ifdef DWARF2_UNWIND_INFO 2003 /* On entry, the Canonical Frame Address is at SP. */ 2004 dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET); 2005 initial_return_save (INCOMING_RETURN_ADDR_RTX); 2006#endif 2007} 2008 2009void 2010dwarf2out_frame_finish () 2011{ 2012 /* Output call frame information. */ 2013#ifdef MIPS_DEBUGGING_INFO 2014 if (write_symbols == DWARF2_DEBUG) 2015 output_call_frame_info (0); 2016 if (flag_exceptions && ! exceptions_via_longjmp) 2017 output_call_frame_info (1); 2018#else 2019 if (write_symbols == DWARF2_DEBUG 2020 || (flag_exceptions && ! exceptions_via_longjmp)) 2021 output_call_frame_info (1); 2022#endif 2023} 2024 2025#endif /* .debug_frame support */ 2026 2027/* And now, the support for symbolic debugging information. */ 2028#ifdef DWARF2_DEBUGGING_INFO 2029 2030extern char *getpwd PROTO((void)); 2031 2032/* NOTE: In the comments in this file, many references are made to 2033 "Debugging Information Entries". This term is abbreviated as `DIE' 2034 throughout the remainder of this file. */ 2035 2036/* An internal representation of the DWARF output is built, and then 2037 walked to generate the DWARF debugging info. The walk of the internal 2038 representation is done after the entire program has been compiled. 2039 The types below are used to describe the internal representation. */ 2040 2041/* Each DIE may have a series of attribute/value pairs. Values 2042 can take on several forms. The forms that are used in this 2043 implementation are listed below. */ 2044 2045typedef enum 2046{ 2047 dw_val_class_addr, 2048 dw_val_class_loc, 2049 dw_val_class_const, 2050 dw_val_class_unsigned_const, 2051 dw_val_class_long_long, 2052 dw_val_class_float, 2053 dw_val_class_flag, 2054 dw_val_class_die_ref, 2055 dw_val_class_fde_ref, 2056 dw_val_class_lbl_id, 2057 dw_val_class_lbl_offset, 2058 dw_val_class_str 2059} 2060dw_val_class; 2061 2062/* Various DIE's use offsets relative to the beginning of the 2063 .debug_info section to refer to each other. */ 2064 2065typedef long int dw_offset; 2066 2067/* Define typedefs here to avoid circular dependencies. */ 2068 2069typedef struct die_struct *dw_die_ref; 2070typedef struct dw_attr_struct *dw_attr_ref; 2071typedef struct dw_val_struct *dw_val_ref; 2072typedef struct dw_line_info_struct *dw_line_info_ref; 2073typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref; 2074typedef struct dw_loc_descr_struct *dw_loc_descr_ref; 2075typedef struct pubname_struct *pubname_ref; 2076typedef dw_die_ref *arange_ref; 2077 2078/* Describe a double word constant value. */ 2079 2080typedef struct dw_long_long_struct 2081{ 2082 unsigned long hi; 2083 unsigned long low; 2084} 2085dw_long_long_const; 2086 2087/* Describe a floating point constant value. */ 2088 2089typedef struct dw_fp_struct 2090{ 2091 long *array; 2092 unsigned length; 2093} 2094dw_float_const; 2095 2096/* Each entry in the line_info_table maintains the file and 2097 line number associated with the label generated for that 2098 entry. The label gives the PC value associated with 2099 the line number entry. */ 2100 2101typedef struct dw_line_info_struct 2102{ 2103 unsigned long dw_file_num; 2104 unsigned long dw_line_num; 2105} 2106dw_line_info_entry; 2107 2108/* Line information for functions in separate sections; each one gets its 2109 own sequence. */ 2110typedef struct dw_separate_line_info_struct 2111{ 2112 unsigned long dw_file_num; 2113 unsigned long dw_line_num; 2114 unsigned long function; 2115} 2116dw_separate_line_info_entry; 2117 2118/* The dw_val_node describes an attribute's value, as it is 2119 represented internally. */ 2120 2121typedef struct dw_val_struct 2122{ 2123 dw_val_class val_class; 2124 union 2125 { 2126 char *val_addr; 2127 dw_loc_descr_ref val_loc; 2128 long int val_int; 2129 long unsigned val_unsigned; 2130 dw_long_long_const val_long_long; 2131 dw_float_const val_float; 2132 dw_die_ref val_die_ref; 2133 unsigned val_fde_index; 2134 char *val_str; 2135 char *val_lbl_id; 2136 unsigned char val_flag; 2137 } 2138 v; 2139} 2140dw_val_node; 2141 2142/* Locations in memory are described using a sequence of stack machine 2143 operations. */ 2144 2145typedef struct dw_loc_descr_struct 2146{ 2147 dw_loc_descr_ref dw_loc_next; 2148 enum dwarf_location_atom dw_loc_opc; 2149 dw_val_node dw_loc_oprnd1; 2150 dw_val_node dw_loc_oprnd2; 2151} 2152dw_loc_descr_node; 2153 2154/* Each DIE attribute has a field specifying the attribute kind, 2155 a link to the next attribute in the chain, and an attribute value. 2156 Attributes are typically linked below the DIE they modify. */ 2157 2158typedef struct dw_attr_struct 2159{ 2160 enum dwarf_attribute dw_attr; 2161 dw_attr_ref dw_attr_next; 2162 dw_val_node dw_attr_val; 2163} 2164dw_attr_node; 2165 2166/* The Debugging Information Entry (DIE) structure */ 2167 2168typedef struct die_struct 2169{ 2170 enum dwarf_tag die_tag; 2171 dw_attr_ref die_attr; 2172 dw_attr_ref die_attr_last; 2173 dw_die_ref die_parent; 2174 dw_die_ref die_child; 2175 dw_die_ref die_child_last; 2176 dw_die_ref die_sib; 2177 dw_offset die_offset; 2178 unsigned long die_abbrev; 2179} 2180die_node; 2181 2182/* The pubname structure */ 2183 2184typedef struct pubname_struct 2185{ 2186 dw_die_ref die; 2187 char * name; 2188} 2189pubname_entry; 2190 2191/* The limbo die list structure. */ 2192typedef struct limbo_die_struct 2193{ 2194 dw_die_ref die; 2195 struct limbo_die_struct *next; 2196} 2197limbo_die_node; 2198 2199/* How to start an assembler comment. */ 2200#ifndef ASM_COMMENT_START 2201#define ASM_COMMENT_START ";#" 2202#endif 2203 2204/* Define a macro which returns non-zero for a TYPE_DECL which was 2205 implicitly generated for a tagged type. 2206 2207 Note that unlike the gcc front end (which generates a NULL named 2208 TYPE_DECL node for each complete tagged type, each array type, and 2209 each function type node created) the g++ front end generates a 2210 _named_ TYPE_DECL node for each tagged type node created. 2211 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to 2212 generate a DW_TAG_typedef DIE for them. */ 2213 2214#define TYPE_DECL_IS_STUB(decl) \ 2215 (DECL_NAME (decl) == NULL_TREE \ 2216 || (DECL_ARTIFICIAL (decl) \ 2217 && is_tagged_type (TREE_TYPE (decl)) \ 2218 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \ 2219 /* This is necessary for stub decls that \ 2220 appear in nested inline functions. */ \ 2221 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \ 2222 && (decl_ultimate_origin (decl) \ 2223 == TYPE_STUB_DECL (TREE_TYPE (decl))))))) 2224 2225/* Information concerning the compilation unit's programming 2226 language, and compiler version. */ 2227 2228extern int flag_traditional; 2229extern char *version_string; 2230extern char *language_string; 2231 2232/* Fixed size portion of the DWARF compilation unit header. */ 2233#define DWARF_COMPILE_UNIT_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 3) 2234 2235/* Fixed size portion of debugging line information prolog. */ 2236#define DWARF_LINE_PROLOG_HEADER_SIZE 5 2237 2238/* Fixed size portion of public names info. */ 2239#define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2) 2240 2241/* Fixed size portion of the address range info. */ 2242#define DWARF_ARANGES_HEADER_SIZE \ 2243 (DWARF_ROUND (2 * DWARF_OFFSET_SIZE + 4, PTR_SIZE * 2) - DWARF_OFFSET_SIZE) 2244 2245/* Define the architecture-dependent minimum instruction length (in bytes). 2246 In this implementation of DWARF, this field is used for information 2247 purposes only. Since GCC generates assembly language, we have 2248 no a priori knowledge of how many instruction bytes are generated 2249 for each source line, and therefore can use only the DW_LNE_set_address 2250 and DW_LNS_fixed_advance_pc line information commands. */ 2251 2252#ifndef DWARF_LINE_MIN_INSTR_LENGTH 2253#define DWARF_LINE_MIN_INSTR_LENGTH 4 2254#endif 2255 2256/* Minimum line offset in a special line info. opcode. 2257 This value was chosen to give a reasonable range of values. */ 2258#define DWARF_LINE_BASE -10 2259 2260/* First special line opcde - leave room for the standard opcodes. */ 2261#define DWARF_LINE_OPCODE_BASE 10 2262 2263/* Range of line offsets in a special line info. opcode. */ 2264#define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1) 2265 2266/* Flag that indicates the initial value of the is_stmt_start flag. 2267 In the present implementation, we do not mark any lines as 2268 the beginning of a source statement, because that information 2269 is not made available by the GCC front-end. */ 2270#define DWARF_LINE_DEFAULT_IS_STMT_START 1 2271 2272/* This location is used by calc_die_sizes() to keep track 2273 the offset of each DIE within the .debug_info section. */ 2274static unsigned long next_die_offset; 2275 2276/* Record the root of the DIE's built for the current compilation unit. */ 2277static dw_die_ref comp_unit_die; 2278 2279/* A list of DIEs with a NULL parent waiting to be relocated. */ 2280static limbo_die_node *limbo_die_list = 0; 2281 2282/* Pointer to an array of filenames referenced by this compilation unit. */ 2283static char **file_table; 2284 2285/* Total number of entries in the table (i.e. array) pointed to by 2286 `file_table'. This is the *total* and includes both used and unused 2287 slots. */ 2288static unsigned file_table_allocated; 2289 2290/* Number of entries in the file_table which are actually in use. */ 2291static unsigned file_table_in_use; 2292 2293/* Size (in elements) of increments by which we may expand the filename 2294 table. */ 2295#define FILE_TABLE_INCREMENT 64 2296 2297/* Local pointer to the name of the main input file. Initialized in 2298 dwarf2out_init. */ 2299static char *primary_filename; 2300 2301/* For Dwarf output, we must assign lexical-blocks id numbers in the order in 2302 which their beginnings are encountered. We output Dwarf debugging info 2303 that refers to the beginnings and ends of the ranges of code for each 2304 lexical block. The labels themselves are generated in final.c, which 2305 assigns numbers to the blocks in the same way. */ 2306static unsigned next_block_number = 2; 2307 2308/* A pointer to the base of a table of references to DIE's that describe 2309 declarations. The table is indexed by DECL_UID() which is a unique 2310 number identifying each decl. */ 2311static dw_die_ref *decl_die_table; 2312 2313/* Number of elements currently allocated for the decl_die_table. */ 2314static unsigned decl_die_table_allocated; 2315 2316/* Number of elements in decl_die_table currently in use. */ 2317static unsigned decl_die_table_in_use; 2318 2319/* Size (in elements) of increments by which we may expand the 2320 decl_die_table. */ 2321#define DECL_DIE_TABLE_INCREMENT 256 2322 2323/* Structure used for the decl_scope table. scope is the current declaration 2324 scope, and previous is the entry that is the parent of this scope. This 2325 is usually but not always the immediately preceeding entry. */ 2326 2327typedef struct decl_scope_struct 2328{ 2329 tree scope; 2330 int previous; 2331} 2332decl_scope_node; 2333 2334/* A pointer to the base of a table of references to declaration 2335 scopes. This table is a display which tracks the nesting 2336 of declaration scopes at the current scope and containing 2337 scopes. This table is used to find the proper place to 2338 define type declaration DIE's. */ 2339static decl_scope_node *decl_scope_table; 2340 2341/* Number of elements currently allocated for the decl_scope_table. */ 2342static int decl_scope_table_allocated; 2343 2344/* Current level of nesting of declaration scopes. */ 2345static int decl_scope_depth; 2346 2347/* Size (in elements) of increments by which we may expand the 2348 decl_scope_table. */ 2349#define DECL_SCOPE_TABLE_INCREMENT 64 2350 2351/* A pointer to the base of a list of references to DIE's that 2352 are uniquely identified by their tag, presence/absence of 2353 children DIE's, and list of attribute/value pairs. */ 2354static dw_die_ref *abbrev_die_table; 2355 2356/* Number of elements currently allocated for abbrev_die_table. */ 2357static unsigned abbrev_die_table_allocated; 2358 2359/* Number of elements in type_die_table currently in use. */ 2360static unsigned abbrev_die_table_in_use; 2361 2362/* Size (in elements) of increments by which we may expand the 2363 abbrev_die_table. */ 2364#define ABBREV_DIE_TABLE_INCREMENT 256 2365 2366/* A pointer to the base of a table that contains line information 2367 for each source code line in .text in the compilation unit. */ 2368static dw_line_info_ref line_info_table; 2369 2370/* Number of elements currently allocated for line_info_table. */ 2371static unsigned line_info_table_allocated; 2372 2373/* Number of elements in separate_line_info_table currently in use. */ 2374static unsigned separate_line_info_table_in_use; 2375 2376/* A pointer to the base of a table that contains line information 2377 for each source code line outside of .text in the compilation unit. */ 2378static dw_separate_line_info_ref separate_line_info_table; 2379 2380/* Number of elements currently allocated for separate_line_info_table. */ 2381static unsigned separate_line_info_table_allocated; 2382 2383/* Number of elements in line_info_table currently in use. */ 2384static unsigned line_info_table_in_use; 2385 2386/* Size (in elements) of increments by which we may expand the 2387 line_info_table. */ 2388#define LINE_INFO_TABLE_INCREMENT 1024 2389 2390/* A pointer to the base of a table that contains a list of publicly 2391 accessible names. */ 2392static pubname_ref pubname_table; 2393 2394/* Number of elements currently allocated for pubname_table. */ 2395static unsigned pubname_table_allocated; 2396 2397/* Number of elements in pubname_table currently in use. */ 2398static unsigned pubname_table_in_use; 2399 2400/* Size (in elements) of increments by which we may expand the 2401 pubname_table. */ 2402#define PUBNAME_TABLE_INCREMENT 64 2403 2404/* A pointer to the base of a table that contains a list of publicly 2405 accessible names. */ 2406static arange_ref arange_table; 2407 2408/* Number of elements currently allocated for arange_table. */ 2409static unsigned arange_table_allocated; 2410 2411/* Number of elements in arange_table currently in use. */ 2412static unsigned arange_table_in_use; 2413 2414/* Size (in elements) of increments by which we may expand the 2415 arange_table. */ 2416#define ARANGE_TABLE_INCREMENT 64 2417 2418/* A pointer to the base of a list of pending types which we haven't 2419 generated DIEs for yet, but which we will have to come back to 2420 later on. */ 2421 2422static tree *pending_types_list; 2423 2424/* Number of elements currently allocated for the pending_types_list. */ 2425static unsigned pending_types_allocated; 2426 2427/* Number of elements of pending_types_list currently in use. */ 2428static unsigned pending_types; 2429 2430/* Size (in elements) of increments by which we may expand the pending 2431 types list. Actually, a single hunk of space of this size should 2432 be enough for most typical programs. */ 2433#define PENDING_TYPES_INCREMENT 64 2434 2435/* A pointer to the base of a list of incomplete types which might be 2436 completed at some later time. */ 2437 2438static tree *incomplete_types_list; 2439 2440/* Number of elements currently allocated for the incomplete_types_list. */ 2441static unsigned incomplete_types_allocated; 2442 2443/* Number of elements of incomplete_types_list currently in use. */ 2444static unsigned incomplete_types; 2445 2446/* Size (in elements) of increments by which we may expand the incomplete 2447 types list. Actually, a single hunk of space of this size should 2448 be enough for most typical programs. */ 2449#define INCOMPLETE_TYPES_INCREMENT 64 2450 2451/* Record whether the function being analyzed contains inlined functions. */ 2452static int current_function_has_inlines; 2453#if 0 && defined (MIPS_DEBUGGING_INFO) 2454static int comp_unit_has_inlines; 2455#endif 2456 2457/* A pointer to the ..._DECL node which we have most recently been working 2458 on. We keep this around just in case something about it looks screwy and 2459 we want to tell the user what the source coordinates for the actual 2460 declaration are. */ 2461static tree dwarf_last_decl; 2462 2463/* Forward declarations for functions defined in this file. */ 2464 2465static void addr_const_to_string PROTO((dyn_string_t, rtx)); 2466static char *addr_to_string PROTO((rtx)); 2467static int is_pseudo_reg PROTO((rtx)); 2468static tree type_main_variant PROTO((tree)); 2469static int is_tagged_type PROTO((tree)); 2470static char *dwarf_tag_name PROTO((unsigned)); 2471static char *dwarf_attr_name PROTO((unsigned)); 2472static char *dwarf_form_name PROTO((unsigned)); 2473static char *dwarf_stack_op_name PROTO((unsigned)); 2474#if 0 2475static char *dwarf_type_encoding_name PROTO((unsigned)); 2476#endif 2477static tree decl_ultimate_origin PROTO((tree)); 2478static tree block_ultimate_origin PROTO((tree)); 2479static tree decl_class_context PROTO((tree)); 2480static void add_dwarf_attr PROTO((dw_die_ref, dw_attr_ref)); 2481static void add_AT_flag PROTO((dw_die_ref, 2482 enum dwarf_attribute, 2483 unsigned)); 2484static void add_AT_int PROTO((dw_die_ref, 2485 enum dwarf_attribute, long)); 2486static void add_AT_unsigned PROTO((dw_die_ref, 2487 enum dwarf_attribute, 2488 unsigned long)); 2489static void add_AT_long_long PROTO((dw_die_ref, 2490 enum dwarf_attribute, 2491 unsigned long, unsigned long)); 2492static void add_AT_float PROTO((dw_die_ref, 2493 enum dwarf_attribute, 2494 unsigned, long *)); 2495static void add_AT_string PROTO((dw_die_ref, 2496 enum dwarf_attribute, char *)); 2497static void add_AT_die_ref PROTO((dw_die_ref, 2498 enum dwarf_attribute, 2499 dw_die_ref)); 2500static void add_AT_fde_ref PROTO((dw_die_ref, 2501 enum dwarf_attribute, 2502 unsigned)); 2503static void add_AT_loc PROTO((dw_die_ref, 2504 enum dwarf_attribute, 2505 dw_loc_descr_ref)); 2506static void add_AT_addr PROTO((dw_die_ref, 2507 enum dwarf_attribute, char *)); 2508static void add_AT_lbl_id PROTO((dw_die_ref, 2509 enum dwarf_attribute, char *)); 2510static void add_AT_lbl_offset PROTO((dw_die_ref, 2511 enum dwarf_attribute, char *)); 2512static int is_extern_subr_die PROTO((dw_die_ref)); 2513static dw_attr_ref get_AT PROTO((dw_die_ref, 2514 enum dwarf_attribute)); 2515static char *get_AT_low_pc PROTO((dw_die_ref)); 2516static char *get_AT_hi_pc PROTO((dw_die_ref)); 2517static char *get_AT_string PROTO((dw_die_ref, 2518 enum dwarf_attribute)); 2519static int get_AT_flag PROTO((dw_die_ref, 2520 enum dwarf_attribute)); 2521static unsigned get_AT_unsigned PROTO((dw_die_ref, 2522 enum dwarf_attribute)); 2523static int is_c_family PROTO((void)); 2524static int is_fortran PROTO((void)); 2525static void remove_AT PROTO((dw_die_ref, 2526 enum dwarf_attribute)); 2527static void remove_children PROTO((dw_die_ref)); 2528static void add_child_die PROTO((dw_die_ref, dw_die_ref)); 2529static dw_die_ref new_die PROTO((enum dwarf_tag, dw_die_ref)); 2530static dw_die_ref lookup_type_die PROTO((tree)); 2531static void equate_type_number_to_die PROTO((tree, dw_die_ref)); 2532static dw_die_ref lookup_decl_die PROTO((tree)); 2533static void equate_decl_number_to_die PROTO((tree, dw_die_ref)); 2534static dw_loc_descr_ref new_loc_descr PROTO((enum dwarf_location_atom, 2535 unsigned long, unsigned long)); 2536static void add_loc_descr PROTO((dw_loc_descr_ref *, 2537 dw_loc_descr_ref)); 2538static void print_spaces PROTO((FILE *)); 2539static void print_die PROTO((dw_die_ref, FILE *)); 2540static void print_dwarf_line_table PROTO((FILE *)); 2541static void add_sibling_attributes PROTO((dw_die_ref)); 2542static void build_abbrev_table PROTO((dw_die_ref)); 2543static unsigned long size_of_string PROTO((char *)); 2544static unsigned long size_of_loc_descr PROTO((dw_loc_descr_ref)); 2545static unsigned long size_of_locs PROTO((dw_loc_descr_ref)); 2546static int constant_size PROTO((long unsigned)); 2547static unsigned long size_of_die PROTO((dw_die_ref)); 2548static void calc_die_sizes PROTO((dw_die_ref)); 2549static unsigned long size_of_line_prolog PROTO((void)); 2550static unsigned long size_of_line_info PROTO((void)); 2551static unsigned long size_of_pubnames PROTO((void)); 2552static unsigned long size_of_aranges PROTO((void)); 2553static enum dwarf_form value_format PROTO((dw_val_ref)); 2554static void output_value_format PROTO((dw_val_ref)); 2555static void output_abbrev_section PROTO((void)); 2556static void output_loc_operands PROTO((dw_loc_descr_ref)); 2557static unsigned long sibling_offset PROTO((dw_die_ref)); 2558static void output_die PROTO((dw_die_ref)); 2559static void output_compilation_unit_header PROTO((void)); 2560static char *dwarf2_name PROTO((tree, int)); 2561static void add_pubname PROTO((tree, dw_die_ref)); 2562static void output_pubnames PROTO((void)); 2563static void add_arange PROTO((tree, dw_die_ref)); 2564static void output_aranges PROTO((void)); 2565static void output_line_info PROTO((void)); 2566static int is_body_block PROTO((tree)); 2567static dw_die_ref base_type_die PROTO((tree)); 2568static tree root_type PROTO((tree)); 2569static int is_base_type PROTO((tree)); 2570static dw_die_ref modified_type_die PROTO((tree, int, int, dw_die_ref)); 2571static int type_is_enum PROTO((tree)); 2572static dw_loc_descr_ref reg_loc_descriptor PROTO((rtx)); 2573static dw_loc_descr_ref based_loc_descr PROTO((unsigned, long)); 2574static int is_based_loc PROTO((rtx)); 2575static dw_loc_descr_ref mem_loc_descriptor PROTO((rtx)); 2576static dw_loc_descr_ref concat_loc_descriptor PROTO((rtx, rtx)); 2577static dw_loc_descr_ref loc_descriptor PROTO((rtx)); 2578static unsigned ceiling PROTO((unsigned, unsigned)); 2579static tree field_type PROTO((tree)); 2580static unsigned simple_type_align_in_bits PROTO((tree)); 2581static unsigned simple_type_size_in_bits PROTO((tree)); 2582static unsigned field_byte_offset PROTO((tree)); 2583static void add_AT_location_description PROTO((dw_die_ref, 2584 enum dwarf_attribute, rtx)); 2585static void add_data_member_location_attribute PROTO((dw_die_ref, tree)); 2586static void add_const_value_attribute PROTO((dw_die_ref, rtx)); 2587static void add_location_or_const_value_attribute PROTO((dw_die_ref, tree)); 2588static void add_name_attribute PROTO((dw_die_ref, char *)); 2589static void add_bound_info PROTO((dw_die_ref, 2590 enum dwarf_attribute, tree)); 2591static void add_subscript_info PROTO((dw_die_ref, tree)); 2592static void add_byte_size_attribute PROTO((dw_die_ref, tree)); 2593static void add_bit_offset_attribute PROTO((dw_die_ref, tree)); 2594static void add_bit_size_attribute PROTO((dw_die_ref, tree)); 2595static void add_prototyped_attribute PROTO((dw_die_ref, tree)); 2596static void add_abstract_origin_attribute PROTO((dw_die_ref, tree)); 2597static void add_pure_or_virtual_attribute PROTO((dw_die_ref, tree)); 2598static void add_src_coords_attributes PROTO((dw_die_ref, tree)); 2599static void add_name_and_src_coords_attributes PROTO((dw_die_ref, tree)); 2600static void push_decl_scope PROTO((tree)); 2601static dw_die_ref scope_die_for PROTO((tree, dw_die_ref)); 2602static void pop_decl_scope PROTO((void)); 2603static void add_type_attribute PROTO((dw_die_ref, tree, int, int, 2604 dw_die_ref)); 2605static char *type_tag PROTO((tree)); 2606static tree member_declared_type PROTO((tree)); 2607#if 0 2608static char *decl_start_label PROTO((tree)); 2609#endif 2610static void gen_array_type_die PROTO((tree, dw_die_ref)); 2611static void gen_set_type_die PROTO((tree, dw_die_ref)); 2612#if 0 2613static void gen_entry_point_die PROTO((tree, dw_die_ref)); 2614#endif 2615static void pend_type PROTO((tree)); 2616static void output_pending_types_for_scope PROTO((dw_die_ref)); 2617static void gen_inlined_enumeration_type_die PROTO((tree, dw_die_ref)); 2618static void gen_inlined_structure_type_die PROTO((tree, dw_die_ref)); 2619static void gen_inlined_union_type_die PROTO((tree, dw_die_ref)); 2620static void gen_enumeration_type_die PROTO((tree, dw_die_ref)); 2621static dw_die_ref gen_formal_parameter_die PROTO((tree, dw_die_ref)); 2622static void gen_unspecified_parameters_die PROTO((tree, dw_die_ref)); 2623static void gen_formal_types_die PROTO((tree, dw_die_ref)); 2624static void gen_subprogram_die PROTO((tree, dw_die_ref)); 2625static void gen_variable_die PROTO((tree, dw_die_ref)); 2626static void gen_label_die PROTO((tree, dw_die_ref)); 2627static void gen_lexical_block_die PROTO((tree, dw_die_ref, int)); 2628static void gen_inlined_subroutine_die PROTO((tree, dw_die_ref, int)); 2629static void gen_field_die PROTO((tree, dw_die_ref)); 2630static void gen_ptr_to_mbr_type_die PROTO((tree, dw_die_ref)); 2631static void gen_compile_unit_die PROTO((char *)); 2632static void gen_string_type_die PROTO((tree, dw_die_ref)); 2633static void gen_inheritance_die PROTO((tree, dw_die_ref)); 2634static void gen_member_die PROTO((tree, dw_die_ref)); 2635static void gen_struct_or_union_type_die PROTO((tree, dw_die_ref)); 2636static void gen_subroutine_type_die PROTO((tree, dw_die_ref)); 2637static void gen_typedef_die PROTO((tree, dw_die_ref)); 2638static void gen_type_die PROTO((tree, dw_die_ref)); 2639static void gen_tagged_type_instantiation_die PROTO((tree, dw_die_ref)); 2640static void gen_block_die PROTO((tree, dw_die_ref, int)); 2641static void decls_for_scope PROTO((tree, dw_die_ref, int)); 2642static int is_redundant_typedef PROTO((tree)); 2643static void gen_decl_die PROTO((tree, dw_die_ref)); 2644static unsigned lookup_filename PROTO((char *)); 2645 2646/* Section names used to hold DWARF debugging information. */ 2647#ifndef DEBUG_INFO_SECTION 2648#define DEBUG_INFO_SECTION ".debug_info" 2649#endif 2650#ifndef ABBREV_SECTION 2651#define ABBREV_SECTION ".debug_abbrev" 2652#endif 2653#ifndef ARANGES_SECTION 2654#define ARANGES_SECTION ".debug_aranges" 2655#endif 2656#ifndef DW_MACINFO_SECTION 2657#define DW_MACINFO_SECTION ".debug_macinfo" 2658#endif 2659#ifndef DEBUG_LINE_SECTION 2660#define DEBUG_LINE_SECTION ".debug_line" 2661#endif 2662#ifndef LOC_SECTION 2663#define LOC_SECTION ".debug_loc" 2664#endif 2665#ifndef PUBNAMES_SECTION 2666#define PUBNAMES_SECTION ".debug_pubnames" 2667#endif 2668#ifndef STR_SECTION 2669#define STR_SECTION ".debug_str" 2670#endif 2671 2672/* Standard ELF section names for compiled code and data. */ 2673#ifndef TEXT_SECTION 2674#define TEXT_SECTION ".text" 2675#endif 2676#ifndef DATA_SECTION 2677#define DATA_SECTION ".data" 2678#endif 2679#ifndef BSS_SECTION 2680#define BSS_SECTION ".bss" 2681#endif 2682 2683/* Labels we insert at beginning sections we can reference instead of 2684 the section names themselves. */ 2685 2686#ifndef TEXT_SECTION_LABEL 2687#define TEXT_SECTION_LABEL "Ltext" 2688#endif 2689#ifndef DEBUG_LINE_SECTION_LABEL 2690#define DEBUG_LINE_SECTION_LABEL "Ldebug_line" 2691#endif 2692#ifndef DEBUG_INFO_SECTION_LABEL 2693#define DEBUG_INFO_SECTION_LABEL "Ldebug_info" 2694#endif 2695#ifndef ABBREV_SECTION_LABEL 2696#define ABBREV_SECTION_LABEL "Ldebug_abbrev" 2697#endif 2698 2699 2700/* Definitions of defaults for formats and names of various special 2701 (artificial) labels which may be generated within this file (when the -g 2702 options is used and DWARF_DEBUGGING_INFO is in effect. 2703 If necessary, these may be overridden from within the tm.h file, but 2704 typically, overriding these defaults is unnecessary. */ 2705 2706static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES]; 2707static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 2708static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 2709static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 2710static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 2711 2712#ifndef TEXT_END_LABEL 2713#define TEXT_END_LABEL "Letext" 2714#endif 2715#ifndef DATA_END_LABEL 2716#define DATA_END_LABEL "Ledata" 2717#endif 2718#ifndef BSS_END_LABEL 2719#define BSS_END_LABEL "Lebss" 2720#endif 2721#ifndef INSN_LABEL_FMT 2722#define INSN_LABEL_FMT "LI%u_" 2723#endif 2724#ifndef BLOCK_BEGIN_LABEL 2725#define BLOCK_BEGIN_LABEL "LBB" 2726#endif 2727#ifndef BLOCK_END_LABEL 2728#define BLOCK_END_LABEL "LBE" 2729#endif 2730#ifndef BODY_BEGIN_LABEL 2731#define BODY_BEGIN_LABEL "Lbb" 2732#endif 2733#ifndef BODY_END_LABEL 2734#define BODY_END_LABEL "Lbe" 2735#endif 2736#ifndef LINE_CODE_LABEL 2737#define LINE_CODE_LABEL "LM" 2738#endif 2739#ifndef SEPARATE_LINE_CODE_LABEL 2740#define SEPARATE_LINE_CODE_LABEL "LSM" 2741#endif 2742 2743/* Convert a reference to the assembler name of a C-level name. This 2744 macro has the same effect as ASM_OUTPUT_LABELREF, but copies to 2745 a string rather than writing to a file. */ 2746#ifndef ASM_NAME_TO_STRING 2747#define ASM_NAME_TO_STRING(STR, NAME) \ 2748 do { \ 2749 if ((NAME)[0] == '*') \ 2750 dyn_string_append (STR, NAME + 1); \ 2751 else \ 2752 { \ 2753 char *newstr; \ 2754 STRIP_NAME_ENCODING (newstr, NAME); \ 2755 dyn_string_append (STR, user_label_prefix); \ 2756 dyn_string_append (STR, newstr); \ 2757 } \ 2758 } \ 2759 while (0) 2760#endif 2761 2762/* Convert an integer constant expression into assembler syntax. Addition 2763 and subtraction are the only arithmetic that may appear in these 2764 expressions. This is an adaptation of output_addr_const in final.c. 2765 Here, the target of the conversion is a string buffer. We can't use 2766 output_addr_const directly, because it writes to a file. */ 2767 2768static void 2769addr_const_to_string (str, x) 2770 dyn_string_t str; 2771 rtx x; 2772{ 2773 char buf1[256]; 2774 2775restart: 2776 switch (GET_CODE (x)) 2777 { 2778 case PC: 2779 if (flag_pic) 2780 dyn_string_append (str, ","); 2781 else 2782 abort (); 2783 break; 2784 2785 case SYMBOL_REF: 2786 ASM_NAME_TO_STRING (str, XSTR (x, 0)); 2787 break; 2788 2789 case LABEL_REF: 2790 ASM_GENERATE_INTERNAL_LABEL (buf1, "L", CODE_LABEL_NUMBER (XEXP (x, 0))); 2791 ASM_NAME_TO_STRING (str, buf1); 2792 break; 2793 2794 case CODE_LABEL: 2795 ASM_GENERATE_INTERNAL_LABEL (buf1, "L", CODE_LABEL_NUMBER (x)); 2796 ASM_NAME_TO_STRING (str, buf1); 2797 break; 2798 2799 case CONST_INT: 2800 sprintf (buf1, HOST_WIDE_INT_PRINT_DEC, INTVAL (x)); 2801 dyn_string_append (str, buf1); 2802 break; 2803 2804 case CONST: 2805 /* This used to output parentheses around the expression, but that does 2806 not work on the 386 (either ATT or BSD assembler). */ 2807 addr_const_to_string (str, XEXP (x, 0)); 2808 break; 2809 2810 case CONST_DOUBLE: 2811 if (GET_MODE (x) == VOIDmode) 2812 { 2813 /* We can use %d if the number is one word and positive. */ 2814 if (CONST_DOUBLE_HIGH (x)) 2815 sprintf (buf1, HOST_WIDE_INT_PRINT_DOUBLE_HEX, 2816 CONST_DOUBLE_HIGH (x), CONST_DOUBLE_LOW (x)); 2817 else if (CONST_DOUBLE_LOW (x) < 0) 2818 sprintf (buf1, HOST_WIDE_INT_PRINT_HEX, CONST_DOUBLE_LOW (x)); 2819 else 2820 sprintf (buf1, HOST_WIDE_INT_PRINT_DEC, 2821 CONST_DOUBLE_LOW (x)); 2822 dyn_string_append (str, buf1); 2823 } 2824 else 2825 /* We can't handle floating point constants; PRINT_OPERAND must 2826 handle them. */ 2827 output_operand_lossage ("floating constant misused"); 2828 break; 2829 2830 case PLUS: 2831 /* Some assemblers need integer constants to appear last (eg masm). */ 2832 if (GET_CODE (XEXP (x, 0)) == CONST_INT) 2833 { 2834 addr_const_to_string (str, XEXP (x, 1)); 2835 if (INTVAL (XEXP (x, 0)) >= 0) 2836 dyn_string_append (str, "+"); 2837 2838 addr_const_to_string (str, XEXP (x, 0)); 2839 } 2840 else 2841 { 2842 addr_const_to_string (str, XEXP (x, 0)); 2843 if (INTVAL (XEXP (x, 1)) >= 0) 2844 dyn_string_append (str, "+"); 2845 2846 addr_const_to_string (str, XEXP (x, 1)); 2847 } 2848 break; 2849 2850 case MINUS: 2851 /* Avoid outputting things like x-x or x+5-x, since some assemblers 2852 can't handle that. */ 2853 x = simplify_subtraction (x); 2854 if (GET_CODE (x) != MINUS) 2855 goto restart; 2856 2857 addr_const_to_string (str, XEXP (x, 0)); 2858 dyn_string_append (str, "-"); 2859 if (GET_CODE (XEXP (x, 1)) == CONST_INT 2860 && INTVAL (XEXP (x, 1)) < 0) 2861 { 2862 dyn_string_append (str, ASM_OPEN_PAREN); 2863 addr_const_to_string (str, XEXP (x, 1)); 2864 dyn_string_append (str, ASM_CLOSE_PAREN); 2865 } 2866 else 2867 addr_const_to_string (str, XEXP (x, 1)); 2868 break; 2869 2870 case ZERO_EXTEND: 2871 case SIGN_EXTEND: 2872 addr_const_to_string (str, XEXP (x, 0)); 2873 break; 2874 2875 default: 2876 output_operand_lossage ("invalid expression as operand"); 2877 } 2878} 2879 2880/* Convert an address constant to a string, and return a pointer to 2881 a copy of the result, located on the heap. */ 2882 2883static char * 2884addr_to_string (x) 2885 rtx x; 2886{ 2887 dyn_string_t ds = dyn_string_new (256); 2888 char *s; 2889 2890 addr_const_to_string (ds, x); 2891 2892 /* Return the dynamically allocated string, but free the 2893 dyn_string_t itself. */ 2894 s = ds->s; 2895 free (ds); 2896 return s; 2897} 2898 2899/* Test if rtl node points to a pseudo register. */ 2900 2901static inline int 2902is_pseudo_reg (rtl) 2903 register rtx rtl; 2904{ 2905 return (((GET_CODE (rtl) == REG) && (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)) 2906 || ((GET_CODE (rtl) == SUBREG) 2907 && (REGNO (XEXP (rtl, 0)) >= FIRST_PSEUDO_REGISTER))); 2908} 2909 2910/* Return a reference to a type, with its const and volatile qualifiers 2911 removed. */ 2912 2913static inline tree 2914type_main_variant (type) 2915 register tree type; 2916{ 2917 type = TYPE_MAIN_VARIANT (type); 2918 2919 /* There really should be only one main variant among any group of variants 2920 of a given type (and all of the MAIN_VARIANT values for all members of 2921 the group should point to that one type) but sometimes the C front-end 2922 messes this up for array types, so we work around that bug here. */ 2923 2924 if (TREE_CODE (type) == ARRAY_TYPE) 2925 while (type != TYPE_MAIN_VARIANT (type)) 2926 type = TYPE_MAIN_VARIANT (type); 2927 2928 return type; 2929} 2930 2931/* Return non-zero if the given type node represents a tagged type. */ 2932 2933static inline int 2934is_tagged_type (type) 2935 register tree type; 2936{ 2937 register enum tree_code code = TREE_CODE (type); 2938 2939 return (code == RECORD_TYPE || code == UNION_TYPE 2940 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE); 2941} 2942 2943/* Convert a DIE tag into its string name. */ 2944 2945static char * 2946dwarf_tag_name (tag) 2947 register unsigned tag; 2948{ 2949 switch (tag) 2950 { 2951 case DW_TAG_padding: 2952 return "DW_TAG_padding"; 2953 case DW_TAG_array_type: 2954 return "DW_TAG_array_type"; 2955 case DW_TAG_class_type: 2956 return "DW_TAG_class_type"; 2957 case DW_TAG_entry_point: 2958 return "DW_TAG_entry_point"; 2959 case DW_TAG_enumeration_type: 2960 return "DW_TAG_enumeration_type"; 2961 case DW_TAG_formal_parameter: 2962 return "DW_TAG_formal_parameter"; 2963 case DW_TAG_imported_declaration: 2964 return "DW_TAG_imported_declaration"; 2965 case DW_TAG_label: 2966 return "DW_TAG_label"; 2967 case DW_TAG_lexical_block: 2968 return "DW_TAG_lexical_block"; 2969 case DW_TAG_member: 2970 return "DW_TAG_member"; 2971 case DW_TAG_pointer_type: 2972 return "DW_TAG_pointer_type"; 2973 case DW_TAG_reference_type: 2974 return "DW_TAG_reference_type"; 2975 case DW_TAG_compile_unit: 2976 return "DW_TAG_compile_unit"; 2977 case DW_TAG_string_type: 2978 return "DW_TAG_string_type"; 2979 case DW_TAG_structure_type: 2980 return "DW_TAG_structure_type"; 2981 case DW_TAG_subroutine_type: 2982 return "DW_TAG_subroutine_type"; 2983 case DW_TAG_typedef: 2984 return "DW_TAG_typedef"; 2985 case DW_TAG_union_type: 2986 return "DW_TAG_union_type"; 2987 case DW_TAG_unspecified_parameters: 2988 return "DW_TAG_unspecified_parameters"; 2989 case DW_TAG_variant: 2990 return "DW_TAG_variant"; 2991 case DW_TAG_common_block: 2992 return "DW_TAG_common_block"; 2993 case DW_TAG_common_inclusion: 2994 return "DW_TAG_common_inclusion"; 2995 case DW_TAG_inheritance: 2996 return "DW_TAG_inheritance"; 2997 case DW_TAG_inlined_subroutine: 2998 return "DW_TAG_inlined_subroutine"; 2999 case DW_TAG_module: 3000 return "DW_TAG_module"; 3001 case DW_TAG_ptr_to_member_type: 3002 return "DW_TAG_ptr_to_member_type"; 3003 case DW_TAG_set_type: 3004 return "DW_TAG_set_type"; 3005 case DW_TAG_subrange_type: 3006 return "DW_TAG_subrange_type"; 3007 case DW_TAG_with_stmt: 3008 return "DW_TAG_with_stmt"; 3009 case DW_TAG_access_declaration: 3010 return "DW_TAG_access_declaration"; 3011 case DW_TAG_base_type: 3012 return "DW_TAG_base_type"; 3013 case DW_TAG_catch_block: 3014 return "DW_TAG_catch_block"; 3015 case DW_TAG_const_type: 3016 return "DW_TAG_const_type"; 3017 case DW_TAG_constant: 3018 return "DW_TAG_constant"; 3019 case DW_TAG_enumerator: 3020 return "DW_TAG_enumerator"; 3021 case DW_TAG_file_type: 3022 return "DW_TAG_file_type"; 3023 case DW_TAG_friend: 3024 return "DW_TAG_friend"; 3025 case DW_TAG_namelist: 3026 return "DW_TAG_namelist"; 3027 case DW_TAG_namelist_item: 3028 return "DW_TAG_namelist_item"; 3029 case DW_TAG_packed_type: 3030 return "DW_TAG_packed_type"; 3031 case DW_TAG_subprogram: 3032 return "DW_TAG_subprogram"; 3033 case DW_TAG_template_type_param: 3034 return "DW_TAG_template_type_param"; 3035 case DW_TAG_template_value_param: 3036 return "DW_TAG_template_value_param"; 3037 case DW_TAG_thrown_type: 3038 return "DW_TAG_thrown_type"; 3039 case DW_TAG_try_block: 3040 return "DW_TAG_try_block"; 3041 case DW_TAG_variant_part: 3042 return "DW_TAG_variant_part"; 3043 case DW_TAG_variable: 3044 return "DW_TAG_variable"; 3045 case DW_TAG_volatile_type: 3046 return "DW_TAG_volatile_type"; 3047 case DW_TAG_MIPS_loop: 3048 return "DW_TAG_MIPS_loop"; 3049 case DW_TAG_format_label: 3050 return "DW_TAG_format_label"; 3051 case DW_TAG_function_template: 3052 return "DW_TAG_function_template"; 3053 case DW_TAG_class_template: 3054 return "DW_TAG_class_template"; 3055 default: 3056 return "DW_TAG_<unknown>"; 3057 } 3058} 3059 3060/* Convert a DWARF attribute code into its string name. */ 3061 3062static char * 3063dwarf_attr_name (attr) 3064 register unsigned attr; 3065{ 3066 switch (attr) 3067 { 3068 case DW_AT_sibling: 3069 return "DW_AT_sibling"; 3070 case DW_AT_location: 3071 return "DW_AT_location"; 3072 case DW_AT_name: 3073 return "DW_AT_name"; 3074 case DW_AT_ordering: 3075 return "DW_AT_ordering"; 3076 case DW_AT_subscr_data: 3077 return "DW_AT_subscr_data"; 3078 case DW_AT_byte_size: 3079 return "DW_AT_byte_size"; 3080 case DW_AT_bit_offset: 3081 return "DW_AT_bit_offset"; 3082 case DW_AT_bit_size: 3083 return "DW_AT_bit_size"; 3084 case DW_AT_element_list: 3085 return "DW_AT_element_list"; 3086 case DW_AT_stmt_list: 3087 return "DW_AT_stmt_list"; 3088 case DW_AT_low_pc: 3089 return "DW_AT_low_pc"; 3090 case DW_AT_high_pc: 3091 return "DW_AT_high_pc"; 3092 case DW_AT_language: 3093 return "DW_AT_language"; 3094 case DW_AT_member: 3095 return "DW_AT_member"; 3096 case DW_AT_discr: 3097 return "DW_AT_discr"; 3098 case DW_AT_discr_value: 3099 return "DW_AT_discr_value"; 3100 case DW_AT_visibility: 3101 return "DW_AT_visibility"; 3102 case DW_AT_import: 3103 return "DW_AT_import"; 3104 case DW_AT_string_length: 3105 return "DW_AT_string_length"; 3106 case DW_AT_common_reference: 3107 return "DW_AT_common_reference"; 3108 case DW_AT_comp_dir: 3109 return "DW_AT_comp_dir"; 3110 case DW_AT_const_value: 3111 return "DW_AT_const_value"; 3112 case DW_AT_containing_type: 3113 return "DW_AT_containing_type"; 3114 case DW_AT_default_value: 3115 return "DW_AT_default_value"; 3116 case DW_AT_inline: 3117 return "DW_AT_inline"; 3118 case DW_AT_is_optional: 3119 return "DW_AT_is_optional"; 3120 case DW_AT_lower_bound: 3121 return "DW_AT_lower_bound"; 3122 case DW_AT_producer: 3123 return "DW_AT_producer"; 3124 case DW_AT_prototyped: 3125 return "DW_AT_prototyped"; 3126 case DW_AT_return_addr: 3127 return "DW_AT_return_addr"; 3128 case DW_AT_start_scope: 3129 return "DW_AT_start_scope"; 3130 case DW_AT_stride_size: 3131 return "DW_AT_stride_size"; 3132 case DW_AT_upper_bound: 3133 return "DW_AT_upper_bound"; 3134 case DW_AT_abstract_origin: 3135 return "DW_AT_abstract_origin"; 3136 case DW_AT_accessibility: 3137 return "DW_AT_accessibility"; 3138 case DW_AT_address_class: 3139 return "DW_AT_address_class"; 3140 case DW_AT_artificial: 3141 return "DW_AT_artificial"; 3142 case DW_AT_base_types: 3143 return "DW_AT_base_types"; 3144 case DW_AT_calling_convention: 3145 return "DW_AT_calling_convention"; 3146 case DW_AT_count: 3147 return "DW_AT_count"; 3148 case DW_AT_data_member_location: 3149 return "DW_AT_data_member_location"; 3150 case DW_AT_decl_column: 3151 return "DW_AT_decl_column"; 3152 case DW_AT_decl_file: 3153 return "DW_AT_decl_file"; 3154 case DW_AT_decl_line: 3155 return "DW_AT_decl_line"; 3156 case DW_AT_declaration: 3157 return "DW_AT_declaration"; 3158 case DW_AT_discr_list: 3159 return "DW_AT_discr_list"; 3160 case DW_AT_encoding: 3161 return "DW_AT_encoding"; 3162 case DW_AT_external: 3163 return "DW_AT_external"; 3164 case DW_AT_frame_base: 3165 return "DW_AT_frame_base"; 3166 case DW_AT_friend: 3167 return "DW_AT_friend"; 3168 case DW_AT_identifier_case: 3169 return "DW_AT_identifier_case"; 3170 case DW_AT_macro_info: 3171 return "DW_AT_macro_info"; 3172 case DW_AT_namelist_items: 3173 return "DW_AT_namelist_items"; 3174 case DW_AT_priority: 3175 return "DW_AT_priority"; 3176 case DW_AT_segment: 3177 return "DW_AT_segment"; 3178 case DW_AT_specification: 3179 return "DW_AT_specification"; 3180 case DW_AT_static_link: 3181 return "DW_AT_static_link"; 3182 case DW_AT_type: 3183 return "DW_AT_type"; 3184 case DW_AT_use_location: 3185 return "DW_AT_use_location"; 3186 case DW_AT_variable_parameter: 3187 return "DW_AT_variable_parameter"; 3188 case DW_AT_virtuality: 3189 return "DW_AT_virtuality"; 3190 case DW_AT_vtable_elem_location: 3191 return "DW_AT_vtable_elem_location"; 3192 3193 case DW_AT_MIPS_fde: 3194 return "DW_AT_MIPS_fde"; 3195 case DW_AT_MIPS_loop_begin: 3196 return "DW_AT_MIPS_loop_begin"; 3197 case DW_AT_MIPS_tail_loop_begin: 3198 return "DW_AT_MIPS_tail_loop_begin"; 3199 case DW_AT_MIPS_epilog_begin: 3200 return "DW_AT_MIPS_epilog_begin"; 3201 case DW_AT_MIPS_loop_unroll_factor: 3202 return "DW_AT_MIPS_loop_unroll_factor"; 3203 case DW_AT_MIPS_software_pipeline_depth: 3204 return "DW_AT_MIPS_software_pipeline_depth"; 3205 case DW_AT_MIPS_linkage_name: 3206 return "DW_AT_MIPS_linkage_name"; 3207 case DW_AT_MIPS_stride: 3208 return "DW_AT_MIPS_stride"; 3209 case DW_AT_MIPS_abstract_name: 3210 return "DW_AT_MIPS_abstract_name"; 3211 case DW_AT_MIPS_clone_origin: 3212 return "DW_AT_MIPS_clone_origin"; 3213 case DW_AT_MIPS_has_inlines: 3214 return "DW_AT_MIPS_has_inlines"; 3215 3216 case DW_AT_sf_names: 3217 return "DW_AT_sf_names"; 3218 case DW_AT_src_info: 3219 return "DW_AT_src_info"; 3220 case DW_AT_mac_info: 3221 return "DW_AT_mac_info"; 3222 case DW_AT_src_coords: 3223 return "DW_AT_src_coords"; 3224 case DW_AT_body_begin: 3225 return "DW_AT_body_begin"; 3226 case DW_AT_body_end: 3227 return "DW_AT_body_end"; 3228 default: 3229 return "DW_AT_<unknown>"; 3230 } 3231} 3232 3233/* Convert a DWARF value form code into its string name. */ 3234 3235static char * 3236dwarf_form_name (form) 3237 register unsigned form; 3238{ 3239 switch (form) 3240 { 3241 case DW_FORM_addr: 3242 return "DW_FORM_addr"; 3243 case DW_FORM_block2: 3244 return "DW_FORM_block2"; 3245 case DW_FORM_block4: 3246 return "DW_FORM_block4"; 3247 case DW_FORM_data2: 3248 return "DW_FORM_data2"; 3249 case DW_FORM_data4: 3250 return "DW_FORM_data4"; 3251 case DW_FORM_data8: 3252 return "DW_FORM_data8"; 3253 case DW_FORM_string: 3254 return "DW_FORM_string"; 3255 case DW_FORM_block: 3256 return "DW_FORM_block"; 3257 case DW_FORM_block1: 3258 return "DW_FORM_block1"; 3259 case DW_FORM_data1: 3260 return "DW_FORM_data1"; 3261 case DW_FORM_flag: 3262 return "DW_FORM_flag"; 3263 case DW_FORM_sdata: 3264 return "DW_FORM_sdata"; 3265 case DW_FORM_strp: 3266 return "DW_FORM_strp"; 3267 case DW_FORM_udata: 3268 return "DW_FORM_udata"; 3269 case DW_FORM_ref_addr: 3270 return "DW_FORM_ref_addr"; 3271 case DW_FORM_ref1: 3272 return "DW_FORM_ref1"; 3273 case DW_FORM_ref2: 3274 return "DW_FORM_ref2"; 3275 case DW_FORM_ref4: 3276 return "DW_FORM_ref4"; 3277 case DW_FORM_ref8: 3278 return "DW_FORM_ref8"; 3279 case DW_FORM_ref_udata: 3280 return "DW_FORM_ref_udata"; 3281 case DW_FORM_indirect: 3282 return "DW_FORM_indirect"; 3283 default: 3284 return "DW_FORM_<unknown>"; 3285 } 3286} 3287 3288/* Convert a DWARF stack opcode into its string name. */ 3289 3290static char * 3291dwarf_stack_op_name (op) 3292 register unsigned op; 3293{ 3294 switch (op) 3295 { 3296 case DW_OP_addr: 3297 return "DW_OP_addr"; 3298 case DW_OP_deref: 3299 return "DW_OP_deref"; 3300 case DW_OP_const1u: 3301 return "DW_OP_const1u"; 3302 case DW_OP_const1s: 3303 return "DW_OP_const1s"; 3304 case DW_OP_const2u: 3305 return "DW_OP_const2u"; 3306 case DW_OP_const2s: 3307 return "DW_OP_const2s"; 3308 case DW_OP_const4u: 3309 return "DW_OP_const4u"; 3310 case DW_OP_const4s: 3311 return "DW_OP_const4s"; 3312 case DW_OP_const8u: 3313 return "DW_OP_const8u"; 3314 case DW_OP_const8s: 3315 return "DW_OP_const8s"; 3316 case DW_OP_constu: 3317 return "DW_OP_constu"; 3318 case DW_OP_consts: 3319 return "DW_OP_consts"; 3320 case DW_OP_dup: 3321 return "DW_OP_dup"; 3322 case DW_OP_drop: 3323 return "DW_OP_drop"; 3324 case DW_OP_over: 3325 return "DW_OP_over"; 3326 case DW_OP_pick: 3327 return "DW_OP_pick"; 3328 case DW_OP_swap: 3329 return "DW_OP_swap"; 3330 case DW_OP_rot: 3331 return "DW_OP_rot"; 3332 case DW_OP_xderef: 3333 return "DW_OP_xderef"; 3334 case DW_OP_abs: 3335 return "DW_OP_abs"; 3336 case DW_OP_and: 3337 return "DW_OP_and"; 3338 case DW_OP_div: 3339 return "DW_OP_div"; 3340 case DW_OP_minus: 3341 return "DW_OP_minus"; 3342 case DW_OP_mod: 3343 return "DW_OP_mod"; 3344 case DW_OP_mul: 3345 return "DW_OP_mul"; 3346 case DW_OP_neg: 3347 return "DW_OP_neg"; 3348 case DW_OP_not: 3349 return "DW_OP_not"; 3350 case DW_OP_or: 3351 return "DW_OP_or"; 3352 case DW_OP_plus: 3353 return "DW_OP_plus"; 3354 case DW_OP_plus_uconst: 3355 return "DW_OP_plus_uconst"; 3356 case DW_OP_shl: 3357 return "DW_OP_shl"; 3358 case DW_OP_shr: 3359 return "DW_OP_shr"; 3360 case DW_OP_shra: 3361 return "DW_OP_shra"; 3362 case DW_OP_xor: 3363 return "DW_OP_xor"; 3364 case DW_OP_bra: 3365 return "DW_OP_bra"; 3366 case DW_OP_eq: 3367 return "DW_OP_eq"; 3368 case DW_OP_ge: 3369 return "DW_OP_ge"; 3370 case DW_OP_gt: 3371 return "DW_OP_gt"; 3372 case DW_OP_le: 3373 return "DW_OP_le"; 3374 case DW_OP_lt: 3375 return "DW_OP_lt"; 3376 case DW_OP_ne: 3377 return "DW_OP_ne"; 3378 case DW_OP_skip: 3379 return "DW_OP_skip"; 3380 case DW_OP_lit0: 3381 return "DW_OP_lit0"; 3382 case DW_OP_lit1: 3383 return "DW_OP_lit1"; 3384 case DW_OP_lit2: 3385 return "DW_OP_lit2"; 3386 case DW_OP_lit3: 3387 return "DW_OP_lit3"; 3388 case DW_OP_lit4: 3389 return "DW_OP_lit4"; 3390 case DW_OP_lit5: 3391 return "DW_OP_lit5"; 3392 case DW_OP_lit6: 3393 return "DW_OP_lit6"; 3394 case DW_OP_lit7: 3395 return "DW_OP_lit7"; 3396 case DW_OP_lit8: 3397 return "DW_OP_lit8"; 3398 case DW_OP_lit9: 3399 return "DW_OP_lit9"; 3400 case DW_OP_lit10: 3401 return "DW_OP_lit10"; 3402 case DW_OP_lit11: 3403 return "DW_OP_lit11"; 3404 case DW_OP_lit12: 3405 return "DW_OP_lit12"; 3406 case DW_OP_lit13: 3407 return "DW_OP_lit13"; 3408 case DW_OP_lit14: 3409 return "DW_OP_lit14"; 3410 case DW_OP_lit15: 3411 return "DW_OP_lit15"; 3412 case DW_OP_lit16: 3413 return "DW_OP_lit16"; 3414 case DW_OP_lit17: 3415 return "DW_OP_lit17"; 3416 case DW_OP_lit18: 3417 return "DW_OP_lit18"; 3418 case DW_OP_lit19: 3419 return "DW_OP_lit19"; 3420 case DW_OP_lit20: 3421 return "DW_OP_lit20"; 3422 case DW_OP_lit21: 3423 return "DW_OP_lit21"; 3424 case DW_OP_lit22: 3425 return "DW_OP_lit22"; 3426 case DW_OP_lit23: 3427 return "DW_OP_lit23"; 3428 case DW_OP_lit24: 3429 return "DW_OP_lit24"; 3430 case DW_OP_lit25: 3431 return "DW_OP_lit25"; 3432 case DW_OP_lit26: 3433 return "DW_OP_lit26"; 3434 case DW_OP_lit27: 3435 return "DW_OP_lit27"; 3436 case DW_OP_lit28: 3437 return "DW_OP_lit28"; 3438 case DW_OP_lit29: 3439 return "DW_OP_lit29"; 3440 case DW_OP_lit30: 3441 return "DW_OP_lit30"; 3442 case DW_OP_lit31: 3443 return "DW_OP_lit31"; 3444 case DW_OP_reg0: 3445 return "DW_OP_reg0"; 3446 case DW_OP_reg1: 3447 return "DW_OP_reg1"; 3448 case DW_OP_reg2: 3449 return "DW_OP_reg2"; 3450 case DW_OP_reg3: 3451 return "DW_OP_reg3"; 3452 case DW_OP_reg4: 3453 return "DW_OP_reg4"; 3454 case DW_OP_reg5: 3455 return "DW_OP_reg5"; 3456 case DW_OP_reg6: 3457 return "DW_OP_reg6"; 3458 case DW_OP_reg7: 3459 return "DW_OP_reg7"; 3460 case DW_OP_reg8: 3461 return "DW_OP_reg8"; 3462 case DW_OP_reg9: 3463 return "DW_OP_reg9"; 3464 case DW_OP_reg10: 3465 return "DW_OP_reg10"; 3466 case DW_OP_reg11: 3467 return "DW_OP_reg11"; 3468 case DW_OP_reg12: 3469 return "DW_OP_reg12"; 3470 case DW_OP_reg13: 3471 return "DW_OP_reg13"; 3472 case DW_OP_reg14: 3473 return "DW_OP_reg14"; 3474 case DW_OP_reg15: 3475 return "DW_OP_reg15"; 3476 case DW_OP_reg16: 3477 return "DW_OP_reg16"; 3478 case DW_OP_reg17: 3479 return "DW_OP_reg17"; 3480 case DW_OP_reg18: 3481 return "DW_OP_reg18"; 3482 case DW_OP_reg19: 3483 return "DW_OP_reg19"; 3484 case DW_OP_reg20: 3485 return "DW_OP_reg20"; 3486 case DW_OP_reg21: 3487 return "DW_OP_reg21"; 3488 case DW_OP_reg22: 3489 return "DW_OP_reg22"; 3490 case DW_OP_reg23: 3491 return "DW_OP_reg23"; 3492 case DW_OP_reg24: 3493 return "DW_OP_reg24"; 3494 case DW_OP_reg25: 3495 return "DW_OP_reg25"; 3496 case DW_OP_reg26: 3497 return "DW_OP_reg26"; 3498 case DW_OP_reg27: 3499 return "DW_OP_reg27"; 3500 case DW_OP_reg28: 3501 return "DW_OP_reg28"; 3502 case DW_OP_reg29: 3503 return "DW_OP_reg29"; 3504 case DW_OP_reg30: 3505 return "DW_OP_reg30"; 3506 case DW_OP_reg31: 3507 return "DW_OP_reg31"; 3508 case DW_OP_breg0: 3509 return "DW_OP_breg0"; 3510 case DW_OP_breg1: 3511 return "DW_OP_breg1"; 3512 case DW_OP_breg2: 3513 return "DW_OP_breg2"; 3514 case DW_OP_breg3: 3515 return "DW_OP_breg3"; 3516 case DW_OP_breg4: 3517 return "DW_OP_breg4"; 3518 case DW_OP_breg5: 3519 return "DW_OP_breg5"; 3520 case DW_OP_breg6: 3521 return "DW_OP_breg6"; 3522 case DW_OP_breg7: 3523 return "DW_OP_breg7"; 3524 case DW_OP_breg8: 3525 return "DW_OP_breg8"; 3526 case DW_OP_breg9: 3527 return "DW_OP_breg9"; 3528 case DW_OP_breg10: 3529 return "DW_OP_breg10"; 3530 case DW_OP_breg11: 3531 return "DW_OP_breg11"; 3532 case DW_OP_breg12: 3533 return "DW_OP_breg12"; 3534 case DW_OP_breg13: 3535 return "DW_OP_breg13"; 3536 case DW_OP_breg14: 3537 return "DW_OP_breg14"; 3538 case DW_OP_breg15: 3539 return "DW_OP_breg15"; 3540 case DW_OP_breg16: 3541 return "DW_OP_breg16"; 3542 case DW_OP_breg17: 3543 return "DW_OP_breg17"; 3544 case DW_OP_breg18: 3545 return "DW_OP_breg18"; 3546 case DW_OP_breg19: 3547 return "DW_OP_breg19"; 3548 case DW_OP_breg20: 3549 return "DW_OP_breg20"; 3550 case DW_OP_breg21: 3551 return "DW_OP_breg21"; 3552 case DW_OP_breg22: 3553 return "DW_OP_breg22"; 3554 case DW_OP_breg23: 3555 return "DW_OP_breg23"; 3556 case DW_OP_breg24: 3557 return "DW_OP_breg24"; 3558 case DW_OP_breg25: 3559 return "DW_OP_breg25"; 3560 case DW_OP_breg26: 3561 return "DW_OP_breg26"; 3562 case DW_OP_breg27: 3563 return "DW_OP_breg27"; 3564 case DW_OP_breg28: 3565 return "DW_OP_breg28"; 3566 case DW_OP_breg29: 3567 return "DW_OP_breg29"; 3568 case DW_OP_breg30: 3569 return "DW_OP_breg30"; 3570 case DW_OP_breg31: 3571 return "DW_OP_breg31"; 3572 case DW_OP_regx: 3573 return "DW_OP_regx"; 3574 case DW_OP_fbreg: 3575 return "DW_OP_fbreg"; 3576 case DW_OP_bregx: 3577 return "DW_OP_bregx"; 3578 case DW_OP_piece: 3579 return "DW_OP_piece"; 3580 case DW_OP_deref_size: 3581 return "DW_OP_deref_size"; 3582 case DW_OP_xderef_size: 3583 return "DW_OP_xderef_size"; 3584 case DW_OP_nop: 3585 return "DW_OP_nop"; 3586 default: 3587 return "OP_<unknown>"; 3588 } 3589} 3590 3591/* Convert a DWARF type code into its string name. */ 3592 3593#if 0 3594static char * 3595dwarf_type_encoding_name (enc) 3596 register unsigned enc; 3597{ 3598 switch (enc) 3599 { 3600 case DW_ATE_address: 3601 return "DW_ATE_address"; 3602 case DW_ATE_boolean: 3603 return "DW_ATE_boolean"; 3604 case DW_ATE_complex_float: 3605 return "DW_ATE_complex_float"; 3606 case DW_ATE_float: 3607 return "DW_ATE_float"; 3608 case DW_ATE_signed: 3609 return "DW_ATE_signed"; 3610 case DW_ATE_signed_char: 3611 return "DW_ATE_signed_char"; 3612 case DW_ATE_unsigned: 3613 return "DW_ATE_unsigned"; 3614 case DW_ATE_unsigned_char: 3615 return "DW_ATE_unsigned_char"; 3616 default: 3617 return "DW_ATE_<unknown>"; 3618 } 3619} 3620#endif 3621 3622/* Determine the "ultimate origin" of a decl. The decl may be an inlined 3623 instance of an inlined instance of a decl which is local to an inline 3624 function, so we have to trace all of the way back through the origin chain 3625 to find out what sort of node actually served as the original seed for the 3626 given block. */ 3627 3628static tree 3629decl_ultimate_origin (decl) 3630 register tree decl; 3631{ 3632#ifdef ENABLE_CHECKING 3633 if (DECL_FROM_INLINE (DECL_ORIGIN (decl))) 3634 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the 3635 most distant ancestor, this should never happen. */ 3636 abort (); 3637#endif 3638 3639 return DECL_ABSTRACT_ORIGIN (decl); 3640} 3641 3642/* Determine the "ultimate origin" of a block. The block may be an inlined 3643 instance of an inlined instance of a block which is local to an inline 3644 function, so we have to trace all of the way back through the origin chain 3645 to find out what sort of node actually served as the original seed for the 3646 given block. */ 3647 3648static tree 3649block_ultimate_origin (block) 3650 register tree block; 3651{ 3652 register tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block); 3653 3654 if (immediate_origin == NULL_TREE) 3655 return NULL_TREE; 3656 else 3657 { 3658 register tree ret_val; 3659 register tree lookahead = immediate_origin; 3660 3661 do 3662 { 3663 ret_val = lookahead; 3664 lookahead = (TREE_CODE (ret_val) == BLOCK) 3665 ? BLOCK_ABSTRACT_ORIGIN (ret_val) 3666 : NULL; 3667 } 3668 while (lookahead != NULL && lookahead != ret_val); 3669 3670 return ret_val; 3671 } 3672} 3673 3674/* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT 3675 of a virtual function may refer to a base class, so we check the 'this' 3676 parameter. */ 3677 3678static tree 3679decl_class_context (decl) 3680 tree decl; 3681{ 3682 tree context = NULL_TREE; 3683 3684 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl)) 3685 context = DECL_CONTEXT (decl); 3686 else 3687 context = TYPE_MAIN_VARIANT 3688 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl))))); 3689 3690 if (context && TREE_CODE_CLASS (TREE_CODE (context)) != 't') 3691 context = NULL_TREE; 3692 3693 return context; 3694} 3695 3696/* Add an attribute/value pair to a DIE */ 3697 3698static inline void 3699add_dwarf_attr (die, attr) 3700 register dw_die_ref die; 3701 register dw_attr_ref attr; 3702{ 3703 if (die != NULL && attr != NULL) 3704 { 3705 if (die->die_attr == NULL) 3706 { 3707 die->die_attr = attr; 3708 die->die_attr_last = attr; 3709 } 3710 else 3711 { 3712 die->die_attr_last->dw_attr_next = attr; 3713 die->die_attr_last = attr; 3714 } 3715 } 3716} 3717 3718/* Add a flag value attribute to a DIE. */ 3719 3720static inline void 3721add_AT_flag (die, attr_kind, flag) 3722 register dw_die_ref die; 3723 register enum dwarf_attribute attr_kind; 3724 register unsigned flag; 3725{ 3726 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node)); 3727 3728 attr->dw_attr_next = NULL; 3729 attr->dw_attr = attr_kind; 3730 attr->dw_attr_val.val_class = dw_val_class_flag; 3731 attr->dw_attr_val.v.val_flag = flag; 3732 add_dwarf_attr (die, attr); 3733} 3734 3735/* Add a signed integer attribute value to a DIE. */ 3736 3737static inline void 3738add_AT_int (die, attr_kind, int_val) 3739 register dw_die_ref die; 3740 register enum dwarf_attribute attr_kind; 3741 register long int int_val; 3742{ 3743 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node)); 3744 3745 attr->dw_attr_next = NULL; 3746 attr->dw_attr = attr_kind; 3747 attr->dw_attr_val.val_class = dw_val_class_const; 3748 attr->dw_attr_val.v.val_int = int_val; 3749 add_dwarf_attr (die, attr); 3750} 3751 3752/* Add an unsigned integer attribute value to a DIE. */ 3753 3754static inline void 3755add_AT_unsigned (die, attr_kind, unsigned_val) 3756 register dw_die_ref die; 3757 register enum dwarf_attribute attr_kind; 3758 register unsigned long unsigned_val; 3759{ 3760 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node)); 3761 3762 attr->dw_attr_next = NULL; 3763 attr->dw_attr = attr_kind; 3764 attr->dw_attr_val.val_class = dw_val_class_unsigned_const; 3765 attr->dw_attr_val.v.val_unsigned = unsigned_val; 3766 add_dwarf_attr (die, attr); 3767} 3768 3769/* Add an unsigned double integer attribute value to a DIE. */ 3770 3771static inline void 3772add_AT_long_long (die, attr_kind, val_hi, val_low) 3773 register dw_die_ref die; 3774 register enum dwarf_attribute attr_kind; 3775 register unsigned long val_hi; 3776 register unsigned long val_low; 3777{ 3778 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node)); 3779 3780 attr->dw_attr_next = NULL; 3781 attr->dw_attr = attr_kind; 3782 attr->dw_attr_val.val_class = dw_val_class_long_long; 3783 attr->dw_attr_val.v.val_long_long.hi = val_hi; 3784 attr->dw_attr_val.v.val_long_long.low = val_low; 3785 add_dwarf_attr (die, attr); 3786} 3787 3788/* Add a floating point attribute value to a DIE and return it. */ 3789 3790static inline void 3791add_AT_float (die, attr_kind, length, array) 3792 register dw_die_ref die; 3793 register enum dwarf_attribute attr_kind; 3794 register unsigned length; 3795 register long *array; 3796{ 3797 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node)); 3798 3799 attr->dw_attr_next = NULL; 3800 attr->dw_attr = attr_kind; 3801 attr->dw_attr_val.val_class = dw_val_class_float; 3802 attr->dw_attr_val.v.val_float.length = length; 3803 attr->dw_attr_val.v.val_float.array = array; 3804 add_dwarf_attr (die, attr); 3805} 3806 3807/* Add a string attribute value to a DIE. */ 3808 3809static inline void 3810add_AT_string (die, attr_kind, str) 3811 register dw_die_ref die; 3812 register enum dwarf_attribute attr_kind; 3813 register char *str; 3814{ 3815 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node)); 3816 3817 attr->dw_attr_next = NULL; 3818 attr->dw_attr = attr_kind; 3819 attr->dw_attr_val.val_class = dw_val_class_str; 3820 attr->dw_attr_val.v.val_str = xstrdup (str); 3821 add_dwarf_attr (die, attr); 3822} 3823 3824/* Add a DIE reference attribute value to a DIE. */ 3825 3826static inline void 3827add_AT_die_ref (die, attr_kind, targ_die) 3828 register dw_die_ref die; 3829 register enum dwarf_attribute attr_kind; 3830 register dw_die_ref targ_die; 3831{ 3832 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node)); 3833 3834 attr->dw_attr_next = NULL; 3835 attr->dw_attr = attr_kind; 3836 attr->dw_attr_val.val_class = dw_val_class_die_ref; 3837 attr->dw_attr_val.v.val_die_ref = targ_die; 3838 add_dwarf_attr (die, attr); 3839} 3840 3841/* Add an FDE reference attribute value to a DIE. */ 3842 3843static inline void 3844add_AT_fde_ref (die, attr_kind, targ_fde) 3845 register dw_die_ref die; 3846 register enum dwarf_attribute attr_kind; 3847 register unsigned targ_fde; 3848{ 3849 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node)); 3850 3851 attr->dw_attr_next = NULL; 3852 attr->dw_attr = attr_kind; 3853 attr->dw_attr_val.val_class = dw_val_class_fde_ref; 3854 attr->dw_attr_val.v.val_fde_index = targ_fde; 3855 add_dwarf_attr (die, attr); 3856} 3857 3858/* Add a location description attribute value to a DIE. */ 3859 3860static inline void 3861add_AT_loc (die, attr_kind, loc) 3862 register dw_die_ref die; 3863 register enum dwarf_attribute attr_kind; 3864 register dw_loc_descr_ref loc; 3865{ 3866 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node)); 3867 3868 attr->dw_attr_next = NULL; 3869 attr->dw_attr = attr_kind; 3870 attr->dw_attr_val.val_class = dw_val_class_loc; 3871 attr->dw_attr_val.v.val_loc = loc; 3872 add_dwarf_attr (die, attr); 3873} 3874 3875/* Add an address constant attribute value to a DIE. */ 3876 3877static inline void 3878add_AT_addr (die, attr_kind, addr) 3879 register dw_die_ref die; 3880 register enum dwarf_attribute attr_kind; 3881 char *addr; 3882{ 3883 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node)); 3884 3885 attr->dw_attr_next = NULL; 3886 attr->dw_attr = attr_kind; 3887 attr->dw_attr_val.val_class = dw_val_class_addr; 3888 attr->dw_attr_val.v.val_addr = addr; 3889 add_dwarf_attr (die, attr); 3890} 3891 3892/* Add a label identifier attribute value to a DIE. */ 3893 3894static inline void 3895add_AT_lbl_id (die, attr_kind, lbl_id) 3896 register dw_die_ref die; 3897 register enum dwarf_attribute attr_kind; 3898 register char *lbl_id; 3899{ 3900 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node)); 3901 3902 attr->dw_attr_next = NULL; 3903 attr->dw_attr = attr_kind; 3904 attr->dw_attr_val.val_class = dw_val_class_lbl_id; 3905 attr->dw_attr_val.v.val_lbl_id = xstrdup (lbl_id); 3906 add_dwarf_attr (die, attr); 3907} 3908 3909/* Add a section offset attribute value to a DIE. */ 3910 3911static inline void 3912add_AT_lbl_offset (die, attr_kind, label) 3913 register dw_die_ref die; 3914 register enum dwarf_attribute attr_kind; 3915 register char *label; 3916{ 3917 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node)); 3918 3919 attr->dw_attr_next = NULL; 3920 attr->dw_attr = attr_kind; 3921 attr->dw_attr_val.val_class = dw_val_class_lbl_offset; 3922 attr->dw_attr_val.v.val_lbl_id = label; 3923 add_dwarf_attr (die, attr); 3924 3925} 3926 3927/* Test if die refers to an external subroutine. */ 3928 3929static inline int 3930is_extern_subr_die (die) 3931 register dw_die_ref die; 3932{ 3933 register dw_attr_ref a; 3934 register int is_subr = FALSE; 3935 register int is_extern = FALSE; 3936 3937 if (die != NULL && die->die_tag == DW_TAG_subprogram) 3938 { 3939 is_subr = TRUE; 3940 for (a = die->die_attr; a != NULL; a = a->dw_attr_next) 3941 { 3942 if (a->dw_attr == DW_AT_external 3943 && a->dw_attr_val.val_class == dw_val_class_flag 3944 && a->dw_attr_val.v.val_flag != 0) 3945 { 3946 is_extern = TRUE; 3947 break; 3948 } 3949 } 3950 } 3951 3952 return is_subr && is_extern; 3953} 3954 3955/* Get the attribute of type attr_kind. */ 3956 3957static inline dw_attr_ref 3958get_AT (die, attr_kind) 3959 register dw_die_ref die; 3960 register enum dwarf_attribute attr_kind; 3961{ 3962 register dw_attr_ref a; 3963 register dw_die_ref spec = NULL; 3964 3965 if (die != NULL) 3966 { 3967 for (a = die->die_attr; a != NULL; a = a->dw_attr_next) 3968 { 3969 if (a->dw_attr == attr_kind) 3970 return a; 3971 3972 if (a->dw_attr == DW_AT_specification 3973 || a->dw_attr == DW_AT_abstract_origin) 3974 spec = a->dw_attr_val.v.val_die_ref; 3975 } 3976 3977 if (spec) 3978 return get_AT (spec, attr_kind); 3979 } 3980 3981 return NULL; 3982} 3983 3984/* Return the "low pc" attribute value, typically associated with 3985 a subprogram DIE. Return null if the "low pc" attribute is 3986 either not prsent, or if it cannot be represented as an 3987 assembler label identifier. */ 3988 3989static inline char * 3990get_AT_low_pc (die) 3991 register dw_die_ref die; 3992{ 3993 register dw_attr_ref a = get_AT (die, DW_AT_low_pc); 3994 3995 if (a && a->dw_attr_val.val_class == dw_val_class_lbl_id) 3996 return a->dw_attr_val.v.val_lbl_id; 3997 3998 return NULL; 3999} 4000 4001/* Return the "high pc" attribute value, typically associated with 4002 a subprogram DIE. Return null if the "high pc" attribute is 4003 either not prsent, or if it cannot be represented as an 4004 assembler label identifier. */ 4005 4006static inline char * 4007get_AT_hi_pc (die) 4008 register dw_die_ref die; 4009{ 4010 register dw_attr_ref a = get_AT (die, DW_AT_high_pc); 4011 4012 if (a && a->dw_attr_val.val_class == dw_val_class_lbl_id) 4013 return a->dw_attr_val.v.val_lbl_id; 4014 4015 return NULL; 4016} 4017 4018/* Return the value of the string attribute designated by ATTR_KIND, or 4019 NULL if it is not present. */ 4020 4021static inline char * 4022get_AT_string (die, attr_kind) 4023 register dw_die_ref die; 4024 register enum dwarf_attribute attr_kind; 4025{ 4026 register dw_attr_ref a = get_AT (die, attr_kind); 4027 4028 if (a && a->dw_attr_val.val_class == dw_val_class_str) 4029 return a->dw_attr_val.v.val_str; 4030 4031 return NULL; 4032} 4033 4034/* Return the value of the flag attribute designated by ATTR_KIND, or -1 4035 if it is not present. */ 4036 4037static inline int 4038get_AT_flag (die, attr_kind) 4039 register dw_die_ref die; 4040 register enum dwarf_attribute attr_kind; 4041{ 4042 register dw_attr_ref a = get_AT (die, attr_kind); 4043 4044 if (a && a->dw_attr_val.val_class == dw_val_class_flag) 4045 return a->dw_attr_val.v.val_flag; 4046 4047 return -1; 4048} 4049 4050/* Return the value of the unsigned attribute designated by ATTR_KIND, or 0 4051 if it is not present. */ 4052 4053static inline unsigned 4054get_AT_unsigned (die, attr_kind) 4055 register dw_die_ref die; 4056 register enum dwarf_attribute attr_kind; 4057{ 4058 register dw_attr_ref a = get_AT (die, attr_kind); 4059 4060 if (a && a->dw_attr_val.val_class == dw_val_class_unsigned_const) 4061 return a->dw_attr_val.v.val_unsigned; 4062 4063 return 0; 4064} 4065 4066static inline int 4067is_c_family () 4068{ 4069 register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language); 4070 4071 return (lang == DW_LANG_C || lang == DW_LANG_C89 4072 || lang == DW_LANG_C_plus_plus); 4073} 4074 4075static inline int 4076is_fortran () 4077{ 4078 register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language); 4079 4080 return (lang == DW_LANG_Fortran77 || lang == DW_LANG_Fortran90); 4081} 4082 4083/* Remove the specified attribute if present. */ 4084 4085static inline void 4086remove_AT (die, attr_kind) 4087 register dw_die_ref die; 4088 register enum dwarf_attribute attr_kind; 4089{ 4090 register dw_attr_ref a; 4091 register dw_attr_ref removed = NULL;; 4092 4093 if (die != NULL) 4094 { 4095 if (die->die_attr->dw_attr == attr_kind) 4096 { 4097 removed = die->die_attr; 4098 if (die->die_attr_last == die->die_attr) 4099 die->die_attr_last = NULL; 4100 4101 die->die_attr = die->die_attr->dw_attr_next; 4102 } 4103 4104 else 4105 for (a = die->die_attr; a->dw_attr_next != NULL; 4106 a = a->dw_attr_next) 4107 if (a->dw_attr_next->dw_attr == attr_kind) 4108 { 4109 removed = a->dw_attr_next; 4110 if (die->die_attr_last == a->dw_attr_next) 4111 die->die_attr_last = a; 4112 4113 a->dw_attr_next = a->dw_attr_next->dw_attr_next; 4114 break; 4115 } 4116 4117 if (removed != 0) 4118 free (removed); 4119 } 4120} 4121 4122/* Discard the children of this DIE. */ 4123 4124static inline void 4125remove_children (die) 4126 register dw_die_ref die; 4127{ 4128 register dw_die_ref child_die = die->die_child; 4129 4130 die->die_child = NULL; 4131 die->die_child_last = NULL; 4132 4133 while (child_die != NULL) 4134 { 4135 register dw_die_ref tmp_die = child_die; 4136 register dw_attr_ref a; 4137 4138 child_die = child_die->die_sib; 4139 4140 for (a = tmp_die->die_attr; a != NULL; ) 4141 { 4142 register dw_attr_ref tmp_a = a; 4143 4144 a = a->dw_attr_next; 4145 free (tmp_a); 4146 } 4147 4148 free (tmp_die); 4149 } 4150} 4151 4152/* Add a child DIE below its parent. */ 4153 4154static inline void 4155add_child_die (die, child_die) 4156 register dw_die_ref die; 4157 register dw_die_ref child_die; 4158{ 4159 if (die != NULL && child_die != NULL) 4160 { 4161 if (die == child_die) 4162 abort (); 4163 child_die->die_parent = die; 4164 child_die->die_sib = NULL; 4165 4166 if (die->die_child == NULL) 4167 { 4168 die->die_child = child_die; 4169 die->die_child_last = child_die; 4170 } 4171 else 4172 { 4173 die->die_child_last->die_sib = child_die; 4174 die->die_child_last = child_die; 4175 } 4176 } 4177} 4178 4179/* Return a pointer to a newly created DIE node. */ 4180 4181static inline dw_die_ref 4182new_die (tag_value, parent_die) 4183 register enum dwarf_tag tag_value; 4184 register dw_die_ref parent_die; 4185{ 4186 register dw_die_ref die = (dw_die_ref) xmalloc (sizeof (die_node)); 4187 4188 die->die_tag = tag_value; 4189 die->die_abbrev = 0; 4190 die->die_offset = 0; 4191 die->die_child = NULL; 4192 die->die_parent = NULL; 4193 die->die_sib = NULL; 4194 die->die_child_last = NULL; 4195 die->die_attr = NULL; 4196 die->die_attr_last = NULL; 4197 4198 if (parent_die != NULL) 4199 add_child_die (parent_die, die); 4200 else 4201 { 4202 limbo_die_node *limbo_node; 4203 4204 limbo_node = (limbo_die_node *) xmalloc (sizeof (limbo_die_node)); 4205 limbo_node->die = die; 4206 limbo_node->next = limbo_die_list; 4207 limbo_die_list = limbo_node; 4208 } 4209 4210 return die; 4211} 4212 4213/* Return the DIE associated with the given type specifier. */ 4214 4215static inline dw_die_ref 4216lookup_type_die (type) 4217 register tree type; 4218{ 4219 return (dw_die_ref) TYPE_SYMTAB_POINTER (type); 4220} 4221 4222/* Equate a DIE to a given type specifier. */ 4223 4224static void 4225equate_type_number_to_die (type, type_die) 4226 register tree type; 4227 register dw_die_ref type_die; 4228{ 4229 TYPE_SYMTAB_POINTER (type) = (char *) type_die; 4230} 4231 4232/* Return the DIE associated with a given declaration. */ 4233 4234static inline dw_die_ref 4235lookup_decl_die (decl) 4236 register tree decl; 4237{ 4238 register unsigned decl_id = DECL_UID (decl); 4239 4240 return (decl_id < decl_die_table_in_use 4241 ? decl_die_table[decl_id] : NULL); 4242} 4243 4244/* Equate a DIE to a particular declaration. */ 4245 4246static void 4247equate_decl_number_to_die (decl, decl_die) 4248 register tree decl; 4249 register dw_die_ref decl_die; 4250{ 4251 register unsigned decl_id = DECL_UID (decl); 4252 register unsigned num_allocated; 4253 4254 if (decl_id >= decl_die_table_allocated) 4255 { 4256 num_allocated 4257 = ((decl_id + 1 + DECL_DIE_TABLE_INCREMENT - 1) 4258 / DECL_DIE_TABLE_INCREMENT) 4259 * DECL_DIE_TABLE_INCREMENT; 4260 4261 decl_die_table 4262 = (dw_die_ref *) xrealloc (decl_die_table, 4263 sizeof (dw_die_ref) * num_allocated); 4264 4265 bzero ((char *) &decl_die_table[decl_die_table_allocated], 4266 (num_allocated - decl_die_table_allocated) * sizeof (dw_die_ref)); 4267 decl_die_table_allocated = num_allocated; 4268 } 4269 4270 if (decl_id >= decl_die_table_in_use) 4271 decl_die_table_in_use = (decl_id + 1); 4272 4273 decl_die_table[decl_id] = decl_die; 4274} 4275 4276/* Return a pointer to a newly allocated location description. Location 4277 descriptions are simple expression terms that can be strung 4278 together to form more complicated location (address) descriptions. */ 4279 4280static inline dw_loc_descr_ref 4281new_loc_descr (op, oprnd1, oprnd2) 4282 register enum dwarf_location_atom op; 4283 register unsigned long oprnd1; 4284 register unsigned long oprnd2; 4285{ 4286 register dw_loc_descr_ref descr 4287 = (dw_loc_descr_ref) xmalloc (sizeof (dw_loc_descr_node)); 4288 4289 descr->dw_loc_next = NULL; 4290 descr->dw_loc_opc = op; 4291 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const; 4292 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1; 4293 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const; 4294 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2; 4295 4296 return descr; 4297} 4298 4299/* Add a location description term to a location description expression. */ 4300 4301static inline void 4302add_loc_descr (list_head, descr) 4303 register dw_loc_descr_ref *list_head; 4304 register dw_loc_descr_ref descr; 4305{ 4306 register dw_loc_descr_ref *d; 4307 4308 /* Find the end of the chain. */ 4309 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next) 4310 ; 4311 4312 *d = descr; 4313} 4314 4315/* Keep track of the number of spaces used to indent the 4316 output of the debugging routines that print the structure of 4317 the DIE internal representation. */ 4318static int print_indent; 4319 4320/* Indent the line the number of spaces given by print_indent. */ 4321 4322static inline void 4323print_spaces (outfile) 4324 FILE *outfile; 4325{ 4326 fprintf (outfile, "%*s", print_indent, ""); 4327} 4328 4329/* Print the information associated with a given DIE, and its children. 4330 This routine is a debugging aid only. */ 4331 4332static void 4333print_die (die, outfile) 4334 dw_die_ref die; 4335 FILE *outfile; 4336{ 4337 register dw_attr_ref a; 4338 register dw_die_ref c; 4339 4340 print_spaces (outfile); 4341 fprintf (outfile, "DIE %4lu: %s\n", 4342 die->die_offset, dwarf_tag_name (die->die_tag)); 4343 print_spaces (outfile); 4344 fprintf (outfile, " abbrev id: %lu", die->die_abbrev); 4345 fprintf (outfile, " offset: %lu\n", die->die_offset); 4346 4347 for (a = die->die_attr; a != NULL; a = a->dw_attr_next) 4348 { 4349 print_spaces (outfile); 4350 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr)); 4351 4352 switch (a->dw_attr_val.val_class) 4353 { 4354 case dw_val_class_addr: 4355 fprintf (outfile, "address"); 4356 break; 4357 case dw_val_class_loc: 4358 fprintf (outfile, "location descriptor"); 4359 break; 4360 case dw_val_class_const: 4361 fprintf (outfile, "%ld", a->dw_attr_val.v.val_int); 4362 break; 4363 case dw_val_class_unsigned_const: 4364 fprintf (outfile, "%lu", a->dw_attr_val.v.val_unsigned); 4365 break; 4366 case dw_val_class_long_long: 4367 fprintf (outfile, "constant (%lu,%lu)", 4368 a->dw_attr_val.v.val_long_long.hi, 4369 a->dw_attr_val.v.val_long_long.low); 4370 break; 4371 case dw_val_class_float: 4372 fprintf (outfile, "floating-point constant"); 4373 break; 4374 case dw_val_class_flag: 4375 fprintf (outfile, "%u", a->dw_attr_val.v.val_flag); 4376 break; 4377 case dw_val_class_die_ref: 4378 if (a->dw_attr_val.v.val_die_ref != NULL) 4379 fprintf (outfile, "die -> %lu", 4380 a->dw_attr_val.v.val_die_ref->die_offset); 4381 else 4382 fprintf (outfile, "die -> <null>"); 4383 break; 4384 case dw_val_class_lbl_id: 4385 case dw_val_class_lbl_offset: 4386 fprintf (outfile, "label: %s", a->dw_attr_val.v.val_lbl_id); 4387 break; 4388 case dw_val_class_str: 4389 if (a->dw_attr_val.v.val_str != NULL) 4390 fprintf (outfile, "\"%s\"", a->dw_attr_val.v.val_str); 4391 else 4392 fprintf (outfile, "<null>"); 4393 break; 4394 default: 4395 break; 4396 } 4397 4398 fprintf (outfile, "\n"); 4399 } 4400 4401 if (die->die_child != NULL) 4402 { 4403 print_indent += 4; 4404 for (c = die->die_child; c != NULL; c = c->die_sib) 4405 print_die (c, outfile); 4406 4407 print_indent -= 4; 4408 } 4409} 4410 4411/* Print the contents of the source code line number correspondence table. 4412 This routine is a debugging aid only. */ 4413 4414static void 4415print_dwarf_line_table (outfile) 4416 FILE *outfile; 4417{ 4418 register unsigned i; 4419 register dw_line_info_ref line_info; 4420 4421 fprintf (outfile, "\n\nDWARF source line information\n"); 4422 for (i = 1; i < line_info_table_in_use; ++i) 4423 { 4424 line_info = &line_info_table[i]; 4425 fprintf (outfile, "%5d: ", i); 4426 fprintf (outfile, "%-20s", file_table[line_info->dw_file_num]); 4427 fprintf (outfile, "%6ld", line_info->dw_line_num); 4428 fprintf (outfile, "\n"); 4429 } 4430 4431 fprintf (outfile, "\n\n"); 4432} 4433 4434/* Print the information collected for a given DIE. */ 4435 4436void 4437debug_dwarf_die (die) 4438 dw_die_ref die; 4439{ 4440 print_die (die, stderr); 4441} 4442 4443/* Print all DWARF information collected for the compilation unit. 4444 This routine is a debugging aid only. */ 4445 4446void 4447debug_dwarf () 4448{ 4449 print_indent = 0; 4450 print_die (comp_unit_die, stderr); 4451 print_dwarf_line_table (stderr); 4452} 4453 4454/* Traverse the DIE, and add a sibling attribute if it may have the 4455 effect of speeding up access to siblings. To save some space, 4456 avoid generating sibling attributes for DIE's without children. */ 4457 4458static void 4459add_sibling_attributes(die) 4460 register dw_die_ref die; 4461{ 4462 register dw_die_ref c; 4463 register dw_attr_ref attr; 4464 if (die != comp_unit_die && die->die_child != NULL) 4465 { 4466 attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node)); 4467 attr->dw_attr_next = NULL; 4468 attr->dw_attr = DW_AT_sibling; 4469 attr->dw_attr_val.val_class = dw_val_class_die_ref; 4470 attr->dw_attr_val.v.val_die_ref = die->die_sib; 4471 4472 /* Add the sibling link to the front of the attribute list. */ 4473 attr->dw_attr_next = die->die_attr; 4474 if (die->die_attr == NULL) 4475 die->die_attr_last = attr; 4476 4477 die->die_attr = attr; 4478 } 4479 4480 for (c = die->die_child; c != NULL; c = c->die_sib) 4481 add_sibling_attributes (c); 4482} 4483 4484/* The format of each DIE (and its attribute value pairs) 4485 is encoded in an abbreviation table. This routine builds the 4486 abbreviation table and assigns a unique abbreviation id for 4487 each abbreviation entry. The children of each die are visited 4488 recursively. */ 4489 4490static void 4491build_abbrev_table (die) 4492 register dw_die_ref die; 4493{ 4494 register unsigned long abbrev_id; 4495 register unsigned long n_alloc; 4496 register dw_die_ref c; 4497 register dw_attr_ref d_attr, a_attr; 4498 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id) 4499 { 4500 register dw_die_ref abbrev = abbrev_die_table[abbrev_id]; 4501 4502 if (abbrev->die_tag == die->die_tag) 4503 { 4504 if ((abbrev->die_child != NULL) == (die->die_child != NULL)) 4505 { 4506 a_attr = abbrev->die_attr; 4507 d_attr = die->die_attr; 4508 4509 while (a_attr != NULL && d_attr != NULL) 4510 { 4511 if ((a_attr->dw_attr != d_attr->dw_attr) 4512 || (value_format (&a_attr->dw_attr_val) 4513 != value_format (&d_attr->dw_attr_val))) 4514 break; 4515 4516 a_attr = a_attr->dw_attr_next; 4517 d_attr = d_attr->dw_attr_next; 4518 } 4519 4520 if (a_attr == NULL && d_attr == NULL) 4521 break; 4522 } 4523 } 4524 } 4525 4526 if (abbrev_id >= abbrev_die_table_in_use) 4527 { 4528 if (abbrev_die_table_in_use >= abbrev_die_table_allocated) 4529 { 4530 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT; 4531 abbrev_die_table 4532 = (dw_die_ref *) xrealloc (abbrev_die_table, 4533 sizeof (dw_die_ref) * n_alloc); 4534 4535 bzero ((char *) &abbrev_die_table[abbrev_die_table_allocated], 4536 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref)); 4537 abbrev_die_table_allocated = n_alloc; 4538 } 4539 4540 ++abbrev_die_table_in_use; 4541 abbrev_die_table[abbrev_id] = die; 4542 } 4543 4544 die->die_abbrev = abbrev_id; 4545 for (c = die->die_child; c != NULL; c = c->die_sib) 4546 build_abbrev_table (c); 4547} 4548 4549/* Return the size of a string, including the null byte. 4550 4551 This used to treat backslashes as escapes, and hence they were not included 4552 in the count. However, that conflicts with what ASM_OUTPUT_ASCII does, 4553 which treats a backslash as a backslash, escaping it if necessary, and hence 4554 we must include them in the count. */ 4555 4556static unsigned long 4557size_of_string (str) 4558 register char *str; 4559{ 4560 return strlen (str) + 1; 4561} 4562 4563/* Return the size of a location descriptor. */ 4564 4565static unsigned long 4566size_of_loc_descr (loc) 4567 register dw_loc_descr_ref loc; 4568{ 4569 register unsigned long size = 1; 4570 4571 switch (loc->dw_loc_opc) 4572 { 4573 case DW_OP_addr: 4574 size += PTR_SIZE; 4575 break; 4576 case DW_OP_const1u: 4577 case DW_OP_const1s: 4578 size += 1; 4579 break; 4580 case DW_OP_const2u: 4581 case DW_OP_const2s: 4582 size += 2; 4583 break; 4584 case DW_OP_const4u: 4585 case DW_OP_const4s: 4586 size += 4; 4587 break; 4588 case DW_OP_const8u: 4589 case DW_OP_const8s: 4590 size += 8; 4591 break; 4592 case DW_OP_constu: 4593 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 4594 break; 4595 case DW_OP_consts: 4596 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int); 4597 break; 4598 case DW_OP_pick: 4599 size += 1; 4600 break; 4601 case DW_OP_plus_uconst: 4602 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 4603 break; 4604 case DW_OP_skip: 4605 case DW_OP_bra: 4606 size += 2; 4607 break; 4608 case DW_OP_breg0: 4609 case DW_OP_breg1: 4610 case DW_OP_breg2: 4611 case DW_OP_breg3: 4612 case DW_OP_breg4: 4613 case DW_OP_breg5: 4614 case DW_OP_breg6: 4615 case DW_OP_breg7: 4616 case DW_OP_breg8: 4617 case DW_OP_breg9: 4618 case DW_OP_breg10: 4619 case DW_OP_breg11: 4620 case DW_OP_breg12: 4621 case DW_OP_breg13: 4622 case DW_OP_breg14: 4623 case DW_OP_breg15: 4624 case DW_OP_breg16: 4625 case DW_OP_breg17: 4626 case DW_OP_breg18: 4627 case DW_OP_breg19: 4628 case DW_OP_breg20: 4629 case DW_OP_breg21: 4630 case DW_OP_breg22: 4631 case DW_OP_breg23: 4632 case DW_OP_breg24: 4633 case DW_OP_breg25: 4634 case DW_OP_breg26: 4635 case DW_OP_breg27: 4636 case DW_OP_breg28: 4637 case DW_OP_breg29: 4638 case DW_OP_breg30: 4639 case DW_OP_breg31: 4640 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int); 4641 break; 4642 case DW_OP_regx: 4643 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 4644 break; 4645 case DW_OP_fbreg: 4646 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int); 4647 break; 4648 case DW_OP_bregx: 4649 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 4650 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int); 4651 break; 4652 case DW_OP_piece: 4653 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 4654 break; 4655 case DW_OP_deref_size: 4656 case DW_OP_xderef_size: 4657 size += 1; 4658 break; 4659 default: 4660 break; 4661 } 4662 4663 return size; 4664} 4665 4666/* Return the size of a series of location descriptors. */ 4667 4668static unsigned long 4669size_of_locs (loc) 4670 register dw_loc_descr_ref loc; 4671{ 4672 register unsigned long size = 0; 4673 4674 for (; loc != NULL; loc = loc->dw_loc_next) 4675 size += size_of_loc_descr (loc); 4676 4677 return size; 4678} 4679 4680/* Return the power-of-two number of bytes necessary to represent VALUE. */ 4681 4682static int 4683constant_size (value) 4684 long unsigned value; 4685{ 4686 int log; 4687 4688 if (value == 0) 4689 log = 0; 4690 else 4691 log = floor_log2 (value); 4692 4693 log = log / 8; 4694 log = 1 << (floor_log2 (log) + 1); 4695 4696 return log; 4697} 4698 4699/* Return the size of a DIE, as it is represented in the 4700 .debug_info section. */ 4701 4702static unsigned long 4703size_of_die (die) 4704 register dw_die_ref die; 4705{ 4706 register unsigned long size = 0; 4707 register dw_attr_ref a; 4708 4709 size += size_of_uleb128 (die->die_abbrev); 4710 for (a = die->die_attr; a != NULL; a = a->dw_attr_next) 4711 { 4712 switch (a->dw_attr_val.val_class) 4713 { 4714 case dw_val_class_addr: 4715 size += PTR_SIZE; 4716 break; 4717 case dw_val_class_loc: 4718 { 4719 register unsigned long lsize 4720 = size_of_locs (a->dw_attr_val.v.val_loc); 4721 4722 /* Block length. */ 4723 size += constant_size (lsize); 4724 size += lsize; 4725 } 4726 break; 4727 case dw_val_class_const: 4728 size += 4; 4729 break; 4730 case dw_val_class_unsigned_const: 4731 size += constant_size (a->dw_attr_val.v.val_unsigned); 4732 break; 4733 case dw_val_class_long_long: 4734 size += 1 + 8; /* block */ 4735 break; 4736 case dw_val_class_float: 4737 size += 1 + a->dw_attr_val.v.val_float.length * 4; /* block */ 4738 break; 4739 case dw_val_class_flag: 4740 size += 1; 4741 break; 4742 case dw_val_class_die_ref: 4743 size += DWARF_OFFSET_SIZE; 4744 break; 4745 case dw_val_class_fde_ref: 4746 size += DWARF_OFFSET_SIZE; 4747 break; 4748 case dw_val_class_lbl_id: 4749 size += PTR_SIZE; 4750 break; 4751 case dw_val_class_lbl_offset: 4752 size += DWARF_OFFSET_SIZE; 4753 break; 4754 case dw_val_class_str: 4755 size += size_of_string (a->dw_attr_val.v.val_str); 4756 break; 4757 default: 4758 abort (); 4759 } 4760 } 4761 4762 return size; 4763} 4764 4765/* Size the debugging information associated with a given DIE. 4766 Visits the DIE's children recursively. Updates the global 4767 variable next_die_offset, on each time through. Uses the 4768 current value of next_die_offset to update the die_offset 4769 field in each DIE. */ 4770 4771static void 4772calc_die_sizes (die) 4773 dw_die_ref die; 4774{ 4775 register dw_die_ref c; 4776 die->die_offset = next_die_offset; 4777 next_die_offset += size_of_die (die); 4778 4779 for (c = die->die_child; c != NULL; c = c->die_sib) 4780 calc_die_sizes (c); 4781 4782 if (die->die_child != NULL) 4783 /* Count the null byte used to terminate sibling lists. */ 4784 next_die_offset += 1; 4785} 4786 4787/* Return the size of the line information prolog generated for the 4788 compilation unit. */ 4789 4790static unsigned long 4791size_of_line_prolog () 4792{ 4793 register unsigned long size; 4794 register unsigned long ft_index; 4795 4796 size = DWARF_LINE_PROLOG_HEADER_SIZE; 4797 4798 /* Count the size of the table giving number of args for each 4799 standard opcode. */ 4800 size += DWARF_LINE_OPCODE_BASE - 1; 4801 4802 /* Include directory table is empty (at present). Count only the 4803 null byte used to terminate the table. */ 4804 size += 1; 4805 4806 for (ft_index = 1; ft_index < file_table_in_use; ++ft_index) 4807 { 4808 /* File name entry. */ 4809 size += size_of_string (file_table[ft_index]); 4810 4811 /* Include directory index. */ 4812 size += size_of_uleb128 (0); 4813 4814 /* Modification time. */ 4815 size += size_of_uleb128 (0); 4816 4817 /* File length in bytes. */ 4818 size += size_of_uleb128 (0); 4819 } 4820 4821 /* Count the file table terminator. */ 4822 size += 1; 4823 return size; 4824} 4825 4826/* Return the size of the line information generated for this 4827 compilation unit. */ 4828 4829static unsigned long 4830size_of_line_info () 4831{ 4832 register unsigned long size; 4833 register unsigned long lt_index; 4834 register unsigned long current_line; 4835 register long line_offset; 4836 register long line_delta; 4837 register unsigned long current_file; 4838 register unsigned long function; 4839 unsigned long size_of_set_address; 4840 4841 /* Size of a DW_LNE_set_address instruction. */ 4842 size_of_set_address = 1 + size_of_uleb128 (1 + PTR_SIZE) + 1 + PTR_SIZE; 4843 4844 /* Version number. */ 4845 size = 2; 4846 4847 /* Prolog length specifier. */ 4848 size += DWARF_OFFSET_SIZE; 4849 4850 /* Prolog. */ 4851 size += size_of_line_prolog (); 4852 4853 current_file = 1; 4854 current_line = 1; 4855 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index) 4856 { 4857 register dw_line_info_ref line_info = &line_info_table[lt_index]; 4858 4859 if (line_info->dw_line_num == current_line 4860 && line_info->dw_file_num == current_file) 4861 continue; 4862 4863 /* Advance pc instruction. */ 4864 /* ??? See the DW_LNS_advance_pc comment in output_line_info. */ 4865 if (0) 4866 size += 1 + 2; 4867 else 4868 size += size_of_set_address; 4869 4870 if (line_info->dw_file_num != current_file) 4871 { 4872 /* Set file number instruction. */ 4873 size += 1; 4874 current_file = line_info->dw_file_num; 4875 size += size_of_uleb128 (current_file); 4876 } 4877 4878 if (line_info->dw_line_num != current_line) 4879 { 4880 line_offset = line_info->dw_line_num - current_line; 4881 line_delta = line_offset - DWARF_LINE_BASE; 4882 current_line = line_info->dw_line_num; 4883 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1)) 4884 /* 1-byte special line number instruction. */ 4885 size += 1; 4886 else 4887 { 4888 /* Advance line instruction. */ 4889 size += 1; 4890 size += size_of_sleb128 (line_offset); 4891 /* Generate line entry instruction. */ 4892 size += 1; 4893 } 4894 } 4895 } 4896 4897 /* Advance pc instruction. */ 4898 if (0) 4899 size += 1 + 2; 4900 else 4901 size += size_of_set_address; 4902 4903 /* End of line number info. marker. */ 4904 size += 1 + size_of_uleb128 (1) + 1; 4905 4906 function = 0; 4907 current_file = 1; 4908 current_line = 1; 4909 for (lt_index = 0; lt_index < separate_line_info_table_in_use; ) 4910 { 4911 register dw_separate_line_info_ref line_info 4912 = &separate_line_info_table[lt_index]; 4913 4914 if (line_info->dw_line_num == current_line 4915 && line_info->dw_file_num == current_file 4916 && line_info->function == function) 4917 goto cont; 4918 4919 if (function != line_info->function) 4920 { 4921 function = line_info->function; 4922 /* Set address register instruction. */ 4923 size += size_of_set_address; 4924 } 4925 else 4926 { 4927 /* Advance pc instruction. */ 4928 if (0) 4929 size += 1 + 2; 4930 else 4931 size += size_of_set_address; 4932 } 4933 4934 if (line_info->dw_file_num != current_file) 4935 { 4936 /* Set file number instruction. */ 4937 size += 1; 4938 current_file = line_info->dw_file_num; 4939 size += size_of_uleb128 (current_file); 4940 } 4941 4942 if (line_info->dw_line_num != current_line) 4943 { 4944 line_offset = line_info->dw_line_num - current_line; 4945 line_delta = line_offset - DWARF_LINE_BASE; 4946 current_line = line_info->dw_line_num; 4947 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1)) 4948 /* 1-byte special line number instruction. */ 4949 size += 1; 4950 else 4951 { 4952 /* Advance line instruction. */ 4953 size += 1; 4954 size += size_of_sleb128 (line_offset); 4955 4956 /* Generate line entry instruction. */ 4957 size += 1; 4958 } 4959 } 4960 4961 cont: 4962 ++lt_index; 4963 4964 /* If we're done with a function, end its sequence. */ 4965 if (lt_index == separate_line_info_table_in_use 4966 || separate_line_info_table[lt_index].function != function) 4967 { 4968 current_file = 1; 4969 current_line = 1; 4970 4971 /* Advance pc instruction. */ 4972 if (0) 4973 size += 1 + 2; 4974 else 4975 size += size_of_set_address; 4976 4977 /* End of line number info. marker. */ 4978 size += 1 + size_of_uleb128 (1) + 1; 4979 } 4980 } 4981 4982 return size; 4983} 4984 4985/* Return the size of the .debug_pubnames table generated for the 4986 compilation unit. */ 4987 4988static unsigned long 4989size_of_pubnames () 4990{ 4991 register unsigned long size; 4992 register unsigned i; 4993 4994 size = DWARF_PUBNAMES_HEADER_SIZE; 4995 for (i = 0; i < pubname_table_in_use; ++i) 4996 { 4997 register pubname_ref p = &pubname_table[i]; 4998 size += DWARF_OFFSET_SIZE + size_of_string (p->name); 4999 } 5000 5001 size += DWARF_OFFSET_SIZE; 5002 return size; 5003} 5004 5005/* Return the size of the information in the .debug_aranges section. */ 5006 5007static unsigned long 5008size_of_aranges () 5009{ 5010 register unsigned long size; 5011 5012 size = DWARF_ARANGES_HEADER_SIZE; 5013 5014 /* Count the address/length pair for this compilation unit. */ 5015 size += 2 * PTR_SIZE; 5016 size += 2 * PTR_SIZE * arange_table_in_use; 5017 5018 /* Count the two zero words used to terminated the address range table. */ 5019 size += 2 * PTR_SIZE; 5020 return size; 5021} 5022 5023/* Select the encoding of an attribute value. */ 5024 5025static enum dwarf_form 5026value_format (v) 5027 dw_val_ref v; 5028{ 5029 switch (v->val_class) 5030 { 5031 case dw_val_class_addr: 5032 return DW_FORM_addr; 5033 case dw_val_class_loc: 5034 switch (constant_size (size_of_locs (v->v.val_loc))) 5035 { 5036 case 1: 5037 return DW_FORM_block1; 5038 case 2: 5039 return DW_FORM_block2; 5040 default: 5041 abort (); 5042 } 5043 case dw_val_class_const: 5044 return DW_FORM_data4; 5045 case dw_val_class_unsigned_const: 5046 switch (constant_size (v->v.val_unsigned)) 5047 { 5048 case 1: 5049 return DW_FORM_data1; 5050 case 2: 5051 return DW_FORM_data2; 5052 case 4: 5053 return DW_FORM_data4; 5054 case 8: 5055 return DW_FORM_data8; 5056 default: 5057 abort (); 5058 } 5059 case dw_val_class_long_long: 5060 return DW_FORM_block1; 5061 case dw_val_class_float: 5062 return DW_FORM_block1; 5063 case dw_val_class_flag: 5064 return DW_FORM_flag; 5065 case dw_val_class_die_ref: 5066 return DW_FORM_ref; 5067 case dw_val_class_fde_ref: 5068 return DW_FORM_data; 5069 case dw_val_class_lbl_id: 5070 return DW_FORM_addr; 5071 case dw_val_class_lbl_offset: 5072 return DW_FORM_data; 5073 case dw_val_class_str: 5074 return DW_FORM_string; 5075 default: 5076 abort (); 5077 } 5078} 5079 5080/* Output the encoding of an attribute value. */ 5081 5082static void 5083output_value_format (v) 5084 dw_val_ref v; 5085{ 5086 enum dwarf_form form = value_format (v); 5087 5088 output_uleb128 (form); 5089 if (flag_debug_asm) 5090 fprintf (asm_out_file, " (%s)", dwarf_form_name (form)); 5091 5092 fputc ('\n', asm_out_file); 5093} 5094 5095/* Output the .debug_abbrev section which defines the DIE abbreviation 5096 table. */ 5097 5098static void 5099output_abbrev_section () 5100{ 5101 unsigned long abbrev_id; 5102 5103 dw_attr_ref a_attr; 5104 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id) 5105 { 5106 register dw_die_ref abbrev = abbrev_die_table[abbrev_id]; 5107 5108 output_uleb128 (abbrev_id); 5109 if (flag_debug_asm) 5110 fprintf (asm_out_file, " (abbrev code)"); 5111 5112 fputc ('\n', asm_out_file); 5113 output_uleb128 (abbrev->die_tag); 5114 if (flag_debug_asm) 5115 fprintf (asm_out_file, " (TAG: %s)", 5116 dwarf_tag_name (abbrev->die_tag)); 5117 5118 fputc ('\n', asm_out_file); 5119 fprintf (asm_out_file, "\t%s\t0x%x", ASM_BYTE_OP, 5120 abbrev->die_child != NULL ? DW_children_yes : DW_children_no); 5121 5122 if (flag_debug_asm) 5123 fprintf (asm_out_file, "\t%s %s", 5124 ASM_COMMENT_START, 5125 (abbrev->die_child != NULL 5126 ? "DW_children_yes" : "DW_children_no")); 5127 5128 fputc ('\n', asm_out_file); 5129 5130 for (a_attr = abbrev->die_attr; a_attr != NULL; 5131 a_attr = a_attr->dw_attr_next) 5132 { 5133 output_uleb128 (a_attr->dw_attr); 5134 if (flag_debug_asm) 5135 fprintf (asm_out_file, " (%s)", 5136 dwarf_attr_name (a_attr->dw_attr)); 5137 5138 fputc ('\n', asm_out_file); 5139 output_value_format (&a_attr->dw_attr_val); 5140 } 5141 5142 fprintf (asm_out_file, "\t%s\t0,0\n", ASM_BYTE_OP); 5143 } 5144 5145 /* We need to properly terminate the abbrev table for this 5146 compilation unit, as per the standard, and not rely on 5147 workarounds in e.g. gdb. */ 5148 fprintf (asm_out_file, "\t%s\t0\n", ASM_BYTE_OP); 5149} 5150 5151/* Output location description stack opcode's operands (if any). */ 5152 5153static void 5154output_loc_operands (loc) 5155 register dw_loc_descr_ref loc; 5156{ 5157 register dw_val_ref val1 = &loc->dw_loc_oprnd1; 5158 register dw_val_ref val2 = &loc->dw_loc_oprnd2; 5159 5160 switch (loc->dw_loc_opc) 5161 { 5162 case DW_OP_addr: 5163 ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, val1->v.val_addr); 5164 fputc ('\n', asm_out_file); 5165 break; 5166 case DW_OP_const1u: 5167 case DW_OP_const1s: 5168 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_flag); 5169 fputc ('\n', asm_out_file); 5170 break; 5171 case DW_OP_const2u: 5172 case DW_OP_const2s: 5173 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, val1->v.val_int); 5174 fputc ('\n', asm_out_file); 5175 break; 5176 case DW_OP_const4u: 5177 case DW_OP_const4s: 5178 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, val1->v.val_int); 5179 fputc ('\n', asm_out_file); 5180 break; 5181 case DW_OP_const8u: 5182 case DW_OP_const8s: 5183 abort (); 5184 fputc ('\n', asm_out_file); 5185 break; 5186 case DW_OP_constu: 5187 output_uleb128 (val1->v.val_unsigned); 5188 fputc ('\n', asm_out_file); 5189 break; 5190 case DW_OP_consts: 5191 output_sleb128 (val1->v.val_int); 5192 fputc ('\n', asm_out_file); 5193 break; 5194 case DW_OP_pick: 5195 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_int); 5196 fputc ('\n', asm_out_file); 5197 break; 5198 case DW_OP_plus_uconst: 5199 output_uleb128 (val1->v.val_unsigned); 5200 fputc ('\n', asm_out_file); 5201 break; 5202 case DW_OP_skip: 5203 case DW_OP_bra: 5204 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, val1->v.val_int); 5205 fputc ('\n', asm_out_file); 5206 break; 5207 case DW_OP_breg0: 5208 case DW_OP_breg1: 5209 case DW_OP_breg2: 5210 case DW_OP_breg3: 5211 case DW_OP_breg4: 5212 case DW_OP_breg5: 5213 case DW_OP_breg6: 5214 case DW_OP_breg7: 5215 case DW_OP_breg8: 5216 case DW_OP_breg9: 5217 case DW_OP_breg10: 5218 case DW_OP_breg11: 5219 case DW_OP_breg12: 5220 case DW_OP_breg13: 5221 case DW_OP_breg14: 5222 case DW_OP_breg15: 5223 case DW_OP_breg16: 5224 case DW_OP_breg17: 5225 case DW_OP_breg18: 5226 case DW_OP_breg19: 5227 case DW_OP_breg20: 5228 case DW_OP_breg21: 5229 case DW_OP_breg22: 5230 case DW_OP_breg23: 5231 case DW_OP_breg24: 5232 case DW_OP_breg25: 5233 case DW_OP_breg26: 5234 case DW_OP_breg27: 5235 case DW_OP_breg28: 5236 case DW_OP_breg29: 5237 case DW_OP_breg30: 5238 case DW_OP_breg31: 5239 output_sleb128 (val1->v.val_int); 5240 fputc ('\n', asm_out_file); 5241 break; 5242 case DW_OP_regx: 5243 output_uleb128 (val1->v.val_unsigned); 5244 fputc ('\n', asm_out_file); 5245 break; 5246 case DW_OP_fbreg: 5247 output_sleb128 (val1->v.val_int); 5248 fputc ('\n', asm_out_file); 5249 break; 5250 case DW_OP_bregx: 5251 output_uleb128 (val1->v.val_unsigned); 5252 fputc ('\n', asm_out_file); 5253 output_sleb128 (val2->v.val_int); 5254 fputc ('\n', asm_out_file); 5255 break; 5256 case DW_OP_piece: 5257 output_uleb128 (val1->v.val_unsigned); 5258 fputc ('\n', asm_out_file); 5259 break; 5260 case DW_OP_deref_size: 5261 case DW_OP_xderef_size: 5262 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_flag); 5263 fputc ('\n', asm_out_file); 5264 break; 5265 default: 5266 break; 5267 } 5268} 5269 5270/* Compute the offset of a sibling. */ 5271 5272static unsigned long 5273sibling_offset (die) 5274 dw_die_ref die; 5275{ 5276 unsigned long offset; 5277 5278 if (die->die_child_last == NULL) 5279 offset = die->die_offset + size_of_die (die); 5280 else 5281 offset = sibling_offset (die->die_child_last) + 1; 5282 5283 return offset; 5284} 5285 5286/* Output the DIE and its attributes. Called recursively to generate 5287 the definitions of each child DIE. */ 5288 5289static void 5290output_die (die) 5291 register dw_die_ref die; 5292{ 5293 register dw_attr_ref a; 5294 register dw_die_ref c; 5295 register unsigned long ref_offset; 5296 register unsigned long size; 5297 register dw_loc_descr_ref loc; 5298 5299 output_uleb128 (die->die_abbrev); 5300 if (flag_debug_asm) 5301 fprintf (asm_out_file, " (DIE (0x%lx) %s)", 5302 die->die_offset, dwarf_tag_name (die->die_tag)); 5303 5304 fputc ('\n', asm_out_file); 5305 5306 for (a = die->die_attr; a != NULL; a = a->dw_attr_next) 5307 { 5308 switch (a->dw_attr_val.val_class) 5309 { 5310 case dw_val_class_addr: 5311 ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, 5312 a->dw_attr_val.v.val_addr); 5313 break; 5314 5315 case dw_val_class_loc: 5316 size = size_of_locs (a->dw_attr_val.v.val_loc); 5317 5318 /* Output the block length for this list of location operations. */ 5319 switch (constant_size (size)) 5320 { 5321 case 1: 5322 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, size); 5323 break; 5324 case 2: 5325 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, size); 5326 break; 5327 default: 5328 abort (); 5329 } 5330 5331 if (flag_debug_asm) 5332 fprintf (asm_out_file, "\t%s %s", 5333 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr)); 5334 5335 fputc ('\n', asm_out_file); 5336 for (loc = a->dw_attr_val.v.val_loc; loc != NULL; 5337 loc = loc->dw_loc_next) 5338 { 5339 /* Output the opcode. */ 5340 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, loc->dw_loc_opc); 5341 if (flag_debug_asm) 5342 fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START, 5343 dwarf_stack_op_name (loc->dw_loc_opc)); 5344 5345 fputc ('\n', asm_out_file); 5346 5347 /* Output the operand(s) (if any). */ 5348 output_loc_operands (loc); 5349 } 5350 break; 5351 5352 case dw_val_class_const: 5353 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, a->dw_attr_val.v.val_int); 5354 break; 5355 5356 case dw_val_class_unsigned_const: 5357 switch (constant_size (a->dw_attr_val.v.val_unsigned)) 5358 { 5359 case 1: 5360 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 5361 a->dw_attr_val.v.val_unsigned); 5362 break; 5363 case 2: 5364 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, 5365 a->dw_attr_val.v.val_unsigned); 5366 break; 5367 case 4: 5368 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 5369 a->dw_attr_val.v.val_unsigned); 5370 break; 5371 case 8: 5372 ASM_OUTPUT_DWARF_DATA8 (asm_out_file, 5373 a->dw_attr_val.v.val_long_long.hi, 5374 a->dw_attr_val.v.val_long_long.low); 5375 break; 5376 default: 5377 abort (); 5378 } 5379 break; 5380 5381 case dw_val_class_long_long: 5382 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 8); 5383 if (flag_debug_asm) 5384 fprintf (asm_out_file, "\t%s %s", 5385 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr)); 5386 5387 fputc ('\n', asm_out_file); 5388 ASM_OUTPUT_DWARF_DATA8 (asm_out_file, 5389 a->dw_attr_val.v.val_long_long.hi, 5390 a->dw_attr_val.v.val_long_long.low); 5391 5392 if (flag_debug_asm) 5393 fprintf (asm_out_file, 5394 "\t%s long long constant", ASM_COMMENT_START); 5395 5396 fputc ('\n', asm_out_file); 5397 break; 5398 5399 case dw_val_class_float: 5400 { 5401 register unsigned int i; 5402 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 5403 a->dw_attr_val.v.val_float.length * 4); 5404 if (flag_debug_asm) 5405 fprintf (asm_out_file, "\t%s %s", 5406 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr)); 5407 5408 fputc ('\n', asm_out_file); 5409 for (i = 0; i < a->dw_attr_val.v.val_float.length; ++i) 5410 { 5411 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 5412 a->dw_attr_val.v.val_float.array[i]); 5413 if (flag_debug_asm) 5414 fprintf (asm_out_file, "\t%s fp constant word %u", 5415 ASM_COMMENT_START, i); 5416 5417 fputc ('\n', asm_out_file); 5418 } 5419 break; 5420 } 5421 5422 case dw_val_class_flag: 5423 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, a->dw_attr_val.v.val_flag); 5424 break; 5425 5426 case dw_val_class_die_ref: 5427 if (a->dw_attr_val.v.val_die_ref != NULL) 5428 ref_offset = a->dw_attr_val.v.val_die_ref->die_offset; 5429 else if (a->dw_attr == DW_AT_sibling) 5430 ref_offset = sibling_offset(die); 5431 else 5432 abort (); 5433 5434 ASM_OUTPUT_DWARF_DATA (asm_out_file, ref_offset); 5435 break; 5436 5437 case dw_val_class_fde_ref: 5438 { 5439 char l1[20]; 5440 ASM_GENERATE_INTERNAL_LABEL 5441 (l1, FDE_AFTER_SIZE_LABEL, a->dw_attr_val.v.val_fde_index * 2); 5442 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, l1); 5443 fprintf (asm_out_file, " - %d", DWARF_OFFSET_SIZE); 5444 } 5445 break; 5446 5447 case dw_val_class_lbl_id: 5448 ASM_OUTPUT_DWARF_ADDR (asm_out_file, a->dw_attr_val.v.val_lbl_id); 5449 break; 5450 5451 case dw_val_class_lbl_offset: 5452 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, a->dw_attr_val.v.val_lbl_id); 5453 break; 5454 5455 case dw_val_class_str: 5456 if (flag_debug_asm) 5457 ASM_OUTPUT_DWARF_STRING (asm_out_file, a->dw_attr_val.v.val_str); 5458 else 5459 ASM_OUTPUT_ASCII (asm_out_file, 5460 a->dw_attr_val.v.val_str, 5461 (int) strlen (a->dw_attr_val.v.val_str) + 1); 5462 break; 5463 5464 default: 5465 abort (); 5466 } 5467 5468 if (a->dw_attr_val.val_class != dw_val_class_loc 5469 && a->dw_attr_val.val_class != dw_val_class_long_long 5470 && a->dw_attr_val.val_class != dw_val_class_float) 5471 { 5472 if (flag_debug_asm) 5473 fprintf (asm_out_file, "\t%s %s", 5474 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr)); 5475 5476 fputc ('\n', asm_out_file); 5477 } 5478 } 5479 5480 for (c = die->die_child; c != NULL; c = c->die_sib) 5481 output_die (c); 5482 5483 if (die->die_child != NULL) 5484 { 5485 /* Add null byte to terminate sibling list. */ 5486 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); 5487 if (flag_debug_asm) 5488 fprintf (asm_out_file, "\t%s end of children of DIE 0x%lx", 5489 ASM_COMMENT_START, die->die_offset); 5490 5491 fputc ('\n', asm_out_file); 5492 } 5493} 5494 5495/* Output the compilation unit that appears at the beginning of the 5496 .debug_info section, and precedes the DIE descriptions. */ 5497 5498static void 5499output_compilation_unit_header () 5500{ 5501 ASM_OUTPUT_DWARF_DATA (asm_out_file, next_die_offset - DWARF_OFFSET_SIZE); 5502 if (flag_debug_asm) 5503 fprintf (asm_out_file, "\t%s Length of Compilation Unit Info.", 5504 ASM_COMMENT_START); 5505 5506 fputc ('\n', asm_out_file); 5507 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION); 5508 if (flag_debug_asm) 5509 fprintf (asm_out_file, "\t%s DWARF version number", ASM_COMMENT_START); 5510 5511 fputc ('\n', asm_out_file); 5512 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, abbrev_section_label); 5513 if (flag_debug_asm) 5514 fprintf (asm_out_file, "\t%s Offset Into Abbrev. Section", 5515 ASM_COMMENT_START); 5516 5517 fputc ('\n', asm_out_file); 5518 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, PTR_SIZE); 5519 if (flag_debug_asm) 5520 fprintf (asm_out_file, "\t%s Pointer Size (in bytes)", ASM_COMMENT_START); 5521 5522 fputc ('\n', asm_out_file); 5523} 5524 5525/* The DWARF2 pubname for a nested thingy looks like "A::f". The output 5526 of decl_printable_name for C++ looks like "A::f(int)". Let's drop the 5527 argument list, and maybe the scope. */ 5528 5529static char * 5530dwarf2_name (decl, scope) 5531 tree decl; 5532 int scope; 5533{ 5534 return (*decl_printable_name) (decl, scope ? 1 : 0); 5535} 5536 5537/* Add a new entry to .debug_pubnames if appropriate. */ 5538 5539static void 5540add_pubname (decl, die) 5541 tree decl; 5542 dw_die_ref die; 5543{ 5544 pubname_ref p; 5545 5546 if (! TREE_PUBLIC (decl)) 5547 return; 5548 5549 if (pubname_table_in_use == pubname_table_allocated) 5550 { 5551 pubname_table_allocated += PUBNAME_TABLE_INCREMENT; 5552 pubname_table = (pubname_ref) xrealloc 5553 (pubname_table, pubname_table_allocated * sizeof (pubname_entry)); 5554 } 5555 5556 p = &pubname_table[pubname_table_in_use++]; 5557 p->die = die; 5558 5559 p->name = xstrdup (dwarf2_name (decl, 1)); 5560} 5561 5562/* Output the public names table used to speed up access to externally 5563 visible names. For now, only generate entries for externally 5564 visible procedures. */ 5565 5566static void 5567output_pubnames () 5568{ 5569 register unsigned i; 5570 register unsigned long pubnames_length = size_of_pubnames (); 5571 5572 ASM_OUTPUT_DWARF_DATA (asm_out_file, pubnames_length); 5573 5574 if (flag_debug_asm) 5575 fprintf (asm_out_file, "\t%s Length of Public Names Info.", 5576 ASM_COMMENT_START); 5577 5578 fputc ('\n', asm_out_file); 5579 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION); 5580 5581 if (flag_debug_asm) 5582 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START); 5583 5584 fputc ('\n', asm_out_file); 5585 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, debug_info_section_label); 5586 if (flag_debug_asm) 5587 fprintf (asm_out_file, "\t%s Offset of Compilation Unit Info.", 5588 ASM_COMMENT_START); 5589 5590 fputc ('\n', asm_out_file); 5591 ASM_OUTPUT_DWARF_DATA (asm_out_file, next_die_offset); 5592 if (flag_debug_asm) 5593 fprintf (asm_out_file, "\t%s Compilation Unit Length", ASM_COMMENT_START); 5594 5595 fputc ('\n', asm_out_file); 5596 for (i = 0; i < pubname_table_in_use; ++i) 5597 { 5598 register pubname_ref pub = &pubname_table[i]; 5599 5600 ASM_OUTPUT_DWARF_DATA (asm_out_file, pub->die->die_offset); 5601 if (flag_debug_asm) 5602 fprintf (asm_out_file, "\t%s DIE offset", ASM_COMMENT_START); 5603 5604 fputc ('\n', asm_out_file); 5605 5606 if (flag_debug_asm) 5607 { 5608 ASM_OUTPUT_DWARF_STRING (asm_out_file, pub->name); 5609 fprintf (asm_out_file, "%s external name", ASM_COMMENT_START); 5610 } 5611 else 5612 { 5613 ASM_OUTPUT_ASCII (asm_out_file, pub->name, 5614 (int) strlen (pub->name) + 1); 5615 } 5616 5617 fputc ('\n', asm_out_file); 5618 } 5619 5620 ASM_OUTPUT_DWARF_DATA (asm_out_file, 0); 5621 fputc ('\n', asm_out_file); 5622} 5623 5624/* Add a new entry to .debug_aranges if appropriate. */ 5625 5626static void 5627add_arange (decl, die) 5628 tree decl; 5629 dw_die_ref die; 5630{ 5631 if (! DECL_SECTION_NAME (decl)) 5632 return; 5633 5634 if (arange_table_in_use == arange_table_allocated) 5635 { 5636 arange_table_allocated += ARANGE_TABLE_INCREMENT; 5637 arange_table 5638 = (arange_ref) xrealloc (arange_table, 5639 arange_table_allocated * sizeof (dw_die_ref)); 5640 } 5641 5642 arange_table[arange_table_in_use++] = die; 5643} 5644 5645/* Output the information that goes into the .debug_aranges table. 5646 Namely, define the beginning and ending address range of the 5647 text section generated for this compilation unit. */ 5648 5649static void 5650output_aranges () 5651{ 5652 register unsigned i; 5653 register unsigned long aranges_length = size_of_aranges (); 5654 5655 ASM_OUTPUT_DWARF_DATA (asm_out_file, aranges_length); 5656 if (flag_debug_asm) 5657 fprintf (asm_out_file, "\t%s Length of Address Ranges Info.", 5658 ASM_COMMENT_START); 5659 5660 fputc ('\n', asm_out_file); 5661 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION); 5662 if (flag_debug_asm) 5663 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START); 5664 5665 fputc ('\n', asm_out_file); 5666 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, debug_info_section_label); 5667 if (flag_debug_asm) 5668 fprintf (asm_out_file, "\t%s Offset of Compilation Unit Info.", 5669 ASM_COMMENT_START); 5670 5671 fputc ('\n', asm_out_file); 5672 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, PTR_SIZE); 5673 if (flag_debug_asm) 5674 fprintf (asm_out_file, "\t%s Size of Address", ASM_COMMENT_START); 5675 5676 fputc ('\n', asm_out_file); 5677 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); 5678 if (flag_debug_asm) 5679 fprintf (asm_out_file, "\t%s Size of Segment Descriptor", 5680 ASM_COMMENT_START); 5681 5682 fputc ('\n', asm_out_file); 5683 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 4); 5684 if (PTR_SIZE == 8) 5685 fprintf (asm_out_file, ",0,0"); 5686 5687 if (flag_debug_asm) 5688 fprintf (asm_out_file, "\t%s Pad to %d byte boundary", 5689 ASM_COMMENT_START, 2 * PTR_SIZE); 5690 5691 fputc ('\n', asm_out_file); 5692 ASM_OUTPUT_DWARF_ADDR (asm_out_file, text_section_label); 5693 if (flag_debug_asm) 5694 fprintf (asm_out_file, "\t%s Address", ASM_COMMENT_START); 5695 5696 fputc ('\n', asm_out_file); 5697 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, text_end_label, 5698 text_section_label); 5699 if (flag_debug_asm) 5700 fprintf (asm_out_file, "%s Length", ASM_COMMENT_START); 5701 5702 fputc ('\n', asm_out_file); 5703 for (i = 0; i < arange_table_in_use; ++i) 5704 { 5705 dw_die_ref a = arange_table[i]; 5706 5707 if (a->die_tag == DW_TAG_subprogram) 5708 ASM_OUTPUT_DWARF_ADDR (asm_out_file, get_AT_low_pc (a)); 5709 else 5710 { 5711 char *name = get_AT_string (a, DW_AT_MIPS_linkage_name); 5712 if (! name) 5713 name = get_AT_string (a, DW_AT_name); 5714 5715 ASM_OUTPUT_DWARF_ADDR (asm_out_file, name); 5716 } 5717 5718 if (flag_debug_asm) 5719 fprintf (asm_out_file, "\t%s Address", ASM_COMMENT_START); 5720 5721 fputc ('\n', asm_out_file); 5722 if (a->die_tag == DW_TAG_subprogram) 5723 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, get_AT_hi_pc (a), 5724 get_AT_low_pc (a)); 5725 else 5726 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, 5727 get_AT_unsigned (a, DW_AT_byte_size)); 5728 5729 if (flag_debug_asm) 5730 fprintf (asm_out_file, "%s Length", ASM_COMMENT_START); 5731 5732 fputc ('\n', asm_out_file); 5733 } 5734 5735 /* Output the terminator words. */ 5736 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, 0); 5737 fputc ('\n', asm_out_file); 5738 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, 0); 5739 fputc ('\n', asm_out_file); 5740} 5741 5742/* Output the source line number correspondence information. This 5743 information goes into the .debug_line section. 5744 5745 If the format of this data changes, then the function size_of_line_info 5746 must also be adjusted the same way. */ 5747 5748static void 5749output_line_info () 5750{ 5751 char line_label[MAX_ARTIFICIAL_LABEL_BYTES]; 5752 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES]; 5753 register unsigned opc; 5754 register unsigned n_op_args; 5755 register unsigned long ft_index; 5756 register unsigned long lt_index; 5757 register unsigned long current_line; 5758 register long line_offset; 5759 register long line_delta; 5760 register unsigned long current_file; 5761 register unsigned long function; 5762 5763 ASM_OUTPUT_DWARF_DATA (asm_out_file, size_of_line_info ()); 5764 if (flag_debug_asm) 5765 fprintf (asm_out_file, "\t%s Length of Source Line Info.", 5766 ASM_COMMENT_START); 5767 5768 fputc ('\n', asm_out_file); 5769 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION); 5770 if (flag_debug_asm) 5771 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START); 5772 5773 fputc ('\n', asm_out_file); 5774 ASM_OUTPUT_DWARF_DATA (asm_out_file, size_of_line_prolog ()); 5775 if (flag_debug_asm) 5776 fprintf (asm_out_file, "\t%s Prolog Length", ASM_COMMENT_START); 5777 5778 fputc ('\n', asm_out_file); 5779 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_LINE_MIN_INSTR_LENGTH); 5780 if (flag_debug_asm) 5781 fprintf (asm_out_file, "\t%s Minimum Instruction Length", 5782 ASM_COMMENT_START); 5783 5784 fputc ('\n', asm_out_file); 5785 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_LINE_DEFAULT_IS_STMT_START); 5786 if (flag_debug_asm) 5787 fprintf (asm_out_file, "\t%s Default is_stmt_start flag", 5788 ASM_COMMENT_START); 5789 5790 fputc ('\n', asm_out_file); 5791 fprintf (asm_out_file, "\t%s\t%d", ASM_BYTE_OP, DWARF_LINE_BASE); 5792 if (flag_debug_asm) 5793 fprintf (asm_out_file, "\t%s Line Base Value (Special Opcodes)", 5794 ASM_COMMENT_START); 5795 5796 fputc ('\n', asm_out_file); 5797 fprintf (asm_out_file, "\t%s\t%u", ASM_BYTE_OP, DWARF_LINE_RANGE); 5798 if (flag_debug_asm) 5799 fprintf (asm_out_file, "\t%s Line Range Value (Special Opcodes)", 5800 ASM_COMMENT_START); 5801 5802 fputc ('\n', asm_out_file); 5803 fprintf (asm_out_file, "\t%s\t%u", ASM_BYTE_OP, DWARF_LINE_OPCODE_BASE); 5804 if (flag_debug_asm) 5805 fprintf (asm_out_file, "\t%s Special Opcode Base", ASM_COMMENT_START); 5806 5807 fputc ('\n', asm_out_file); 5808 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; ++opc) 5809 { 5810 switch (opc) 5811 { 5812 case DW_LNS_advance_pc: 5813 case DW_LNS_advance_line: 5814 case DW_LNS_set_file: 5815 case DW_LNS_set_column: 5816 case DW_LNS_fixed_advance_pc: 5817 n_op_args = 1; 5818 break; 5819 default: 5820 n_op_args = 0; 5821 break; 5822 } 5823 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, n_op_args); 5824 if (flag_debug_asm) 5825 fprintf (asm_out_file, "\t%s opcode: 0x%x has %d args", 5826 ASM_COMMENT_START, opc, n_op_args); 5827 fputc ('\n', asm_out_file); 5828 } 5829 5830 if (flag_debug_asm) 5831 fprintf (asm_out_file, "%s Include Directory Table\n", ASM_COMMENT_START); 5832 5833 /* Include directory table is empty, at present */ 5834 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); 5835 fputc ('\n', asm_out_file); 5836 if (flag_debug_asm) 5837 fprintf (asm_out_file, "%s File Name Table\n", ASM_COMMENT_START); 5838 5839 for (ft_index = 1; ft_index < file_table_in_use; ++ft_index) 5840 { 5841 if (flag_debug_asm) 5842 { 5843 ASM_OUTPUT_DWARF_STRING (asm_out_file, file_table[ft_index]); 5844 fprintf (asm_out_file, "%s File Entry: 0x%lx", 5845 ASM_COMMENT_START, ft_index); 5846 } 5847 else 5848 { 5849 ASM_OUTPUT_ASCII (asm_out_file, 5850 file_table[ft_index], 5851 (int) strlen (file_table[ft_index]) + 1); 5852 } 5853 5854 fputc ('\n', asm_out_file); 5855 5856 /* Include directory index */ 5857 output_uleb128 (0); 5858 fputc ('\n', asm_out_file); 5859 5860 /* Modification time */ 5861 output_uleb128 (0); 5862 fputc ('\n', asm_out_file); 5863 5864 /* File length in bytes */ 5865 output_uleb128 (0); 5866 fputc ('\n', asm_out_file); 5867 } 5868 5869 /* Terminate the file name table */ 5870 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); 5871 fputc ('\n', asm_out_file); 5872 5873 /* We used to set the address register to the first location in the text 5874 section here, but that didn't accomplish anything since we already 5875 have a line note for the opening brace of the first function. */ 5876 5877 /* Generate the line number to PC correspondence table, encoded as 5878 a series of state machine operations. */ 5879 current_file = 1; 5880 current_line = 1; 5881 strcpy (prev_line_label, text_section_label); 5882 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index) 5883 { 5884 register dw_line_info_ref line_info = &line_info_table[lt_index]; 5885 5886 /* Don't emit anything for redundant notes. Just updating the 5887 address doesn't accomplish anything, because we already assume 5888 that anything after the last address is this line. */ 5889 if (line_info->dw_line_num == current_line 5890 && line_info->dw_file_num == current_file) 5891 continue; 5892 5893 /* Emit debug info for the address of the current line, choosing 5894 the encoding that uses the least amount of space. */ 5895 /* ??? Unfortunately, we have little choice here currently, and must 5896 always use the most general form. Gcc does not know the address 5897 delta itself, so we can't use DW_LNS_advance_pc. There are no known 5898 dwarf2 aware assemblers at this time, so we can't use any special 5899 pseudo ops that would allow the assembler to optimally encode this for 5900 us. Many ports do have length attributes which will give an upper 5901 bound on the address range. We could perhaps use length attributes 5902 to determine when it is safe to use DW_LNS_fixed_advance_pc. */ 5903 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index); 5904 if (0) 5905 { 5906 /* This can handle deltas up to 0xffff. This takes 3 bytes. */ 5907 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc); 5908 if (flag_debug_asm) 5909 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc", 5910 ASM_COMMENT_START); 5911 5912 fputc ('\n', asm_out_file); 5913 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label, prev_line_label); 5914 fputc ('\n', asm_out_file); 5915 } 5916 else 5917 { 5918 /* This can handle any delta. This takes 4+PTR_SIZE bytes. */ 5919 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); 5920 if (flag_debug_asm) 5921 fprintf (asm_out_file, "\t%s DW_LNE_set_address", 5922 ASM_COMMENT_START); 5923 fputc ('\n', asm_out_file); 5924 output_uleb128 (1 + PTR_SIZE); 5925 fputc ('\n', asm_out_file); 5926 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address); 5927 fputc ('\n', asm_out_file); 5928 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label); 5929 fputc ('\n', asm_out_file); 5930 } 5931 strcpy (prev_line_label, line_label); 5932 5933 /* Emit debug info for the source file of the current line, if 5934 different from the previous line. */ 5935 if (line_info->dw_file_num != current_file) 5936 { 5937 current_file = line_info->dw_file_num; 5938 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_set_file); 5939 if (flag_debug_asm) 5940 fprintf (asm_out_file, "\t%s DW_LNS_set_file", ASM_COMMENT_START); 5941 5942 fputc ('\n', asm_out_file); 5943 output_uleb128 (current_file); 5944 if (flag_debug_asm) 5945 fprintf (asm_out_file, " (\"%s\")", file_table[current_file]); 5946 5947 fputc ('\n', asm_out_file); 5948 } 5949 5950 /* Emit debug info for the current line number, choosing the encoding 5951 that uses the least amount of space. */ 5952 if (line_info->dw_line_num != current_line) 5953 { 5954 line_offset = line_info->dw_line_num - current_line; 5955 line_delta = line_offset - DWARF_LINE_BASE; 5956 current_line = line_info->dw_line_num; 5957 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1)) 5958 { 5959 /* This can handle deltas from -10 to 234, using the current 5960 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This 5961 takes 1 byte. */ 5962 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 5963 DWARF_LINE_OPCODE_BASE + line_delta); 5964 if (flag_debug_asm) 5965 fprintf (asm_out_file, 5966 "\t%s line %ld", ASM_COMMENT_START, current_line); 5967 5968 fputc ('\n', asm_out_file); 5969 } 5970 else 5971 { 5972 /* This can handle any delta. This takes at least 4 bytes, 5973 depending on the value being encoded. */ 5974 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line); 5975 if (flag_debug_asm) 5976 fprintf (asm_out_file, "\t%s advance to line %ld", 5977 ASM_COMMENT_START, current_line); 5978 5979 fputc ('\n', asm_out_file); 5980 output_sleb128 (line_offset); 5981 fputc ('\n', asm_out_file); 5982 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy); 5983 if (flag_debug_asm) 5984 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START); 5985 fputc ('\n', asm_out_file); 5986 } 5987 } 5988 else 5989 { 5990 /* We still need to start a new row, so output a copy insn. */ 5991 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy); 5992 if (flag_debug_asm) 5993 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START); 5994 fputc ('\n', asm_out_file); 5995 } 5996 } 5997 5998 /* Emit debug info for the address of the end of the function. */ 5999 if (0) 6000 { 6001 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc); 6002 if (flag_debug_asm) 6003 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc", 6004 ASM_COMMENT_START); 6005 6006 fputc ('\n', asm_out_file); 6007 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, text_end_label, prev_line_label); 6008 fputc ('\n', asm_out_file); 6009 } 6010 else 6011 { 6012 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); 6013 if (flag_debug_asm) 6014 fprintf (asm_out_file, "\t%s DW_LNE_set_address", ASM_COMMENT_START); 6015 fputc ('\n', asm_out_file); 6016 output_uleb128 (1 + PTR_SIZE); 6017 fputc ('\n', asm_out_file); 6018 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address); 6019 fputc ('\n', asm_out_file); 6020 ASM_OUTPUT_DWARF_ADDR (asm_out_file, text_end_label); 6021 fputc ('\n', asm_out_file); 6022 } 6023 6024 /* Output the marker for the end of the line number info. */ 6025 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); 6026 if (flag_debug_asm) 6027 fprintf (asm_out_file, "\t%s DW_LNE_end_sequence", ASM_COMMENT_START); 6028 6029 fputc ('\n', asm_out_file); 6030 output_uleb128 (1); 6031 fputc ('\n', asm_out_file); 6032 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_end_sequence); 6033 fputc ('\n', asm_out_file); 6034 6035 function = 0; 6036 current_file = 1; 6037 current_line = 1; 6038 for (lt_index = 0; lt_index < separate_line_info_table_in_use; ) 6039 { 6040 register dw_separate_line_info_ref line_info 6041 = &separate_line_info_table[lt_index]; 6042 6043 /* Don't emit anything for redundant notes. */ 6044 if (line_info->dw_line_num == current_line 6045 && line_info->dw_file_num == current_file 6046 && line_info->function == function) 6047 goto cont; 6048 6049 /* Emit debug info for the address of the current line. If this is 6050 a new function, or the first line of a function, then we need 6051 to handle it differently. */ 6052 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL, 6053 lt_index); 6054 if (function != line_info->function) 6055 { 6056 function = line_info->function; 6057 6058 /* Set the address register to the first line in the function */ 6059 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); 6060 if (flag_debug_asm) 6061 fprintf (asm_out_file, "\t%s DW_LNE_set_address", 6062 ASM_COMMENT_START); 6063 6064 fputc ('\n', asm_out_file); 6065 output_uleb128 (1 + PTR_SIZE); 6066 fputc ('\n', asm_out_file); 6067 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address); 6068 fputc ('\n', asm_out_file); 6069 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label); 6070 fputc ('\n', asm_out_file); 6071 } 6072 else 6073 { 6074 /* ??? See the DW_LNS_advance_pc comment above. */ 6075 if (0) 6076 { 6077 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc); 6078 if (flag_debug_asm) 6079 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc", 6080 ASM_COMMENT_START); 6081 6082 fputc ('\n', asm_out_file); 6083 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label, 6084 prev_line_label); 6085 fputc ('\n', asm_out_file); 6086 } 6087 else 6088 { 6089 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); 6090 if (flag_debug_asm) 6091 fprintf (asm_out_file, "\t%s DW_LNE_set_address", 6092 ASM_COMMENT_START); 6093 fputc ('\n', asm_out_file); 6094 output_uleb128 (1 + PTR_SIZE); 6095 fputc ('\n', asm_out_file); 6096 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address); 6097 fputc ('\n', asm_out_file); 6098 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label); 6099 fputc ('\n', asm_out_file); 6100 } 6101 } 6102 strcpy (prev_line_label, line_label); 6103 6104 /* Emit debug info for the source file of the current line, if 6105 different from the previous line. */ 6106 if (line_info->dw_file_num != current_file) 6107 { 6108 current_file = line_info->dw_file_num; 6109 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_set_file); 6110 if (flag_debug_asm) 6111 fprintf (asm_out_file, "\t%s DW_LNS_set_file", ASM_COMMENT_START); 6112 6113 fputc ('\n', asm_out_file); 6114 output_uleb128 (current_file); 6115 if (flag_debug_asm) 6116 fprintf (asm_out_file, " (\"%s\")", file_table[current_file]); 6117 6118 fputc ('\n', asm_out_file); 6119 } 6120 6121 /* Emit debug info for the current line number, choosing the encoding 6122 that uses the least amount of space. */ 6123 if (line_info->dw_line_num != current_line) 6124 { 6125 line_offset = line_info->dw_line_num - current_line; 6126 line_delta = line_offset - DWARF_LINE_BASE; 6127 current_line = line_info->dw_line_num; 6128 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1)) 6129 { 6130 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 6131 DWARF_LINE_OPCODE_BASE + line_delta); 6132 if (flag_debug_asm) 6133 fprintf (asm_out_file, 6134 "\t%s line %ld", ASM_COMMENT_START, current_line); 6135 6136 fputc ('\n', asm_out_file); 6137 } 6138 else 6139 { 6140 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line); 6141 if (flag_debug_asm) 6142 fprintf (asm_out_file, "\t%s advance to line %ld", 6143 ASM_COMMENT_START, current_line); 6144 6145 fputc ('\n', asm_out_file); 6146 output_sleb128 (line_offset); 6147 fputc ('\n', asm_out_file); 6148 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy); 6149 if (flag_debug_asm) 6150 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START); 6151 fputc ('\n', asm_out_file); 6152 } 6153 } 6154 else 6155 { 6156 /* We still need to start a new row, so output a copy insn. */ 6157 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy); 6158 if (flag_debug_asm) 6159 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START); 6160 fputc ('\n', asm_out_file); 6161 } 6162 6163 cont: 6164 ++lt_index; 6165 6166 /* If we're done with a function, end its sequence. */ 6167 if (lt_index == separate_line_info_table_in_use 6168 || separate_line_info_table[lt_index].function != function) 6169 { 6170 current_file = 1; 6171 current_line = 1; 6172 6173 /* Emit debug info for the address of the end of the function. */ 6174 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function); 6175 if (0) 6176 { 6177 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc); 6178 if (flag_debug_asm) 6179 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc", 6180 ASM_COMMENT_START); 6181 6182 fputc ('\n', asm_out_file); 6183 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label, 6184 prev_line_label); 6185 fputc ('\n', asm_out_file); 6186 } 6187 else 6188 { 6189 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); 6190 if (flag_debug_asm) 6191 fprintf (asm_out_file, "\t%s DW_LNE_set_address", 6192 ASM_COMMENT_START); 6193 fputc ('\n', asm_out_file); 6194 output_uleb128 (1 + PTR_SIZE); 6195 fputc ('\n', asm_out_file); 6196 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address); 6197 fputc ('\n', asm_out_file); 6198 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label); 6199 fputc ('\n', asm_out_file); 6200 } 6201 6202 /* Output the marker for the end of this sequence. */ 6203 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); 6204 if (flag_debug_asm) 6205 fprintf (asm_out_file, "\t%s DW_LNE_end_sequence", 6206 ASM_COMMENT_START); 6207 6208 fputc ('\n', asm_out_file); 6209 output_uleb128 (1); 6210 fputc ('\n', asm_out_file); 6211 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_end_sequence); 6212 fputc ('\n', asm_out_file); 6213 } 6214 } 6215} 6216 6217/* Given a pointer to a BLOCK node return non-zero if (and only if) the node 6218 in question represents the outermost pair of curly braces (i.e. the "body 6219 block") of a function or method. 6220 6221 For any BLOCK node representing a "body block" of a function or method, the 6222 BLOCK_SUPERCONTEXT of the node will point to another BLOCK node which 6223 represents the outermost (function) scope for the function or method (i.e. 6224 the one which includes the formal parameters). The BLOCK_SUPERCONTEXT of 6225 *that* node in turn will point to the relevant FUNCTION_DECL node. */ 6226 6227static inline int 6228is_body_block (stmt) 6229 register tree stmt; 6230{ 6231 if (TREE_CODE (stmt) == BLOCK) 6232 { 6233 register tree parent = BLOCK_SUPERCONTEXT (stmt); 6234 6235 if (TREE_CODE (parent) == BLOCK) 6236 { 6237 register tree grandparent = BLOCK_SUPERCONTEXT (parent); 6238 6239 if (TREE_CODE (grandparent) == FUNCTION_DECL) 6240 return 1; 6241 } 6242 } 6243 6244 return 0; 6245} 6246 6247/* Given a pointer to a tree node for some base type, return a pointer to 6248 a DIE that describes the given type. 6249 6250 This routine must only be called for GCC type nodes that correspond to 6251 Dwarf base (fundamental) types. */ 6252 6253static dw_die_ref 6254base_type_die (type) 6255 register tree type; 6256{ 6257 register dw_die_ref base_type_result; 6258 register char *type_name; 6259 register enum dwarf_type encoding; 6260 register tree name = TYPE_NAME (type); 6261 6262 if (TREE_CODE (type) == ERROR_MARK 6263 || TREE_CODE (type) == VOID_TYPE) 6264 return 0; 6265 6266 if (TREE_CODE (name) == TYPE_DECL) 6267 name = DECL_NAME (name); 6268 type_name = IDENTIFIER_POINTER (name); 6269 6270 switch (TREE_CODE (type)) 6271 { 6272 case INTEGER_TYPE: 6273 /* Carefully distinguish the C character types, without messing 6274 up if the language is not C. Note that we check only for the names 6275 that contain spaces; other names might occur by coincidence in other 6276 languages. */ 6277 if (! (TYPE_PRECISION (type) == CHAR_TYPE_SIZE 6278 && (type == char_type_node 6279 || ! strcmp (type_name, "signed char") 6280 || ! strcmp (type_name, "unsigned char")))) 6281 { 6282 if (TREE_UNSIGNED (type)) 6283 encoding = DW_ATE_unsigned; 6284 else 6285 encoding = DW_ATE_signed; 6286 break; 6287 } 6288 /* else fall through */ 6289 6290 case CHAR_TYPE: 6291 /* GNU Pascal/Ada CHAR type. Not used in C. */ 6292 if (TREE_UNSIGNED (type)) 6293 encoding = DW_ATE_unsigned_char; 6294 else 6295 encoding = DW_ATE_signed_char; 6296 break; 6297 6298 case REAL_TYPE: 6299 encoding = DW_ATE_float; 6300 break; 6301 6302 case COMPLEX_TYPE: 6303 encoding = DW_ATE_complex_float; 6304 break; 6305 6306 case BOOLEAN_TYPE: 6307 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */ 6308 encoding = DW_ATE_boolean; 6309 break; 6310 6311 default: 6312 abort (); /* No other TREE_CODEs are Dwarf fundamental types. */ 6313 } 6314 6315 base_type_result = new_die (DW_TAG_base_type, comp_unit_die); 6316 add_AT_string (base_type_result, DW_AT_name, type_name); 6317 add_AT_unsigned (base_type_result, DW_AT_byte_size, 6318 int_size_in_bytes (type)); 6319 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding); 6320 6321 return base_type_result; 6322} 6323 6324/* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to 6325 the Dwarf "root" type for the given input type. The Dwarf "root" type of 6326 a given type is generally the same as the given type, except that if the 6327 given type is a pointer or reference type, then the root type of the given 6328 type is the root type of the "basis" type for the pointer or reference 6329 type. (This definition of the "root" type is recursive.) Also, the root 6330 type of a `const' qualified type or a `volatile' qualified type is the 6331 root type of the given type without the qualifiers. */ 6332 6333static tree 6334root_type (type) 6335 register tree type; 6336{ 6337 if (TREE_CODE (type) == ERROR_MARK) 6338 return error_mark_node; 6339 6340 switch (TREE_CODE (type)) 6341 { 6342 case ERROR_MARK: 6343 return error_mark_node; 6344 6345 case POINTER_TYPE: 6346 case REFERENCE_TYPE: 6347 return type_main_variant (root_type (TREE_TYPE (type))); 6348 6349 default: 6350 return type_main_variant (type); 6351 } 6352} 6353 6354/* Given a pointer to an arbitrary ..._TYPE tree node, return non-zero if the 6355 given input type is a Dwarf "fundamental" type. Otherwise return null. */ 6356 6357static inline int 6358is_base_type (type) 6359 register tree type; 6360{ 6361 switch (TREE_CODE (type)) 6362 { 6363 case ERROR_MARK: 6364 case VOID_TYPE: 6365 case INTEGER_TYPE: 6366 case REAL_TYPE: 6367 case COMPLEX_TYPE: 6368 case BOOLEAN_TYPE: 6369 case CHAR_TYPE: 6370 return 1; 6371 6372 case SET_TYPE: 6373 case ARRAY_TYPE: 6374 case RECORD_TYPE: 6375 case UNION_TYPE: 6376 case QUAL_UNION_TYPE: 6377 case ENUMERAL_TYPE: 6378 case FUNCTION_TYPE: 6379 case METHOD_TYPE: 6380 case POINTER_TYPE: 6381 case REFERENCE_TYPE: 6382 case FILE_TYPE: 6383 case OFFSET_TYPE: 6384 case LANG_TYPE: 6385 return 0; 6386 6387 default: 6388 abort (); 6389 } 6390 6391 return 0; 6392} 6393 6394/* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging 6395 entry that chains various modifiers in front of the given type. */ 6396 6397static dw_die_ref 6398modified_type_die (type, is_const_type, is_volatile_type, context_die) 6399 register tree type; 6400 register int is_const_type; 6401 register int is_volatile_type; 6402 register dw_die_ref context_die; 6403{ 6404 register enum tree_code code = TREE_CODE (type); 6405 register dw_die_ref mod_type_die = NULL; 6406 register dw_die_ref sub_die = NULL; 6407 register tree item_type = NULL; 6408 6409 if (code != ERROR_MARK) 6410 { 6411 type = build_type_variant (type, is_const_type, is_volatile_type); 6412 6413 mod_type_die = lookup_type_die (type); 6414 if (mod_type_die) 6415 return mod_type_die; 6416 6417 /* Handle C typedef types. */ 6418 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 6419 && DECL_ORIGINAL_TYPE (TYPE_NAME (type))) 6420 { 6421 tree dtype = TREE_TYPE (TYPE_NAME (type)); 6422 if (type == dtype) 6423 { 6424 /* For a named type, use the typedef. */ 6425 gen_type_die (type, context_die); 6426 mod_type_die = lookup_type_die (type); 6427 } 6428 6429 else if (is_const_type < TYPE_READONLY (dtype) 6430 || is_volatile_type < TYPE_VOLATILE (dtype)) 6431 /* cv-unqualified version of named type. Just use the unnamed 6432 type to which it refers. */ 6433 mod_type_die 6434 = modified_type_die (DECL_ORIGINAL_TYPE (TYPE_NAME (type)), 6435 is_const_type, is_volatile_type, 6436 context_die); 6437 /* Else cv-qualified version of named type; fall through. */ 6438 } 6439 6440 if (mod_type_die) 6441 /* OK */; 6442 else if (is_const_type) 6443 { 6444 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die); 6445 sub_die = modified_type_die (type, 0, is_volatile_type, context_die); 6446 } 6447 else if (is_volatile_type) 6448 { 6449 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die); 6450 sub_die = modified_type_die (type, 0, 0, context_die); 6451 } 6452 else if (code == POINTER_TYPE) 6453 { 6454 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die); 6455 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE); 6456#if 0 6457 add_AT_unsigned (mod_type_die, DW_AT_address_class, 0); 6458#endif 6459 item_type = TREE_TYPE (type); 6460 } 6461 else if (code == REFERENCE_TYPE) 6462 { 6463 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die); 6464 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE); 6465#if 0 6466 add_AT_unsigned (mod_type_die, DW_AT_address_class, 0); 6467#endif 6468 item_type = TREE_TYPE (type); 6469 } 6470 else if (is_base_type (type)) 6471 mod_type_die = base_type_die (type); 6472 else 6473 { 6474 gen_type_die (type, context_die); 6475 6476 /* We have to get the type_main_variant here (and pass that to the 6477 `lookup_type_die' routine) because the ..._TYPE node we have 6478 might simply be a *copy* of some original type node (where the 6479 copy was created to help us keep track of typedef names) and 6480 that copy might have a different TYPE_UID from the original 6481 ..._TYPE node. */ 6482 mod_type_die = lookup_type_die (type_main_variant (type)); 6483 if (mod_type_die == NULL) 6484 abort (); 6485 } 6486 } 6487 6488 equate_type_number_to_die (type, mod_type_die); 6489 if (item_type) 6490 /* We must do this after the equate_type_number_to_die call, in case 6491 this is a recursive type. This ensures that the modified_type_die 6492 recursion will terminate even if the type is recursive. Recursive 6493 types are possible in Ada. */ 6494 sub_die = modified_type_die (item_type, 6495 TYPE_READONLY (item_type), 6496 TYPE_VOLATILE (item_type), 6497 context_die); 6498 6499 if (sub_die != NULL) 6500 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die); 6501 6502 return mod_type_die; 6503} 6504 6505/* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is 6506 an enumerated type. */ 6507 6508static inline int 6509type_is_enum (type) 6510 register tree type; 6511{ 6512 return TREE_CODE (type) == ENUMERAL_TYPE; 6513} 6514 6515/* Return a location descriptor that designates a machine register. */ 6516 6517static dw_loc_descr_ref 6518reg_loc_descriptor (rtl) 6519 register rtx rtl; 6520{ 6521 register dw_loc_descr_ref loc_result = NULL; 6522 register unsigned reg = reg_number (rtl); 6523 6524 if (reg <= 31) 6525 loc_result = new_loc_descr (DW_OP_reg0 + reg, 0, 0); 6526 else 6527 loc_result = new_loc_descr (DW_OP_regx, reg, 0); 6528 6529 return loc_result; 6530} 6531 6532/* Return a location descriptor that designates a base+offset location. */ 6533 6534static dw_loc_descr_ref 6535based_loc_descr (reg, offset) 6536 unsigned reg; 6537 long int offset; 6538{ 6539 register dw_loc_descr_ref loc_result; 6540 /* For the "frame base", we use the frame pointer or stack pointer 6541 registers, since the RTL for local variables is relative to one of 6542 them. */ 6543 register unsigned fp_reg = DBX_REGISTER_NUMBER (frame_pointer_needed 6544 ? HARD_FRAME_POINTER_REGNUM 6545 : STACK_POINTER_REGNUM); 6546 6547 if (reg == fp_reg) 6548 loc_result = new_loc_descr (DW_OP_fbreg, offset, 0); 6549 else if (reg <= 31) 6550 loc_result = new_loc_descr (DW_OP_breg0 + reg, offset, 0); 6551 else 6552 loc_result = new_loc_descr (DW_OP_bregx, reg, offset); 6553 6554 return loc_result; 6555} 6556 6557/* Return true if this RTL expression describes a base+offset calculation. */ 6558 6559static inline int 6560is_based_loc (rtl) 6561 register rtx rtl; 6562{ 6563 return (GET_CODE (rtl) == PLUS 6564 && ((GET_CODE (XEXP (rtl, 0)) == REG 6565 && GET_CODE (XEXP (rtl, 1)) == CONST_INT))); 6566} 6567 6568/* The following routine converts the RTL for a variable or parameter 6569 (resident in memory) into an equivalent Dwarf representation of a 6570 mechanism for getting the address of that same variable onto the top of a 6571 hypothetical "address evaluation" stack. 6572 6573 When creating memory location descriptors, we are effectively transforming 6574 the RTL for a memory-resident object into its Dwarf postfix expression 6575 equivalent. This routine recursively descends an RTL tree, turning 6576 it into Dwarf postfix code as it goes. */ 6577 6578static dw_loc_descr_ref 6579mem_loc_descriptor (rtl) 6580 register rtx rtl; 6581{ 6582 dw_loc_descr_ref mem_loc_result = NULL; 6583 /* Note that for a dynamically sized array, the location we will generate a 6584 description of here will be the lowest numbered location which is 6585 actually within the array. That's *not* necessarily the same as the 6586 zeroth element of the array. */ 6587 6588 switch (GET_CODE (rtl)) 6589 { 6590 case SUBREG: 6591 /* The case of a subreg may arise when we have a local (register) 6592 variable or a formal (register) parameter which doesn't quite fill 6593 up an entire register. For now, just assume that it is 6594 legitimate to make the Dwarf info refer to the whole register which 6595 contains the given subreg. */ 6596 rtl = XEXP (rtl, 0); 6597 6598 /* ... fall through ... */ 6599 6600 case REG: 6601 /* Whenever a register number forms a part of the description of the 6602 method for calculating the (dynamic) address of a memory resident 6603 object, DWARF rules require the register number be referred to as 6604 a "base register". This distinction is not based in any way upon 6605 what category of register the hardware believes the given register 6606 belongs to. This is strictly DWARF terminology we're dealing with 6607 here. Note that in cases where the location of a memory-resident 6608 data object could be expressed as: OP_ADD (OP_BASEREG (basereg), 6609 OP_CONST (0)) the actual DWARF location descriptor that we generate 6610 may just be OP_BASEREG (basereg). This may look deceptively like 6611 the object in question was allocated to a register (rather than in 6612 memory) so DWARF consumers need to be aware of the subtle 6613 distinction between OP_REG and OP_BASEREG. */ 6614 mem_loc_result = based_loc_descr (reg_number (rtl), 0); 6615 break; 6616 6617 case MEM: 6618 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0)); 6619 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0)); 6620 break; 6621 6622 case CONST: 6623 case SYMBOL_REF: 6624 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0); 6625 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr; 6626 mem_loc_result->dw_loc_oprnd1.v.val_addr = addr_to_string (rtl); 6627 break; 6628 6629 case PLUS: 6630 if (is_based_loc (rtl)) 6631 mem_loc_result = based_loc_descr (reg_number (XEXP (rtl, 0)), 6632 INTVAL (XEXP (rtl, 1))); 6633 else 6634 { 6635 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 0))); 6636 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 1))); 6637 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_plus, 0, 0)); 6638 } 6639 break; 6640 6641 case MULT: 6642 /* If a pseudo-reg is optimized away, it is possible for it to 6643 be replaced with a MEM containing a multiply. */ 6644 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 0))); 6645 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 1))); 6646 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0)); 6647 break; 6648 6649 case CONST_INT: 6650 mem_loc_result = new_loc_descr (DW_OP_constu, INTVAL (rtl), 0); 6651 break; 6652 6653 default: 6654 abort (); 6655 } 6656 6657 return mem_loc_result; 6658} 6659 6660/* Return a descriptor that describes the concatenation of two locations. 6661 This is typically a complex variable. */ 6662 6663static dw_loc_descr_ref 6664concat_loc_descriptor (x0, x1) 6665 register rtx x0, x1; 6666{ 6667 dw_loc_descr_ref cc_loc_result = NULL; 6668 6669 if (!is_pseudo_reg (x0) 6670 && (GET_CODE (x0) != MEM || !is_pseudo_reg (XEXP (x0, 0)))) 6671 add_loc_descr (&cc_loc_result, loc_descriptor (x0)); 6672 add_loc_descr (&cc_loc_result, 6673 new_loc_descr (DW_OP_piece, GET_MODE_SIZE (GET_MODE (x0)), 0)); 6674 6675 if (!is_pseudo_reg (x1) 6676 && (GET_CODE (x1) != MEM || !is_pseudo_reg (XEXP (x1, 0)))) 6677 add_loc_descr (&cc_loc_result, loc_descriptor (x1)); 6678 add_loc_descr (&cc_loc_result, 6679 new_loc_descr (DW_OP_piece, GET_MODE_SIZE (GET_MODE (x1)), 0)); 6680 6681 return cc_loc_result; 6682} 6683 6684/* Output a proper Dwarf location descriptor for a variable or parameter 6685 which is either allocated in a register or in a memory location. For a 6686 register, we just generate an OP_REG and the register number. For a 6687 memory location we provide a Dwarf postfix expression describing how to 6688 generate the (dynamic) address of the object onto the address stack. */ 6689 6690static dw_loc_descr_ref 6691loc_descriptor (rtl) 6692 register rtx rtl; 6693{ 6694 dw_loc_descr_ref loc_result = NULL; 6695 switch (GET_CODE (rtl)) 6696 { 6697 case SUBREG: 6698 /* The case of a subreg may arise when we have a local (register) 6699 variable or a formal (register) parameter which doesn't quite fill 6700 up an entire register. For now, just assume that it is 6701 legitimate to make the Dwarf info refer to the whole register which 6702 contains the given subreg. */ 6703 rtl = XEXP (rtl, 0); 6704 6705 /* ... fall through ... */ 6706 6707 case REG: 6708 loc_result = reg_loc_descriptor (rtl); 6709 break; 6710 6711 case MEM: 6712 loc_result = mem_loc_descriptor (XEXP (rtl, 0)); 6713 break; 6714 6715 case CONCAT: 6716 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1)); 6717 break; 6718 6719 default: 6720 abort (); 6721 } 6722 6723 return loc_result; 6724} 6725 6726/* Given an unsigned value, round it up to the lowest multiple of `boundary' 6727 which is not less than the value itself. */ 6728 6729static inline unsigned 6730ceiling (value, boundary) 6731 register unsigned value; 6732 register unsigned boundary; 6733{ 6734 return (((value + boundary - 1) / boundary) * boundary); 6735} 6736 6737/* Given a pointer to what is assumed to be a FIELD_DECL node, return a 6738 pointer to the declared type for the relevant field variable, or return 6739 `integer_type_node' if the given node turns out to be an 6740 ERROR_MARK node. */ 6741 6742static inline tree 6743field_type (decl) 6744 register tree decl; 6745{ 6746 register tree type; 6747 6748 if (TREE_CODE (decl) == ERROR_MARK) 6749 return integer_type_node; 6750 6751 type = DECL_BIT_FIELD_TYPE (decl); 6752 if (type == NULL_TREE) 6753 type = TREE_TYPE (decl); 6754 6755 return type; 6756} 6757 6758/* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE 6759 node, return the alignment in bits for the type, or else return 6760 BITS_PER_WORD if the node actually turns out to be an 6761 ERROR_MARK node. */ 6762 6763static inline unsigned 6764simple_type_align_in_bits (type) 6765 register tree type; 6766{ 6767 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD; 6768} 6769 6770/* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE 6771 node, return the size in bits for the type if it is a constant, or else 6772 return the alignment for the type if the type's size is not constant, or 6773 else return BITS_PER_WORD if the type actually turns out to be an 6774 ERROR_MARK node. */ 6775 6776static inline unsigned 6777simple_type_size_in_bits (type) 6778 register tree type; 6779{ 6780 if (TREE_CODE (type) == ERROR_MARK) 6781 return BITS_PER_WORD; 6782 else 6783 { 6784 register tree type_size_tree = TYPE_SIZE (type); 6785 6786 if (TREE_CODE (type_size_tree) != INTEGER_CST) 6787 return TYPE_ALIGN (type); 6788 6789 return (unsigned) TREE_INT_CST_LOW (type_size_tree); 6790 } 6791} 6792 6793/* Given a pointer to what is assumed to be a FIELD_DECL node, compute and 6794 return the byte offset of the lowest addressed byte of the "containing 6795 object" for the given FIELD_DECL, or return 0 if we are unable to 6796 determine what that offset is, either because the argument turns out to 6797 be a pointer to an ERROR_MARK node, or because the offset is actually 6798 variable. (We can't handle the latter case just yet). */ 6799 6800static unsigned 6801field_byte_offset (decl) 6802 register tree decl; 6803{ 6804 register unsigned type_align_in_bytes; 6805 register unsigned type_align_in_bits; 6806 register unsigned type_size_in_bits; 6807 register unsigned object_offset_in_align_units; 6808 register unsigned object_offset_in_bits; 6809 register unsigned object_offset_in_bytes; 6810 register tree type; 6811 register tree bitpos_tree; 6812 register tree field_size_tree; 6813 register unsigned bitpos_int; 6814 register unsigned deepest_bitpos; 6815 register unsigned field_size_in_bits; 6816 6817 if (TREE_CODE (decl) == ERROR_MARK) 6818 return 0; 6819 6820 if (TREE_CODE (decl) != FIELD_DECL) 6821 abort (); 6822 6823 type = field_type (decl); 6824 6825 bitpos_tree = DECL_FIELD_BITPOS (decl); 6826 field_size_tree = DECL_SIZE (decl); 6827 6828 /* We cannot yet cope with fields whose positions or sizes are variable, so 6829 for now, when we see such things, we simply return 0. Someday, we may 6830 be able to handle such cases, but it will be damn difficult. */ 6831 if (TREE_CODE (bitpos_tree) != INTEGER_CST) 6832 return 0; 6833 bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree); 6834 6835 if (TREE_CODE (field_size_tree) != INTEGER_CST) 6836 return 0; 6837 6838 field_size_in_bits = (unsigned) TREE_INT_CST_LOW (field_size_tree); 6839 type_size_in_bits = simple_type_size_in_bits (type); 6840 type_align_in_bits = simple_type_align_in_bits (type); 6841 type_align_in_bytes = type_align_in_bits / BITS_PER_UNIT; 6842 6843 /* Note that the GCC front-end doesn't make any attempt to keep track of 6844 the starting bit offset (relative to the start of the containing 6845 structure type) of the hypothetical "containing object" for a bit- 6846 field. Thus, when computing the byte offset value for the start of the 6847 "containing object" of a bit-field, we must deduce this information on 6848 our own. This can be rather tricky to do in some cases. For example, 6849 handling the following structure type definition when compiling for an 6850 i386/i486 target (which only aligns long long's to 32-bit boundaries) 6851 can be very tricky: 6852 6853 struct S { int field1; long long field2:31; }; 6854 6855 Fortunately, there is a simple rule-of-thumb which can be 6856 used in such cases. When compiling for an i386/i486, GCC will allocate 6857 8 bytes for the structure shown above. It decides to do this based upon 6858 one simple rule for bit-field allocation. Quite simply, GCC allocates 6859 each "containing object" for each bit-field at the first (i.e. lowest 6860 addressed) legitimate alignment boundary (based upon the required 6861 minimum alignment for the declared type of the field) which it can 6862 possibly use, subject to the condition that there is still enough 6863 available space remaining in the containing object (when allocated at 6864 the selected point) to fully accommodate all of the bits of the 6865 bit-field itself. This simple rule makes it obvious why GCC allocates 6866 8 bytes for each object of the structure type shown above. When looking 6867 for a place to allocate the "containing object" for `field2', the 6868 compiler simply tries to allocate a 64-bit "containing object" at each 6869 successive 32-bit boundary (starting at zero) until it finds a place to 6870 allocate that 64- bit field such that at least 31 contiguous (and 6871 previously unallocated) bits remain within that selected 64 bit field. 6872 (As it turns out, for the example above, the compiler finds that it is 6873 OK to allocate the "containing object" 64-bit field at bit-offset zero 6874 within the structure type.) Here we attempt to work backwards from the 6875 limited set of facts we're given, and we try to deduce from those facts, 6876 where GCC must have believed that the containing object started (within 6877 the structure type). The value we deduce is then used (by the callers of 6878 this routine) to generate DW_AT_location and DW_AT_bit_offset attributes 6879 for fields (both bit-fields and, in the case of DW_AT_location, regular 6880 fields as well). */ 6881 6882 /* Figure out the bit-distance from the start of the structure to the 6883 "deepest" bit of the bit-field. */ 6884 deepest_bitpos = bitpos_int + field_size_in_bits; 6885 6886 /* This is the tricky part. Use some fancy footwork to deduce where the 6887 lowest addressed bit of the containing object must be. */ 6888 object_offset_in_bits 6889 = ceiling (deepest_bitpos, type_align_in_bits) - type_size_in_bits; 6890 6891 /* Compute the offset of the containing object in "alignment units". */ 6892 object_offset_in_align_units = object_offset_in_bits / type_align_in_bits; 6893 6894 /* Compute the offset of the containing object in bytes. */ 6895 object_offset_in_bytes = object_offset_in_align_units * type_align_in_bytes; 6896 6897 return object_offset_in_bytes; 6898} 6899 6900/* The following routines define various Dwarf attributes and any data 6901 associated with them. */ 6902 6903/* Add a location description attribute value to a DIE. 6904 6905 This emits location attributes suitable for whole variables and 6906 whole parameters. Note that the location attributes for struct fields are 6907 generated by the routine `data_member_location_attribute' below. */ 6908 6909static void 6910add_AT_location_description (die, attr_kind, rtl) 6911 dw_die_ref die; 6912 enum dwarf_attribute attr_kind; 6913 register rtx rtl; 6914{ 6915 /* Handle a special case. If we are about to output a location descriptor 6916 for a variable or parameter which has been optimized out of existence, 6917 don't do that. A variable which has been optimized out 6918 of existence will have a DECL_RTL value which denotes a pseudo-reg. 6919 Currently, in some rare cases, variables can have DECL_RTL values which 6920 look like (MEM (REG pseudo-reg#)). These cases are due to bugs 6921 elsewhere in the compiler. We treat such cases as if the variable(s) in 6922 question had been optimized out of existence. */ 6923 6924 if (is_pseudo_reg (rtl) 6925 || (GET_CODE (rtl) == MEM 6926 && is_pseudo_reg (XEXP (rtl, 0))) 6927 || (GET_CODE (rtl) == CONCAT 6928 && is_pseudo_reg (XEXP (rtl, 0)) 6929 && is_pseudo_reg (XEXP (rtl, 1)))) 6930 return; 6931 6932 add_AT_loc (die, attr_kind, loc_descriptor (rtl)); 6933} 6934 6935/* Attach the specialized form of location attribute used for data 6936 members of struct and union types. In the special case of a 6937 FIELD_DECL node which represents a bit-field, the "offset" part 6938 of this special location descriptor must indicate the distance 6939 in bytes from the lowest-addressed byte of the containing struct 6940 or union type to the lowest-addressed byte of the "containing 6941 object" for the bit-field. (See the `field_byte_offset' function 6942 above).. For any given bit-field, the "containing object" is a 6943 hypothetical object (of some integral or enum type) within which 6944 the given bit-field lives. The type of this hypothetical 6945 "containing object" is always the same as the declared type of 6946 the individual bit-field itself (for GCC anyway... the DWARF 6947 spec doesn't actually mandate this). Note that it is the size 6948 (in bytes) of the hypothetical "containing object" which will 6949 be given in the DW_AT_byte_size attribute for this bit-field. 6950 (See the `byte_size_attribute' function below.) It is also used 6951 when calculating the value of the DW_AT_bit_offset attribute. 6952 (See the `bit_offset_attribute' function below). */ 6953 6954static void 6955add_data_member_location_attribute (die, decl) 6956 register dw_die_ref die; 6957 register tree decl; 6958{ 6959 register unsigned long offset; 6960 register dw_loc_descr_ref loc_descr; 6961 register enum dwarf_location_atom op; 6962 6963 if (TREE_CODE (decl) == TREE_VEC) 6964 offset = TREE_INT_CST_LOW (BINFO_OFFSET (decl)); 6965 else 6966 offset = field_byte_offset (decl); 6967 6968 /* The DWARF2 standard says that we should assume that the structure address 6969 is already on the stack, so we can specify a structure field address 6970 by using DW_OP_plus_uconst. */ 6971 6972#ifdef MIPS_DEBUGGING_INFO 6973 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst operator 6974 correctly. It works only if we leave the offset on the stack. */ 6975 op = DW_OP_constu; 6976#else 6977 op = DW_OP_plus_uconst; 6978#endif 6979 6980 loc_descr = new_loc_descr (op, offset, 0); 6981 add_AT_loc (die, DW_AT_data_member_location, loc_descr); 6982} 6983 6984/* Attach an DW_AT_const_value attribute for a variable or a parameter which 6985 does not have a "location" either in memory or in a register. These 6986 things can arise in GNU C when a constant is passed as an actual parameter 6987 to an inlined function. They can also arise in C++ where declared 6988 constants do not necessarily get memory "homes". */ 6989 6990static void 6991add_const_value_attribute (die, rtl) 6992 register dw_die_ref die; 6993 register rtx rtl; 6994{ 6995 switch (GET_CODE (rtl)) 6996 { 6997 case CONST_INT: 6998 /* Note that a CONST_INT rtx could represent either an integer or a 6999 floating-point constant. A CONST_INT is used whenever the constant 7000 will fit into a single word. In all such cases, the original mode 7001 of the constant value is wiped out, and the CONST_INT rtx is 7002 assigned VOIDmode. */ 7003 add_AT_unsigned (die, DW_AT_const_value, (unsigned) INTVAL (rtl)); 7004 break; 7005 7006 case CONST_DOUBLE: 7007 /* Note that a CONST_DOUBLE rtx could represent either an integer or a 7008 floating-point constant. A CONST_DOUBLE is used whenever the 7009 constant requires more than one word in order to be adequately 7010 represented. We output CONST_DOUBLEs as blocks. */ 7011 { 7012 register enum machine_mode mode = GET_MODE (rtl); 7013 7014 if (GET_MODE_CLASS (mode) == MODE_FLOAT) 7015 { 7016 register unsigned length = GET_MODE_SIZE (mode) / sizeof (long); 7017 long array[4]; 7018 REAL_VALUE_TYPE rv; 7019 7020 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl); 7021 switch (mode) 7022 { 7023 case SFmode: 7024 REAL_VALUE_TO_TARGET_SINGLE (rv, array[0]); 7025 break; 7026 7027 case DFmode: 7028 REAL_VALUE_TO_TARGET_DOUBLE (rv, array); 7029 break; 7030 7031 case XFmode: 7032 case TFmode: 7033 REAL_VALUE_TO_TARGET_LONG_DOUBLE (rv, array); 7034 break; 7035 7036 default: 7037 abort (); 7038 } 7039 7040 add_AT_float (die, DW_AT_const_value, length, array); 7041 } 7042 else 7043 add_AT_long_long (die, DW_AT_const_value, 7044 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl)); 7045 } 7046 break; 7047 7048 case CONST_STRING: 7049 add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0)); 7050 break; 7051 7052 case SYMBOL_REF: 7053 case LABEL_REF: 7054 case CONST: 7055 add_AT_addr (die, DW_AT_const_value, addr_to_string (rtl)); 7056 break; 7057 7058 case PLUS: 7059 /* In cases where an inlined instance of an inline function is passed 7060 the address of an `auto' variable (which is local to the caller) we 7061 can get a situation where the DECL_RTL of the artificial local 7062 variable (for the inlining) which acts as a stand-in for the 7063 corresponding formal parameter (of the inline function) will look 7064 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not 7065 exactly a compile-time constant expression, but it isn't the address 7066 of the (artificial) local variable either. Rather, it represents the 7067 *value* which the artificial local variable always has during its 7068 lifetime. We currently have no way to represent such quasi-constant 7069 values in Dwarf, so for now we just punt and generate nothing. */ 7070 break; 7071 7072 default: 7073 /* No other kinds of rtx should be possible here. */ 7074 abort (); 7075 } 7076 7077} 7078 7079/* Generate *either* an DW_AT_location attribute or else an DW_AT_const_value 7080 data attribute for a variable or a parameter. We generate the 7081 DW_AT_const_value attribute only in those cases where the given variable 7082 or parameter does not have a true "location" either in memory or in a 7083 register. This can happen (for example) when a constant is passed as an 7084 actual argument in a call to an inline function. (It's possible that 7085 these things can crop up in other ways also.) Note that one type of 7086 constant value which can be passed into an inlined function is a constant 7087 pointer. This can happen for example if an actual argument in an inlined 7088 function call evaluates to a compile-time constant address. */ 7089 7090static void 7091add_location_or_const_value_attribute (die, decl) 7092 register dw_die_ref die; 7093 register tree decl; 7094{ 7095 register rtx rtl; 7096 register tree declared_type; 7097 register tree passed_type; 7098 7099 if (TREE_CODE (decl) == ERROR_MARK) 7100 return; 7101 7102 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != PARM_DECL) 7103 abort (); 7104 7105 /* Here we have to decide where we are going to say the parameter "lives" 7106 (as far as the debugger is concerned). We only have a couple of 7107 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL. 7108 7109 DECL_RTL normally indicates where the parameter lives during most of the 7110 activation of the function. If optimization is enabled however, this 7111 could be either NULL or else a pseudo-reg. Both of those cases indicate 7112 that the parameter doesn't really live anywhere (as far as the code 7113 generation parts of GCC are concerned) during most of the function's 7114 activation. That will happen (for example) if the parameter is never 7115 referenced within the function. 7116 7117 We could just generate a location descriptor here for all non-NULL 7118 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be 7119 a little nicer than that if we also consider DECL_INCOMING_RTL in cases 7120 where DECL_RTL is NULL or is a pseudo-reg. 7121 7122 Note however that we can only get away with using DECL_INCOMING_RTL as 7123 a backup substitute for DECL_RTL in certain limited cases. In cases 7124 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl), 7125 we can be sure that the parameter was passed using the same type as it is 7126 declared to have within the function, and that its DECL_INCOMING_RTL 7127 points us to a place where a value of that type is passed. 7128 7129 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different, 7130 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL 7131 because in these cases DECL_INCOMING_RTL points us to a value of some 7132 type which is *different* from the type of the parameter itself. Thus, 7133 if we tried to use DECL_INCOMING_RTL to generate a location attribute in 7134 such cases, the debugger would end up (for example) trying to fetch a 7135 `float' from a place which actually contains the first part of a 7136 `double'. That would lead to really incorrect and confusing 7137 output at debug-time. 7138 7139 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL 7140 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There 7141 are a couple of exceptions however. On little-endian machines we can 7142 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is 7143 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is 7144 an integral type that is smaller than TREE_TYPE (decl). These cases arise 7145 when (on a little-endian machine) a non-prototyped function has a 7146 parameter declared to be of type `short' or `char'. In such cases, 7147 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will 7148 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the 7149 passed `int' value. If the debugger then uses that address to fetch 7150 a `short' or a `char' (on a little-endian machine) the result will be 7151 the correct data, so we allow for such exceptional cases below. 7152 7153 Note that our goal here is to describe the place where the given formal 7154 parameter lives during most of the function's activation (i.e. between 7155 the end of the prologue and the start of the epilogue). We'll do that 7156 as best as we can. Note however that if the given formal parameter is 7157 modified sometime during the execution of the function, then a stack 7158 backtrace (at debug-time) will show the function as having been 7159 called with the *new* value rather than the value which was 7160 originally passed in. This happens rarely enough that it is not 7161 a major problem, but it *is* a problem, and I'd like to fix it. 7162 7163 A future version of dwarf2out.c may generate two additional 7164 attributes for any given DW_TAG_formal_parameter DIE which will 7165 describe the "passed type" and the "passed location" for the 7166 given formal parameter in addition to the attributes we now 7167 generate to indicate the "declared type" and the "active 7168 location" for each parameter. This additional set of attributes 7169 could be used by debuggers for stack backtraces. Separately, note 7170 that sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be 7171 NULL also. This happens (for example) for inlined-instances of 7172 inline function formal parameters which are never referenced. 7173 This really shouldn't be happening. All PARM_DECL nodes should 7174 get valid non-NULL DECL_INCOMING_RTL values, but integrate.c 7175 doesn't currently generate these values for inlined instances of 7176 inline function parameters, so when we see such cases, we are 7177 just out-of-luck for the time being (until integrate.c 7178 gets fixed). */ 7179 7180 /* Use DECL_RTL as the "location" unless we find something better. */ 7181 rtl = DECL_RTL (decl); 7182 7183 if (TREE_CODE (decl) == PARM_DECL) 7184 { 7185 if (rtl == NULL_RTX || is_pseudo_reg (rtl)) 7186 { 7187 declared_type = type_main_variant (TREE_TYPE (decl)); 7188 passed_type = type_main_variant (DECL_ARG_TYPE (decl)); 7189 7190 /* This decl represents a formal parameter which was optimized out. 7191 Note that DECL_INCOMING_RTL may be NULL in here, but we handle 7192 all* cases where (rtl == NULL_RTX) just below. */ 7193 if (declared_type == passed_type) 7194 rtl = DECL_INCOMING_RTL (decl); 7195 else if (! BYTES_BIG_ENDIAN 7196 && TREE_CODE (declared_type) == INTEGER_TYPE 7197 && (GET_MODE_SIZE (TYPE_MODE (declared_type)) 7198 <= GET_MODE_SIZE (TYPE_MODE (passed_type)))) 7199 rtl = DECL_INCOMING_RTL (decl); 7200 } 7201 7202 /* If the parm was passed in registers, but lives on the stack, then 7203 make a big endian correction if the mode of the type of the 7204 parameter is not the same as the mode of the rtl. */ 7205 /* ??? This is the same series of checks that are made in dbxout.c before 7206 we reach the big endian correction code there. It isn't clear if all 7207 of these checks are necessary here, but keeping them all is the safe 7208 thing to do. */ 7209 else if (GET_CODE (rtl) == MEM 7210 && XEXP (rtl, 0) != const0_rtx 7211 && ! CONSTANT_P (XEXP (rtl, 0)) 7212 /* Not passed in memory. */ 7213 && GET_CODE (DECL_INCOMING_RTL (decl)) != MEM 7214 /* Not passed by invisible reference. */ 7215 && (GET_CODE (XEXP (rtl, 0)) != REG 7216 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM 7217 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM 7218#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM 7219 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM 7220#endif 7221 ) 7222 /* Big endian correction check. */ 7223 && BYTES_BIG_ENDIAN 7224 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl) 7225 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))) 7226 < UNITS_PER_WORD)) 7227 { 7228 int offset = (UNITS_PER_WORD 7229 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))); 7230 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)), 7231 plus_constant (XEXP (rtl, 0), offset)); 7232 } 7233 } 7234 7235 if (rtl == NULL_RTX) 7236 return; 7237 7238 rtl = eliminate_regs (rtl, 0, NULL_RTX); 7239#ifdef LEAF_REG_REMAP 7240 if (current_function_uses_only_leaf_regs) 7241 leaf_renumber_regs_insn (rtl); 7242#endif 7243 7244 switch (GET_CODE (rtl)) 7245 { 7246 case ADDRESSOF: 7247 /* The address of a variable that was optimized away; don't emit 7248 anything. */ 7249 break; 7250 7251 case CONST_INT: 7252 case CONST_DOUBLE: 7253 case CONST_STRING: 7254 case SYMBOL_REF: 7255 case LABEL_REF: 7256 case CONST: 7257 case PLUS: 7258 /* DECL_RTL could be (plus (reg ...) (const_int ...)) */ 7259 add_const_value_attribute (die, rtl); 7260 break; 7261 7262 case MEM: 7263 case REG: 7264 case SUBREG: 7265 case CONCAT: 7266 add_AT_location_description (die, DW_AT_location, rtl); 7267 break; 7268 7269 default: 7270 abort (); 7271 } 7272} 7273 7274/* Generate an DW_AT_name attribute given some string value to be included as 7275 the value of the attribute. */ 7276 7277static inline void 7278add_name_attribute (die, name_string) 7279 register dw_die_ref die; 7280 register char *name_string; 7281{ 7282 if (name_string != NULL && *name_string != 0) 7283 add_AT_string (die, DW_AT_name, name_string); 7284} 7285 7286/* Given a tree node describing an array bound (either lower or upper) output 7287 a representation for that bound. */ 7288 7289static void 7290add_bound_info (subrange_die, bound_attr, bound) 7291 register dw_die_ref subrange_die; 7292 register enum dwarf_attribute bound_attr; 7293 register tree bound; 7294{ 7295 register unsigned bound_value = 0; 7296 7297 /* If this is an Ada unconstrained array type, then don't emit any debug 7298 info because the array bounds are unknown. They are parameterized when 7299 the type is instantiated. */ 7300 if (contains_placeholder_p (bound)) 7301 return; 7302 7303 switch (TREE_CODE (bound)) 7304 { 7305 case ERROR_MARK: 7306 return; 7307 7308 /* All fixed-bounds are represented by INTEGER_CST nodes. */ 7309 case INTEGER_CST: 7310 bound_value = TREE_INT_CST_LOW (bound); 7311 if (bound_attr == DW_AT_lower_bound 7312 && ((is_c_family () && bound_value == 0) 7313 || (is_fortran () && bound_value == 1))) 7314 /* use the default */; 7315 else 7316 add_AT_unsigned (subrange_die, bound_attr, bound_value); 7317 break; 7318 7319 case CONVERT_EXPR: 7320 case NOP_EXPR: 7321 case NON_LVALUE_EXPR: 7322 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0)); 7323 break; 7324 7325 case SAVE_EXPR: 7326 /* If optimization is turned on, the SAVE_EXPRs that describe how to 7327 access the upper bound values may be bogus. If they refer to a 7328 register, they may only describe how to get at these values at the 7329 points in the generated code right after they have just been 7330 computed. Worse yet, in the typical case, the upper bound values 7331 will not even *be* computed in the optimized code (though the 7332 number of elements will), so these SAVE_EXPRs are entirely 7333 bogus. In order to compensate for this fact, we check here to see 7334 if optimization is enabled, and if so, we don't add an attribute 7335 for the (unknown and unknowable) upper bound. This should not 7336 cause too much trouble for existing (stupid?) debuggers because 7337 they have to deal with empty upper bounds location descriptions 7338 anyway in order to be able to deal with incomplete array types. 7339 Of course an intelligent debugger (GDB?) should be able to 7340 comprehend that a missing upper bound specification in a array 7341 type used for a storage class `auto' local array variable 7342 indicates that the upper bound is both unknown (at compile- time) 7343 and unknowable (at run-time) due to optimization. 7344 7345 We assume that a MEM rtx is safe because gcc wouldn't put the 7346 value there unless it was going to be used repeatedly in the 7347 function, i.e. for cleanups. */ 7348 if (! optimize || GET_CODE (SAVE_EXPR_RTL (bound)) == MEM) 7349 { 7350 register dw_die_ref ctx = lookup_decl_die (current_function_decl); 7351 register dw_die_ref decl_die = new_die (DW_TAG_variable, ctx); 7352 register rtx loc = SAVE_EXPR_RTL (bound); 7353 7354 /* If the RTL for the SAVE_EXPR is memory, handle the case where 7355 it references an outer function's frame. */ 7356 7357 if (GET_CODE (loc) == MEM) 7358 { 7359 rtx new_addr = fix_lexical_addr (XEXP (loc, 0), bound); 7360 7361 if (XEXP (loc, 0) != new_addr) 7362 loc = gen_rtx (MEM, GET_MODE (loc), new_addr); 7363 } 7364 7365 add_AT_flag (decl_die, DW_AT_artificial, 1); 7366 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx); 7367 add_AT_location_description (decl_die, DW_AT_location, loc); 7368 add_AT_die_ref (subrange_die, bound_attr, decl_die); 7369 } 7370 7371 /* Else leave out the attribute. */ 7372 break; 7373 7374 case MAX_EXPR: 7375 case VAR_DECL: 7376 case COMPONENT_REF: 7377 /* ??? These types of bounds can be created by the Ada front end, 7378 and it isn't clear how to emit debug info for them. */ 7379 break; 7380 7381 default: 7382 abort (); 7383 } 7384} 7385 7386/* Note that the block of subscript information for an array type also 7387 includes information about the element type of type given array type. */ 7388 7389static void 7390add_subscript_info (type_die, type) 7391 register dw_die_ref type_die; 7392 register tree type; 7393{ 7394#ifndef MIPS_DEBUGGING_INFO 7395 register unsigned dimension_number; 7396#endif 7397 register tree lower, upper; 7398 register dw_die_ref subrange_die; 7399 7400 /* The GNU compilers represent multidimensional array types as sequences of 7401 one dimensional array types whose element types are themselves array 7402 types. Here we squish that down, so that each multidimensional array 7403 type gets only one array_type DIE in the Dwarf debugging info. The draft 7404 Dwarf specification say that we are allowed to do this kind of 7405 compression in C (because there is no difference between an array or 7406 arrays and a multidimensional array in C) but for other source languages 7407 (e.g. Ada) we probably shouldn't do this. */ 7408 7409 /* ??? The SGI dwarf reader fails for multidimensional arrays with a 7410 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10]. 7411 We work around this by disabling this feature. See also 7412 gen_array_type_die. */ 7413#ifndef MIPS_DEBUGGING_INFO 7414 for (dimension_number = 0; 7415 TREE_CODE (type) == ARRAY_TYPE; 7416 type = TREE_TYPE (type), dimension_number++) 7417 { 7418#endif 7419 register tree domain = TYPE_DOMAIN (type); 7420 7421 /* Arrays come in three flavors: Unspecified bounds, fixed bounds, 7422 and (in GNU C only) variable bounds. Handle all three forms 7423 here. */ 7424 subrange_die = new_die (DW_TAG_subrange_type, type_die); 7425 if (domain) 7426 { 7427 /* We have an array type with specified bounds. */ 7428 lower = TYPE_MIN_VALUE (domain); 7429 upper = TYPE_MAX_VALUE (domain); 7430 7431 /* define the index type. */ 7432 if (TREE_TYPE (domain)) 7433 { 7434 /* ??? This is probably an Ada unnamed subrange type. Ignore the 7435 TREE_TYPE field. We can't emit debug info for this 7436 because it is an unnamed integral type. */ 7437 if (TREE_CODE (domain) == INTEGER_TYPE 7438 && TYPE_NAME (domain) == NULL_TREE 7439 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE 7440 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE) 7441 ; 7442 else 7443 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0, 7444 type_die); 7445 } 7446 7447 /* ??? If upper is NULL, the array has unspecified length, 7448 but it does have a lower bound. This happens with Fortran 7449 dimension arr(N:*) 7450 Since the debugger is definitely going to need to know N 7451 to produce useful results, go ahead and output the lower 7452 bound solo, and hope the debugger can cope. */ 7453 7454 add_bound_info (subrange_die, DW_AT_lower_bound, lower); 7455 if (upper) 7456 add_bound_info (subrange_die, DW_AT_upper_bound, upper); 7457 } 7458 else 7459 /* We have an array type with an unspecified length. The DWARF-2 7460 spec does not say how to handle this; let's just leave out the 7461 bounds. */ 7462 {;} 7463 7464 7465#ifndef MIPS_DEBUGGING_INFO 7466 } 7467#endif 7468} 7469 7470static void 7471add_byte_size_attribute (die, tree_node) 7472 dw_die_ref die; 7473 register tree tree_node; 7474{ 7475 register unsigned size; 7476 7477 switch (TREE_CODE (tree_node)) 7478 { 7479 case ERROR_MARK: 7480 size = 0; 7481 break; 7482 case ENUMERAL_TYPE: 7483 case RECORD_TYPE: 7484 case UNION_TYPE: 7485 case QUAL_UNION_TYPE: 7486 size = int_size_in_bytes (tree_node); 7487 break; 7488 case FIELD_DECL: 7489 /* For a data member of a struct or union, the DW_AT_byte_size is 7490 generally given as the number of bytes normally allocated for an 7491 object of the *declared* type of the member itself. This is true 7492 even for bit-fields. */ 7493 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT; 7494 break; 7495 default: 7496 abort (); 7497 } 7498 7499 /* Note that `size' might be -1 when we get to this point. If it is, that 7500 indicates that the byte size of the entity in question is variable. We 7501 have no good way of expressing this fact in Dwarf at the present time, 7502 so just let the -1 pass on through. */ 7503 7504 add_AT_unsigned (die, DW_AT_byte_size, size); 7505} 7506 7507/* For a FIELD_DECL node which represents a bit-field, output an attribute 7508 which specifies the distance in bits from the highest order bit of the 7509 "containing object" for the bit-field to the highest order bit of the 7510 bit-field itself. 7511 7512 For any given bit-field, the "containing object" is a hypothetical 7513 object (of some integral or enum type) within which the given bit-field 7514 lives. The type of this hypothetical "containing object" is always the 7515 same as the declared type of the individual bit-field itself. The 7516 determination of the exact location of the "containing object" for a 7517 bit-field is rather complicated. It's handled by the 7518 `field_byte_offset' function (above). 7519 7520 Note that it is the size (in bytes) of the hypothetical "containing object" 7521 which will be given in the DW_AT_byte_size attribute for this bit-field. 7522 (See `byte_size_attribute' above). */ 7523 7524static inline void 7525add_bit_offset_attribute (die, decl) 7526 register dw_die_ref die; 7527 register tree decl; 7528{ 7529 register unsigned object_offset_in_bytes = field_byte_offset (decl); 7530 register tree type = DECL_BIT_FIELD_TYPE (decl); 7531 register tree bitpos_tree = DECL_FIELD_BITPOS (decl); 7532 register unsigned bitpos_int; 7533 register unsigned highest_order_object_bit_offset; 7534 register unsigned highest_order_field_bit_offset; 7535 register unsigned bit_offset; 7536 7537 /* Must be a field and a bit field. */ 7538 if (!type 7539 || TREE_CODE (decl) != FIELD_DECL) 7540 abort (); 7541 7542 /* We can't yet handle bit-fields whose offsets are variable, so if we 7543 encounter such things, just return without generating any attribute 7544 whatsoever. */ 7545 if (TREE_CODE (bitpos_tree) != INTEGER_CST) 7546 return; 7547 7548 bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree); 7549 7550 /* Note that the bit offset is always the distance (in bits) from the 7551 highest-order bit of the "containing object" to the highest-order bit of 7552 the bit-field itself. Since the "high-order end" of any object or field 7553 is different on big-endian and little-endian machines, the computation 7554 below must take account of these differences. */ 7555 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT; 7556 highest_order_field_bit_offset = bitpos_int; 7557 7558 if (! BYTES_BIG_ENDIAN) 7559 { 7560 highest_order_field_bit_offset 7561 += (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl)); 7562 7563 highest_order_object_bit_offset += simple_type_size_in_bits (type); 7564 } 7565 7566 bit_offset 7567 = (! BYTES_BIG_ENDIAN 7568 ? highest_order_object_bit_offset - highest_order_field_bit_offset 7569 : highest_order_field_bit_offset - highest_order_object_bit_offset); 7570 7571 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset); 7572} 7573 7574/* For a FIELD_DECL node which represents a bit field, output an attribute 7575 which specifies the length in bits of the given field. */ 7576 7577static inline void 7578add_bit_size_attribute (die, decl) 7579 register dw_die_ref die; 7580 register tree decl; 7581{ 7582 /* Must be a field and a bit field. */ 7583 if (TREE_CODE (decl) != FIELD_DECL 7584 || ! DECL_BIT_FIELD_TYPE (decl)) 7585 abort (); 7586 add_AT_unsigned (die, DW_AT_bit_size, 7587 (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl))); 7588} 7589 7590/* If the compiled language is ANSI C, then add a 'prototyped' 7591 attribute, if arg types are given for the parameters of a function. */ 7592 7593static inline void 7594add_prototyped_attribute (die, func_type) 7595 register dw_die_ref die; 7596 register tree func_type; 7597{ 7598 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89 7599 && TYPE_ARG_TYPES (func_type) != NULL) 7600 add_AT_flag (die, DW_AT_prototyped, 1); 7601} 7602 7603 7604/* Add an 'abstract_origin' attribute below a given DIE. The DIE is found 7605 by looking in either the type declaration or object declaration 7606 equate table. */ 7607 7608static inline void 7609add_abstract_origin_attribute (die, origin) 7610 register dw_die_ref die; 7611 register tree origin; 7612{ 7613 dw_die_ref origin_die = NULL; 7614 if (TREE_CODE_CLASS (TREE_CODE (origin)) == 'd') 7615 origin_die = lookup_decl_die (origin); 7616 else if (TREE_CODE_CLASS (TREE_CODE (origin)) == 't') 7617 origin_die = lookup_type_die (origin); 7618 7619 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die); 7620} 7621 7622/* We do not currently support the pure_virtual attribute. */ 7623 7624static inline void 7625add_pure_or_virtual_attribute (die, func_decl) 7626 register dw_die_ref die; 7627 register tree func_decl; 7628{ 7629 if (DECL_VINDEX (func_decl)) 7630 { 7631 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual); 7632 add_AT_loc (die, DW_AT_vtable_elem_location, 7633 new_loc_descr (DW_OP_constu, 7634 TREE_INT_CST_LOW (DECL_VINDEX (func_decl)), 7635 0)); 7636 7637 /* GNU extension: Record what type this method came from originally. */ 7638 if (debug_info_level > DINFO_LEVEL_TERSE) 7639 add_AT_die_ref (die, DW_AT_containing_type, 7640 lookup_type_die (DECL_CONTEXT (func_decl))); 7641 } 7642} 7643 7644/* Add source coordinate attributes for the given decl. */ 7645 7646static void 7647add_src_coords_attributes (die, decl) 7648 register dw_die_ref die; 7649 register tree decl; 7650{ 7651 register unsigned file_index = lookup_filename (DECL_SOURCE_FILE (decl)); 7652 7653 add_AT_unsigned (die, DW_AT_decl_file, file_index); 7654 add_AT_unsigned (die, DW_AT_decl_line, DECL_SOURCE_LINE (decl)); 7655} 7656 7657/* Add an DW_AT_name attribute and source coordinate attribute for the 7658 given decl, but only if it actually has a name. */ 7659 7660static void 7661add_name_and_src_coords_attributes (die, decl) 7662 register dw_die_ref die; 7663 register tree decl; 7664{ 7665 register tree decl_name; 7666 7667 decl_name = DECL_NAME (decl); 7668 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL) 7669 { 7670 add_name_attribute (die, dwarf2_name (decl, 0)); 7671 add_src_coords_attributes (die, decl); 7672 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL) 7673 && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)) 7674 add_AT_string (die, DW_AT_MIPS_linkage_name, 7675 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))); 7676 } 7677} 7678 7679/* Push a new declaration scope. */ 7680 7681static void 7682push_decl_scope (scope) 7683 tree scope; 7684{ 7685 tree containing_scope; 7686 int i; 7687 7688 /* Make room in the decl_scope_table, if necessary. */ 7689 if (decl_scope_table_allocated == decl_scope_depth) 7690 { 7691 decl_scope_table_allocated += DECL_SCOPE_TABLE_INCREMENT; 7692 decl_scope_table 7693 = (decl_scope_node *) xrealloc (decl_scope_table, 7694 (decl_scope_table_allocated 7695 * sizeof (decl_scope_node))); 7696 } 7697 7698 decl_scope_table[decl_scope_depth].scope = scope; 7699 7700 /* Sometimes, while recursively emitting subtypes within a class type, 7701 we end up recuring on a subtype at a higher level then the current 7702 subtype. In such a case, we need to search the decl_scope_table to 7703 find the parent of this subtype. */ 7704 7705 if (AGGREGATE_TYPE_P (scope)) 7706 containing_scope = TYPE_CONTEXT (scope); 7707 else 7708 containing_scope = NULL_TREE; 7709 7710 /* The normal case. */ 7711 if (decl_scope_depth == 0 7712 || containing_scope == NULL_TREE 7713 /* Ignore namespaces for the moment. */ 7714 || TREE_CODE (containing_scope) == NAMESPACE_DECL 7715 || containing_scope == decl_scope_table[decl_scope_depth - 1].scope) 7716 decl_scope_table[decl_scope_depth].previous = decl_scope_depth - 1; 7717 else 7718 { 7719 /* We need to search for the containing_scope. */ 7720 for (i = 0; i < decl_scope_depth; i++) 7721 if (decl_scope_table[i].scope == containing_scope) 7722 break; 7723 7724 if (i == decl_scope_depth) 7725 abort (); 7726 else 7727 decl_scope_table[decl_scope_depth].previous = i; 7728 } 7729 7730 decl_scope_depth++; 7731} 7732 7733/* Return the DIE for the scope that immediately contains this declaration. */ 7734 7735static dw_die_ref 7736scope_die_for (t, context_die) 7737 register tree t; 7738 register dw_die_ref context_die; 7739{ 7740 register dw_die_ref scope_die = NULL; 7741 register tree containing_scope; 7742 register int i; 7743 7744 /* Walk back up the declaration tree looking for a place to define 7745 this type. */ 7746 if (TREE_CODE_CLASS (TREE_CODE (t)) == 't') 7747 containing_scope = TYPE_CONTEXT (t); 7748 else if (TREE_CODE (t) == FUNCTION_DECL && DECL_VINDEX (t)) 7749 containing_scope = decl_class_context (t); 7750 else 7751 containing_scope = DECL_CONTEXT (t); 7752 7753 /* Ignore namespaces for the moment. */ 7754 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL) 7755 containing_scope = NULL_TREE; 7756 7757 /* Ignore function type "scopes" from the C frontend. They mean that 7758 a tagged type is local to a parmlist of a function declarator, but 7759 that isn't useful to DWARF. */ 7760 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE) 7761 containing_scope = NULL_TREE; 7762 7763 /* Function-local tags and functions get stuck in limbo until they are 7764 fixed up by decls_for_scope. */ 7765 if (context_die == NULL && containing_scope != NULL_TREE 7766 && (TREE_CODE (t) == FUNCTION_DECL || is_tagged_type (t))) 7767 return NULL; 7768 7769 if (containing_scope == NULL_TREE) 7770 scope_die = comp_unit_die; 7771 else 7772 { 7773 for (i = decl_scope_depth - 1, scope_die = context_die; 7774 i >= 0 && decl_scope_table[i].scope != containing_scope; 7775 (scope_die = scope_die->die_parent, 7776 i = decl_scope_table[i].previous)) 7777 ; 7778 7779 /* ??? Integrate_decl_tree does not handle BLOCK_TYPE_TAGS, nor 7780 does it try to handle types defined by TYPE_DECLs. Such types 7781 thus have an incorrect TYPE_CONTEXT, which points to the block 7782 they were originally defined in, instead of the current block 7783 created by function inlining. We try to detect that here and 7784 work around it. */ 7785 7786 if (i < 0 && scope_die == comp_unit_die 7787 && TREE_CODE (containing_scope) == BLOCK 7788 && is_tagged_type (t) 7789 && (block_ultimate_origin (decl_scope_table[decl_scope_depth - 1].scope) 7790 == containing_scope)) 7791 { 7792 scope_die = context_die; 7793 /* Since the checks below are no longer applicable. */ 7794 i = 0; 7795 } 7796 7797 if (i < 0) 7798 { 7799 if (TREE_CODE_CLASS (TREE_CODE (containing_scope)) != 't') 7800 abort (); 7801 if (debug_info_level > DINFO_LEVEL_TERSE 7802 && !TREE_ASM_WRITTEN (containing_scope)) 7803 abort (); 7804 7805 /* If none of the current dies are suitable, we get file scope. */ 7806 scope_die = comp_unit_die; 7807 } 7808 } 7809 7810 return scope_die; 7811} 7812 7813/* Pop a declaration scope. */ 7814static inline void 7815pop_decl_scope () 7816{ 7817 if (decl_scope_depth <= 0) 7818 abort (); 7819 --decl_scope_depth; 7820} 7821 7822/* Many forms of DIEs require a "type description" attribute. This 7823 routine locates the proper "type descriptor" die for the type given 7824 by 'type', and adds an DW_AT_type attribute below the given die. */ 7825 7826static void 7827add_type_attribute (object_die, type, decl_const, decl_volatile, context_die) 7828 register dw_die_ref object_die; 7829 register tree type; 7830 register int decl_const; 7831 register int decl_volatile; 7832 register dw_die_ref context_die; 7833{ 7834 register enum tree_code code = TREE_CODE (type); 7835 register dw_die_ref type_die = NULL; 7836 7837 /* ??? If this type is an unnamed subrange type of an integral or 7838 floating-point type, use the inner type. This is because we have no 7839 support for unnamed types in base_type_die. This can happen if this is 7840 an Ada subrange type. Correct solution is emit a subrange type die. */ 7841 if ((code == INTEGER_TYPE || code == REAL_TYPE) 7842 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0) 7843 type = TREE_TYPE (type), code = TREE_CODE (type); 7844 7845 if (code == ERROR_MARK) 7846 return; 7847 7848 /* Handle a special case. For functions whose return type is void, we 7849 generate *no* type attribute. (Note that no object may have type 7850 `void', so this only applies to function return types). */ 7851 if (code == VOID_TYPE) 7852 return; 7853 7854 type_die = modified_type_die (type, 7855 decl_const || TYPE_READONLY (type), 7856 decl_volatile || TYPE_VOLATILE (type), 7857 context_die); 7858 if (type_die != NULL) 7859 add_AT_die_ref (object_die, DW_AT_type, type_die); 7860} 7861 7862/* Given a tree pointer to a struct, class, union, or enum type node, return 7863 a pointer to the (string) tag name for the given type, or zero if the type 7864 was declared without a tag. */ 7865 7866static char * 7867type_tag (type) 7868 register tree type; 7869{ 7870 register char *name = 0; 7871 7872 if (TYPE_NAME (type) != 0) 7873 { 7874 register tree t = 0; 7875 7876 /* Find the IDENTIFIER_NODE for the type name. */ 7877 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE) 7878 t = TYPE_NAME (type); 7879 7880 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to 7881 a TYPE_DECL node, regardless of whether or not a `typedef' was 7882 involved. */ 7883 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 7884 && ! DECL_IGNORED_P (TYPE_NAME (type))) 7885 t = DECL_NAME (TYPE_NAME (type)); 7886 7887 /* Now get the name as a string, or invent one. */ 7888 if (t != 0) 7889 name = IDENTIFIER_POINTER (t); 7890 } 7891 7892 return (name == 0 || *name == '\0') ? 0 : name; 7893} 7894 7895/* Return the type associated with a data member, make a special check 7896 for bit field types. */ 7897 7898static inline tree 7899member_declared_type (member) 7900 register tree member; 7901{ 7902 return (DECL_BIT_FIELD_TYPE (member) 7903 ? DECL_BIT_FIELD_TYPE (member) 7904 : TREE_TYPE (member)); 7905} 7906 7907/* Get the decl's label, as described by its RTL. This may be different 7908 from the DECL_NAME name used in the source file. */ 7909 7910#if 0 7911static char * 7912decl_start_label (decl) 7913 register tree decl; 7914{ 7915 rtx x; 7916 char *fnname; 7917 x = DECL_RTL (decl); 7918 if (GET_CODE (x) != MEM) 7919 abort (); 7920 7921 x = XEXP (x, 0); 7922 if (GET_CODE (x) != SYMBOL_REF) 7923 abort (); 7924 7925 fnname = XSTR (x, 0); 7926 return fnname; 7927} 7928#endif 7929 7930/* These routines generate the internal representation of the DIE's for 7931 the compilation unit. Debugging information is collected by walking 7932 the declaration trees passed in from dwarf2out_decl(). */ 7933 7934static void 7935gen_array_type_die (type, context_die) 7936 register tree type; 7937 register dw_die_ref context_die; 7938{ 7939 register dw_die_ref scope_die = scope_die_for (type, context_die); 7940 register dw_die_ref array_die; 7941 register tree element_type; 7942 7943 /* ??? The SGI dwarf reader fails for array of array of enum types unless 7944 the inner array type comes before the outer array type. Thus we must 7945 call gen_type_die before we call new_die. See below also. */ 7946#ifdef MIPS_DEBUGGING_INFO 7947 gen_type_die (TREE_TYPE (type), context_die); 7948#endif 7949 7950 array_die = new_die (DW_TAG_array_type, scope_die); 7951 7952#if 0 7953 /* We default the array ordering. SDB will probably do 7954 the right things even if DW_AT_ordering is not present. It's not even 7955 an issue until we start to get into multidimensional arrays anyway. If 7956 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays, 7957 then we'll have to put the DW_AT_ordering attribute back in. (But if 7958 and when we find out that we need to put these in, we will only do so 7959 for multidimensional arrays. */ 7960 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major); 7961#endif 7962 7963#ifdef MIPS_DEBUGGING_INFO 7964 /* The SGI compilers handle arrays of unknown bound by setting 7965 AT_declaration and not emitting any subrange DIEs. */ 7966 if (! TYPE_DOMAIN (type)) 7967 add_AT_unsigned (array_die, DW_AT_declaration, 1); 7968 else 7969#endif 7970 add_subscript_info (array_die, type); 7971 7972 equate_type_number_to_die (type, array_die); 7973 7974 /* Add representation of the type of the elements of this array type. */ 7975 element_type = TREE_TYPE (type); 7976 7977 /* ??? The SGI dwarf reader fails for multidimensional arrays with a 7978 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10]. 7979 We work around this by disabling this feature. See also 7980 add_subscript_info. */ 7981#ifndef MIPS_DEBUGGING_INFO 7982 while (TREE_CODE (element_type) == ARRAY_TYPE) 7983 element_type = TREE_TYPE (element_type); 7984 7985 gen_type_die (element_type, context_die); 7986#endif 7987 7988 add_type_attribute (array_die, element_type, 0, 0, context_die); 7989} 7990 7991static void 7992gen_set_type_die (type, context_die) 7993 register tree type; 7994 register dw_die_ref context_die; 7995{ 7996 register dw_die_ref type_die 7997 = new_die (DW_TAG_set_type, scope_die_for (type, context_die)); 7998 7999 equate_type_number_to_die (type, type_die); 8000 add_type_attribute (type_die, TREE_TYPE (type), 0, 0, context_die); 8001} 8002 8003#if 0 8004static void 8005gen_entry_point_die (decl, context_die) 8006 register tree decl; 8007 register dw_die_ref context_die; 8008{ 8009 register tree origin = decl_ultimate_origin (decl); 8010 register dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die); 8011 if (origin != NULL) 8012 add_abstract_origin_attribute (decl_die, origin); 8013 else 8014 { 8015 add_name_and_src_coords_attributes (decl_die, decl); 8016 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)), 8017 0, 0, context_die); 8018 } 8019 8020 if (DECL_ABSTRACT (decl)) 8021 equate_decl_number_to_die (decl, decl_die); 8022 else 8023 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl)); 8024} 8025#endif 8026 8027/* Remember a type in the pending_types_list. */ 8028 8029static void 8030pend_type (type) 8031 register tree type; 8032{ 8033 if (pending_types == pending_types_allocated) 8034 { 8035 pending_types_allocated += PENDING_TYPES_INCREMENT; 8036 pending_types_list 8037 = (tree *) xrealloc (pending_types_list, 8038 sizeof (tree) * pending_types_allocated); 8039 } 8040 8041 pending_types_list[pending_types++] = type; 8042} 8043 8044/* Output any pending types (from the pending_types list) which we can output 8045 now (taking into account the scope that we are working on now). 8046 8047 For each type output, remove the given type from the pending_types_list 8048 *before* we try to output it. */ 8049 8050static void 8051output_pending_types_for_scope (context_die) 8052 register dw_die_ref context_die; 8053{ 8054 register tree type; 8055 8056 while (pending_types) 8057 { 8058 --pending_types; 8059 type = pending_types_list[pending_types]; 8060 gen_type_die (type, context_die); 8061 if (!TREE_ASM_WRITTEN (type)) 8062 abort (); 8063 } 8064} 8065 8066/* Remember a type in the incomplete_types_list. */ 8067 8068static void 8069add_incomplete_type (type) 8070 tree type; 8071{ 8072 if (incomplete_types == incomplete_types_allocated) 8073 { 8074 incomplete_types_allocated += INCOMPLETE_TYPES_INCREMENT; 8075 incomplete_types_list 8076 = (tree *) xrealloc (incomplete_types_list, 8077 sizeof (tree) * incomplete_types_allocated); 8078 } 8079 8080 incomplete_types_list[incomplete_types++] = type; 8081} 8082 8083/* Walk through the list of incomplete types again, trying once more to 8084 emit full debugging info for them. */ 8085 8086static void 8087retry_incomplete_types () 8088{ 8089 register tree type; 8090 8091 while (incomplete_types) 8092 { 8093 --incomplete_types; 8094 type = incomplete_types_list[incomplete_types]; 8095 gen_type_die (type, comp_unit_die); 8096 } 8097} 8098 8099/* Generate a DIE to represent an inlined instance of an enumeration type. */ 8100 8101static void 8102gen_inlined_enumeration_type_die (type, context_die) 8103 register tree type; 8104 register dw_die_ref context_die; 8105{ 8106 register dw_die_ref type_die = new_die (DW_TAG_enumeration_type, 8107 scope_die_for (type, context_die)); 8108 8109 if (!TREE_ASM_WRITTEN (type)) 8110 abort (); 8111 add_abstract_origin_attribute (type_die, type); 8112} 8113 8114/* Generate a DIE to represent an inlined instance of a structure type. */ 8115 8116static void 8117gen_inlined_structure_type_die (type, context_die) 8118 register tree type; 8119 register dw_die_ref context_die; 8120{ 8121 register dw_die_ref type_die = new_die (DW_TAG_structure_type, 8122 scope_die_for (type, context_die)); 8123 8124 if (!TREE_ASM_WRITTEN (type)) 8125 abort (); 8126 add_abstract_origin_attribute (type_die, type); 8127} 8128 8129/* Generate a DIE to represent an inlined instance of a union type. */ 8130 8131static void 8132gen_inlined_union_type_die (type, context_die) 8133 register tree type; 8134 register dw_die_ref context_die; 8135{ 8136 register dw_die_ref type_die = new_die (DW_TAG_union_type, 8137 scope_die_for (type, context_die)); 8138 8139 if (!TREE_ASM_WRITTEN (type)) 8140 abort (); 8141 add_abstract_origin_attribute (type_die, type); 8142} 8143 8144/* Generate a DIE to represent an enumeration type. Note that these DIEs 8145 include all of the information about the enumeration values also. Each 8146 enumerated type name/value is listed as a child of the enumerated type 8147 DIE. */ 8148 8149static void 8150gen_enumeration_type_die (type, context_die) 8151 register tree type; 8152 register dw_die_ref context_die; 8153{ 8154 register dw_die_ref type_die = lookup_type_die (type); 8155 8156 if (type_die == NULL) 8157 { 8158 type_die = new_die (DW_TAG_enumeration_type, 8159 scope_die_for (type, context_die)); 8160 equate_type_number_to_die (type, type_die); 8161 add_name_attribute (type_die, type_tag (type)); 8162 } 8163 else if (! TYPE_SIZE (type)) 8164 return; 8165 else 8166 remove_AT (type_die, DW_AT_declaration); 8167 8168 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the 8169 given enum type is incomplete, do not generate the DW_AT_byte_size 8170 attribute or the DW_AT_element_list attribute. */ 8171 if (TYPE_SIZE (type)) 8172 { 8173 register tree link; 8174 8175 TREE_ASM_WRITTEN (type) = 1; 8176 add_byte_size_attribute (type_die, type); 8177 if (TYPE_STUB_DECL (type) != NULL_TREE) 8178 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type)); 8179 8180 /* If the first reference to this type was as the return type of an 8181 inline function, then it may not have a parent. Fix this now. */ 8182 if (type_die->die_parent == NULL) 8183 add_child_die (scope_die_for (type, context_die), type_die); 8184 8185 for (link = TYPE_FIELDS (type); 8186 link != NULL; link = TREE_CHAIN (link)) 8187 { 8188 register dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die); 8189 8190 add_name_attribute (enum_die, 8191 IDENTIFIER_POINTER (TREE_PURPOSE (link))); 8192 add_AT_unsigned (enum_die, DW_AT_const_value, 8193 (unsigned) TREE_INT_CST_LOW (TREE_VALUE (link))); 8194 } 8195 } 8196 else 8197 add_AT_flag (type_die, DW_AT_declaration, 1); 8198} 8199 8200 8201/* Generate a DIE to represent either a real live formal parameter decl or to 8202 represent just the type of some formal parameter position in some function 8203 type. 8204 8205 Note that this routine is a bit unusual because its argument may be a 8206 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which 8207 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE 8208 node. If it's the former then this function is being called to output a 8209 DIE to represent a formal parameter object (or some inlining thereof). If 8210 it's the latter, then this function is only being called to output a 8211 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal 8212 argument type of some subprogram type. */ 8213 8214static dw_die_ref 8215gen_formal_parameter_die (node, context_die) 8216 register tree node; 8217 register dw_die_ref context_die; 8218{ 8219 register dw_die_ref parm_die 8220 = new_die (DW_TAG_formal_parameter, context_die); 8221 register tree origin; 8222 8223 switch (TREE_CODE_CLASS (TREE_CODE (node))) 8224 { 8225 case 'd': 8226 origin = decl_ultimate_origin (node); 8227 if (origin != NULL) 8228 add_abstract_origin_attribute (parm_die, origin); 8229 else 8230 { 8231 add_name_and_src_coords_attributes (parm_die, node); 8232 add_type_attribute (parm_die, TREE_TYPE (node), 8233 TREE_READONLY (node), 8234 TREE_THIS_VOLATILE (node), 8235 context_die); 8236 if (DECL_ARTIFICIAL (node)) 8237 add_AT_flag (parm_die, DW_AT_artificial, 1); 8238 } 8239 8240 equate_decl_number_to_die (node, parm_die); 8241 if (! DECL_ABSTRACT (node)) 8242 add_location_or_const_value_attribute (parm_die, node); 8243 8244 break; 8245 8246 case 't': 8247 /* We were called with some kind of a ..._TYPE node. */ 8248 add_type_attribute (parm_die, node, 0, 0, context_die); 8249 break; 8250 8251 default: 8252 abort (); 8253 } 8254 8255 return parm_die; 8256} 8257 8258/* Generate a special type of DIE used as a stand-in for a trailing ellipsis 8259 at the end of an (ANSI prototyped) formal parameters list. */ 8260 8261static void 8262gen_unspecified_parameters_die (decl_or_type, context_die) 8263 register tree decl_or_type; 8264 register dw_die_ref context_die; 8265{ 8266 new_die (DW_TAG_unspecified_parameters, context_die); 8267} 8268 8269/* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a 8270 DW_TAG_unspecified_parameters DIE) to represent the types of the formal 8271 parameters as specified in some function type specification (except for 8272 those which appear as part of a function *definition*). 8273 8274 Note we must be careful here to output all of the parameter DIEs before* 8275 we output any DIEs needed to represent the types of the formal parameters. 8276 This keeps svr4 SDB happy because it (incorrectly) thinks that the first 8277 non-parameter DIE it sees ends the formal parameter list. */ 8278 8279static void 8280gen_formal_types_die (function_or_method_type, context_die) 8281 register tree function_or_method_type; 8282 register dw_die_ref context_die; 8283{ 8284 register tree link; 8285 register tree formal_type = NULL; 8286 register tree first_parm_type = TYPE_ARG_TYPES (function_or_method_type); 8287 8288#if 0 8289 /* In the case where we are generating a formal types list for a C++ 8290 non-static member function type, skip over the first thing on the 8291 TYPE_ARG_TYPES list because it only represents the type of the hidden 8292 `this pointer'. The debugger should be able to figure out (without 8293 being explicitly told) that this non-static member function type takes a 8294 `this pointer' and should be able to figure what the type of that hidden 8295 parameter is from the DW_AT_member attribute of the parent 8296 DW_TAG_subroutine_type DIE. */ 8297 if (TREE_CODE (function_or_method_type) == METHOD_TYPE) 8298 first_parm_type = TREE_CHAIN (first_parm_type); 8299#endif 8300 8301 /* Make our first pass over the list of formal parameter types and output a 8302 DW_TAG_formal_parameter DIE for each one. */ 8303 for (link = first_parm_type; link; link = TREE_CHAIN (link)) 8304 { 8305 register dw_die_ref parm_die; 8306 8307 formal_type = TREE_VALUE (link); 8308 if (formal_type == void_type_node) 8309 break; 8310 8311 /* Output a (nameless) DIE to represent the formal parameter itself. */ 8312 parm_die = gen_formal_parameter_die (formal_type, context_die); 8313 if (TREE_CODE (function_or_method_type) == METHOD_TYPE 8314 && link == first_parm_type) 8315 add_AT_flag (parm_die, DW_AT_artificial, 1); 8316 } 8317 8318 /* If this function type has an ellipsis, add a 8319 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */ 8320 if (formal_type != void_type_node) 8321 gen_unspecified_parameters_die (function_or_method_type, context_die); 8322 8323 /* Make our second (and final) pass over the list of formal parameter types 8324 and output DIEs to represent those types (as necessary). */ 8325 for (link = TYPE_ARG_TYPES (function_or_method_type); 8326 link; 8327 link = TREE_CHAIN (link)) 8328 { 8329 formal_type = TREE_VALUE (link); 8330 if (formal_type == void_type_node) 8331 break; 8332 8333 gen_type_die (formal_type, context_die); 8334 } 8335} 8336 8337/* Generate a DIE to represent a declared function (either file-scope or 8338 block-local). */ 8339 8340static void 8341gen_subprogram_die (decl, context_die) 8342 register tree decl; 8343 register dw_die_ref context_die; 8344{ 8345 char label_id[MAX_ARTIFICIAL_LABEL_BYTES]; 8346 register tree origin = decl_ultimate_origin (decl); 8347 register dw_die_ref subr_die; 8348 register rtx fp_reg; 8349 register tree fn_arg_types; 8350 register tree outer_scope; 8351 register dw_die_ref old_die = lookup_decl_die (decl); 8352 register int declaration 8353 = (current_function_decl != decl 8354 || (context_die 8355 && (context_die->die_tag == DW_TAG_structure_type 8356 || context_die->die_tag == DW_TAG_union_type))); 8357 8358 if (origin != NULL) 8359 { 8360 subr_die = new_die (DW_TAG_subprogram, context_die); 8361 add_abstract_origin_attribute (subr_die, origin); 8362 } 8363 else if (old_die && DECL_ABSTRACT (decl) 8364 && get_AT_unsigned (old_die, DW_AT_inline)) 8365 { 8366 /* This must be a redefinition of an extern inline function. 8367 We can just reuse the old die here. */ 8368 subr_die = old_die; 8369 8370 /* Clear out the inlined attribute and parm types. */ 8371 remove_AT (subr_die, DW_AT_inline); 8372 remove_children (subr_die); 8373 } 8374 else if (old_die) 8375 { 8376 register unsigned file_index 8377 = lookup_filename (DECL_SOURCE_FILE (decl)); 8378 8379 if (get_AT_flag (old_die, DW_AT_declaration) != 1) 8380 { 8381 /* ??? This can happen if there is a bug in the program, for 8382 instance, if it has duplicate function definitions. Ideally, 8383 we should detect this case and ignore it. For now, if we have 8384 already reported an error, any error at all, then assume that 8385 we got here because of a input error, not a dwarf2 bug. */ 8386 extern int errorcount; 8387 if (errorcount) 8388 return; 8389 abort (); 8390 } 8391 8392 /* If the definition comes from the same place as the declaration, 8393 maybe use the old DIE. We always want the DIE for this function 8394 that has the *_pc attributes to be under comp_unit_die so the 8395 debugger can find it. For inlines, that is the concrete instance, 8396 so we can use the old DIE here. For non-inline methods, we want a 8397 specification DIE at toplevel, so we need a new DIE. For local 8398 class methods, this does not apply. */ 8399 if ((DECL_ABSTRACT (decl) || old_die->die_parent == comp_unit_die 8400 || context_die == NULL) 8401 && get_AT_unsigned (old_die, DW_AT_decl_file) == file_index 8402 && (get_AT_unsigned (old_die, DW_AT_decl_line) 8403 == DECL_SOURCE_LINE (decl))) 8404 { 8405 subr_die = old_die; 8406 8407 /* Clear out the declaration attribute and the parm types. */ 8408 remove_AT (subr_die, DW_AT_declaration); 8409 remove_children (subr_die); 8410 } 8411 else 8412 { 8413 subr_die = new_die (DW_TAG_subprogram, context_die); 8414 add_AT_die_ref (subr_die, DW_AT_specification, old_die); 8415 if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index) 8416 add_AT_unsigned (subr_die, DW_AT_decl_file, file_index); 8417 if (get_AT_unsigned (old_die, DW_AT_decl_line) 8418 != DECL_SOURCE_LINE (decl)) 8419 add_AT_unsigned 8420 (subr_die, DW_AT_decl_line, DECL_SOURCE_LINE (decl)); 8421 } 8422 } 8423 else 8424 { 8425 register dw_die_ref scope_die; 8426 8427 if (DECL_CONTEXT (decl)) 8428 scope_die = scope_die_for (decl, context_die); 8429 else 8430 /* Don't put block extern declarations under comp_unit_die. */ 8431 scope_die = context_die; 8432 8433 subr_die = new_die (DW_TAG_subprogram, scope_die); 8434 8435 if (TREE_PUBLIC (decl)) 8436 add_AT_flag (subr_die, DW_AT_external, 1); 8437 8438 add_name_and_src_coords_attributes (subr_die, decl); 8439 if (debug_info_level > DINFO_LEVEL_TERSE) 8440 { 8441 register tree type = TREE_TYPE (decl); 8442 8443 add_prototyped_attribute (subr_die, type); 8444 add_type_attribute (subr_die, TREE_TYPE (type), 0, 0, context_die); 8445 } 8446 8447 add_pure_or_virtual_attribute (subr_die, decl); 8448 if (DECL_ARTIFICIAL (decl)) 8449 add_AT_flag (subr_die, DW_AT_artificial, 1); 8450 if (TREE_PROTECTED (decl)) 8451 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected); 8452 else if (TREE_PRIVATE (decl)) 8453 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private); 8454 } 8455 8456 if (declaration) 8457 { 8458 add_AT_flag (subr_die, DW_AT_declaration, 1); 8459 8460 /* The first time we see a member function, it is in the context of 8461 the class to which it belongs. We make sure of this by emitting 8462 the class first. The next time is the definition, which is 8463 handled above. The two may come from the same source text. */ 8464 if (DECL_CONTEXT (decl)) 8465 equate_decl_number_to_die (decl, subr_die); 8466 } 8467 else if (DECL_ABSTRACT (decl)) 8468 { 8469 /* ??? Checking DECL_DEFER_OUTPUT is correct for static inline functions, 8470 but not for extern inline functions. We can't get this completely 8471 correct because information about whether the function was declared 8472 inline is not saved anywhere. */ 8473 if (DECL_DEFER_OUTPUT (decl)) 8474 { 8475 if (DECL_INLINE (decl)) 8476 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined); 8477 else 8478 add_AT_unsigned (subr_die, DW_AT_inline, 8479 DW_INL_declared_not_inlined); 8480 } 8481 else if (DECL_INLINE (decl)) 8482 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined); 8483 else 8484 abort (); 8485 8486 equate_decl_number_to_die (decl, subr_die); 8487 } 8488 else if (!DECL_EXTERNAL (decl)) 8489 { 8490 if (origin == NULL_TREE) 8491 equate_decl_number_to_die (decl, subr_die); 8492 8493 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL, 8494 current_funcdef_number); 8495 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id); 8496 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL, 8497 current_funcdef_number); 8498 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id); 8499 8500 add_pubname (decl, subr_die); 8501 add_arange (decl, subr_die); 8502 8503#ifdef MIPS_DEBUGGING_INFO 8504 /* Add a reference to the FDE for this routine. */ 8505 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde); 8506#endif 8507 8508 /* Define the "frame base" location for this routine. We use the 8509 frame pointer or stack pointer registers, since the RTL for local 8510 variables is relative to one of them. */ 8511 fp_reg 8512 = frame_pointer_needed ? hard_frame_pointer_rtx : stack_pointer_rtx; 8513 add_AT_loc (subr_die, DW_AT_frame_base, reg_loc_descriptor (fp_reg)); 8514 8515#if 0 8516 /* ??? This fails for nested inline functions, because context_display 8517 is not part of the state saved/restored for inline functions. */ 8518 if (current_function_needs_context) 8519 add_AT_location_description (subr_die, DW_AT_static_link, 8520 lookup_static_chain (decl)); 8521#endif 8522 } 8523 8524 /* Now output descriptions of the arguments for this function. This gets 8525 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list 8526 for a FUNCTION_DECL doesn't indicate cases where there was a trailing 8527 `...' at the end of the formal parameter list. In order to find out if 8528 there was a trailing ellipsis or not, we must instead look at the type 8529 associated with the FUNCTION_DECL. This will be a node of type 8530 FUNCTION_TYPE. If the chain of type nodes hanging off of this 8531 FUNCTION_TYPE node ends with a void_type_node then there should *not* be 8532 an ellipsis at the end. */ 8533 push_decl_scope (decl); 8534 8535 /* In the case where we are describing a mere function declaration, all we 8536 need to do here (and all we *can* do here) is to describe the *types* of 8537 its formal parameters. */ 8538 if (debug_info_level <= DINFO_LEVEL_TERSE) 8539 ; 8540 else if (declaration) 8541 gen_formal_types_die (TREE_TYPE (decl), subr_die); 8542 else 8543 { 8544 /* Generate DIEs to represent all known formal parameters */ 8545 register tree arg_decls = DECL_ARGUMENTS (decl); 8546 register tree parm; 8547 8548 /* When generating DIEs, generate the unspecified_parameters DIE 8549 instead if we come across the arg "__builtin_va_alist" */ 8550 for (parm = arg_decls; parm; parm = TREE_CHAIN (parm)) 8551 if (TREE_CODE (parm) == PARM_DECL) 8552 { 8553 if (DECL_NAME (parm) 8554 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)), 8555 "__builtin_va_alist")) 8556 gen_unspecified_parameters_die (parm, subr_die); 8557 else 8558 gen_decl_die (parm, subr_die); 8559 } 8560 8561 /* Decide whether we need a unspecified_parameters DIE at the end. 8562 There are 2 more cases to do this for: 1) the ansi ... declaration - 8563 this is detectable when the end of the arg list is not a 8564 void_type_node 2) an unprototyped function declaration (not a 8565 definition). This just means that we have no info about the 8566 parameters at all. */ 8567 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl)); 8568 if (fn_arg_types != NULL) 8569 { 8570 /* this is the prototyped case, check for ... */ 8571 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node) 8572 gen_unspecified_parameters_die (decl, subr_die); 8573 } 8574 else if (DECL_INITIAL (decl) == NULL_TREE) 8575 gen_unspecified_parameters_die (decl, subr_die); 8576 } 8577 8578 /* Output Dwarf info for all of the stuff within the body of the function 8579 (if it has one - it may be just a declaration). */ 8580 outer_scope = DECL_INITIAL (decl); 8581 8582 /* Note that here, `outer_scope' is a pointer to the outermost BLOCK 8583 node created to represent a function. This outermost BLOCK actually 8584 represents the outermost binding contour for the function, i.e. the 8585 contour in which the function's formal parameters and labels get 8586 declared. Curiously, it appears that the front end doesn't actually 8587 put the PARM_DECL nodes for the current function onto the BLOCK_VARS 8588 list for this outer scope. (They are strung off of the DECL_ARGUMENTS 8589 list for the function instead.) The BLOCK_VARS list for the 8590 `outer_scope' does provide us with a list of the LABEL_DECL nodes for 8591 the function however, and we output DWARF info for those in 8592 decls_for_scope. Just within the `outer_scope' there will be a BLOCK 8593 node representing the function's outermost pair of curly braces, and 8594 any blocks used for the base and member initializers of a C++ 8595 constructor function. */ 8596 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK) 8597 { 8598 current_function_has_inlines = 0; 8599 decls_for_scope (outer_scope, subr_die, 0); 8600 8601#if 0 && defined (MIPS_DEBUGGING_INFO) 8602 if (current_function_has_inlines) 8603 { 8604 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1); 8605 if (! comp_unit_has_inlines) 8606 { 8607 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1); 8608 comp_unit_has_inlines = 1; 8609 } 8610 } 8611#endif 8612 } 8613 8614 pop_decl_scope (); 8615} 8616 8617/* Generate a DIE to represent a declared data object. */ 8618 8619static void 8620gen_variable_die (decl, context_die) 8621 register tree decl; 8622 register dw_die_ref context_die; 8623{ 8624 register tree origin = decl_ultimate_origin (decl); 8625 register dw_die_ref var_die = new_die (DW_TAG_variable, context_die); 8626 8627 dw_die_ref old_die = lookup_decl_die (decl); 8628 int declaration 8629 = (DECL_EXTERNAL (decl) 8630 || current_function_decl != decl_function_context (decl) 8631 || context_die->die_tag == DW_TAG_structure_type 8632 || context_die->die_tag == DW_TAG_union_type); 8633 8634 if (origin != NULL) 8635 add_abstract_origin_attribute (var_die, origin); 8636 /* Loop unrolling can create multiple blocks that refer to the same 8637 static variable, so we must test for the DW_AT_declaration flag. */ 8638 /* ??? Loop unrolling/reorder_blocks should perhaps be rewritten to 8639 copy decls and set the DECL_ABSTRACT flag on them instead of 8640 sharing them. */ 8641 else if (old_die && TREE_STATIC (decl) 8642 && get_AT_flag (old_die, DW_AT_declaration) == 1) 8643 { 8644 /* ??? This is an instantiation of a C++ class level static. */ 8645 add_AT_die_ref (var_die, DW_AT_specification, old_die); 8646 if (DECL_NAME (decl)) 8647 { 8648 register unsigned file_index 8649 = lookup_filename (DECL_SOURCE_FILE (decl)); 8650 8651 if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index) 8652 add_AT_unsigned (var_die, DW_AT_decl_file, file_index); 8653 8654 if (get_AT_unsigned (old_die, DW_AT_decl_line) 8655 != DECL_SOURCE_LINE (decl)) 8656 8657 add_AT_unsigned (var_die, DW_AT_decl_line, 8658 DECL_SOURCE_LINE (decl)); 8659 } 8660 } 8661 else 8662 { 8663 add_name_and_src_coords_attributes (var_die, decl); 8664 add_type_attribute (var_die, TREE_TYPE (decl), 8665 TREE_READONLY (decl), 8666 TREE_THIS_VOLATILE (decl), context_die); 8667 8668 if (TREE_PUBLIC (decl)) 8669 add_AT_flag (var_die, DW_AT_external, 1); 8670 8671 if (DECL_ARTIFICIAL (decl)) 8672 add_AT_flag (var_die, DW_AT_artificial, 1); 8673 8674 if (TREE_PROTECTED (decl)) 8675 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected); 8676 8677 else if (TREE_PRIVATE (decl)) 8678 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private); 8679 } 8680 8681 if (declaration) 8682 add_AT_flag (var_die, DW_AT_declaration, 1); 8683 8684 if ((declaration && decl_class_context (decl)) || DECL_ABSTRACT (decl)) 8685 equate_decl_number_to_die (decl, var_die); 8686 8687 if (! declaration && ! DECL_ABSTRACT (decl)) 8688 { 8689 equate_decl_number_to_die (decl, var_die); 8690 add_location_or_const_value_attribute (var_die, decl); 8691 add_pubname (decl, var_die); 8692 } 8693} 8694 8695/* Generate a DIE to represent a label identifier. */ 8696 8697static void 8698gen_label_die (decl, context_die) 8699 register tree decl; 8700 register dw_die_ref context_die; 8701{ 8702 register tree origin = decl_ultimate_origin (decl); 8703 register dw_die_ref lbl_die = new_die (DW_TAG_label, context_die); 8704 register rtx insn; 8705 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 8706 char label2[MAX_ARTIFICIAL_LABEL_BYTES]; 8707 8708 if (origin != NULL) 8709 add_abstract_origin_attribute (lbl_die, origin); 8710 else 8711 add_name_and_src_coords_attributes (lbl_die, decl); 8712 8713 if (DECL_ABSTRACT (decl)) 8714 equate_decl_number_to_die (decl, lbl_die); 8715 else 8716 { 8717 insn = DECL_RTL (decl); 8718 8719 /* Deleted labels are programmer specified labels which have been 8720 eliminated because of various optimisations. We still emit them 8721 here so that it is possible to put breakpoints on them. */ 8722 if (GET_CODE (insn) == CODE_LABEL 8723 || ((GET_CODE (insn) == NOTE 8724 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL))) 8725 { 8726 /* When optimization is enabled (via -O) some parts of the compiler 8727 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which 8728 represent source-level labels which were explicitly declared by 8729 the user. This really shouldn't be happening though, so catch 8730 it if it ever does happen. */ 8731 if (INSN_DELETED_P (insn)) 8732 abort (); 8733 8734 sprintf (label2, INSN_LABEL_FMT, current_funcdef_number); 8735 ASM_GENERATE_INTERNAL_LABEL (label, label2, 8736 (unsigned) INSN_UID (insn)); 8737 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label); 8738 } 8739 } 8740} 8741 8742/* Generate a DIE for a lexical block. */ 8743 8744static void 8745gen_lexical_block_die (stmt, context_die, depth) 8746 register tree stmt; 8747 register dw_die_ref context_die; 8748 int depth; 8749{ 8750 register dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die); 8751 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 8752 8753 if (! BLOCK_ABSTRACT (stmt)) 8754 { 8755 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL, 8756 next_block_number); 8757 add_AT_lbl_id (stmt_die, DW_AT_low_pc, label); 8758 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, next_block_number); 8759 add_AT_lbl_id (stmt_die, DW_AT_high_pc, label); 8760 } 8761 8762 push_decl_scope (stmt); 8763 decls_for_scope (stmt, stmt_die, depth); 8764 pop_decl_scope (); 8765} 8766 8767/* Generate a DIE for an inlined subprogram. */ 8768 8769static void 8770gen_inlined_subroutine_die (stmt, context_die, depth) 8771 register tree stmt; 8772 register dw_die_ref context_die; 8773 int depth; 8774{ 8775 if (! BLOCK_ABSTRACT (stmt)) 8776 { 8777 register dw_die_ref subr_die 8778 = new_die (DW_TAG_inlined_subroutine, context_die); 8779 register tree decl = block_ultimate_origin (stmt); 8780 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 8781 8782 add_abstract_origin_attribute (subr_die, decl); 8783 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL, 8784 next_block_number); 8785 add_AT_lbl_id (subr_die, DW_AT_low_pc, label); 8786 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, next_block_number); 8787 add_AT_lbl_id (subr_die, DW_AT_high_pc, label); 8788 push_decl_scope (decl); 8789 decls_for_scope (stmt, subr_die, depth); 8790 pop_decl_scope (); 8791 current_function_has_inlines = 1; 8792 } 8793} 8794 8795/* Generate a DIE for a field in a record, or structure. */ 8796 8797static void 8798gen_field_die (decl, context_die) 8799 register tree decl; 8800 register dw_die_ref context_die; 8801{ 8802 register dw_die_ref decl_die = new_die (DW_TAG_member, context_die); 8803 8804 add_name_and_src_coords_attributes (decl_die, decl); 8805 add_type_attribute (decl_die, member_declared_type (decl), 8806 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl), 8807 context_die); 8808 8809 /* If this is a bit field... */ 8810 if (DECL_BIT_FIELD_TYPE (decl)) 8811 { 8812 add_byte_size_attribute (decl_die, decl); 8813 add_bit_size_attribute (decl_die, decl); 8814 add_bit_offset_attribute (decl_die, decl); 8815 } 8816 8817 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE) 8818 add_data_member_location_attribute (decl_die, decl); 8819 8820 if (DECL_ARTIFICIAL (decl)) 8821 add_AT_flag (decl_die, DW_AT_artificial, 1); 8822 8823 if (TREE_PROTECTED (decl)) 8824 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected); 8825 8826 else if (TREE_PRIVATE (decl)) 8827 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private); 8828} 8829 8830#if 0 8831/* Don't generate either pointer_type DIEs or reference_type DIEs here. 8832 Use modified_type_die instead. 8833 We keep this code here just in case these types of DIEs may be needed to 8834 represent certain things in other languages (e.g. Pascal) someday. */ 8835static void 8836gen_pointer_type_die (type, context_die) 8837 register tree type; 8838 register dw_die_ref context_die; 8839{ 8840 register dw_die_ref ptr_die 8841 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die)); 8842 8843 equate_type_number_to_die (type, ptr_die); 8844 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die); 8845 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE); 8846} 8847 8848/* Don't generate either pointer_type DIEs or reference_type DIEs here. 8849 Use modified_type_die instead. 8850 We keep this code here just in case these types of DIEs may be needed to 8851 represent certain things in other languages (e.g. Pascal) someday. */ 8852static void 8853gen_reference_type_die (type, context_die) 8854 register tree type; 8855 register dw_die_ref context_die; 8856{ 8857 register dw_die_ref ref_die 8858 = new_die (DW_TAG_reference_type, scope_die_for (type, context_die)); 8859 8860 equate_type_number_to_die (type, ref_die); 8861 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die); 8862 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE); 8863} 8864#endif 8865 8866/* Generate a DIE for a pointer to a member type. */ 8867static void 8868gen_ptr_to_mbr_type_die (type, context_die) 8869 register tree type; 8870 register dw_die_ref context_die; 8871{ 8872 register dw_die_ref ptr_die 8873 = new_die (DW_TAG_ptr_to_member_type, scope_die_for (type, context_die)); 8874 8875 equate_type_number_to_die (type, ptr_die); 8876 add_AT_die_ref (ptr_die, DW_AT_containing_type, 8877 lookup_type_die (TYPE_OFFSET_BASETYPE (type))); 8878 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die); 8879} 8880 8881/* Generate the DIE for the compilation unit. */ 8882 8883static void 8884gen_compile_unit_die (main_input_filename) 8885 register char *main_input_filename; 8886{ 8887 char producer[250]; 8888 char *wd = getpwd (); 8889 8890 comp_unit_die = new_die (DW_TAG_compile_unit, NULL); 8891 add_name_attribute (comp_unit_die, main_input_filename); 8892 8893 if (wd != NULL) 8894 add_AT_string (comp_unit_die, DW_AT_comp_dir, wd); 8895 8896 sprintf (producer, "%s %s", language_string, version_string); 8897 8898#ifdef MIPS_DEBUGGING_INFO 8899 /* The MIPS/SGI compilers place the 'cc' command line options in the producer 8900 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do 8901 not appear in the producer string, the debugger reaches the conclusion 8902 that the object file is stripped and has no debugging information. 8903 To get the MIPS/SGI debugger to believe that there is debugging 8904 information in the object file, we add a -g to the producer string. */ 8905 if (debug_info_level > DINFO_LEVEL_TERSE) 8906 strcat (producer, " -g"); 8907#endif 8908 8909 add_AT_string (comp_unit_die, DW_AT_producer, producer); 8910 8911 if (strcmp (language_string, "GNU C++") == 0) 8912 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_C_plus_plus); 8913 8914 else if (strcmp (language_string, "GNU Ada") == 0) 8915 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_Ada83); 8916 8917 else if (strcmp (language_string, "GNU F77") == 0) 8918 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_Fortran77); 8919 8920 else if (strcmp (language_string, "GNU Pascal") == 0) 8921 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_Pascal83); 8922 8923 else if (flag_traditional) 8924 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_C); 8925 8926 else 8927 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_C89); 8928 8929#if 0 /* unimplemented */ 8930 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 8931 add_AT_unsigned (comp_unit_die, DW_AT_macro_info, 0); 8932#endif 8933} 8934 8935/* Generate a DIE for a string type. */ 8936 8937static void 8938gen_string_type_die (type, context_die) 8939 register tree type; 8940 register dw_die_ref context_die; 8941{ 8942 register dw_die_ref type_die 8943 = new_die (DW_TAG_string_type, scope_die_for (type, context_die)); 8944 8945 equate_type_number_to_die (type, type_die); 8946 8947 /* Fudge the string length attribute for now. */ 8948 8949 /* TODO: add string length info. 8950 string_length_attribute (TYPE_MAX_VALUE (TYPE_DOMAIN (type))); 8951 bound_representation (upper_bound, 0, 'u'); */ 8952} 8953 8954/* Generate the DIE for a base class. */ 8955 8956static void 8957gen_inheritance_die (binfo, context_die) 8958 register tree binfo; 8959 register dw_die_ref context_die; 8960{ 8961 dw_die_ref die = new_die (DW_TAG_inheritance, context_die); 8962 8963 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die); 8964 add_data_member_location_attribute (die, binfo); 8965 8966 if (TREE_VIA_VIRTUAL (binfo)) 8967 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual); 8968 if (TREE_VIA_PUBLIC (binfo)) 8969 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public); 8970 else if (TREE_VIA_PROTECTED (binfo)) 8971 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected); 8972} 8973 8974/* Generate a DIE for a class member. */ 8975 8976static void 8977gen_member_die (type, context_die) 8978 register tree type; 8979 register dw_die_ref context_die; 8980{ 8981 register tree member; 8982 8983 /* If this is not an incomplete type, output descriptions of each of its 8984 members. Note that as we output the DIEs necessary to represent the 8985 members of this record or union type, we will also be trying to output 8986 DIEs to represent the *types* of those members. However the `type' 8987 function (above) will specifically avoid generating type DIEs for member 8988 types *within* the list of member DIEs for this (containing) type execpt 8989 for those types (of members) which are explicitly marked as also being 8990 members of this (containing) type themselves. The g++ front- end can 8991 force any given type to be treated as a member of some other 8992 (containing) type by setting the TYPE_CONTEXT of the given (member) type 8993 to point to the TREE node representing the appropriate (containing) 8994 type. */ 8995 8996 /* First output info about the base classes. */ 8997 if (TYPE_BINFO (type) && TYPE_BINFO_BASETYPES (type)) 8998 { 8999 register tree bases = TYPE_BINFO_BASETYPES (type); 9000 register int n_bases = TREE_VEC_LENGTH (bases); 9001 register int i; 9002 9003 for (i = 0; i < n_bases; i++) 9004 gen_inheritance_die (TREE_VEC_ELT (bases, i), context_die); 9005 } 9006 9007 /* Now output info about the data members and type members. */ 9008 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member)) 9009 gen_decl_die (member, context_die); 9010 9011 /* Now output info about the function members (if any). */ 9012 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member)) 9013 gen_decl_die (member, context_die); 9014} 9015 9016/* Generate a DIE for a structure or union type. */ 9017 9018static void 9019gen_struct_or_union_type_die (type, context_die) 9020 register tree type; 9021 register dw_die_ref context_die; 9022{ 9023 register dw_die_ref type_die = lookup_type_die (type); 9024 register dw_die_ref scope_die = 0; 9025 register int nested = 0; 9026 9027 if (type_die && ! TYPE_SIZE (type)) 9028 return; 9029 9030 if (TYPE_CONTEXT (type) != NULL_TREE 9031 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))) 9032 nested = 1; 9033 9034 scope_die = scope_die_for (type, context_die); 9035 9036 if (! type_die || (nested && scope_die == comp_unit_die)) 9037 /* First occurrence of type or toplevel definition of nested class. */ 9038 { 9039 register dw_die_ref old_die = type_die; 9040 9041 type_die = new_die (TREE_CODE (type) == RECORD_TYPE 9042 ? DW_TAG_structure_type : DW_TAG_union_type, 9043 scope_die); 9044 equate_type_number_to_die (type, type_die); 9045 add_name_attribute (type_die, type_tag (type)); 9046 if (old_die) 9047 add_AT_die_ref (type_die, DW_AT_specification, old_die); 9048 } 9049 else 9050 remove_AT (type_die, DW_AT_declaration); 9051 9052 /* If we're not in the right context to be defining this type, defer to 9053 avoid tricky recursion. */ 9054 if (TYPE_SIZE (type) && decl_scope_depth > 0 && scope_die == comp_unit_die) 9055 { 9056 add_AT_flag (type_die, DW_AT_declaration, 1); 9057 pend_type (type); 9058 } 9059 /* If this type has been completed, then give it a byte_size attribute and 9060 then give a list of members. */ 9061 else if (TYPE_SIZE (type)) 9062 { 9063 /* Prevent infinite recursion in cases where the type of some member of 9064 this type is expressed in terms of this type itself. */ 9065 TREE_ASM_WRITTEN (type) = 1; 9066 add_byte_size_attribute (type_die, type); 9067 if (TYPE_STUB_DECL (type) != NULL_TREE) 9068 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type)); 9069 9070 /* If the first reference to this type was as the return type of an 9071 inline function, then it may not have a parent. Fix this now. */ 9072 if (type_die->die_parent == NULL) 9073 add_child_die (scope_die, type_die); 9074 9075 push_decl_scope (type); 9076 gen_member_die (type, type_die); 9077 pop_decl_scope (); 9078 9079 /* GNU extension: Record what type our vtable lives in. */ 9080 if (TYPE_VFIELD (type)) 9081 { 9082 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type)); 9083 9084 gen_type_die (vtype, context_die); 9085 add_AT_die_ref (type_die, DW_AT_containing_type, 9086 lookup_type_die (vtype)); 9087 } 9088 } 9089 else 9090 { 9091 add_AT_flag (type_die, DW_AT_declaration, 1); 9092 9093 /* We can't do this for function-local types, and we don't need to. */ 9094 if (TREE_PERMANENT (type)) 9095 add_incomplete_type (type); 9096 } 9097} 9098 9099/* Generate a DIE for a subroutine _type_. */ 9100 9101static void 9102gen_subroutine_type_die (type, context_die) 9103 register tree type; 9104 register dw_die_ref context_die; 9105{ 9106 register tree return_type = TREE_TYPE (type); 9107 register dw_die_ref subr_die 9108 = new_die (DW_TAG_subroutine_type, scope_die_for (type, context_die)); 9109 9110 equate_type_number_to_die (type, subr_die); 9111 add_prototyped_attribute (subr_die, type); 9112 add_type_attribute (subr_die, return_type, 0, 0, context_die); 9113 gen_formal_types_die (type, subr_die); 9114} 9115 9116/* Generate a DIE for a type definition */ 9117 9118static void 9119gen_typedef_die (decl, context_die) 9120 register tree decl; 9121 register dw_die_ref context_die; 9122{ 9123 register dw_die_ref type_die; 9124 register tree origin; 9125 9126 if (TREE_ASM_WRITTEN (decl)) 9127 return; 9128 TREE_ASM_WRITTEN (decl) = 1; 9129 9130 type_die = new_die (DW_TAG_typedef, scope_die_for (decl, context_die)); 9131 origin = decl_ultimate_origin (decl); 9132 if (origin != NULL) 9133 add_abstract_origin_attribute (type_die, origin); 9134 else 9135 { 9136 register tree type; 9137 add_name_and_src_coords_attributes (type_die, decl); 9138 if (DECL_ORIGINAL_TYPE (decl)) 9139 { 9140 type = DECL_ORIGINAL_TYPE (decl); 9141 equate_type_number_to_die (TREE_TYPE (decl), type_die); 9142 } 9143 else 9144 type = TREE_TYPE (decl); 9145 add_type_attribute (type_die, type, TREE_READONLY (decl), 9146 TREE_THIS_VOLATILE (decl), context_die); 9147 } 9148 9149 if (DECL_ABSTRACT (decl)) 9150 equate_decl_number_to_die (decl, type_die); 9151} 9152 9153/* Generate a type description DIE. */ 9154 9155static void 9156gen_type_die (type, context_die) 9157 register tree type; 9158 register dw_die_ref context_die; 9159{ 9160 if (type == NULL_TREE || type == error_mark_node) 9161 return; 9162 9163 /* We are going to output a DIE to represent the unqualified version of 9164 this type (i.e. without any const or volatile qualifiers) so get the 9165 main variant (i.e. the unqualified version) of this type now. */ 9166 type = type_main_variant (type); 9167 9168 if (TREE_ASM_WRITTEN (type)) 9169 return; 9170 9171 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 9172 && DECL_ORIGINAL_TYPE (TYPE_NAME (type))) 9173 { 9174 TREE_ASM_WRITTEN (type) = 1; 9175 gen_decl_die (TYPE_NAME (type), context_die); 9176 return; 9177 } 9178 9179 switch (TREE_CODE (type)) 9180 { 9181 case ERROR_MARK: 9182 break; 9183 9184 case POINTER_TYPE: 9185 case REFERENCE_TYPE: 9186 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This 9187 ensures that the gen_type_die recursion will terminate even if the 9188 type is recursive. Recursive types are possible in Ada. */ 9189 /* ??? We could perhaps do this for all types before the switch 9190 statement. */ 9191 TREE_ASM_WRITTEN (type) = 1; 9192 9193 /* For these types, all that is required is that we output a DIE (or a 9194 set of DIEs) to represent the "basis" type. */ 9195 gen_type_die (TREE_TYPE (type), context_die); 9196 break; 9197 9198 case OFFSET_TYPE: 9199 /* This code is used for C++ pointer-to-data-member types. 9200 Output a description of the relevant class type. */ 9201 gen_type_die (TYPE_OFFSET_BASETYPE (type), context_die); 9202 9203 /* Output a description of the type of the object pointed to. */ 9204 gen_type_die (TREE_TYPE (type), context_die); 9205 9206 /* Now output a DIE to represent this pointer-to-data-member type 9207 itself. */ 9208 gen_ptr_to_mbr_type_die (type, context_die); 9209 break; 9210 9211 case SET_TYPE: 9212 gen_type_die (TYPE_DOMAIN (type), context_die); 9213 gen_set_type_die (type, context_die); 9214 break; 9215 9216 case FILE_TYPE: 9217 gen_type_die (TREE_TYPE (type), context_die); 9218 abort (); /* No way to represent these in Dwarf yet! */ 9219 break; 9220 9221 case FUNCTION_TYPE: 9222 /* Force out return type (in case it wasn't forced out already). */ 9223 gen_type_die (TREE_TYPE (type), context_die); 9224 gen_subroutine_type_die (type, context_die); 9225 break; 9226 9227 case METHOD_TYPE: 9228 /* Force out return type (in case it wasn't forced out already). */ 9229 gen_type_die (TREE_TYPE (type), context_die); 9230 gen_subroutine_type_die (type, context_die); 9231 break; 9232 9233 case ARRAY_TYPE: 9234 if (TYPE_STRING_FLAG (type) && TREE_CODE (TREE_TYPE (type)) == CHAR_TYPE) 9235 { 9236 gen_type_die (TREE_TYPE (type), context_die); 9237 gen_string_type_die (type, context_die); 9238 } 9239 else 9240 gen_array_type_die (type, context_die); 9241 break; 9242 9243 case ENUMERAL_TYPE: 9244 case RECORD_TYPE: 9245 case UNION_TYPE: 9246 case QUAL_UNION_TYPE: 9247 /* If this is a nested type whose containing class hasn't been 9248 written out yet, writing it out will cover this one, too. */ 9249 if (TYPE_CONTEXT (type) 9250 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type)) 9251 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type))) 9252 { 9253 gen_type_die (TYPE_CONTEXT (type), context_die); 9254 9255 if (TREE_ASM_WRITTEN (TYPE_CONTEXT (type))) 9256 return; 9257 9258 /* If that failed, attach ourselves to the stub. */ 9259 push_decl_scope (TYPE_CONTEXT (type)); 9260 context_die = lookup_type_die (TYPE_CONTEXT (type)); 9261 } 9262 9263 if (TREE_CODE (type) == ENUMERAL_TYPE) 9264 gen_enumeration_type_die (type, context_die); 9265 else 9266 gen_struct_or_union_type_die (type, context_die); 9267 9268 if (TYPE_CONTEXT (type) 9269 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type)) 9270 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type))) 9271 pop_decl_scope (); 9272 9273 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix 9274 it up if it is ever completed. gen_*_type_die will set it for us 9275 when appropriate. */ 9276 return; 9277 9278 case VOID_TYPE: 9279 case INTEGER_TYPE: 9280 case REAL_TYPE: 9281 case COMPLEX_TYPE: 9282 case BOOLEAN_TYPE: 9283 case CHAR_TYPE: 9284 /* No DIEs needed for fundamental types. */ 9285 break; 9286 9287 case LANG_TYPE: 9288 /* No Dwarf representation currently defined. */ 9289 break; 9290 9291 default: 9292 abort (); 9293 } 9294 9295 TREE_ASM_WRITTEN (type) = 1; 9296} 9297 9298/* Generate a DIE for a tagged type instantiation. */ 9299 9300static void 9301gen_tagged_type_instantiation_die (type, context_die) 9302 register tree type; 9303 register dw_die_ref context_die; 9304{ 9305 if (type == NULL_TREE || type == error_mark_node) 9306 return; 9307 9308 /* We are going to output a DIE to represent the unqualified version of 9309 this type (i.e. without any const or volatile qualifiers) so make sure 9310 that we have the main variant (i.e. the unqualified version) of this 9311 type now. */ 9312 if (type != type_main_variant (type) 9313 || !TREE_ASM_WRITTEN (type)) 9314 abort (); 9315 9316 switch (TREE_CODE (type)) 9317 { 9318 case ERROR_MARK: 9319 break; 9320 9321 case ENUMERAL_TYPE: 9322 gen_inlined_enumeration_type_die (type, context_die); 9323 break; 9324 9325 case RECORD_TYPE: 9326 gen_inlined_structure_type_die (type, context_die); 9327 break; 9328 9329 case UNION_TYPE: 9330 case QUAL_UNION_TYPE: 9331 gen_inlined_union_type_die (type, context_die); 9332 break; 9333 9334 default: 9335 abort (); 9336 } 9337} 9338 9339/* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the 9340 things which are local to the given block. */ 9341 9342static void 9343gen_block_die (stmt, context_die, depth) 9344 register tree stmt; 9345 register dw_die_ref context_die; 9346 int depth; 9347{ 9348 register int must_output_die = 0; 9349 register tree origin; 9350 register tree decl; 9351 register enum tree_code origin_code; 9352 9353 /* Ignore blocks never really used to make RTL. */ 9354 9355 if (stmt == NULL_TREE || !TREE_USED (stmt)) 9356 return; 9357 9358 /* Determine the "ultimate origin" of this block. This block may be an 9359 inlined instance of an inlined instance of inline function, so we have 9360 to trace all of the way back through the origin chain to find out what 9361 sort of node actually served as the original seed for the creation of 9362 the current block. */ 9363 origin = block_ultimate_origin (stmt); 9364 origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK; 9365 9366 /* Determine if we need to output any Dwarf DIEs at all to represent this 9367 block. */ 9368 if (origin_code == FUNCTION_DECL) 9369 /* The outer scopes for inlinings *must* always be represented. We 9370 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */ 9371 must_output_die = 1; 9372 else 9373 { 9374 /* In the case where the current block represents an inlining of the 9375 "body block" of an inline function, we must *NOT* output any DIE for 9376 this block because we have already output a DIE to represent the 9377 whole inlined function scope and the "body block" of any function 9378 doesn't really represent a different scope according to ANSI C 9379 rules. So we check here to make sure that this block does not 9380 represent a "body block inlining" before trying to set the 9381 `must_output_die' flag. */ 9382 if (! is_body_block (origin ? origin : stmt)) 9383 { 9384 /* Determine if this block directly contains any "significant" 9385 local declarations which we will need to output DIEs for. */ 9386 if (debug_info_level > DINFO_LEVEL_TERSE) 9387 /* We are not in terse mode so *any* local declaration counts 9388 as being a "significant" one. */ 9389 must_output_die = (BLOCK_VARS (stmt) != NULL); 9390 else 9391 /* We are in terse mode, so only local (nested) function 9392 definitions count as "significant" local declarations. */ 9393 for (decl = BLOCK_VARS (stmt); 9394 decl != NULL; decl = TREE_CHAIN (decl)) 9395 if (TREE_CODE (decl) == FUNCTION_DECL 9396 && DECL_INITIAL (decl)) 9397 { 9398 must_output_die = 1; 9399 break; 9400 } 9401 } 9402 } 9403 9404 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block 9405 DIE for any block which contains no significant local declarations at 9406 all. Rather, in such cases we just call `decls_for_scope' so that any 9407 needed Dwarf info for any sub-blocks will get properly generated. Note 9408 that in terse mode, our definition of what constitutes a "significant" 9409 local declaration gets restricted to include only inlined function 9410 instances and local (nested) function definitions. */ 9411 if (must_output_die) 9412 { 9413 if (origin_code == FUNCTION_DECL) 9414 gen_inlined_subroutine_die (stmt, context_die, depth); 9415 else 9416 gen_lexical_block_die (stmt, context_die, depth); 9417 } 9418 else 9419 decls_for_scope (stmt, context_die, depth); 9420} 9421 9422/* Generate all of the decls declared within a given scope and (recursively) 9423 all of its sub-blocks. */ 9424 9425static void 9426decls_for_scope (stmt, context_die, depth) 9427 register tree stmt; 9428 register dw_die_ref context_die; 9429 int depth; 9430{ 9431 register tree decl; 9432 register tree subblocks; 9433 9434 /* Ignore blocks never really used to make RTL. */ 9435 if (stmt == NULL_TREE || ! TREE_USED (stmt)) 9436 return; 9437 9438 if (!BLOCK_ABSTRACT (stmt) && depth > 0) 9439 next_block_number++; 9440 9441 /* Output the DIEs to represent all of the data objects and typedefs 9442 declared directly within this block but not within any nested 9443 sub-blocks. Also, nested function and tag DIEs have been 9444 generated with a parent of NULL; fix that up now. */ 9445 for (decl = BLOCK_VARS (stmt); 9446 decl != NULL; decl = TREE_CHAIN (decl)) 9447 { 9448 register dw_die_ref die; 9449 9450 if (TREE_CODE (decl) == FUNCTION_DECL) 9451 die = lookup_decl_die (decl); 9452 else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)) 9453 die = lookup_type_die (TREE_TYPE (decl)); 9454 else 9455 die = NULL; 9456 9457 if (die != NULL && die->die_parent == NULL) 9458 add_child_die (context_die, die); 9459 else 9460 gen_decl_die (decl, context_die); 9461 } 9462 9463 /* Output the DIEs to represent all sub-blocks (and the items declared 9464 therein) of this block. */ 9465 for (subblocks = BLOCK_SUBBLOCKS (stmt); 9466 subblocks != NULL; 9467 subblocks = BLOCK_CHAIN (subblocks)) 9468 gen_block_die (subblocks, context_die, depth + 1); 9469} 9470 9471/* Is this a typedef we can avoid emitting? */ 9472 9473static inline int 9474is_redundant_typedef (decl) 9475 register tree decl; 9476{ 9477 if (TYPE_DECL_IS_STUB (decl)) 9478 return 1; 9479 9480 if (DECL_ARTIFICIAL (decl) 9481 && DECL_CONTEXT (decl) 9482 && is_tagged_type (DECL_CONTEXT (decl)) 9483 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL 9484 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))) 9485 /* Also ignore the artificial member typedef for the class name. */ 9486 return 1; 9487 9488 return 0; 9489} 9490 9491/* Generate Dwarf debug information for a decl described by DECL. */ 9492 9493static void 9494gen_decl_die (decl, context_die) 9495 register tree decl; 9496 register dw_die_ref context_die; 9497{ 9498 register tree origin; 9499 9500 /* Make a note of the decl node we are going to be working on. We may need 9501 to give the user the source coordinates of where it appeared in case we 9502 notice (later on) that something about it looks screwy. */ 9503 dwarf_last_decl = decl; 9504 9505 if (TREE_CODE (decl) == ERROR_MARK) 9506 return; 9507 9508 /* If this ..._DECL node is marked to be ignored, then ignore it. But don't 9509 ignore a function definition, since that would screw up our count of 9510 blocks, and that in turn will completely screw up the labels we will 9511 reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for 9512 subsequent blocks). */ 9513 if (DECL_IGNORED_P (decl) && TREE_CODE (decl) != FUNCTION_DECL) 9514 return; 9515 9516 switch (TREE_CODE (decl)) 9517 { 9518 case CONST_DECL: 9519 /* The individual enumerators of an enum type get output when we output 9520 the Dwarf representation of the relevant enum type itself. */ 9521 break; 9522 9523 case FUNCTION_DECL: 9524 /* Don't output any DIEs to represent mere function declarations, 9525 unless they are class members or explicit block externs. */ 9526 if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE 9527 && (current_function_decl == NULL_TREE || ! DECL_ARTIFICIAL (decl))) 9528 break; 9529 9530 if (debug_info_level > DINFO_LEVEL_TERSE) 9531 { 9532 /* Before we describe the FUNCTION_DECL itself, make sure that we 9533 have described its return type. */ 9534 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die); 9535 9536 /* And its containing type. */ 9537 origin = decl_class_context (decl); 9538 if (origin != NULL_TREE) 9539 gen_type_die (origin, context_die); 9540 9541 /* And its virtual context. */ 9542 if (DECL_VINDEX (decl) != NULL_TREE) 9543 gen_type_die (DECL_CONTEXT (decl), context_die); 9544 } 9545 9546 /* Now output a DIE to represent the function itself. */ 9547 gen_subprogram_die (decl, context_die); 9548 break; 9549 9550 case TYPE_DECL: 9551 /* If we are in terse mode, don't generate any DIEs to represent any 9552 actual typedefs. */ 9553 if (debug_info_level <= DINFO_LEVEL_TERSE) 9554 break; 9555 9556 /* In the special case of a TYPE_DECL node representing the 9557 declaration of some type tag, if the given TYPE_DECL is marked as 9558 having been instantiated from some other (original) TYPE_DECL node 9559 (e.g. one which was generated within the original definition of an 9560 inline function) we have to generate a special (abbreviated) 9561 DW_TAG_structure_type, DW_TAG_union_type, or DW_TAG_enumeration_type 9562 DIE here. */ 9563 if (TYPE_DECL_IS_STUB (decl) && DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE) 9564 { 9565 gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die); 9566 break; 9567 } 9568 9569 if (is_redundant_typedef (decl)) 9570 gen_type_die (TREE_TYPE (decl), context_die); 9571 else 9572 /* Output a DIE to represent the typedef itself. */ 9573 gen_typedef_die (decl, context_die); 9574 break; 9575 9576 case LABEL_DECL: 9577 if (debug_info_level >= DINFO_LEVEL_NORMAL) 9578 gen_label_die (decl, context_die); 9579 break; 9580 9581 case VAR_DECL: 9582 /* If we are in terse mode, don't generate any DIEs to represent any 9583 variable declarations or definitions. */ 9584 if (debug_info_level <= DINFO_LEVEL_TERSE) 9585 break; 9586 9587 /* Output any DIEs that are needed to specify the type of this data 9588 object. */ 9589 gen_type_die (TREE_TYPE (decl), context_die); 9590 9591 /* And its containing type. */ 9592 origin = decl_class_context (decl); 9593 if (origin != NULL_TREE) 9594 gen_type_die (origin, context_die); 9595 9596 /* Now output the DIE to represent the data object itself. This gets 9597 complicated because of the possibility that the VAR_DECL really 9598 represents an inlined instance of a formal parameter for an inline 9599 function. */ 9600 origin = decl_ultimate_origin (decl); 9601 if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL) 9602 gen_formal_parameter_die (decl, context_die); 9603 else 9604 gen_variable_die (decl, context_die); 9605 break; 9606 9607 case FIELD_DECL: 9608 /* Ignore the nameless fields that are used to skip bits, but 9609 handle C++ anonymous unions. */ 9610 if (DECL_NAME (decl) != NULL_TREE 9611 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE) 9612 { 9613 gen_type_die (member_declared_type (decl), context_die); 9614 gen_field_die (decl, context_die); 9615 } 9616 break; 9617 9618 case PARM_DECL: 9619 gen_type_die (TREE_TYPE (decl), context_die); 9620 gen_formal_parameter_die (decl, context_die); 9621 break; 9622 9623 default: 9624 abort (); 9625 } 9626} 9627 9628/* Write the debugging output for DECL. */ 9629 9630void 9631dwarf2out_decl (decl) 9632 register tree decl; 9633{ 9634 register dw_die_ref context_die = comp_unit_die; 9635 9636 if (TREE_CODE (decl) == ERROR_MARK) 9637 return; 9638 9639 /* If this ..._DECL node is marked to be ignored, then ignore it. We gotta 9640 hope that the node in question doesn't represent a function definition. 9641 If it does, then totally ignoring it is bound to screw up our count of 9642 blocks, and that in turn will completely screw up the labels we will 9643 reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for 9644 subsequent blocks). (It's too bad that BLOCK nodes don't carry their 9645 own sequence numbers with them!) */ 9646 if (DECL_IGNORED_P (decl)) 9647 { 9648 if (TREE_CODE (decl) == FUNCTION_DECL 9649 && DECL_INITIAL (decl) != NULL) 9650 abort (); 9651 9652 return; 9653 } 9654 9655 switch (TREE_CODE (decl)) 9656 { 9657 case FUNCTION_DECL: 9658 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration of a 9659 builtin function. Explicit programmer-supplied declarations of 9660 these same functions should NOT be ignored however. */ 9661 if (DECL_EXTERNAL (decl) && DECL_FUNCTION_CODE (decl)) 9662 return; 9663 9664 /* What we would really like to do here is to filter out all mere 9665 file-scope declarations of file-scope functions which are never 9666 referenced later within this translation unit (and keep all of ones 9667 that *are* referenced later on) but we aren't clairvoyant, so we have 9668 no idea which functions will be referenced in the future (i.e. later 9669 on within the current translation unit). So here we just ignore all 9670 file-scope function declarations which are not also definitions. If 9671 and when the debugger needs to know something about these functions, 9672 it wil have to hunt around and find the DWARF information associated 9673 with the definition of the function. Note that we can't just check 9674 `DECL_EXTERNAL' to find out which FUNCTION_DECL nodes represent 9675 definitions and which ones represent mere declarations. We have to 9676 check `DECL_INITIAL' instead. That's because the C front-end 9677 supports some weird semantics for "extern inline" function 9678 definitions. These can get inlined within the current translation 9679 unit (an thus, we need to generate DWARF info for their abstract 9680 instances so that the DWARF info for the concrete inlined instances 9681 can have something to refer to) but the compiler never generates any 9682 out-of-lines instances of such things (despite the fact that they 9683 *are* definitions). The important point is that the C front-end 9684 marks these "extern inline" functions as DECL_EXTERNAL, but we need 9685 to generate DWARF for them anyway. Note that the C++ front-end also 9686 plays some similar games for inline function definitions appearing 9687 within include files which also contain 9688 `#pragma interface' pragmas. */ 9689 if (DECL_INITIAL (decl) == NULL_TREE) 9690 return; 9691 9692 /* If we're a nested function, initially use a parent of NULL; if we're 9693 a plain function, this will be fixed up in decls_for_scope. If 9694 we're a method, it will be ignored, since we already have a DIE. */ 9695 if (decl_function_context (decl)) 9696 context_die = NULL; 9697 9698 break; 9699 9700 case VAR_DECL: 9701 /* Ignore this VAR_DECL if it refers to a file-scope extern data object 9702 declaration and if the declaration was never even referenced from 9703 within this entire compilation unit. We suppress these DIEs in 9704 order to save space in the .debug section (by eliminating entries 9705 which are probably useless). Note that we must not suppress 9706 block-local extern declarations (whether used or not) because that 9707 would screw-up the debugger's name lookup mechanism and cause it to 9708 miss things which really ought to be in scope at a given point. */ 9709 if (DECL_EXTERNAL (decl) && !TREE_USED (decl)) 9710 return; 9711 9712 /* If we are in terse mode, don't generate any DIEs to represent any 9713 variable declarations or definitions. */ 9714 if (debug_info_level <= DINFO_LEVEL_TERSE) 9715 return; 9716 break; 9717 9718 case TYPE_DECL: 9719 /* Don't bother trying to generate any DIEs to represent any of the 9720 normal built-in types for the language we are compiling. */ 9721 if (DECL_SOURCE_LINE (decl) == 0) 9722 { 9723 /* OK, we need to generate one for `bool' so GDB knows what type 9724 comparisons have. */ 9725 if ((get_AT_unsigned (comp_unit_die, DW_AT_language) 9726 == DW_LANG_C_plus_plus) 9727 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE) 9728 modified_type_die (TREE_TYPE (decl), 0, 0, NULL); 9729 9730 return; 9731 } 9732 9733 /* If we are in terse mode, don't generate any DIEs for types. */ 9734 if (debug_info_level <= DINFO_LEVEL_TERSE) 9735 return; 9736 9737 /* If we're a function-scope tag, initially use a parent of NULL; 9738 this will be fixed up in decls_for_scope. */ 9739 if (decl_function_context (decl)) 9740 context_die = NULL; 9741 9742 break; 9743 9744 default: 9745 return; 9746 } 9747 9748 gen_decl_die (decl, context_die); 9749 output_pending_types_for_scope (comp_unit_die); 9750} 9751 9752/* Output a marker (i.e. a label) for the beginning of the generated code for 9753 a lexical block. */ 9754 9755void 9756dwarf2out_begin_block (blocknum) 9757 register unsigned blocknum; 9758{ 9759 function_section (current_function_decl); 9760 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum); 9761} 9762 9763/* Output a marker (i.e. a label) for the end of the generated code for a 9764 lexical block. */ 9765 9766void 9767dwarf2out_end_block (blocknum) 9768 register unsigned blocknum; 9769{ 9770 function_section (current_function_decl); 9771 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum); 9772} 9773 9774/* Output a marker (i.e. a label) at a point in the assembly code which 9775 corresponds to a given source level label. */ 9776 9777void 9778dwarf2out_label (insn) 9779 register rtx insn; 9780{ 9781 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 9782 9783 if (debug_info_level >= DINFO_LEVEL_NORMAL) 9784 { 9785 function_section (current_function_decl); 9786 sprintf (label, INSN_LABEL_FMT, current_funcdef_number); 9787 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, label, 9788 (unsigned) INSN_UID (insn)); 9789 } 9790} 9791 9792/* Lookup a filename (in the list of filenames that we know about here in 9793 dwarf2out.c) and return its "index". The index of each (known) filename is 9794 just a unique number which is associated with only that one filename. 9795 We need such numbers for the sake of generating labels 9796 (in the .debug_sfnames section) and references to those 9797 files numbers (in the .debug_srcinfo and.debug_macinfo sections). 9798 If the filename given as an argument is not found in our current list, 9799 add it to the list and assign it the next available unique index number. 9800 In order to speed up searches, we remember the index of the filename 9801 was looked up last. This handles the majority of all searches. */ 9802 9803static unsigned 9804lookup_filename (file_name) 9805 char *file_name; 9806{ 9807 static unsigned last_file_lookup_index = 0; 9808 register unsigned i; 9809 9810 /* Check to see if the file name that was searched on the previous call 9811 matches this file name. If so, return the index. */ 9812 if (last_file_lookup_index != 0) 9813 if (strcmp (file_name, file_table[last_file_lookup_index]) == 0) 9814 return last_file_lookup_index; 9815 9816 /* Didn't match the previous lookup, search the table */ 9817 for (i = 1; i < file_table_in_use; ++i) 9818 if (strcmp (file_name, file_table[i]) == 0) 9819 { 9820 last_file_lookup_index = i; 9821 return i; 9822 } 9823 9824 /* Prepare to add a new table entry by making sure there is enough space in 9825 the table to do so. If not, expand the current table. */ 9826 if (file_table_in_use == file_table_allocated) 9827 { 9828 file_table_allocated += FILE_TABLE_INCREMENT; 9829 file_table 9830 = (char **) xrealloc (file_table, 9831 file_table_allocated * sizeof (char *)); 9832 } 9833 9834 /* Add the new entry to the end of the filename table. */ 9835 file_table[file_table_in_use] = xstrdup (file_name); 9836 last_file_lookup_index = file_table_in_use++; 9837 9838 return last_file_lookup_index; 9839} 9840 9841/* Output a label to mark the beginning of a source code line entry 9842 and record information relating to this source line, in 9843 'line_info_table' for later output of the .debug_line section. */ 9844 9845void 9846dwarf2out_line (filename, line) 9847 register char *filename; 9848 register unsigned line; 9849{ 9850 if (debug_info_level >= DINFO_LEVEL_NORMAL) 9851 { 9852 function_section (current_function_decl); 9853 9854 if (DECL_SECTION_NAME (current_function_decl)) 9855 { 9856 register dw_separate_line_info_ref line_info; 9857 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, SEPARATE_LINE_CODE_LABEL, 9858 separate_line_info_table_in_use); 9859 fputc ('\n', asm_out_file); 9860 9861 /* expand the line info table if necessary */ 9862 if (separate_line_info_table_in_use 9863 == separate_line_info_table_allocated) 9864 { 9865 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT; 9866 separate_line_info_table 9867 = (dw_separate_line_info_ref) 9868 xrealloc (separate_line_info_table, 9869 separate_line_info_table_allocated 9870 * sizeof (dw_separate_line_info_entry)); 9871 } 9872 9873 /* Add the new entry at the end of the line_info_table. */ 9874 line_info 9875 = &separate_line_info_table[separate_line_info_table_in_use++]; 9876 line_info->dw_file_num = lookup_filename (filename); 9877 line_info->dw_line_num = line; 9878 line_info->function = current_funcdef_number; 9879 } 9880 else 9881 { 9882 register dw_line_info_ref line_info; 9883 9884 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, LINE_CODE_LABEL, 9885 line_info_table_in_use); 9886 fputc ('\n', asm_out_file); 9887 9888 /* Expand the line info table if necessary. */ 9889 if (line_info_table_in_use == line_info_table_allocated) 9890 { 9891 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT; 9892 line_info_table 9893 = (dw_line_info_ref) 9894 xrealloc (line_info_table, 9895 (line_info_table_allocated 9896 * sizeof (dw_line_info_entry))); 9897 } 9898 9899 /* Add the new entry at the end of the line_info_table. */ 9900 line_info = &line_info_table[line_info_table_in_use++]; 9901 line_info->dw_file_num = lookup_filename (filename); 9902 line_info->dw_line_num = line; 9903 } 9904 } 9905} 9906 9907/* Record the beginning of a new source file, for later output 9908 of the .debug_macinfo section. At present, unimplemented. */ 9909 9910void 9911dwarf2out_start_source_file (filename) 9912 register char *filename ATTRIBUTE_UNUSED; 9913{ 9914} 9915 9916/* Record the end of a source file, for later output 9917 of the .debug_macinfo section. At present, unimplemented. */ 9918 9919void 9920dwarf2out_end_source_file () 9921{ 9922} 9923 9924/* Called from check_newline in c-parse.y. The `buffer' parameter contains 9925 the tail part of the directive line, i.e. the part which is past the 9926 initial whitespace, #, whitespace, directive-name, whitespace part. */ 9927 9928void 9929dwarf2out_define (lineno, buffer) 9930 register unsigned lineno; 9931 register char *buffer; 9932{ 9933 static int initialized = 0; 9934 if (!initialized) 9935 { 9936 dwarf2out_start_source_file (primary_filename); 9937 initialized = 1; 9938 } 9939} 9940 9941/* Called from check_newline in c-parse.y. The `buffer' parameter contains 9942 the tail part of the directive line, i.e. the part which is past the 9943 initial whitespace, #, whitespace, directive-name, whitespace part. */ 9944 9945void 9946dwarf2out_undef (lineno, buffer) 9947 register unsigned lineno ATTRIBUTE_UNUSED; 9948 register char *buffer ATTRIBUTE_UNUSED; 9949{ 9950} 9951 9952/* Set up for Dwarf output at the start of compilation. */ 9953 9954void 9955dwarf2out_init (asm_out_file, main_input_filename) 9956 register FILE *asm_out_file; 9957 register char *main_input_filename; 9958{ 9959 /* Remember the name of the primary input file. */ 9960 primary_filename = main_input_filename; 9961 9962 /* Allocate the initial hunk of the file_table. */ 9963 file_table = (char **) xmalloc (FILE_TABLE_INCREMENT * sizeof (char *)); 9964 bzero ((char *) file_table, FILE_TABLE_INCREMENT * sizeof (char *)); 9965 file_table_allocated = FILE_TABLE_INCREMENT; 9966 9967 /* Skip the first entry - file numbers begin at 1. */ 9968 file_table_in_use = 1; 9969 9970 /* Allocate the initial hunk of the decl_die_table. */ 9971 decl_die_table 9972 = (dw_die_ref *) xmalloc (DECL_DIE_TABLE_INCREMENT * sizeof (dw_die_ref)); 9973 bzero ((char *) decl_die_table, 9974 DECL_DIE_TABLE_INCREMENT * sizeof (dw_die_ref)); 9975 decl_die_table_allocated = DECL_DIE_TABLE_INCREMENT; 9976 decl_die_table_in_use = 0; 9977 9978 /* Allocate the initial hunk of the decl_scope_table. */ 9979 decl_scope_table 9980 = (decl_scope_node *) xmalloc (DECL_SCOPE_TABLE_INCREMENT 9981 * sizeof (decl_scope_node)); 9982 bzero ((char *) decl_scope_table, 9983 DECL_SCOPE_TABLE_INCREMENT * sizeof (decl_scope_node)); 9984 decl_scope_table_allocated = DECL_SCOPE_TABLE_INCREMENT; 9985 decl_scope_depth = 0; 9986 9987 /* Allocate the initial hunk of the abbrev_die_table. */ 9988 abbrev_die_table 9989 = (dw_die_ref *) xmalloc (ABBREV_DIE_TABLE_INCREMENT 9990 * sizeof (dw_die_ref)); 9991 bzero ((char *) abbrev_die_table, 9992 ABBREV_DIE_TABLE_INCREMENT * sizeof (dw_die_ref)); 9993 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT; 9994 /* Zero-th entry is allocated, but unused */ 9995 abbrev_die_table_in_use = 1; 9996 9997 /* Allocate the initial hunk of the line_info_table. */ 9998 line_info_table 9999 = (dw_line_info_ref) xmalloc (LINE_INFO_TABLE_INCREMENT 10000 * sizeof (dw_line_info_entry)); 10001 bzero ((char *) line_info_table, 10002 LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry)); 10003 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT; 10004 /* Zero-th entry is allocated, but unused */ 10005 line_info_table_in_use = 1; 10006 10007 /* Generate the initial DIE for the .debug section. Note that the (string) 10008 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE 10009 will (typically) be a relative pathname and that this pathname should be 10010 taken as being relative to the directory from which the compiler was 10011 invoked when the given (base) source file was compiled. */ 10012 gen_compile_unit_die (main_input_filename); 10013 10014 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0); 10015 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label, ABBREV_SECTION_LABEL, 0); 10016 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0); 10017 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label, 10018 DEBUG_INFO_SECTION_LABEL, 0); 10019 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label, 10020 DEBUG_LINE_SECTION_LABEL, 0); 10021 10022 ASM_OUTPUT_SECTION (asm_out_file, ABBREV_SECTION); 10023 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label); 10024 ASM_OUTPUT_SECTION (asm_out_file, TEXT_SECTION); 10025 ASM_OUTPUT_LABEL (asm_out_file, text_section_label); 10026 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_INFO_SECTION); 10027 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label); 10028 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_LINE_SECTION); 10029 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label); 10030} 10031 10032/* Output stuff that dwarf requires at the end of every file, 10033 and generate the DWARF-2 debugging info. */ 10034 10035void 10036dwarf2out_finish () 10037{ 10038 limbo_die_node *node, *next_node; 10039 dw_die_ref die; 10040 dw_attr_ref a; 10041 10042 /* Traverse the limbo die list, and add parent/child links. The only 10043 dies without parents that should be here are concrete instances of 10044 inline functions, and the comp_unit_die. We can ignore the comp_unit_die. 10045 For concrete instances, we can get the parent die from the abstract 10046 instance. */ 10047 for (node = limbo_die_list; node; node = next_node) 10048 { 10049 next_node = node->next; 10050 die = node->die; 10051 10052 if (die->die_parent == NULL) 10053 { 10054 a = get_AT (die, DW_AT_abstract_origin); 10055 if (a) 10056 add_child_die (a->dw_attr_val.v.val_die_ref->die_parent, die); 10057 else if (die == comp_unit_die) 10058 ; 10059 else 10060 abort (); 10061 } 10062 free (node); 10063 } 10064 10065 /* Walk through the list of incomplete types again, trying once more to 10066 emit full debugging info for them. */ 10067 retry_incomplete_types (); 10068 10069 /* Traverse the DIE tree and add sibling attributes to those DIE's 10070 that have children. */ 10071 add_sibling_attributes (comp_unit_die); 10072 10073 /* Output a terminator label for the .text section. */ 10074 fputc ('\n', asm_out_file); 10075 ASM_OUTPUT_SECTION (asm_out_file, TEXT_SECTION); 10076 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, TEXT_END_LABEL, 0); 10077 10078#if 0 10079 /* Output a terminator label for the .data section. */ 10080 fputc ('\n', asm_out_file); 10081 ASM_OUTPUT_SECTION (asm_out_file, DATA_SECTION); 10082 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, DATA_END_LABEL, 0); 10083 10084 /* Output a terminator label for the .bss section. */ 10085 fputc ('\n', asm_out_file); 10086 ASM_OUTPUT_SECTION (asm_out_file, BSS_SECTION); 10087 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BSS_END_LABEL, 0); 10088#endif 10089 10090 /* Output the source line correspondence table. */ 10091 if (line_info_table_in_use > 1 || separate_line_info_table_in_use) 10092 { 10093 fputc ('\n', asm_out_file); 10094 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_LINE_SECTION); 10095 output_line_info (); 10096 10097 /* We can only use the low/high_pc attributes if all of the code 10098 was in .text. */ 10099 if (separate_line_info_table_in_use == 0) 10100 { 10101 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label); 10102 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label); 10103 } 10104 10105 add_AT_lbl_offset (comp_unit_die, DW_AT_stmt_list, 10106 debug_line_section_label); 10107 } 10108 10109 /* Output the abbreviation table. */ 10110 fputc ('\n', asm_out_file); 10111 ASM_OUTPUT_SECTION (asm_out_file, ABBREV_SECTION); 10112 build_abbrev_table (comp_unit_die); 10113 output_abbrev_section (); 10114 10115 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */ 10116 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE; 10117 calc_die_sizes (comp_unit_die); 10118 10119 /* Output debugging information. */ 10120 fputc ('\n', asm_out_file); 10121 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_INFO_SECTION); 10122 output_compilation_unit_header (); 10123 output_die (comp_unit_die); 10124 10125 if (pubname_table_in_use) 10126 { 10127 /* Output public names table. */ 10128 fputc ('\n', asm_out_file); 10129 ASM_OUTPUT_SECTION (asm_out_file, PUBNAMES_SECTION); 10130 output_pubnames (); 10131 } 10132 10133 if (fde_table_in_use) 10134 { 10135 /* Output the address range information. */ 10136 fputc ('\n', asm_out_file); 10137 ASM_OUTPUT_SECTION (asm_out_file, ARANGES_SECTION); 10138 output_aranges (); 10139 } 10140} 10141#endif /* DWARF2_DEBUGGING_INFO */ 10142