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