dwarf2out.c revision 220150
150476Speter/* Output Dwarf2 format symbol table information from GCC. 23455Sache Copyright (C) 1992, 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 350624Speter 2003, 2004, 2005, 2006 Free Software Foundation, Inc. 43410Sache Contributed by Gary Funck (gary@intrepid.com). 550624Speter Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com). 650624Speter Extensively modified by Jason Merrill (jason@cygnus.com). 750624Speter 83410SacheThis file is part of GCC. 950624Speter 1050624SpeterGCC is free software; you can redistribute it and/or modify it under 1150624Speterthe terms of the GNU General Public License as published by the Free 123523SacheSoftware Foundation; either version 2, or (at your option) any later 1350624Speterversion. 1450624Speter 1550624SpeterGCC is distributed in the hope that it will be useful, but WITHOUT ANY 163410SacheWARRANTY; without even the implied warranty of MERCHANTABILITY or 1750624SpeterFITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 1850624Speterfor more details. 1950624Speter 2050624SpeterYou should have received a copy of the GNU General Public License 2150624Speteralong with GCC; see the file COPYING. If not, write to the Free 2250624SpeterSoftware Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 2350624Speter02110-1301, USA. */ 2450624Speter 2550624Speter/* TODO: Emit .debug_line header even when there are no functions, since 2650624Speter the file numbers are used by .debug_info. Alternately, leave 2750624Speter out locations for types and decls. 2850624Speter Avoid talking about ctors and op= for PODs. 293410Sache Factor out common prologue sequences into multiple CIEs. */ 3050624Speter 3150624Speter/* The first part of this file deals with the DWARF 2 frame unwind 3250624Speter information, which is also used by the GCC efficient exception handling 3350624Speter mechanism. The second part, controlled only by an #ifdef 3450624Speter DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging 3550624Speter information. */ 3650624Speter 373410Sache#include "config.h" 3850624Speter#include "system.h" 3950624Speter#include "coretypes.h" 403410Sache#include "tm.h" 4150624Speter#include "tree.h" 4250624Speter#include "version.h" 4350624Speter#include "flags.h" 4450624Speter#include "real.h" 4550624Speter#include "rtl.h" 4650624Speter#include "hard-reg-set.h" 4750624Speter#include "regs.h" 4850624Speter#include "insn-config.h" 493410Sache#include "reload.h" 5050624Speter#include "function.h" 5150624Speter#include "output.h" 5250624Speter#include "expr.h" 5350624Speter#include "libfuncs.h" 5450624Speter#include "except.h" 5550624Speter#include "dwarf2.h" 5650624Speter#include "dwarf2out.h" 5750624Speter#include "dwarf2asm.h" 5850624Speter#include "toplev.h" 5950624Speter#include "varray.h" 6050624Speter#include "ggc.h" 6150624Speter#include "md5.h" 6250624Speter#include "tm_p.h" 6350624Speter#include "diagnostic.h" 6450624Speter#include "debug.h" 6550624Speter#include "target.h" 6650624Speter#include "langhooks.h" 6750624Speter#include "hashtab.h" 6850624Speter#include "cgraph.h" 6950624Speter#include "input.h" 7050624Speter 7150624Speter#ifdef DWARF2_DEBUGGING_INFO 7250624Speterstatic void dwarf2out_source_line (unsigned int, const char *); 7350624Speter#endif 7450624Speter 7550624Speter/* DWARF2 Abbreviation Glossary: 7650624Speter CFA = Canonical Frame Address 7750624Speter a fixed address on the stack which identifies a call frame. 7850624Speter We define it to be the value of SP just before the call insn. 7950624Speter The CFA register and offset, which may change during the course 8050624Speter of the function, are used to calculate its value at runtime. 8150624Speter CFI = Call Frame Instruction 8250624Speter an instruction for the DWARF2 abstract machine 8350624Speter CIE = Common Information Entry 8450624Speter information describing information common to one or more FDEs 8550624Speter DIE = Debugging Information Entry 8650624Speter FDE = Frame Description Entry 8750624Speter information describing the stack call frame, in particular, 8850624Speter how to restore registers 8950624Speter 9050624Speter DW_CFA_... = DWARF2 CFA call frame instruction 9150624Speter DW_TAG_... = DWARF2 DIE tag */ 9250624Speter 9350624Speter#ifndef DWARF2_FRAME_INFO 9450624Speter# ifdef DWARF2_DEBUGGING_INFO 9550624Speter# define DWARF2_FRAME_INFO \ 9650624Speter (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG) 9750624Speter# else 9850624Speter# define DWARF2_FRAME_INFO 0 9950624Speter# endif 10050624Speter#endif 10150624Speter 10250624Speter/* Map register numbers held in the call frame info that gcc has 10350624Speter collected using DWARF_FRAME_REGNUM to those that should be output in 10450624Speter .debug_frame and .eh_frame. */ 10550624Speter#ifndef DWARF2_FRAME_REG_OUT 10650624Speter#define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO) 10750624Speter#endif 10850624Speter 10950624Speter/* Decide whether we want to emit frame unwind information for the current 11050624Speter translation unit. */ 11150624Speter 11250624Speterint 11350624Speterdwarf2out_do_frame (void) 11450624Speter{ 11550624Speter /* We want to emit correct CFA location expressions or lists, so we 11650624Speter have to return true if we're going to output debug info, even if 11750624Speter we're not going to output frame or unwind info. */ 11850624Speter return (write_symbols == DWARF2_DEBUG 11950624Speter || write_symbols == VMS_AND_DWARF2_DEBUG 12050624Speter || DWARF2_FRAME_INFO 12150624Speter#ifdef DWARF2_UNWIND_INFO 12250624Speter || (DWARF2_UNWIND_INFO 12350624Speter && (flag_unwind_tables 12450624Speter || (flag_exceptions && ! USING_SJLJ_EXCEPTIONS))) 12550624Speter#endif 12650624Speter ); 12750624Speter} 12850624Speter 12950624Speter/* The size of the target's pointer type. */ 13050624Speter#ifndef PTR_SIZE 13150624Speter#define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT) 13250624Speter#endif 13350624Speter 13450624Speter/* Array of RTXes referenced by the debugging information, which therefore 13550624Speter must be kept around forever. */ 13650624Speterstatic GTY(()) VEC(rtx,gc) *used_rtx_array; 13750624Speter 13850624Speter/* A pointer to the base of a list of incomplete types which might be 13950624Speter completed at some later time. incomplete_types_list needs to be a 14050624Speter VEC(tree,gc) because we want to tell the garbage collector about 14150624Speter it. */ 14250624Speterstatic GTY(()) VEC(tree,gc) *incomplete_types; 14350624Speter 14450624Speter/* A pointer to the base of a table of references to declaration 14550624Speter scopes. This table is a display which tracks the nesting 14650624Speter of declaration scopes at the current scope and containing 14750624Speter scopes. This table is used to find the proper place to 14850624Speter define type declaration DIE's. */ 14950624Speterstatic GTY(()) VEC(tree,gc) *decl_scope_table; 15050624Speter 15150624Speter/* Pointers to various DWARF2 sections. */ 15250624Speterstatic GTY(()) section *debug_info_section; 15350624Speterstatic GTY(()) section *debug_abbrev_section; 15450624Speterstatic GTY(()) section *debug_aranges_section; 15550624Speterstatic GTY(()) section *debug_macinfo_section; 15650624Speterstatic GTY(()) section *debug_line_section; 15750624Speterstatic GTY(()) section *debug_loc_section; 15850624Speterstatic GTY(()) section *debug_pubnames_section; 15950624Speterstatic GTY(()) section *debug_str_section; 16050624Speterstatic GTY(()) section *debug_ranges_section; 16150624Speterstatic GTY(()) section *debug_frame_section; 16250624Speter 16350624Speter/* How to start an assembler comment. */ 16450624Speter#ifndef ASM_COMMENT_START 16550624Speter#define ASM_COMMENT_START ";#" 16650624Speter#endif 16750624Speter 16850624Spetertypedef struct dw_cfi_struct *dw_cfi_ref; 16950624Spetertypedef struct dw_fde_struct *dw_fde_ref; 17050624Spetertypedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref; 17150624Speter 17250624Speter/* Call frames are described using a sequence of Call Frame 17350624Speter Information instructions. The register number, offset 17450624Speter and address fields are provided as possible operands; 17550624Speter their use is selected by the opcode field. */ 17650624Speter 17750624Speterenum dw_cfi_oprnd_type { 17850624Speter dw_cfi_oprnd_unused, 17950624Speter dw_cfi_oprnd_reg_num, 18050624Speter dw_cfi_oprnd_offset, 18150624Speter dw_cfi_oprnd_addr, 18250624Speter dw_cfi_oprnd_loc 18350624Speter}; 18450624Speter 18550624Spetertypedef union dw_cfi_oprnd_struct GTY(()) 18650624Speter{ 18750624Speter unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num; 18850624Speter HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset; 18950624Speter const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr; 19050624Speter struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc; 19150624Speter} 19250624Speterdw_cfi_oprnd; 19350624Speter 19450624Spetertypedef struct dw_cfi_struct GTY(()) 19550624Speter{ 19650624Speter dw_cfi_ref dw_cfi_next; 19750624Speter enum dwarf_call_frame_info dw_cfi_opc; 19850624Speter dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)"))) 19950624Speter dw_cfi_oprnd1; 20050624Speter dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)"))) 20150624Speter dw_cfi_oprnd2; 20250624Speter} 20350624Speterdw_cfi_node; 20450624Speter 20550624Speter/* This is how we define the location of the CFA. We use to handle it 20650624Speter as REG + OFFSET all the time, but now it can be more complex. 20750624Speter It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET. 20850624Speter Instead of passing around REG and OFFSET, we pass a copy 20950624Speter of this structure. */ 21050624Spetertypedef struct cfa_loc GTY(()) 21150624Speter{ 21250624Speter HOST_WIDE_INT offset; 21350624Speter HOST_WIDE_INT base_offset; 21450624Speter unsigned int reg; 21550624Speter int indirect; /* 1 if CFA is accessed via a dereference. */ 21650624Speter} dw_cfa_location; 21750624Speter 21850624Speter/* All call frame descriptions (FDE's) in the GCC generated DWARF 21950624Speter refer to a single Common Information Entry (CIE), defined at 22050624Speter the beginning of the .debug_frame section. This use of a single 22150624Speter CIE obviates the need to keep track of multiple CIE's 22250624Speter in the DWARF generation routines below. */ 22350624Speter 22450624Spetertypedef struct dw_fde_struct GTY(()) 22550624Speter{ 22650624Speter tree decl; 22750624Speter const char *dw_fde_begin; 22850624Speter const char *dw_fde_current_label; 22950624Speter const char *dw_fde_end; 23050624Speter const char *dw_fde_hot_section_label; 23150624Speter const char *dw_fde_hot_section_end_label; 23250624Speter const char *dw_fde_unlikely_section_label; 23350624Speter const char *dw_fde_unlikely_section_end_label; 23450624Speter bool dw_fde_switched_sections; 23550624Speter dw_cfi_ref dw_fde_cfi; 23650624Speter unsigned funcdef_number; 23750624Speter unsigned all_throwers_are_sibcalls : 1; 23850624Speter unsigned nothrow : 1; 23950624Speter unsigned uses_eh_lsda : 1; 24050624Speter} 24150624Speterdw_fde_node; 24250624Speter 24350624Speter/* Maximum size (in bytes) of an artificially generated label. */ 24450624Speter#define MAX_ARTIFICIAL_LABEL_BYTES 30 24550624Speter 24650624Speter/* The size of addresses as they appear in the Dwarf 2 data. 24750624Speter Some architectures use word addresses to refer to code locations, 24850624Speter but Dwarf 2 info always uses byte addresses. On such machines, 24950624Speter Dwarf 2 addresses need to be larger than the architecture's 25050624Speter pointers. */ 25150624Speter#ifndef DWARF2_ADDR_SIZE 25250624Speter#define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT) 25350624Speter#endif 25450624Speter 25550624Speter/* The size in bytes of a DWARF field indicating an offset or length 25650624Speter relative to a debug info section, specified to be 4 bytes in the 25750624Speter DWARF-2 specification. The SGI/MIPS ABI defines it to be the same 25850624Speter as PTR_SIZE. */ 25950624Speter 26050624Speter#ifndef DWARF_OFFSET_SIZE 26150624Speter#define DWARF_OFFSET_SIZE 4 26250624Speter#endif 26350624Speter 26450624Speter/* According to the (draft) DWARF 3 specification, the initial length 26550624Speter should either be 4 or 12 bytes. When it's 12 bytes, the first 4 26650624Speter bytes are 0xffffffff, followed by the length stored in the next 8 26750624Speter bytes. 26850624Speter 26950624Speter However, the SGI/MIPS ABI uses an initial length which is equal to 27050624Speter DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */ 27150624Speter 27250624Speter#ifndef DWARF_INITIAL_LENGTH_SIZE 27350624Speter#define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12) 27450624Speter#endif 27550624Speter 27650624Speter#define DWARF_VERSION 2 27750624Speter 27850624Speter/* Round SIZE up to the nearest BOUNDARY. */ 27950624Speter#define DWARF_ROUND(SIZE,BOUNDARY) \ 28050624Speter ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY)) 28150624Speter 28250624Speter/* Offsets recorded in opcodes are a multiple of this alignment factor. */ 28350624Speter#ifndef DWARF_CIE_DATA_ALIGNMENT 28450624Speter#ifdef STACK_GROWS_DOWNWARD 28550624Speter#define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD)) 28650624Speter#else 28750624Speter#define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD) 28850624Speter#endif 28950624Speter#endif 29050624Speter 29150624Speter/* CIE identifier. */ 29250624Speter#if HOST_BITS_PER_WIDE_INT >= 64 29350624Speter#define DWARF_CIE_ID \ 29450624Speter (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID) 29550624Speter#else 29650624Speter#define DWARF_CIE_ID DW_CIE_ID 29750624Speter#endif 29850624Speter 29950624Speter/* A pointer to the base of a table that contains frame description 30050624Speter information for each routine. */ 30150624Speterstatic GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table; 30250624Speter 30350624Speter/* Number of elements currently allocated for fde_table. */ 30450624Speterstatic GTY(()) unsigned fde_table_allocated; 30550624Speter 30650624Speter/* Number of elements in fde_table currently in use. */ 30750624Speterstatic GTY(()) unsigned fde_table_in_use; 30850624Speter 30950624Speter/* Size (in elements) of increments by which we may expand the 31050624Speter fde_table. */ 31150624Speter#define FDE_TABLE_INCREMENT 256 31250624Speter 31350624Speter/* A list of call frame insns for the CIE. */ 31450624Speterstatic GTY(()) dw_cfi_ref cie_cfi_head; 31550624Speter 31650624Speter#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO) 31750624Speter/* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram 31850624Speter attribute that accelerates the lookup of the FDE associated 31950624Speter with the subprogram. This variable holds the table index of the FDE 32050624Speter associated with the current function (body) definition. */ 32150624Speterstatic unsigned current_funcdef_fde; 32250624Speter#endif 32350624Speter 32450624Speterstruct indirect_string_node GTY(()) 32550624Speter{ 32650624Speter const char *str; 32750624Speter unsigned int refcount; 32850624Speter unsigned int form; 32950624Speter char *label; 33050624Speter}; 33150624Speter 33250624Speterstatic GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash; 33350624Speter 33450624Speterstatic GTY(()) int dw2_string_counter; 33550624Speterstatic GTY(()) unsigned long dwarf2out_cfi_label_num; 33650624Speter 33750624Speter#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO) 33850624Speter 33950624Speter/* Forward declarations for functions defined in this file. */ 34050624Speter 34150624Speterstatic char *stripattributes (const char *); 34250624Speterstatic const char *dwarf_cfi_name (unsigned); 34350624Speterstatic dw_cfi_ref new_cfi (void); 34450624Speterstatic void add_cfi (dw_cfi_ref *, dw_cfi_ref); 34550624Speterstatic void add_fde_cfi (const char *, dw_cfi_ref); 34650624Speterstatic void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *); 34750624Speterstatic void lookup_cfa (dw_cfa_location *); 34850624Speterstatic void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT); 34950624Speterstatic void initial_return_save (rtx); 35050624Speterstatic HOST_WIDE_INT stack_adjust_offset (rtx); 35150624Speterstatic void output_cfi (dw_cfi_ref, dw_fde_ref, int); 35250624Speterstatic void output_call_frame_info (int); 35350624Speterstatic void dwarf2out_stack_adjust (rtx, bool); 35450624Speterstatic void flush_queued_reg_saves (void); 35550624Speterstatic bool clobbers_queued_reg_save (rtx); 35650624Speterstatic void dwarf2out_frame_debug_expr (rtx, const char *); 35750624Speter 35850624Speter/* Support for complex CFA locations. */ 35950624Speterstatic void output_cfa_loc (dw_cfi_ref); 36050624Speterstatic void get_cfa_from_loc_descr (dw_cfa_location *, 36150624Speter struct dw_loc_descr_struct *); 36250624Speterstatic struct dw_loc_descr_struct *build_cfa_loc 36350624Speter (dw_cfa_location *, HOST_WIDE_INT); 36450624Speterstatic void def_cfa_1 (const char *, dw_cfa_location *); 36550624Speter 36650624Speter/* How to start an assembler comment. */ 36750624Speter#ifndef ASM_COMMENT_START 36850624Speter#define ASM_COMMENT_START ";#" 36950624Speter#endif 37050624Speter 37150624Speter/* Data and reference forms for relocatable data. */ 37250624Speter#define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4) 37350624Speter#define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4) 37450624Speter 37550624Speter#ifndef DEBUG_FRAME_SECTION 37650624Speter#define DEBUG_FRAME_SECTION ".debug_frame" 37750624Speter#endif 37850624Speter 37950624Speter#ifndef FUNC_BEGIN_LABEL 38050624Speter#define FUNC_BEGIN_LABEL "LFB" 38150624Speter#endif 38250624Speter 38350624Speter#ifndef FUNC_END_LABEL 38450624Speter#define FUNC_END_LABEL "LFE" 38550624Speter#endif 38650624Speter 38750624Speter#ifndef FRAME_BEGIN_LABEL 38850624Speter#define FRAME_BEGIN_LABEL "Lframe" 38950624Speter#endif 39050624Speter#define CIE_AFTER_SIZE_LABEL "LSCIE" 39150624Speter#define CIE_END_LABEL "LECIE" 39250624Speter#define FDE_LABEL "LSFDE" 39350624Speter#define FDE_AFTER_SIZE_LABEL "LASFDE" 39450624Speter#define FDE_END_LABEL "LEFDE" 39550624Speter#define LINE_NUMBER_BEGIN_LABEL "LSLT" 39650624Speter#define LINE_NUMBER_END_LABEL "LELT" 39713987Smpp#define LN_PROLOG_AS_LABEL "LASLTP" 39850624Speter#define LN_PROLOG_END_LABEL "LELTP" 39950624Speter#define DIE_LABEL_PREFIX "DW" 40050624Speter 40150624Speter/* The DWARF 2 CFA column which tracks the return address. Normally this 40250624Speter is the column for PC, or the first column after all of the hard 40350624Speter registers. */ 40450624Speter#ifndef DWARF_FRAME_RETURN_COLUMN 40550624Speter#ifdef PC_REGNUM 40650624Speter#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM) 40750624Speter#else 40850624Speter#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS 40950624Speter#endif 41050624Speter#endif 41150624Speter 41250624Speter/* The mapping from gcc register number to DWARF 2 CFA column number. By 41350624Speter default, we just provide columns for all registers. */ 41450624Speter#ifndef DWARF_FRAME_REGNUM 41550624Speter#define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG) 41650624Speter#endif 41750624Speter 41850624Speter/* Hook used by __throw. */ 41950624Speter 42050624Speterrtx 42150624Speterexpand_builtin_dwarf_sp_column (void) 42250624Speter{ 42350624Speter unsigned int dwarf_regnum = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM); 42450624Speter return GEN_INT (DWARF2_FRAME_REG_OUT (dwarf_regnum, 1)); 42550624Speter} 42650624Speter 42750624Speter/* Return a pointer to a copy of the section string name S with all 42850624Speter attributes stripped off, and an asterisk prepended (for assemble_name). */ 42950624Speter 43050624Speterstatic inline char * 43150624Speterstripattributes (const char *s) 43250624Speter{ 43350624Speter char *stripped = XNEWVEC (char, strlen (s) + 2); 43413987Smpp char *p = stripped; 43550624Speter 43650624Speter *p++ = '*'; 43750624Speter 43850624Speter while (*s && *s != ',') 43950624Speter *p++ = *s++; 44050624Speter 44150624Speter *p = '\0'; 44250624Speter return stripped; 44350624Speter} 44450624Speter 44550624Speter/* Generate code to initialize the register size table. */ 44650624Speter 44750624Spetervoid 44850624Speterexpand_builtin_init_dwarf_reg_sizes (tree address) 44950624Speter{ 45050624Speter unsigned int i; 45150624Speter enum machine_mode mode = TYPE_MODE (char_type_node); 45250624Speter rtx addr = expand_normal (address); 45350624Speter rtx mem = gen_rtx_MEM (BLKmode, addr); 45450624Speter bool wrote_return_column = false; 45550624Speter 45650624Speter for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) 45750624Speter { 45813987Smpp int rnum = DWARF2_FRAME_REG_OUT (DWARF_FRAME_REGNUM (i), 1); 45950624Speter 46050624Speter if (rnum < DWARF_FRAME_REGISTERS) 46150624Speter { 46250624Speter HOST_WIDE_INT offset = rnum * GET_MODE_SIZE (mode); 46350624Speter enum machine_mode save_mode = reg_raw_mode[i]; 46450624Speter HOST_WIDE_INT size; 46550624Speter 46650624Speter if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode)) 46750624Speter save_mode = choose_hard_reg_mode (i, 1, true); 46850624Speter if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN) 46950624Speter { 47050624Speter if (save_mode == VOIDmode) 47150624Speter continue; 47250624Speter wrote_return_column = true; 47350624Speter } 47450624Speter size = GET_MODE_SIZE (save_mode); 47550624Speter if (offset < 0) 47650624Speter continue; 47750624Speter 47850624Speter emit_move_insn (adjust_address (mem, mode, offset), 47950624Speter gen_int_mode (size, mode)); 48050624Speter } 48150624Speter } 48250624Speter 48350624Speter#ifdef DWARF_ALT_FRAME_RETURN_COLUMN 48450624Speter gcc_assert (wrote_return_column); 48550624Speter i = DWARF_ALT_FRAME_RETURN_COLUMN; 48650624Speter wrote_return_column = false; 48750624Speter#else 48850624Speter i = DWARF_FRAME_RETURN_COLUMN; 48950624Speter#endif 49050624Speter 49150624Speter if (! wrote_return_column) 49250624Speter { 49350624Speter enum machine_mode save_mode = Pmode; 49450624Speter HOST_WIDE_INT offset = i * GET_MODE_SIZE (mode); 49550624Speter HOST_WIDE_INT size = GET_MODE_SIZE (save_mode); 49650624Speter emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size)); 49750624Speter } 49850624Speter} 49950624Speter 50050624Speter/* Convert a DWARF call frame info. operation to its string name */ 50150624Speter 50250624Speterstatic const char * 50350624Speterdwarf_cfi_name (unsigned int cfi_opc) 50450624Speter{ 50550624Speter switch (cfi_opc) 50650624Speter { 50750624Speter case DW_CFA_advance_loc: 50850624Speter return "DW_CFA_advance_loc"; 50950624Speter case DW_CFA_offset: 51050624Speter return "DW_CFA_offset"; 51150624Speter case DW_CFA_restore: 51250624Speter return "DW_CFA_restore"; 51315947Swosch case DW_CFA_nop: 51450624Speter return "DW_CFA_nop"; 51513987Smpp case DW_CFA_set_loc: 51650624Speter return "DW_CFA_set_loc"; 517 case DW_CFA_advance_loc1: 518 return "DW_CFA_advance_loc1"; 519 case DW_CFA_advance_loc2: 520 return "DW_CFA_advance_loc2"; 521 case DW_CFA_advance_loc4: 522 return "DW_CFA_advance_loc4"; 523 case DW_CFA_offset_extended: 524 return "DW_CFA_offset_extended"; 525 case DW_CFA_restore_extended: 526 return "DW_CFA_restore_extended"; 527 case DW_CFA_undefined: 528 return "DW_CFA_undefined"; 529 case DW_CFA_same_value: 530 return "DW_CFA_same_value"; 531 case DW_CFA_register: 532 return "DW_CFA_register"; 533 case DW_CFA_remember_state: 534 return "DW_CFA_remember_state"; 535 case DW_CFA_restore_state: 536 return "DW_CFA_restore_state"; 537 case DW_CFA_def_cfa: 538 return "DW_CFA_def_cfa"; 539 case DW_CFA_def_cfa_register: 540 return "DW_CFA_def_cfa_register"; 541 case DW_CFA_def_cfa_offset: 542 return "DW_CFA_def_cfa_offset"; 543 544 /* DWARF 3 */ 545 case DW_CFA_def_cfa_expression: 546 return "DW_CFA_def_cfa_expression"; 547 case DW_CFA_expression: 548 return "DW_CFA_expression"; 549 case DW_CFA_offset_extended_sf: 550 return "DW_CFA_offset_extended_sf"; 551 case DW_CFA_def_cfa_sf: 552 return "DW_CFA_def_cfa_sf"; 553 case DW_CFA_def_cfa_offset_sf: 554 return "DW_CFA_def_cfa_offset_sf"; 555 556 /* SGI/MIPS specific */ 557 case DW_CFA_MIPS_advance_loc8: 558 return "DW_CFA_MIPS_advance_loc8"; 559 560 /* GNU extensions */ 561 case DW_CFA_GNU_window_save: 562 return "DW_CFA_GNU_window_save"; 563 case DW_CFA_GNU_args_size: 564 return "DW_CFA_GNU_args_size"; 565 case DW_CFA_GNU_negative_offset_extended: 566 return "DW_CFA_GNU_negative_offset_extended"; 567 568 default: 569 return "DW_CFA_<unknown>"; 570 } 571} 572 573/* Return a pointer to a newly allocated Call Frame Instruction. */ 574 575static inline dw_cfi_ref 576new_cfi (void) 577{ 578 dw_cfi_ref cfi = ggc_alloc (sizeof (dw_cfi_node)); 579 580 cfi->dw_cfi_next = NULL; 581 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0; 582 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0; 583 584 return cfi; 585} 586 587/* Add a Call Frame Instruction to list of instructions. */ 588 589static inline void 590add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi) 591{ 592 dw_cfi_ref *p; 593 594 /* Find the end of the chain. */ 595 for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next) 596 ; 597 598 *p = cfi; 599} 600 601/* Generate a new label for the CFI info to refer to. */ 602 603char * 604dwarf2out_cfi_label (void) 605{ 606 static char label[20]; 607 608 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", dwarf2out_cfi_label_num++); 609 ASM_OUTPUT_LABEL (asm_out_file, label); 610 return label; 611} 612 613/* Add CFI to the current fde at the PC value indicated by LABEL if specified, 614 or to the CIE if LABEL is NULL. */ 615 616static void 617add_fde_cfi (const char *label, dw_cfi_ref cfi) 618{ 619 if (label) 620 { 621 dw_fde_ref fde = &fde_table[fde_table_in_use - 1]; 622 623 if (*label == 0) 624 label = dwarf2out_cfi_label (); 625 626 if (fde->dw_fde_current_label == NULL 627 || strcmp (label, fde->dw_fde_current_label) != 0) 628 { 629 dw_cfi_ref xcfi; 630 631 label = xstrdup (label); 632 633 /* Set the location counter to the new label. */ 634 xcfi = new_cfi (); 635 /* If we have a current label, advance from there, otherwise 636 set the location directly using set_loc. */ 637 xcfi->dw_cfi_opc = fde->dw_fde_current_label 638 ? DW_CFA_advance_loc4 639 : DW_CFA_set_loc; 640 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label; 641 add_cfi (&fde->dw_fde_cfi, xcfi); 642 643 fde->dw_fde_current_label = label; 644 } 645 646 add_cfi (&fde->dw_fde_cfi, cfi); 647 } 648 649 else 650 add_cfi (&cie_cfi_head, cfi); 651} 652 653/* Subroutine of lookup_cfa. */ 654 655static void 656lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc) 657{ 658 switch (cfi->dw_cfi_opc) 659 { 660 case DW_CFA_def_cfa_offset: 661 loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset; 662 break; 663 case DW_CFA_def_cfa_offset_sf: 664 loc->offset 665 = cfi->dw_cfi_oprnd1.dw_cfi_offset * DWARF_CIE_DATA_ALIGNMENT; 666 break; 667 case DW_CFA_def_cfa_register: 668 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num; 669 break; 670 case DW_CFA_def_cfa: 671 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num; 672 loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset; 673 break; 674 case DW_CFA_def_cfa_sf: 675 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num; 676 loc->offset 677 = cfi->dw_cfi_oprnd2.dw_cfi_offset * DWARF_CIE_DATA_ALIGNMENT; 678 break; 679 case DW_CFA_def_cfa_expression: 680 get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc); 681 break; 682 default: 683 break; 684 } 685} 686 687/* Find the previous value for the CFA. */ 688 689static void 690lookup_cfa (dw_cfa_location *loc) 691{ 692 dw_cfi_ref cfi; 693 694 loc->reg = INVALID_REGNUM; 695 loc->offset = 0; 696 loc->indirect = 0; 697 loc->base_offset = 0; 698 699 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next) 700 lookup_cfa_1 (cfi, loc); 701 702 if (fde_table_in_use) 703 { 704 dw_fde_ref fde = &fde_table[fde_table_in_use - 1]; 705 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next) 706 lookup_cfa_1 (cfi, loc); 707 } 708} 709 710/* The current rule for calculating the DWARF2 canonical frame address. */ 711static dw_cfa_location cfa; 712 713/* The register used for saving registers to the stack, and its offset 714 from the CFA. */ 715static dw_cfa_location cfa_store; 716 717/* The running total of the size of arguments pushed onto the stack. */ 718static HOST_WIDE_INT args_size; 719 720/* The last args_size we actually output. */ 721static HOST_WIDE_INT old_args_size; 722 723/* Entry point to update the canonical frame address (CFA). 724 LABEL is passed to add_fde_cfi. The value of CFA is now to be 725 calculated from REG+OFFSET. */ 726 727void 728dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset) 729{ 730 dw_cfa_location loc; 731 loc.indirect = 0; 732 loc.base_offset = 0; 733 loc.reg = reg; 734 loc.offset = offset; 735 def_cfa_1 (label, &loc); 736} 737 738/* Determine if two dw_cfa_location structures define the same data. */ 739 740static bool 741cfa_equal_p (const dw_cfa_location *loc1, const dw_cfa_location *loc2) 742{ 743 return (loc1->reg == loc2->reg 744 && loc1->offset == loc2->offset 745 && loc1->indirect == loc2->indirect 746 && (loc1->indirect == 0 747 || loc1->base_offset == loc2->base_offset)); 748} 749 750/* This routine does the actual work. The CFA is now calculated from 751 the dw_cfa_location structure. */ 752 753static void 754def_cfa_1 (const char *label, dw_cfa_location *loc_p) 755{ 756 dw_cfi_ref cfi; 757 dw_cfa_location old_cfa, loc; 758 759 cfa = *loc_p; 760 loc = *loc_p; 761 762 if (cfa_store.reg == loc.reg && loc.indirect == 0) 763 cfa_store.offset = loc.offset; 764 765 loc.reg = DWARF_FRAME_REGNUM (loc.reg); 766 lookup_cfa (&old_cfa); 767 768 /* If nothing changed, no need to issue any call frame instructions. */ 769 if (cfa_equal_p (&loc, &old_cfa)) 770 return; 771 772 cfi = new_cfi (); 773 774 if (loc.reg == old_cfa.reg && !loc.indirect) 775 { 776 /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction, indicating 777 the CFA register did not change but the offset did. */ 778 if (loc.offset < 0) 779 { 780 HOST_WIDE_INT f_offset = loc.offset / DWARF_CIE_DATA_ALIGNMENT; 781 gcc_assert (f_offset * DWARF_CIE_DATA_ALIGNMENT == loc.offset); 782 783 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset_sf; 784 cfi->dw_cfi_oprnd1.dw_cfi_offset = f_offset; 785 } 786 else 787 { 788 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset; 789 cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset; 790 } 791 } 792 793#ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */ 794 else if (loc.offset == old_cfa.offset 795 && old_cfa.reg != INVALID_REGNUM 796 && !loc.indirect) 797 { 798 /* Construct a "DW_CFA_def_cfa_register <register>" instruction, 799 indicating the CFA register has changed to <register> but the 800 offset has not changed. */ 801 cfi->dw_cfi_opc = DW_CFA_def_cfa_register; 802 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg; 803 } 804#endif 805 806 else if (loc.indirect == 0) 807 { 808 /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction, 809 indicating the CFA register has changed to <register> with 810 the specified offset. */ 811 if (loc.offset < 0) 812 { 813 HOST_WIDE_INT f_offset = loc.offset / DWARF_CIE_DATA_ALIGNMENT; 814 gcc_assert (f_offset * DWARF_CIE_DATA_ALIGNMENT == loc.offset); 815 816 cfi->dw_cfi_opc = DW_CFA_def_cfa_sf; 817 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg; 818 cfi->dw_cfi_oprnd2.dw_cfi_offset = f_offset; 819 } 820 else 821 { 822 cfi->dw_cfi_opc = DW_CFA_def_cfa; 823 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg; 824 cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset; 825 } 826 } 827 else 828 { 829 /* Construct a DW_CFA_def_cfa_expression instruction to 830 calculate the CFA using a full location expression since no 831 register-offset pair is available. */ 832 struct dw_loc_descr_struct *loc_list; 833 834 cfi->dw_cfi_opc = DW_CFA_def_cfa_expression; 835 loc_list = build_cfa_loc (&loc, 0); 836 cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list; 837 } 838 839 add_fde_cfi (label, cfi); 840} 841 842/* Add the CFI for saving a register. REG is the CFA column number. 843 LABEL is passed to add_fde_cfi. 844 If SREG is -1, the register is saved at OFFSET from the CFA; 845 otherwise it is saved in SREG. */ 846 847static void 848reg_save (const char *label, unsigned int reg, unsigned int sreg, HOST_WIDE_INT offset) 849{ 850 dw_cfi_ref cfi = new_cfi (); 851 852 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg; 853 854 if (sreg == INVALID_REGNUM) 855 { 856 if (reg & ~0x3f) 857 /* The register number won't fit in 6 bits, so we have to use 858 the long form. */ 859 cfi->dw_cfi_opc = DW_CFA_offset_extended; 860 else 861 cfi->dw_cfi_opc = DW_CFA_offset; 862 863#ifdef ENABLE_CHECKING 864 { 865 /* If we get an offset that is not a multiple of 866 DWARF_CIE_DATA_ALIGNMENT, there is either a bug in the 867 definition of DWARF_CIE_DATA_ALIGNMENT, or a bug in the machine 868 description. */ 869 HOST_WIDE_INT check_offset = offset / DWARF_CIE_DATA_ALIGNMENT; 870 871 gcc_assert (check_offset * DWARF_CIE_DATA_ALIGNMENT == offset); 872 } 873#endif 874 offset /= DWARF_CIE_DATA_ALIGNMENT; 875 if (offset < 0) 876 cfi->dw_cfi_opc = DW_CFA_offset_extended_sf; 877 878 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset; 879 } 880 else if (sreg == reg) 881 cfi->dw_cfi_opc = DW_CFA_same_value; 882 else 883 { 884 cfi->dw_cfi_opc = DW_CFA_register; 885 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg; 886 } 887 888 add_fde_cfi (label, cfi); 889} 890 891/* Add the CFI for saving a register window. LABEL is passed to reg_save. 892 This CFI tells the unwinder that it needs to restore the window registers 893 from the previous frame's window save area. 894 895 ??? Perhaps we should note in the CIE where windows are saved (instead of 896 assuming 0(cfa)) and what registers are in the window. */ 897 898void 899dwarf2out_window_save (const char *label) 900{ 901 dw_cfi_ref cfi = new_cfi (); 902 903 cfi->dw_cfi_opc = DW_CFA_GNU_window_save; 904 add_fde_cfi (label, cfi); 905} 906 907/* Add a CFI to update the running total of the size of arguments 908 pushed onto the stack. */ 909 910void 911dwarf2out_args_size (const char *label, HOST_WIDE_INT size) 912{ 913 dw_cfi_ref cfi; 914 915 if (size == old_args_size) 916 return; 917 918 old_args_size = size; 919 920 cfi = new_cfi (); 921 cfi->dw_cfi_opc = DW_CFA_GNU_args_size; 922 cfi->dw_cfi_oprnd1.dw_cfi_offset = size; 923 add_fde_cfi (label, cfi); 924} 925 926/* Entry point for saving a register to the stack. REG is the GCC register 927 number. LABEL and OFFSET are passed to reg_save. */ 928 929void 930dwarf2out_reg_save (const char *label, unsigned int reg, HOST_WIDE_INT offset) 931{ 932 reg_save (label, DWARF_FRAME_REGNUM (reg), INVALID_REGNUM, offset); 933} 934 935/* Entry point for saving the return address in the stack. 936 LABEL and OFFSET are passed to reg_save. */ 937 938void 939dwarf2out_return_save (const char *label, HOST_WIDE_INT offset) 940{ 941 reg_save (label, DWARF_FRAME_RETURN_COLUMN, INVALID_REGNUM, offset); 942} 943 944/* Entry point for saving the return address in a register. 945 LABEL and SREG are passed to reg_save. */ 946 947void 948dwarf2out_return_reg (const char *label, unsigned int sreg) 949{ 950 reg_save (label, DWARF_FRAME_RETURN_COLUMN, DWARF_FRAME_REGNUM (sreg), 0); 951} 952 953/* Record the initial position of the return address. RTL is 954 INCOMING_RETURN_ADDR_RTX. */ 955 956static void 957initial_return_save (rtx rtl) 958{ 959 unsigned int reg = INVALID_REGNUM; 960 HOST_WIDE_INT offset = 0; 961 962 switch (GET_CODE (rtl)) 963 { 964 case REG: 965 /* RA is in a register. */ 966 reg = DWARF_FRAME_REGNUM (REGNO (rtl)); 967 break; 968 969 case MEM: 970 /* RA is on the stack. */ 971 rtl = XEXP (rtl, 0); 972 switch (GET_CODE (rtl)) 973 { 974 case REG: 975 gcc_assert (REGNO (rtl) == STACK_POINTER_REGNUM); 976 offset = 0; 977 break; 978 979 case PLUS: 980 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM); 981 offset = INTVAL (XEXP (rtl, 1)); 982 break; 983 984 case MINUS: 985 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM); 986 offset = -INTVAL (XEXP (rtl, 1)); 987 break; 988 989 default: 990 gcc_unreachable (); 991 } 992 993 break; 994 995 case PLUS: 996 /* The return address is at some offset from any value we can 997 actually load. For instance, on the SPARC it is in %i7+8. Just 998 ignore the offset for now; it doesn't matter for unwinding frames. */ 999 gcc_assert (GET_CODE (XEXP (rtl, 1)) == CONST_INT); 1000 initial_return_save (XEXP (rtl, 0)); 1001 return; 1002 1003 default: 1004 gcc_unreachable (); 1005 } 1006 1007 if (reg != DWARF_FRAME_RETURN_COLUMN) 1008 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset); 1009} 1010 1011/* Given a SET, calculate the amount of stack adjustment it 1012 contains. */ 1013 1014static HOST_WIDE_INT 1015stack_adjust_offset (rtx pattern) 1016{ 1017 rtx src = SET_SRC (pattern); 1018 rtx dest = SET_DEST (pattern); 1019 HOST_WIDE_INT offset = 0; 1020 enum rtx_code code; 1021 1022 if (dest == stack_pointer_rtx) 1023 { 1024 /* (set (reg sp) (plus (reg sp) (const_int))) */ 1025 code = GET_CODE (src); 1026 if (! (code == PLUS || code == MINUS) 1027 || XEXP (src, 0) != stack_pointer_rtx 1028 || GET_CODE (XEXP (src, 1)) != CONST_INT) 1029 return 0; 1030 1031 offset = INTVAL (XEXP (src, 1)); 1032 if (code == PLUS) 1033 offset = -offset; 1034 } 1035 else if (MEM_P (dest)) 1036 { 1037 /* (set (mem (pre_dec (reg sp))) (foo)) */ 1038 src = XEXP (dest, 0); 1039 code = GET_CODE (src); 1040 1041 switch (code) 1042 { 1043 case PRE_MODIFY: 1044 case POST_MODIFY: 1045 if (XEXP (src, 0) == stack_pointer_rtx) 1046 { 1047 rtx val = XEXP (XEXP (src, 1), 1); 1048 /* We handle only adjustments by constant amount. */ 1049 gcc_assert (GET_CODE (XEXP (src, 1)) == PLUS 1050 && GET_CODE (val) == CONST_INT); 1051 offset = -INTVAL (val); 1052 break; 1053 } 1054 return 0; 1055 1056 case PRE_DEC: 1057 case POST_DEC: 1058 if (XEXP (src, 0) == stack_pointer_rtx) 1059 { 1060 offset = GET_MODE_SIZE (GET_MODE (dest)); 1061 break; 1062 } 1063 return 0; 1064 1065 case PRE_INC: 1066 case POST_INC: 1067 if (XEXP (src, 0) == stack_pointer_rtx) 1068 { 1069 offset = -GET_MODE_SIZE (GET_MODE (dest)); 1070 break; 1071 } 1072 return 0; 1073 1074 default: 1075 return 0; 1076 } 1077 } 1078 else 1079 return 0; 1080 1081 return offset; 1082} 1083 1084/* Check INSN to see if it looks like a push or a stack adjustment, and 1085 make a note of it if it does. EH uses this information to find out how 1086 much extra space it needs to pop off the stack. */ 1087 1088static void 1089dwarf2out_stack_adjust (rtx insn, bool after_p) 1090{ 1091 HOST_WIDE_INT offset; 1092 const char *label; 1093 int i; 1094 1095 /* Don't handle epilogues at all. Certainly it would be wrong to do so 1096 with this function. Proper support would require all frame-related 1097 insns to be marked, and to be able to handle saving state around 1098 epilogues textually in the middle of the function. */ 1099 if (prologue_epilogue_contains (insn) || sibcall_epilogue_contains (insn)) 1100 return; 1101 1102 /* If only calls can throw, and we have a frame pointer, 1103 save up adjustments until we see the CALL_INSN. */ 1104 if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM) 1105 { 1106 if (CALL_P (insn) && !after_p) 1107 { 1108 /* Extract the size of the args from the CALL rtx itself. */ 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 gcc_assert (GET_CODE (insn) == CALL); 1115 dwarf2out_args_size ("", INTVAL (XEXP (insn, 1))); 1116 } 1117 return; 1118 } 1119 1120 if (CALL_P (insn) && !after_p) 1121 { 1122 if (!flag_asynchronous_unwind_tables) 1123 dwarf2out_args_size ("", args_size); 1124 return; 1125 } 1126 else if (BARRIER_P (insn)) 1127 { 1128 /* When we see a BARRIER, we know to reset args_size to 0. Usually 1129 the compiler will have already emitted a stack adjustment, but 1130 doesn't bother for calls to noreturn functions. */ 1131#ifdef STACK_GROWS_DOWNWARD 1132 offset = -args_size; 1133#else 1134 offset = args_size; 1135#endif 1136 } 1137 else if (GET_CODE (PATTERN (insn)) == SET) 1138 offset = stack_adjust_offset (PATTERN (insn)); 1139 else if (GET_CODE (PATTERN (insn)) == PARALLEL 1140 || GET_CODE (PATTERN (insn)) == SEQUENCE) 1141 { 1142 /* There may be stack adjustments inside compound insns. Search 1143 for them. */ 1144 for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--) 1145 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET) 1146 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i)); 1147 } 1148 else 1149 return; 1150 1151 if (offset == 0) 1152 return; 1153 1154 if (cfa.reg == STACK_POINTER_REGNUM) 1155 cfa.offset += offset; 1156 1157#ifndef STACK_GROWS_DOWNWARD 1158 offset = -offset; 1159#endif 1160 1161 args_size += offset; 1162 if (args_size < 0) 1163 args_size = 0; 1164 1165 label = dwarf2out_cfi_label (); 1166 def_cfa_1 (label, &cfa); 1167 if (flag_asynchronous_unwind_tables) 1168 dwarf2out_args_size (label, args_size); 1169} 1170 1171#endif 1172 1173/* We delay emitting a register save until either (a) we reach the end 1174 of the prologue or (b) the register is clobbered. This clusters 1175 register saves so that there are fewer pc advances. */ 1176 1177struct queued_reg_save GTY(()) 1178{ 1179 struct queued_reg_save *next; 1180 rtx reg; 1181 HOST_WIDE_INT cfa_offset; 1182 rtx saved_reg; 1183}; 1184 1185static GTY(()) struct queued_reg_save *queued_reg_saves; 1186 1187/* The caller's ORIG_REG is saved in SAVED_IN_REG. */ 1188struct reg_saved_in_data GTY(()) { 1189 rtx orig_reg; 1190 rtx saved_in_reg; 1191}; 1192 1193/* A list of registers saved in other registers. 1194 The list intentionally has a small maximum capacity of 4; if your 1195 port needs more than that, you might consider implementing a 1196 more efficient data structure. */ 1197static GTY(()) struct reg_saved_in_data regs_saved_in_regs[4]; 1198static GTY(()) size_t num_regs_saved_in_regs; 1199 1200#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO) 1201static const char *last_reg_save_label; 1202 1203/* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at 1204 SREG, or if SREG is NULL then it is saved at OFFSET to the CFA. */ 1205 1206static void 1207queue_reg_save (const char *label, rtx reg, rtx sreg, HOST_WIDE_INT offset) 1208{ 1209 struct queued_reg_save *q; 1210 1211 /* Duplicates waste space, but it's also necessary to remove them 1212 for correctness, since the queue gets output in reverse 1213 order. */ 1214 for (q = queued_reg_saves; q != NULL; q = q->next) 1215 if (REGNO (q->reg) == REGNO (reg)) 1216 break; 1217 1218 if (q == NULL) 1219 { 1220 q = ggc_alloc (sizeof (*q)); 1221 q->next = queued_reg_saves; 1222 queued_reg_saves = q; 1223 } 1224 1225 q->reg = reg; 1226 q->cfa_offset = offset; 1227 q->saved_reg = sreg; 1228 1229 last_reg_save_label = label; 1230} 1231 1232/* Output all the entries in QUEUED_REG_SAVES. */ 1233 1234static void 1235flush_queued_reg_saves (void) 1236{ 1237 struct queued_reg_save *q; 1238 1239 for (q = queued_reg_saves; q; q = q->next) 1240 { 1241 size_t i; 1242 unsigned int reg, sreg; 1243 1244 for (i = 0; i < num_regs_saved_in_regs; i++) 1245 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (q->reg)) 1246 break; 1247 if (q->saved_reg && i == num_regs_saved_in_regs) 1248 { 1249 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs)); 1250 num_regs_saved_in_regs++; 1251 } 1252 if (i != num_regs_saved_in_regs) 1253 { 1254 regs_saved_in_regs[i].orig_reg = q->reg; 1255 regs_saved_in_regs[i].saved_in_reg = q->saved_reg; 1256 } 1257 1258 reg = DWARF_FRAME_REGNUM (REGNO (q->reg)); 1259 if (q->saved_reg) 1260 sreg = DWARF_FRAME_REGNUM (REGNO (q->saved_reg)); 1261 else 1262 sreg = INVALID_REGNUM; 1263 reg_save (last_reg_save_label, reg, sreg, q->cfa_offset); 1264 } 1265 1266 queued_reg_saves = NULL; 1267 last_reg_save_label = NULL; 1268} 1269 1270/* Does INSN clobber any register which QUEUED_REG_SAVES lists a saved 1271 location for? Or, does it clobber a register which we've previously 1272 said that some other register is saved in, and for which we now 1273 have a new location for? */ 1274 1275static bool 1276clobbers_queued_reg_save (rtx insn) 1277{ 1278 struct queued_reg_save *q; 1279 1280 for (q = queued_reg_saves; q; q = q->next) 1281 { 1282 size_t i; 1283 if (modified_in_p (q->reg, insn)) 1284 return true; 1285 for (i = 0; i < num_regs_saved_in_regs; i++) 1286 if (REGNO (q->reg) == REGNO (regs_saved_in_regs[i].orig_reg) 1287 && modified_in_p (regs_saved_in_regs[i].saved_in_reg, insn)) 1288 return true; 1289 } 1290 1291 return false; 1292} 1293 1294/* Entry point for saving the first register into the second. */ 1295 1296void 1297dwarf2out_reg_save_reg (const char *label, rtx reg, rtx sreg) 1298{ 1299 size_t i; 1300 unsigned int regno, sregno; 1301 1302 for (i = 0; i < num_regs_saved_in_regs; i++) 1303 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (reg)) 1304 break; 1305 if (i == num_regs_saved_in_regs) 1306 { 1307 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs)); 1308 num_regs_saved_in_regs++; 1309 } 1310 regs_saved_in_regs[i].orig_reg = reg; 1311 regs_saved_in_regs[i].saved_in_reg = sreg; 1312 1313 regno = DWARF_FRAME_REGNUM (REGNO (reg)); 1314 sregno = DWARF_FRAME_REGNUM (REGNO (sreg)); 1315 reg_save (label, regno, sregno, 0); 1316} 1317 1318/* What register, if any, is currently saved in REG? */ 1319 1320static rtx 1321reg_saved_in (rtx reg) 1322{ 1323 unsigned int regn = REGNO (reg); 1324 size_t i; 1325 struct queued_reg_save *q; 1326 1327 for (q = queued_reg_saves; q; q = q->next) 1328 if (q->saved_reg && regn == REGNO (q->saved_reg)) 1329 return q->reg; 1330 1331 for (i = 0; i < num_regs_saved_in_regs; i++) 1332 if (regs_saved_in_regs[i].saved_in_reg 1333 && regn == REGNO (regs_saved_in_regs[i].saved_in_reg)) 1334 return regs_saved_in_regs[i].orig_reg; 1335 1336 return NULL_RTX; 1337} 1338 1339 1340/* A temporary register holding an integral value used in adjusting SP 1341 or setting up the store_reg. The "offset" field holds the integer 1342 value, not an offset. */ 1343static dw_cfa_location cfa_temp; 1344 1345/* Record call frame debugging information for an expression EXPR, 1346 which either sets SP or FP (adjusting how we calculate the frame 1347 address) or saves a register to the stack or another register. 1348 LABEL indicates the address of EXPR. 1349 1350 This function encodes a state machine mapping rtxes to actions on 1351 cfa, cfa_store, and cfa_temp.reg. We describe these rules so 1352 users need not read the source code. 1353 1354 The High-Level Picture 1355 1356 Changes in the register we use to calculate the CFA: Currently we 1357 assume that if you copy the CFA register into another register, we 1358 should take the other one as the new CFA register; this seems to 1359 work pretty well. If it's wrong for some target, it's simple 1360 enough not to set RTX_FRAME_RELATED_P on the insn in question. 1361 1362 Changes in the register we use for saving registers to the stack: 1363 This is usually SP, but not always. Again, we deduce that if you 1364 copy SP into another register (and SP is not the CFA register), 1365 then the new register is the one we will be using for register 1366 saves. This also seems to work. 1367 1368 Register saves: There's not much guesswork about this one; if 1369 RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a 1370 register save, and the register used to calculate the destination 1371 had better be the one we think we're using for this purpose. 1372 It's also assumed that a copy from a call-saved register to another 1373 register is saving that register if RTX_FRAME_RELATED_P is set on 1374 that instruction. If the copy is from a call-saved register to 1375 the *same* register, that means that the register is now the same 1376 value as in the caller. 1377 1378 Except: If the register being saved is the CFA register, and the 1379 offset is nonzero, we are saving the CFA, so we assume we have to 1380 use DW_CFA_def_cfa_expression. If the offset is 0, we assume that 1381 the intent is to save the value of SP from the previous frame. 1382 1383 In addition, if a register has previously been saved to a different 1384 register, 1385 1386 Invariants / Summaries of Rules 1387 1388 cfa current rule for calculating the CFA. It usually 1389 consists of a register and an offset. 1390 cfa_store register used by prologue code to save things to the stack 1391 cfa_store.offset is the offset from the value of 1392 cfa_store.reg to the actual CFA 1393 cfa_temp register holding an integral value. cfa_temp.offset 1394 stores the value, which will be used to adjust the 1395 stack pointer. cfa_temp is also used like cfa_store, 1396 to track stores to the stack via fp or a temp reg. 1397 1398 Rules 1- 4: Setting a register's value to cfa.reg or an expression 1399 with cfa.reg as the first operand changes the cfa.reg and its 1400 cfa.offset. Rule 1 and 4 also set cfa_temp.reg and 1401 cfa_temp.offset. 1402 1403 Rules 6- 9: Set a non-cfa.reg register value to a constant or an 1404 expression yielding a constant. This sets cfa_temp.reg 1405 and cfa_temp.offset. 1406 1407 Rule 5: Create a new register cfa_store used to save items to the 1408 stack. 1409 1410 Rules 10-14: Save a register to the stack. Define offset as the 1411 difference of the original location and cfa_store's 1412 location (or cfa_temp's location if cfa_temp is used). 1413 1414 The Rules 1415 1416 "{a,b}" indicates a choice of a xor b. 1417 "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg. 1418 1419 Rule 1: 1420 (set <reg1> <reg2>:cfa.reg) 1421 effects: cfa.reg = <reg1> 1422 cfa.offset unchanged 1423 cfa_temp.reg = <reg1> 1424 cfa_temp.offset = cfa.offset 1425 1426 Rule 2: 1427 (set sp ({minus,plus,losum} {sp,fp}:cfa.reg 1428 {<const_int>,<reg>:cfa_temp.reg})) 1429 effects: cfa.reg = sp if fp used 1430 cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp 1431 cfa_store.offset += {+/- <const_int>, cfa_temp.offset} 1432 if cfa_store.reg==sp 1433 1434 Rule 3: 1435 (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>)) 1436 effects: cfa.reg = fp 1437 cfa_offset += +/- <const_int> 1438 1439 Rule 4: 1440 (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>)) 1441 constraints: <reg1> != fp 1442 <reg1> != sp 1443 effects: cfa.reg = <reg1> 1444 cfa_temp.reg = <reg1> 1445 cfa_temp.offset = cfa.offset 1446 1447 Rule 5: 1448 (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg)) 1449 constraints: <reg1> != fp 1450 <reg1> != sp 1451 effects: cfa_store.reg = <reg1> 1452 cfa_store.offset = cfa.offset - cfa_temp.offset 1453 1454 Rule 6: 1455 (set <reg> <const_int>) 1456 effects: cfa_temp.reg = <reg> 1457 cfa_temp.offset = <const_int> 1458 1459 Rule 7: 1460 (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>)) 1461 effects: cfa_temp.reg = <reg1> 1462 cfa_temp.offset |= <const_int> 1463 1464 Rule 8: 1465 (set <reg> (high <exp>)) 1466 effects: none 1467 1468 Rule 9: 1469 (set <reg> (lo_sum <exp> <const_int>)) 1470 effects: cfa_temp.reg = <reg> 1471 cfa_temp.offset = <const_int> 1472 1473 Rule 10: 1474 (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>) 1475 effects: cfa_store.offset -= <const_int> 1476 cfa.offset = cfa_store.offset if cfa.reg == sp 1477 cfa.reg = sp 1478 cfa.base_offset = -cfa_store.offset 1479 1480 Rule 11: 1481 (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>) 1482 effects: cfa_store.offset += -/+ mode_size(mem) 1483 cfa.offset = cfa_store.offset if cfa.reg == sp 1484 cfa.reg = sp 1485 cfa.base_offset = -cfa_store.offset 1486 1487 Rule 12: 1488 (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>)) 1489 1490 <reg2>) 1491 effects: cfa.reg = <reg1> 1492 cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset 1493 1494 Rule 13: 1495 (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>) 1496 effects: cfa.reg = <reg1> 1497 cfa.base_offset = -{cfa_store,cfa_temp}.offset 1498 1499 Rule 14: 1500 (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>) 1501 effects: cfa.reg = <reg1> 1502 cfa.base_offset = -cfa_temp.offset 1503 cfa_temp.offset -= mode_size(mem) 1504 1505 Rule 15: 1506 (set <reg> {unspec, unspec_volatile}) 1507 effects: target-dependent */ 1508 1509static void 1510dwarf2out_frame_debug_expr (rtx expr, const char *label) 1511{ 1512 rtx src, dest; 1513 HOST_WIDE_INT offset; 1514 1515 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of 1516 the PARALLEL independently. The first element is always processed if 1517 it is a SET. This is for backward compatibility. Other elements 1518 are processed only if they are SETs and the RTX_FRAME_RELATED_P 1519 flag is set in them. */ 1520 if (GET_CODE (expr) == PARALLEL || GET_CODE (expr) == SEQUENCE) 1521 { 1522 int par_index; 1523 int limit = XVECLEN (expr, 0); 1524 1525 for (par_index = 0; par_index < limit; par_index++) 1526 if (GET_CODE (XVECEXP (expr, 0, par_index)) == SET 1527 && (RTX_FRAME_RELATED_P (XVECEXP (expr, 0, par_index)) 1528 || par_index == 0)) 1529 dwarf2out_frame_debug_expr (XVECEXP (expr, 0, par_index), label); 1530 1531 return; 1532 } 1533 1534 gcc_assert (GET_CODE (expr) == SET); 1535 1536 src = SET_SRC (expr); 1537 dest = SET_DEST (expr); 1538 1539 if (REG_P (src)) 1540 { 1541 rtx rsi = reg_saved_in (src); 1542 if (rsi) 1543 src = rsi; 1544 } 1545 1546 switch (GET_CODE (dest)) 1547 { 1548 case REG: 1549 switch (GET_CODE (src)) 1550 { 1551 /* Setting FP from SP. */ 1552 case REG: 1553 if (cfa.reg == (unsigned) REGNO (src)) 1554 { 1555 /* Rule 1 */ 1556 /* Update the CFA rule wrt SP or FP. Make sure src is 1557 relative to the current CFA register. 1558 1559 We used to require that dest be either SP or FP, but the 1560 ARM copies SP to a temporary register, and from there to 1561 FP. So we just rely on the backends to only set 1562 RTX_FRAME_RELATED_P on appropriate insns. */ 1563 cfa.reg = REGNO (dest); 1564 cfa_temp.reg = cfa.reg; 1565 cfa_temp.offset = cfa.offset; 1566 } 1567 else 1568 { 1569 /* Saving a register in a register. */ 1570 gcc_assert (!fixed_regs [REGNO (dest)] 1571 /* For the SPARC and its register window. */ 1572 || (DWARF_FRAME_REGNUM (REGNO (src)) 1573 == DWARF_FRAME_RETURN_COLUMN)); 1574 queue_reg_save (label, src, dest, 0); 1575 } 1576 break; 1577 1578 case PLUS: 1579 case MINUS: 1580 case LO_SUM: 1581 if (dest == stack_pointer_rtx) 1582 { 1583 /* Rule 2 */ 1584 /* Adjusting SP. */ 1585 switch (GET_CODE (XEXP (src, 1))) 1586 { 1587 case CONST_INT: 1588 offset = INTVAL (XEXP (src, 1)); 1589 break; 1590 case REG: 1591 gcc_assert ((unsigned) REGNO (XEXP (src, 1)) 1592 == cfa_temp.reg); 1593 offset = cfa_temp.offset; 1594 break; 1595 default: 1596 gcc_unreachable (); 1597 } 1598 1599 if (XEXP (src, 0) == hard_frame_pointer_rtx) 1600 { 1601 /* Restoring SP from FP in the epilogue. */ 1602 gcc_assert (cfa.reg == (unsigned) HARD_FRAME_POINTER_REGNUM); 1603 cfa.reg = STACK_POINTER_REGNUM; 1604 } 1605 else if (GET_CODE (src) == LO_SUM) 1606 /* Assume we've set the source reg of the LO_SUM from sp. */ 1607 ; 1608 else 1609 gcc_assert (XEXP (src, 0) == stack_pointer_rtx); 1610 1611 if (GET_CODE (src) != MINUS) 1612 offset = -offset; 1613 if (cfa.reg == STACK_POINTER_REGNUM) 1614 cfa.offset += offset; 1615 if (cfa_store.reg == STACK_POINTER_REGNUM) 1616 cfa_store.offset += offset; 1617 } 1618 else if (dest == hard_frame_pointer_rtx) 1619 { 1620 /* Rule 3 */ 1621 /* Either setting the FP from an offset of the SP, 1622 or adjusting the FP */ 1623 gcc_assert (frame_pointer_needed); 1624 1625 gcc_assert (REG_P (XEXP (src, 0)) 1626 && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg 1627 && GET_CODE (XEXP (src, 1)) == CONST_INT); 1628 offset = INTVAL (XEXP (src, 1)); 1629 if (GET_CODE (src) != MINUS) 1630 offset = -offset; 1631 cfa.offset += offset; 1632 cfa.reg = HARD_FRAME_POINTER_REGNUM; 1633 } 1634 else 1635 { 1636 gcc_assert (GET_CODE (src) != MINUS); 1637 1638 /* Rule 4 */ 1639 if (REG_P (XEXP (src, 0)) 1640 && REGNO (XEXP (src, 0)) == cfa.reg 1641 && GET_CODE (XEXP (src, 1)) == CONST_INT) 1642 { 1643 /* Setting a temporary CFA register that will be copied 1644 into the FP later on. */ 1645 offset = - INTVAL (XEXP (src, 1)); 1646 cfa.offset += offset; 1647 cfa.reg = REGNO (dest); 1648 /* Or used to save regs to the stack. */ 1649 cfa_temp.reg = cfa.reg; 1650 cfa_temp.offset = cfa.offset; 1651 } 1652 1653 /* Rule 5 */ 1654 else if (REG_P (XEXP (src, 0)) 1655 && REGNO (XEXP (src, 0)) == cfa_temp.reg 1656 && XEXP (src, 1) == stack_pointer_rtx) 1657 { 1658 /* Setting a scratch register that we will use instead 1659 of SP for saving registers to the stack. */ 1660 gcc_assert (cfa.reg == STACK_POINTER_REGNUM); 1661 cfa_store.reg = REGNO (dest); 1662 cfa_store.offset = cfa.offset - cfa_temp.offset; 1663 } 1664 1665 /* Rule 9 */ 1666 else if (GET_CODE (src) == LO_SUM 1667 && GET_CODE (XEXP (src, 1)) == CONST_INT) 1668 { 1669 cfa_temp.reg = REGNO (dest); 1670 cfa_temp.offset = INTVAL (XEXP (src, 1)); 1671 } 1672 else 1673 gcc_unreachable (); 1674 } 1675 break; 1676 1677 /* Rule 6 */ 1678 case CONST_INT: 1679 cfa_temp.reg = REGNO (dest); 1680 cfa_temp.offset = INTVAL (src); 1681 break; 1682 1683 /* Rule 7 */ 1684 case IOR: 1685 gcc_assert (REG_P (XEXP (src, 0)) 1686 && (unsigned) REGNO (XEXP (src, 0)) == cfa_temp.reg 1687 && GET_CODE (XEXP (src, 1)) == CONST_INT); 1688 1689 if ((unsigned) REGNO (dest) != cfa_temp.reg) 1690 cfa_temp.reg = REGNO (dest); 1691 cfa_temp.offset |= INTVAL (XEXP (src, 1)); 1692 break; 1693 1694 /* Skip over HIGH, assuming it will be followed by a LO_SUM, 1695 which will fill in all of the bits. */ 1696 /* Rule 8 */ 1697 case HIGH: 1698 break; 1699 1700 /* Rule 15 */ 1701 case UNSPEC: 1702 case UNSPEC_VOLATILE: 1703 gcc_assert (targetm.dwarf_handle_frame_unspec); 1704 targetm.dwarf_handle_frame_unspec (label, expr, XINT (src, 1)); 1705 return; 1706 1707 default: 1708 gcc_unreachable (); 1709 } 1710 1711 def_cfa_1 (label, &cfa); 1712 break; 1713 1714 case MEM: 1715 gcc_assert (REG_P (src)); 1716 1717 /* Saving a register to the stack. Make sure dest is relative to the 1718 CFA register. */ 1719 switch (GET_CODE (XEXP (dest, 0))) 1720 { 1721 /* Rule 10 */ 1722 /* With a push. */ 1723 case PRE_MODIFY: 1724 /* We can't handle variable size modifications. */ 1725 gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1)) 1726 == CONST_INT); 1727 offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1)); 1728 1729 gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM 1730 && cfa_store.reg == STACK_POINTER_REGNUM); 1731 1732 cfa_store.offset += offset; 1733 if (cfa.reg == STACK_POINTER_REGNUM) 1734 cfa.offset = cfa_store.offset; 1735 1736 offset = -cfa_store.offset; 1737 break; 1738 1739 /* Rule 11 */ 1740 case PRE_INC: 1741 case PRE_DEC: 1742 offset = GET_MODE_SIZE (GET_MODE (dest)); 1743 if (GET_CODE (XEXP (dest, 0)) == PRE_INC) 1744 offset = -offset; 1745 1746 gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM 1747 && cfa_store.reg == STACK_POINTER_REGNUM); 1748 1749 cfa_store.offset += offset; 1750 if (cfa.reg == STACK_POINTER_REGNUM) 1751 cfa.offset = cfa_store.offset; 1752 1753 offset = -cfa_store.offset; 1754 break; 1755 1756 /* Rule 12 */ 1757 /* With an offset. */ 1758 case PLUS: 1759 case MINUS: 1760 case LO_SUM: 1761 { 1762 int regno; 1763 1764 gcc_assert (GET_CODE (XEXP (XEXP (dest, 0), 1)) == CONST_INT 1765 && REG_P (XEXP (XEXP (dest, 0), 0))); 1766 offset = INTVAL (XEXP (XEXP (dest, 0), 1)); 1767 if (GET_CODE (XEXP (dest, 0)) == MINUS) 1768 offset = -offset; 1769 1770 regno = REGNO (XEXP (XEXP (dest, 0), 0)); 1771 1772 if (cfa_store.reg == (unsigned) regno) 1773 offset -= cfa_store.offset; 1774 else 1775 { 1776 gcc_assert (cfa_temp.reg == (unsigned) regno); 1777 offset -= cfa_temp.offset; 1778 } 1779 } 1780 break; 1781 1782 /* Rule 13 */ 1783 /* Without an offset. */ 1784 case REG: 1785 { 1786 int regno = REGNO (XEXP (dest, 0)); 1787 1788 if (cfa_store.reg == (unsigned) regno) 1789 offset = -cfa_store.offset; 1790 else 1791 { 1792 gcc_assert (cfa_temp.reg == (unsigned) regno); 1793 offset = -cfa_temp.offset; 1794 } 1795 } 1796 break; 1797 1798 /* Rule 14 */ 1799 case POST_INC: 1800 gcc_assert (cfa_temp.reg 1801 == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0))); 1802 offset = -cfa_temp.offset; 1803 cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest)); 1804 break; 1805 1806 default: 1807 gcc_unreachable (); 1808 } 1809 1810 if (REGNO (src) != STACK_POINTER_REGNUM 1811 && REGNO (src) != HARD_FRAME_POINTER_REGNUM 1812 && (unsigned) REGNO (src) == cfa.reg) 1813 { 1814 /* We're storing the current CFA reg into the stack. */ 1815 1816 if (cfa.offset == 0) 1817 { 1818 /* If the source register is exactly the CFA, assume 1819 we're saving SP like any other register; this happens 1820 on the ARM. */ 1821 def_cfa_1 (label, &cfa); 1822 queue_reg_save (label, stack_pointer_rtx, NULL_RTX, offset); 1823 break; 1824 } 1825 else 1826 { 1827 /* Otherwise, we'll need to look in the stack to 1828 calculate the CFA. */ 1829 rtx x = XEXP (dest, 0); 1830 1831 if (!REG_P (x)) 1832 x = XEXP (x, 0); 1833 gcc_assert (REG_P (x)); 1834 1835 cfa.reg = REGNO (x); 1836 cfa.base_offset = offset; 1837 cfa.indirect = 1; 1838 def_cfa_1 (label, &cfa); 1839 break; 1840 } 1841 } 1842 1843 def_cfa_1 (label, &cfa); 1844 queue_reg_save (label, src, NULL_RTX, offset); 1845 break; 1846 1847 default: 1848 gcc_unreachable (); 1849 } 1850} 1851 1852/* Record call frame debugging information for INSN, which either 1853 sets SP or FP (adjusting how we calculate the frame address) or saves a 1854 register to the stack. If INSN is NULL_RTX, initialize our state. 1855 1856 If AFTER_P is false, we're being called before the insn is emitted, 1857 otherwise after. Call instructions get invoked twice. */ 1858 1859void 1860dwarf2out_frame_debug (rtx insn, bool after_p) 1861{ 1862 const char *label; 1863 rtx src; 1864 1865 if (insn == NULL_RTX) 1866 { 1867 size_t i; 1868 1869 /* Flush any queued register saves. */ 1870 flush_queued_reg_saves (); 1871 1872 /* Set up state for generating call frame debug info. */ 1873 lookup_cfa (&cfa); 1874 gcc_assert (cfa.reg 1875 == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM)); 1876 1877 cfa.reg = STACK_POINTER_REGNUM; 1878 cfa_store = cfa; 1879 cfa_temp.reg = -1; 1880 cfa_temp.offset = 0; 1881 1882 for (i = 0; i < num_regs_saved_in_regs; i++) 1883 { 1884 regs_saved_in_regs[i].orig_reg = NULL_RTX; 1885 regs_saved_in_regs[i].saved_in_reg = NULL_RTX; 1886 } 1887 num_regs_saved_in_regs = 0; 1888 return; 1889 } 1890 1891 if (!NONJUMP_INSN_P (insn) || clobbers_queued_reg_save (insn)) 1892 flush_queued_reg_saves (); 1893 1894 if (! RTX_FRAME_RELATED_P (insn)) 1895 { 1896 if (!ACCUMULATE_OUTGOING_ARGS) 1897 dwarf2out_stack_adjust (insn, after_p); 1898 return; 1899 } 1900 1901 label = dwarf2out_cfi_label (); 1902 src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX); 1903 if (src) 1904 insn = XEXP (src, 0); 1905 else 1906 insn = PATTERN (insn); 1907 1908 dwarf2out_frame_debug_expr (insn, label); 1909} 1910 1911#endif 1912 1913/* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */ 1914static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc 1915 (enum dwarf_call_frame_info cfi); 1916 1917static enum dw_cfi_oprnd_type 1918dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi) 1919{ 1920 switch (cfi) 1921 { 1922 case DW_CFA_nop: 1923 case DW_CFA_GNU_window_save: 1924 return dw_cfi_oprnd_unused; 1925 1926 case DW_CFA_set_loc: 1927 case DW_CFA_advance_loc1: 1928 case DW_CFA_advance_loc2: 1929 case DW_CFA_advance_loc4: 1930 case DW_CFA_MIPS_advance_loc8: 1931 return dw_cfi_oprnd_addr; 1932 1933 case DW_CFA_offset: 1934 case DW_CFA_offset_extended: 1935 case DW_CFA_def_cfa: 1936 case DW_CFA_offset_extended_sf: 1937 case DW_CFA_def_cfa_sf: 1938 case DW_CFA_restore_extended: 1939 case DW_CFA_undefined: 1940 case DW_CFA_same_value: 1941 case DW_CFA_def_cfa_register: 1942 case DW_CFA_register: 1943 return dw_cfi_oprnd_reg_num; 1944 1945 case DW_CFA_def_cfa_offset: 1946 case DW_CFA_GNU_args_size: 1947 case DW_CFA_def_cfa_offset_sf: 1948 return dw_cfi_oprnd_offset; 1949 1950 case DW_CFA_def_cfa_expression: 1951 case DW_CFA_expression: 1952 return dw_cfi_oprnd_loc; 1953 1954 default: 1955 gcc_unreachable (); 1956 } 1957} 1958 1959/* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */ 1960static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc 1961 (enum dwarf_call_frame_info cfi); 1962 1963static enum dw_cfi_oprnd_type 1964dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi) 1965{ 1966 switch (cfi) 1967 { 1968 case DW_CFA_def_cfa: 1969 case DW_CFA_def_cfa_sf: 1970 case DW_CFA_offset: 1971 case DW_CFA_offset_extended_sf: 1972 case DW_CFA_offset_extended: 1973 return dw_cfi_oprnd_offset; 1974 1975 case DW_CFA_register: 1976 return dw_cfi_oprnd_reg_num; 1977 1978 default: 1979 return dw_cfi_oprnd_unused; 1980 } 1981} 1982 1983#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO) 1984 1985/* Switch to eh_frame_section. If we don't have an eh_frame_section, 1986 switch to the data section instead, and write out a synthetic label 1987 for collect2. */ 1988 1989static void 1990switch_to_eh_frame_section (void) 1991{ 1992 tree label; 1993 1994#ifdef EH_FRAME_SECTION_NAME 1995 if (eh_frame_section == 0) 1996 { 1997 int flags; 1998 1999 if (EH_TABLES_CAN_BE_READ_ONLY) 2000 { 2001 int fde_encoding; 2002 int per_encoding; 2003 int lsda_encoding; 2004 2005 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, 2006 /*global=*/0); 2007 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, 2008 /*global=*/1); 2009 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, 2010 /*global=*/0); 2011 flags = ((! flag_pic 2012 || ((fde_encoding & 0x70) != DW_EH_PE_absptr 2013 && (fde_encoding & 0x70) != DW_EH_PE_aligned 2014 && (per_encoding & 0x70) != DW_EH_PE_absptr 2015 && (per_encoding & 0x70) != DW_EH_PE_aligned 2016 && (lsda_encoding & 0x70) != DW_EH_PE_absptr 2017 && (lsda_encoding & 0x70) != DW_EH_PE_aligned)) 2018 ? 0 : SECTION_WRITE); 2019 } 2020 else 2021 flags = SECTION_WRITE; 2022 eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL); 2023 } 2024#endif 2025 2026 if (eh_frame_section) 2027 switch_to_section (eh_frame_section); 2028 else 2029 { 2030 /* We have no special eh_frame section. Put the information in 2031 the data section and emit special labels to guide collect2. */ 2032 switch_to_section (data_section); 2033 label = get_file_function_name ('F'); 2034 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE)); 2035 targetm.asm_out.globalize_label (asm_out_file, 2036 IDENTIFIER_POINTER (label)); 2037 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label)); 2038 } 2039} 2040 2041/* Output a Call Frame Information opcode and its operand(s). */ 2042 2043static void 2044output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int for_eh) 2045{ 2046 unsigned long r; 2047 if (cfi->dw_cfi_opc == DW_CFA_advance_loc) 2048 dw2_asm_output_data (1, (cfi->dw_cfi_opc 2049 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)), 2050 "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX, 2051 cfi->dw_cfi_oprnd1.dw_cfi_offset); 2052 else if (cfi->dw_cfi_opc == DW_CFA_offset) 2053 { 2054 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 2055 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)), 2056 "DW_CFA_offset, column 0x%lx", r); 2057 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL); 2058 } 2059 else if (cfi->dw_cfi_opc == DW_CFA_restore) 2060 { 2061 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 2062 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)), 2063 "DW_CFA_restore, column 0x%lx", r); 2064 } 2065 else 2066 { 2067 dw2_asm_output_data (1, cfi->dw_cfi_opc, 2068 "%s", dwarf_cfi_name (cfi->dw_cfi_opc)); 2069 2070 switch (cfi->dw_cfi_opc) 2071 { 2072 case DW_CFA_set_loc: 2073 if (for_eh) 2074 dw2_asm_output_encoded_addr_rtx ( 2075 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0), 2076 gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr), 2077 false, NULL); 2078 else 2079 dw2_asm_output_addr (DWARF2_ADDR_SIZE, 2080 cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL); 2081 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 2082 break; 2083 2084 case DW_CFA_advance_loc1: 2085 dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr, 2086 fde->dw_fde_current_label, NULL); 2087 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 2088 break; 2089 2090 case DW_CFA_advance_loc2: 2091 dw2_asm_output_delta (2, cfi->dw_cfi_oprnd1.dw_cfi_addr, 2092 fde->dw_fde_current_label, NULL); 2093 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 2094 break; 2095 2096 case DW_CFA_advance_loc4: 2097 dw2_asm_output_delta (4, cfi->dw_cfi_oprnd1.dw_cfi_addr, 2098 fde->dw_fde_current_label, NULL); 2099 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 2100 break; 2101 2102 case DW_CFA_MIPS_advance_loc8: 2103 dw2_asm_output_delta (8, cfi->dw_cfi_oprnd1.dw_cfi_addr, 2104 fde->dw_fde_current_label, NULL); 2105 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 2106 break; 2107 2108 case DW_CFA_offset_extended: 2109 case DW_CFA_def_cfa: 2110 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 2111 dw2_asm_output_data_uleb128 (r, NULL); 2112 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL); 2113 break; 2114 2115 case DW_CFA_offset_extended_sf: 2116 case DW_CFA_def_cfa_sf: 2117 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 2118 dw2_asm_output_data_uleb128 (r, NULL); 2119 dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL); 2120 break; 2121 2122 case DW_CFA_restore_extended: 2123 case DW_CFA_undefined: 2124 case DW_CFA_same_value: 2125 case DW_CFA_def_cfa_register: 2126 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 2127 dw2_asm_output_data_uleb128 (r, NULL); 2128 break; 2129 2130 case DW_CFA_register: 2131 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 2132 dw2_asm_output_data_uleb128 (r, NULL); 2133 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, for_eh); 2134 dw2_asm_output_data_uleb128 (r, NULL); 2135 break; 2136 2137 case DW_CFA_def_cfa_offset: 2138 case DW_CFA_GNU_args_size: 2139 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL); 2140 break; 2141 2142 case DW_CFA_def_cfa_offset_sf: 2143 dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL); 2144 break; 2145 2146 case DW_CFA_GNU_window_save: 2147 break; 2148 2149 case DW_CFA_def_cfa_expression: 2150 case DW_CFA_expression: 2151 output_cfa_loc (cfi); 2152 break; 2153 2154 case DW_CFA_GNU_negative_offset_extended: 2155 /* Obsoleted by DW_CFA_offset_extended_sf. */ 2156 gcc_unreachable (); 2157 2158 default: 2159 break; 2160 } 2161 } 2162} 2163 2164/* Output the call frame information used to record information 2165 that relates to calculating the frame pointer, and records the 2166 location of saved registers. */ 2167 2168static void 2169output_call_frame_info (int for_eh) 2170{ 2171 unsigned int i; 2172 dw_fde_ref fde; 2173 dw_cfi_ref cfi; 2174 char l1[20], l2[20], section_start_label[20]; 2175 bool any_lsda_needed = false; 2176 char augmentation[6]; 2177 int augmentation_size; 2178 int fde_encoding = DW_EH_PE_absptr; 2179 int per_encoding = DW_EH_PE_absptr; 2180 int lsda_encoding = DW_EH_PE_absptr; 2181 int return_reg; 2182 2183 /* Don't emit a CIE if there won't be any FDEs. */ 2184 if (fde_table_in_use == 0) 2185 return; 2186 2187 /* If we make FDEs linkonce, we may have to emit an empty label for 2188 an FDE that wouldn't otherwise be emitted. We want to avoid 2189 having an FDE kept around when the function it refers to is 2190 discarded. Example where this matters: a primary function 2191 template in C++ requires EH information, but an explicit 2192 specialization doesn't. */ 2193 if (TARGET_USES_WEAK_UNWIND_INFO 2194 && ! flag_asynchronous_unwind_tables 2195 && for_eh) 2196 for (i = 0; i < fde_table_in_use; i++) 2197 if ((fde_table[i].nothrow || fde_table[i].all_throwers_are_sibcalls) 2198 && !fde_table[i].uses_eh_lsda 2199 && ! DECL_WEAK (fde_table[i].decl)) 2200 targetm.asm_out.unwind_label (asm_out_file, fde_table[i].decl, 2201 for_eh, /* empty */ 1); 2202 2203 /* If we don't have any functions we'll want to unwind out of, don't 2204 emit any EH unwind information. Note that if exceptions aren't 2205 enabled, we won't have collected nothrow information, and if we 2206 asked for asynchronous tables, we always want this info. */ 2207 if (for_eh) 2208 { 2209 bool any_eh_needed = !flag_exceptions || flag_asynchronous_unwind_tables; 2210 2211 for (i = 0; i < fde_table_in_use; i++) 2212 if (fde_table[i].uses_eh_lsda) 2213 any_eh_needed = any_lsda_needed = true; 2214 else if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl)) 2215 any_eh_needed = true; 2216 else if (! fde_table[i].nothrow 2217 && ! fde_table[i].all_throwers_are_sibcalls) 2218 any_eh_needed = true; 2219 2220 if (! any_eh_needed) 2221 return; 2222 } 2223 2224 /* We're going to be generating comments, so turn on app. */ 2225 if (flag_debug_asm) 2226 app_enable (); 2227 2228 if (for_eh) 2229 switch_to_eh_frame_section (); 2230 else 2231 { 2232 if (!debug_frame_section) 2233 debug_frame_section = get_section (DEBUG_FRAME_SECTION, 2234 SECTION_DEBUG, NULL); 2235 switch_to_section (debug_frame_section); 2236 } 2237 2238 ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh); 2239 ASM_OUTPUT_LABEL (asm_out_file, section_start_label); 2240 2241 /* Output the CIE. */ 2242 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh); 2243 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh); 2244 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh) 2245 dw2_asm_output_data (4, 0xffffffff, 2246 "Initial length escape value indicating 64-bit DWARF extension"); 2247 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1, 2248 "Length of Common Information Entry"); 2249 ASM_OUTPUT_LABEL (asm_out_file, l1); 2250 2251 /* Now that the CIE pointer is PC-relative for EH, 2252 use 0 to identify the CIE. */ 2253 dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE), 2254 (for_eh ? 0 : DWARF_CIE_ID), 2255 "CIE Identifier Tag"); 2256 2257 dw2_asm_output_data (1, DW_CIE_VERSION, "CIE Version"); 2258 2259 augmentation[0] = 0; 2260 augmentation_size = 0; 2261 if (for_eh) 2262 { 2263 char *p; 2264 2265 /* Augmentation: 2266 z Indicates that a uleb128 is present to size the 2267 augmentation section. 2268 L Indicates the encoding (and thus presence) of 2269 an LSDA pointer in the FDE augmentation. 2270 R Indicates a non-default pointer encoding for 2271 FDE code pointers. 2272 P Indicates the presence of an encoding + language 2273 personality routine in the CIE augmentation. */ 2274 2275 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0); 2276 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1); 2277 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0); 2278 2279 p = augmentation + 1; 2280 if (eh_personality_libfunc) 2281 { 2282 *p++ = 'P'; 2283 augmentation_size += 1 + size_of_encoded_value (per_encoding); 2284 } 2285 if (any_lsda_needed) 2286 { 2287 *p++ = 'L'; 2288 augmentation_size += 1; 2289 } 2290 if (fde_encoding != DW_EH_PE_absptr) 2291 { 2292 *p++ = 'R'; 2293 augmentation_size += 1; 2294 } 2295 if (p > augmentation + 1) 2296 { 2297 augmentation[0] = 'z'; 2298 *p = '\0'; 2299 } 2300 2301 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */ 2302 if (eh_personality_libfunc && per_encoding == DW_EH_PE_aligned) 2303 { 2304 int offset = ( 4 /* Length */ 2305 + 4 /* CIE Id */ 2306 + 1 /* CIE version */ 2307 + strlen (augmentation) + 1 /* Augmentation */ 2308 + size_of_uleb128 (1) /* Code alignment */ 2309 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT) 2310 + 1 /* RA column */ 2311 + 1 /* Augmentation size */ 2312 + 1 /* Personality encoding */ ); 2313 int pad = -offset & (PTR_SIZE - 1); 2314 2315 augmentation_size += pad; 2316 2317 /* Augmentations should be small, so there's scarce need to 2318 iterate for a solution. Die if we exceed one uleb128 byte. */ 2319 gcc_assert (size_of_uleb128 (augmentation_size) == 1); 2320 } 2321 } 2322 2323 dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation"); 2324 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor"); 2325 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT, 2326 "CIE Data Alignment Factor"); 2327 2328 return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh); 2329 if (DW_CIE_VERSION == 1) 2330 dw2_asm_output_data (1, return_reg, "CIE RA Column"); 2331 else 2332 dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column"); 2333 2334 if (augmentation[0]) 2335 { 2336 dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size"); 2337 if (eh_personality_libfunc) 2338 { 2339 dw2_asm_output_data (1, per_encoding, "Personality (%s)", 2340 eh_data_format_name (per_encoding)); 2341 dw2_asm_output_encoded_addr_rtx (per_encoding, 2342 eh_personality_libfunc, 2343 true, NULL); 2344 } 2345 2346 if (any_lsda_needed) 2347 dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)", 2348 eh_data_format_name (lsda_encoding)); 2349 2350 if (fde_encoding != DW_EH_PE_absptr) 2351 dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)", 2352 eh_data_format_name (fde_encoding)); 2353 } 2354 2355 for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next) 2356 output_cfi (cfi, NULL, for_eh); 2357 2358 /* Pad the CIE out to an address sized boundary. */ 2359 ASM_OUTPUT_ALIGN (asm_out_file, 2360 floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)); 2361 ASM_OUTPUT_LABEL (asm_out_file, l2); 2362 2363 /* Loop through all of the FDE's. */ 2364 for (i = 0; i < fde_table_in_use; i++) 2365 { 2366 fde = &fde_table[i]; 2367 2368 /* Don't emit EH unwind info for leaf functions that don't need it. */ 2369 if (for_eh && !flag_asynchronous_unwind_tables && flag_exceptions 2370 && (fde->nothrow || fde->all_throwers_are_sibcalls) 2371 && ! (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl)) 2372 && !fde->uses_eh_lsda) 2373 continue; 2374 2375 targetm.asm_out.unwind_label (asm_out_file, fde->decl, for_eh, /* empty */ 0); 2376 targetm.asm_out.internal_label (asm_out_file, FDE_LABEL, for_eh + i * 2); 2377 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i * 2); 2378 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i * 2); 2379 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh) 2380 dw2_asm_output_data (4, 0xffffffff, 2381 "Initial length escape value indicating 64-bit DWARF extension"); 2382 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1, 2383 "FDE Length"); 2384 ASM_OUTPUT_LABEL (asm_out_file, l1); 2385 2386 if (for_eh) 2387 dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset"); 2388 else 2389 dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label, 2390 debug_frame_section, "FDE CIE offset"); 2391 2392 if (for_eh) 2393 { 2394 rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, fde->dw_fde_begin); 2395 SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL; 2396 dw2_asm_output_encoded_addr_rtx (fde_encoding, 2397 sym_ref, 2398 false, 2399 "FDE initial location"); 2400 if (fde->dw_fde_switched_sections) 2401 { 2402 rtx sym_ref2 = gen_rtx_SYMBOL_REF (Pmode, 2403 fde->dw_fde_unlikely_section_label); 2404 rtx sym_ref3= gen_rtx_SYMBOL_REF (Pmode, 2405 fde->dw_fde_hot_section_label); 2406 SYMBOL_REF_FLAGS (sym_ref2) |= SYMBOL_FLAG_LOCAL; 2407 SYMBOL_REF_FLAGS (sym_ref3) |= SYMBOL_FLAG_LOCAL; 2408 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref3, false, 2409 "FDE initial location"); 2410 dw2_asm_output_delta (size_of_encoded_value (fde_encoding), 2411 fde->dw_fde_hot_section_end_label, 2412 fde->dw_fde_hot_section_label, 2413 "FDE address range"); 2414 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref2, false, 2415 "FDE initial location"); 2416 dw2_asm_output_delta (size_of_encoded_value (fde_encoding), 2417 fde->dw_fde_unlikely_section_end_label, 2418 fde->dw_fde_unlikely_section_label, 2419 "FDE address range"); 2420 } 2421 else 2422 dw2_asm_output_delta (size_of_encoded_value (fde_encoding), 2423 fde->dw_fde_end, fde->dw_fde_begin, 2424 "FDE address range"); 2425 } 2426 else 2427 { 2428 dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin, 2429 "FDE initial location"); 2430 if (fde->dw_fde_switched_sections) 2431 { 2432 dw2_asm_output_addr (DWARF2_ADDR_SIZE, 2433 fde->dw_fde_hot_section_label, 2434 "FDE initial location"); 2435 dw2_asm_output_delta (DWARF2_ADDR_SIZE, 2436 fde->dw_fde_hot_section_end_label, 2437 fde->dw_fde_hot_section_label, 2438 "FDE address range"); 2439 dw2_asm_output_addr (DWARF2_ADDR_SIZE, 2440 fde->dw_fde_unlikely_section_label, 2441 "FDE initial location"); 2442 dw2_asm_output_delta (DWARF2_ADDR_SIZE, 2443 fde->dw_fde_unlikely_section_end_label, 2444 fde->dw_fde_unlikely_section_label, 2445 "FDE address range"); 2446 } 2447 else 2448 dw2_asm_output_delta (DWARF2_ADDR_SIZE, 2449 fde->dw_fde_end, fde->dw_fde_begin, 2450 "FDE address range"); 2451 } 2452 2453 if (augmentation[0]) 2454 { 2455 if (any_lsda_needed) 2456 { 2457 int size = size_of_encoded_value (lsda_encoding); 2458 2459 if (lsda_encoding == DW_EH_PE_aligned) 2460 { 2461 int offset = ( 4 /* Length */ 2462 + 4 /* CIE offset */ 2463 + 2 * size_of_encoded_value (fde_encoding) 2464 + 1 /* Augmentation size */ ); 2465 int pad = -offset & (PTR_SIZE - 1); 2466 2467 size += pad; 2468 gcc_assert (size_of_uleb128 (size) == 1); 2469 } 2470 2471 dw2_asm_output_data_uleb128 (size, "Augmentation size"); 2472 2473 if (fde->uses_eh_lsda) 2474 { 2475 ASM_GENERATE_INTERNAL_LABEL (l1, "LLSDA", 2476 fde->funcdef_number); 2477 dw2_asm_output_encoded_addr_rtx ( 2478 lsda_encoding, gen_rtx_SYMBOL_REF (Pmode, l1), 2479 false, "Language Specific Data Area"); 2480 } 2481 else 2482 { 2483 if (lsda_encoding == DW_EH_PE_aligned) 2484 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE)); 2485 dw2_asm_output_data 2486 (size_of_encoded_value (lsda_encoding), 0, 2487 "Language Specific Data Area (none)"); 2488 } 2489 } 2490 else 2491 dw2_asm_output_data_uleb128 (0, "Augmentation size"); 2492 } 2493 2494 /* Loop through the Call Frame Instructions associated with 2495 this FDE. */ 2496 fde->dw_fde_current_label = fde->dw_fde_begin; 2497 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next) 2498 output_cfi (cfi, fde, for_eh); 2499 2500 /* Pad the FDE out to an address sized boundary. */ 2501 ASM_OUTPUT_ALIGN (asm_out_file, 2502 floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE))); 2503 ASM_OUTPUT_LABEL (asm_out_file, l2); 2504 } 2505 2506 if (for_eh && targetm.terminate_dw2_eh_frame_info) 2507 dw2_asm_output_data (4, 0, "End of Table"); 2508#ifdef MIPS_DEBUGGING_INFO 2509 /* Work around Irix 6 assembler bug whereby labels at the end of a section 2510 get a value of 0. Putting .align 0 after the label fixes it. */ 2511 ASM_OUTPUT_ALIGN (asm_out_file, 0); 2512#endif 2513 2514 /* Turn off app to make assembly quicker. */ 2515 if (flag_debug_asm) 2516 app_disable (); 2517} 2518 2519/* Output a marker (i.e. a label) for the beginning of a function, before 2520 the prologue. */ 2521 2522void 2523dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED, 2524 const char *file ATTRIBUTE_UNUSED) 2525{ 2526 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 2527 char * dup_label; 2528 dw_fde_ref fde; 2529 2530 current_function_func_begin_label = NULL; 2531 2532#ifdef TARGET_UNWIND_INFO 2533 /* ??? current_function_func_begin_label is also used by except.c 2534 for call-site information. We must emit this label if it might 2535 be used. */ 2536 if ((! flag_exceptions || USING_SJLJ_EXCEPTIONS) 2537 && ! dwarf2out_do_frame ()) 2538 return; 2539#else 2540 if (! dwarf2out_do_frame ()) 2541 return; 2542#endif 2543 2544 switch_to_section (function_section (current_function_decl)); 2545 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL, 2546 current_function_funcdef_no); 2547 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL, 2548 current_function_funcdef_no); 2549 dup_label = xstrdup (label); 2550 current_function_func_begin_label = dup_label; 2551 2552#ifdef TARGET_UNWIND_INFO 2553 /* We can elide the fde allocation if we're not emitting debug info. */ 2554 if (! dwarf2out_do_frame ()) 2555 return; 2556#endif 2557 2558 /* Expand the fde table if necessary. */ 2559 if (fde_table_in_use == fde_table_allocated) 2560 { 2561 fde_table_allocated += FDE_TABLE_INCREMENT; 2562 fde_table = ggc_realloc (fde_table, 2563 fde_table_allocated * sizeof (dw_fde_node)); 2564 memset (fde_table + fde_table_in_use, 0, 2565 FDE_TABLE_INCREMENT * sizeof (dw_fde_node)); 2566 } 2567 2568 /* Record the FDE associated with this function. */ 2569 current_funcdef_fde = fde_table_in_use; 2570 2571 /* Add the new FDE at the end of the fde_table. */ 2572 fde = &fde_table[fde_table_in_use++]; 2573 fde->decl = current_function_decl; 2574 fde->dw_fde_begin = dup_label; 2575 fde->dw_fde_current_label = dup_label; 2576 fde->dw_fde_hot_section_label = NULL; 2577 fde->dw_fde_hot_section_end_label = NULL; 2578 fde->dw_fde_unlikely_section_label = NULL; 2579 fde->dw_fde_unlikely_section_end_label = NULL; 2580 fde->dw_fde_switched_sections = false; 2581 fde->dw_fde_end = NULL; 2582 fde->dw_fde_cfi = NULL; 2583 fde->funcdef_number = current_function_funcdef_no; 2584 fde->nothrow = TREE_NOTHROW (current_function_decl); 2585 fde->uses_eh_lsda = cfun->uses_eh_lsda; 2586 fde->all_throwers_are_sibcalls = cfun->all_throwers_are_sibcalls; 2587 2588 args_size = old_args_size = 0; 2589 2590 /* We only want to output line number information for the genuine dwarf2 2591 prologue case, not the eh frame case. */ 2592#ifdef DWARF2_DEBUGGING_INFO 2593 if (file) 2594 dwarf2out_source_line (line, file); 2595#endif 2596} 2597 2598/* Output a marker (i.e. a label) for the absolute end of the generated code 2599 for a function definition. This gets called *after* the epilogue code has 2600 been generated. */ 2601 2602void 2603dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED, 2604 const char *file ATTRIBUTE_UNUSED) 2605{ 2606 dw_fde_ref fde; 2607 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 2608 2609 /* Output a label to mark the endpoint of the code generated for this 2610 function. */ 2611 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL, 2612 current_function_funcdef_no); 2613 ASM_OUTPUT_LABEL (asm_out_file, label); 2614 fde = &fde_table[fde_table_in_use - 1]; 2615 fde->dw_fde_end = xstrdup (label); 2616} 2617 2618void 2619dwarf2out_frame_init (void) 2620{ 2621 /* Allocate the initial hunk of the fde_table. */ 2622 fde_table = ggc_alloc_cleared (FDE_TABLE_INCREMENT * sizeof (dw_fde_node)); 2623 fde_table_allocated = FDE_TABLE_INCREMENT; 2624 fde_table_in_use = 0; 2625 2626 /* Generate the CFA instructions common to all FDE's. Do it now for the 2627 sake of lookup_cfa. */ 2628 2629 /* On entry, the Canonical Frame Address is at SP. */ 2630 dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET); 2631 2632#ifdef DWARF2_UNWIND_INFO 2633 if (DWARF2_UNWIND_INFO) 2634 initial_return_save (INCOMING_RETURN_ADDR_RTX); 2635#endif 2636} 2637 2638void 2639dwarf2out_frame_finish (void) 2640{ 2641 /* Output call frame information. */ 2642 if (DWARF2_FRAME_INFO) 2643 output_call_frame_info (0); 2644 2645#ifndef TARGET_UNWIND_INFO 2646 /* Output another copy for the unwinder. */ 2647 if (! USING_SJLJ_EXCEPTIONS && (flag_unwind_tables || flag_exceptions)) 2648 output_call_frame_info (1); 2649#endif 2650} 2651#endif 2652 2653/* And now, the subset of the debugging information support code necessary 2654 for emitting location expressions. */ 2655 2656/* Data about a single source file. */ 2657struct dwarf_file_data GTY(()) 2658{ 2659 const char * filename; 2660 int emitted_number; 2661}; 2662 2663/* We need some way to distinguish DW_OP_addr with a direct symbol 2664 relocation from DW_OP_addr with a dtp-relative symbol relocation. */ 2665#define INTERNAL_DW_OP_tls_addr (0x100 + DW_OP_addr) 2666 2667 2668typedef struct dw_val_struct *dw_val_ref; 2669typedef struct die_struct *dw_die_ref; 2670typedef struct dw_loc_descr_struct *dw_loc_descr_ref; 2671typedef struct dw_loc_list_struct *dw_loc_list_ref; 2672 2673/* Each DIE may have a series of attribute/value pairs. Values 2674 can take on several forms. The forms that are used in this 2675 implementation are listed below. */ 2676 2677enum dw_val_class 2678{ 2679 dw_val_class_addr, 2680 dw_val_class_offset, 2681 dw_val_class_loc, 2682 dw_val_class_loc_list, 2683 dw_val_class_range_list, 2684 dw_val_class_const, 2685 dw_val_class_unsigned_const, 2686 dw_val_class_long_long, 2687 dw_val_class_vec, 2688 dw_val_class_flag, 2689 dw_val_class_die_ref, 2690 dw_val_class_fde_ref, 2691 dw_val_class_lbl_id, 2692 dw_val_class_lineptr, 2693 dw_val_class_str, 2694 dw_val_class_macptr, 2695 dw_val_class_file 2696}; 2697 2698/* Describe a double word constant value. */ 2699/* ??? Every instance of long_long in the code really means CONST_DOUBLE. */ 2700 2701typedef struct dw_long_long_struct GTY(()) 2702{ 2703 unsigned long hi; 2704 unsigned long low; 2705} 2706dw_long_long_const; 2707 2708/* Describe a floating point constant value, or a vector constant value. */ 2709 2710typedef struct dw_vec_struct GTY(()) 2711{ 2712 unsigned char * GTY((length ("%h.length"))) array; 2713 unsigned length; 2714 unsigned elt_size; 2715} 2716dw_vec_const; 2717 2718/* The dw_val_node describes an attribute's value, as it is 2719 represented internally. */ 2720 2721typedef struct dw_val_struct GTY(()) 2722{ 2723 enum dw_val_class val_class; 2724 union dw_val_struct_union 2725 { 2726 rtx GTY ((tag ("dw_val_class_addr"))) val_addr; 2727 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset; 2728 dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list; 2729 dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc; 2730 HOST_WIDE_INT GTY ((default)) val_int; 2731 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned; 2732 dw_long_long_const GTY ((tag ("dw_val_class_long_long"))) val_long_long; 2733 dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec; 2734 struct dw_val_die_union 2735 { 2736 dw_die_ref die; 2737 int external; 2738 } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref; 2739 unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index; 2740 struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str; 2741 char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id; 2742 unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag; 2743 struct dwarf_file_data * GTY ((tag ("dw_val_class_file"))) val_file; 2744 } 2745 GTY ((desc ("%1.val_class"))) v; 2746} 2747dw_val_node; 2748 2749/* Locations in memory are described using a sequence of stack machine 2750 operations. */ 2751 2752typedef struct dw_loc_descr_struct GTY(()) 2753{ 2754 dw_loc_descr_ref dw_loc_next; 2755 enum dwarf_location_atom dw_loc_opc; 2756 dw_val_node dw_loc_oprnd1; 2757 dw_val_node dw_loc_oprnd2; 2758 int dw_loc_addr; 2759} 2760dw_loc_descr_node; 2761 2762/* Location lists are ranges + location descriptions for that range, 2763 so you can track variables that are in different places over 2764 their entire life. */ 2765typedef struct dw_loc_list_struct GTY(()) 2766{ 2767 dw_loc_list_ref dw_loc_next; 2768 const char *begin; /* Label for begin address of range */ 2769 const char *end; /* Label for end address of range */ 2770 char *ll_symbol; /* Label for beginning of location list. 2771 Only on head of list */ 2772 const char *section; /* Section this loclist is relative to */ 2773 dw_loc_descr_ref expr; 2774} dw_loc_list_node; 2775 2776#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO) 2777 2778static const char *dwarf_stack_op_name (unsigned); 2779static dw_loc_descr_ref new_loc_descr (enum dwarf_location_atom, 2780 unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT); 2781static void add_loc_descr (dw_loc_descr_ref *, dw_loc_descr_ref); 2782static unsigned long size_of_loc_descr (dw_loc_descr_ref); 2783static unsigned long size_of_locs (dw_loc_descr_ref); 2784static void output_loc_operands (dw_loc_descr_ref); 2785static void output_loc_sequence (dw_loc_descr_ref); 2786 2787/* Convert a DWARF stack opcode into its string name. */ 2788 2789static const char * 2790dwarf_stack_op_name (unsigned int op) 2791{ 2792 switch (op) 2793 { 2794 case DW_OP_addr: 2795 case INTERNAL_DW_OP_tls_addr: 2796 return "DW_OP_addr"; 2797 case DW_OP_deref: 2798 return "DW_OP_deref"; 2799 case DW_OP_const1u: 2800 return "DW_OP_const1u"; 2801 case DW_OP_const1s: 2802 return "DW_OP_const1s"; 2803 case DW_OP_const2u: 2804 return "DW_OP_const2u"; 2805 case DW_OP_const2s: 2806 return "DW_OP_const2s"; 2807 case DW_OP_const4u: 2808 return "DW_OP_const4u"; 2809 case DW_OP_const4s: 2810 return "DW_OP_const4s"; 2811 case DW_OP_const8u: 2812 return "DW_OP_const8u"; 2813 case DW_OP_const8s: 2814 return "DW_OP_const8s"; 2815 case DW_OP_constu: 2816 return "DW_OP_constu"; 2817 case DW_OP_consts: 2818 return "DW_OP_consts"; 2819 case DW_OP_dup: 2820 return "DW_OP_dup"; 2821 case DW_OP_drop: 2822 return "DW_OP_drop"; 2823 case DW_OP_over: 2824 return "DW_OP_over"; 2825 case DW_OP_pick: 2826 return "DW_OP_pick"; 2827 case DW_OP_swap: 2828 return "DW_OP_swap"; 2829 case DW_OP_rot: 2830 return "DW_OP_rot"; 2831 case DW_OP_xderef: 2832 return "DW_OP_xderef"; 2833 case DW_OP_abs: 2834 return "DW_OP_abs"; 2835 case DW_OP_and: 2836 return "DW_OP_and"; 2837 case DW_OP_div: 2838 return "DW_OP_div"; 2839 case DW_OP_minus: 2840 return "DW_OP_minus"; 2841 case DW_OP_mod: 2842 return "DW_OP_mod"; 2843 case DW_OP_mul: 2844 return "DW_OP_mul"; 2845 case DW_OP_neg: 2846 return "DW_OP_neg"; 2847 case DW_OP_not: 2848 return "DW_OP_not"; 2849 case DW_OP_or: 2850 return "DW_OP_or"; 2851 case DW_OP_plus: 2852 return "DW_OP_plus"; 2853 case DW_OP_plus_uconst: 2854 return "DW_OP_plus_uconst"; 2855 case DW_OP_shl: 2856 return "DW_OP_shl"; 2857 case DW_OP_shr: 2858 return "DW_OP_shr"; 2859 case DW_OP_shra: 2860 return "DW_OP_shra"; 2861 case DW_OP_xor: 2862 return "DW_OP_xor"; 2863 case DW_OP_bra: 2864 return "DW_OP_bra"; 2865 case DW_OP_eq: 2866 return "DW_OP_eq"; 2867 case DW_OP_ge: 2868 return "DW_OP_ge"; 2869 case DW_OP_gt: 2870 return "DW_OP_gt"; 2871 case DW_OP_le: 2872 return "DW_OP_le"; 2873 case DW_OP_lt: 2874 return "DW_OP_lt"; 2875 case DW_OP_ne: 2876 return "DW_OP_ne"; 2877 case DW_OP_skip: 2878 return "DW_OP_skip"; 2879 case DW_OP_lit0: 2880 return "DW_OP_lit0"; 2881 case DW_OP_lit1: 2882 return "DW_OP_lit1"; 2883 case DW_OP_lit2: 2884 return "DW_OP_lit2"; 2885 case DW_OP_lit3: 2886 return "DW_OP_lit3"; 2887 case DW_OP_lit4: 2888 return "DW_OP_lit4"; 2889 case DW_OP_lit5: 2890 return "DW_OP_lit5"; 2891 case DW_OP_lit6: 2892 return "DW_OP_lit6"; 2893 case DW_OP_lit7: 2894 return "DW_OP_lit7"; 2895 case DW_OP_lit8: 2896 return "DW_OP_lit8"; 2897 case DW_OP_lit9: 2898 return "DW_OP_lit9"; 2899 case DW_OP_lit10: 2900 return "DW_OP_lit10"; 2901 case DW_OP_lit11: 2902 return "DW_OP_lit11"; 2903 case DW_OP_lit12: 2904 return "DW_OP_lit12"; 2905 case DW_OP_lit13: 2906 return "DW_OP_lit13"; 2907 case DW_OP_lit14: 2908 return "DW_OP_lit14"; 2909 case DW_OP_lit15: 2910 return "DW_OP_lit15"; 2911 case DW_OP_lit16: 2912 return "DW_OP_lit16"; 2913 case DW_OP_lit17: 2914 return "DW_OP_lit17"; 2915 case DW_OP_lit18: 2916 return "DW_OP_lit18"; 2917 case DW_OP_lit19: 2918 return "DW_OP_lit19"; 2919 case DW_OP_lit20: 2920 return "DW_OP_lit20"; 2921 case DW_OP_lit21: 2922 return "DW_OP_lit21"; 2923 case DW_OP_lit22: 2924 return "DW_OP_lit22"; 2925 case DW_OP_lit23: 2926 return "DW_OP_lit23"; 2927 case DW_OP_lit24: 2928 return "DW_OP_lit24"; 2929 case DW_OP_lit25: 2930 return "DW_OP_lit25"; 2931 case DW_OP_lit26: 2932 return "DW_OP_lit26"; 2933 case DW_OP_lit27: 2934 return "DW_OP_lit27"; 2935 case DW_OP_lit28: 2936 return "DW_OP_lit28"; 2937 case DW_OP_lit29: 2938 return "DW_OP_lit29"; 2939 case DW_OP_lit30: 2940 return "DW_OP_lit30"; 2941 case DW_OP_lit31: 2942 return "DW_OP_lit31"; 2943 case DW_OP_reg0: 2944 return "DW_OP_reg0"; 2945 case DW_OP_reg1: 2946 return "DW_OP_reg1"; 2947 case DW_OP_reg2: 2948 return "DW_OP_reg2"; 2949 case DW_OP_reg3: 2950 return "DW_OP_reg3"; 2951 case DW_OP_reg4: 2952 return "DW_OP_reg4"; 2953 case DW_OP_reg5: 2954 return "DW_OP_reg5"; 2955 case DW_OP_reg6: 2956 return "DW_OP_reg6"; 2957 case DW_OP_reg7: 2958 return "DW_OP_reg7"; 2959 case DW_OP_reg8: 2960 return "DW_OP_reg8"; 2961 case DW_OP_reg9: 2962 return "DW_OP_reg9"; 2963 case DW_OP_reg10: 2964 return "DW_OP_reg10"; 2965 case DW_OP_reg11: 2966 return "DW_OP_reg11"; 2967 case DW_OP_reg12: 2968 return "DW_OP_reg12"; 2969 case DW_OP_reg13: 2970 return "DW_OP_reg13"; 2971 case DW_OP_reg14: 2972 return "DW_OP_reg14"; 2973 case DW_OP_reg15: 2974 return "DW_OP_reg15"; 2975 case DW_OP_reg16: 2976 return "DW_OP_reg16"; 2977 case DW_OP_reg17: 2978 return "DW_OP_reg17"; 2979 case DW_OP_reg18: 2980 return "DW_OP_reg18"; 2981 case DW_OP_reg19: 2982 return "DW_OP_reg19"; 2983 case DW_OP_reg20: 2984 return "DW_OP_reg20"; 2985 case DW_OP_reg21: 2986 return "DW_OP_reg21"; 2987 case DW_OP_reg22: 2988 return "DW_OP_reg22"; 2989 case DW_OP_reg23: 2990 return "DW_OP_reg23"; 2991 case DW_OP_reg24: 2992 return "DW_OP_reg24"; 2993 case DW_OP_reg25: 2994 return "DW_OP_reg25"; 2995 case DW_OP_reg26: 2996 return "DW_OP_reg26"; 2997 case DW_OP_reg27: 2998 return "DW_OP_reg27"; 2999 case DW_OP_reg28: 3000 return "DW_OP_reg28"; 3001 case DW_OP_reg29: 3002 return "DW_OP_reg29"; 3003 case DW_OP_reg30: 3004 return "DW_OP_reg30"; 3005 case DW_OP_reg31: 3006 return "DW_OP_reg31"; 3007 case DW_OP_breg0: 3008 return "DW_OP_breg0"; 3009 case DW_OP_breg1: 3010 return "DW_OP_breg1"; 3011 case DW_OP_breg2: 3012 return "DW_OP_breg2"; 3013 case DW_OP_breg3: 3014 return "DW_OP_breg3"; 3015 case DW_OP_breg4: 3016 return "DW_OP_breg4"; 3017 case DW_OP_breg5: 3018 return "DW_OP_breg5"; 3019 case DW_OP_breg6: 3020 return "DW_OP_breg6"; 3021 case DW_OP_breg7: 3022 return "DW_OP_breg7"; 3023 case DW_OP_breg8: 3024 return "DW_OP_breg8"; 3025 case DW_OP_breg9: 3026 return "DW_OP_breg9"; 3027 case DW_OP_breg10: 3028 return "DW_OP_breg10"; 3029 case DW_OP_breg11: 3030 return "DW_OP_breg11"; 3031 case DW_OP_breg12: 3032 return "DW_OP_breg12"; 3033 case DW_OP_breg13: 3034 return "DW_OP_breg13"; 3035 case DW_OP_breg14: 3036 return "DW_OP_breg14"; 3037 case DW_OP_breg15: 3038 return "DW_OP_breg15"; 3039 case DW_OP_breg16: 3040 return "DW_OP_breg16"; 3041 case DW_OP_breg17: 3042 return "DW_OP_breg17"; 3043 case DW_OP_breg18: 3044 return "DW_OP_breg18"; 3045 case DW_OP_breg19: 3046 return "DW_OP_breg19"; 3047 case DW_OP_breg20: 3048 return "DW_OP_breg20"; 3049 case DW_OP_breg21: 3050 return "DW_OP_breg21"; 3051 case DW_OP_breg22: 3052 return "DW_OP_breg22"; 3053 case DW_OP_breg23: 3054 return "DW_OP_breg23"; 3055 case DW_OP_breg24: 3056 return "DW_OP_breg24"; 3057 case DW_OP_breg25: 3058 return "DW_OP_breg25"; 3059 case DW_OP_breg26: 3060 return "DW_OP_breg26"; 3061 case DW_OP_breg27: 3062 return "DW_OP_breg27"; 3063 case DW_OP_breg28: 3064 return "DW_OP_breg28"; 3065 case DW_OP_breg29: 3066 return "DW_OP_breg29"; 3067 case DW_OP_breg30: 3068 return "DW_OP_breg30"; 3069 case DW_OP_breg31: 3070 return "DW_OP_breg31"; 3071 case DW_OP_regx: 3072 return "DW_OP_regx"; 3073 case DW_OP_fbreg: 3074 return "DW_OP_fbreg"; 3075 case DW_OP_bregx: 3076 return "DW_OP_bregx"; 3077 case DW_OP_piece: 3078 return "DW_OP_piece"; 3079 case DW_OP_deref_size: 3080 return "DW_OP_deref_size"; 3081 case DW_OP_xderef_size: 3082 return "DW_OP_xderef_size"; 3083 case DW_OP_nop: 3084 return "DW_OP_nop"; 3085 case DW_OP_push_object_address: 3086 return "DW_OP_push_object_address"; 3087 case DW_OP_call2: 3088 return "DW_OP_call2"; 3089 case DW_OP_call4: 3090 return "DW_OP_call4"; 3091 case DW_OP_call_ref: 3092 return "DW_OP_call_ref"; 3093 case DW_OP_GNU_push_tls_address: 3094 return "DW_OP_GNU_push_tls_address"; 3095 default: 3096 return "OP_<unknown>"; 3097 } 3098} 3099 3100/* Return a pointer to a newly allocated location description. Location 3101 descriptions are simple expression terms that can be strung 3102 together to form more complicated location (address) descriptions. */ 3103 3104static inline dw_loc_descr_ref 3105new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1, 3106 unsigned HOST_WIDE_INT oprnd2) 3107{ 3108 dw_loc_descr_ref descr = ggc_alloc_cleared (sizeof (dw_loc_descr_node)); 3109 3110 descr->dw_loc_opc = op; 3111 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const; 3112 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1; 3113 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const; 3114 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2; 3115 3116 return descr; 3117} 3118 3119/* Add a location description term to a location description expression. */ 3120 3121static inline void 3122add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr) 3123{ 3124 dw_loc_descr_ref *d; 3125 3126 /* Find the end of the chain. */ 3127 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next) 3128 ; 3129 3130 *d = descr; 3131} 3132 3133/* Return the size of a location descriptor. */ 3134 3135static unsigned long 3136size_of_loc_descr (dw_loc_descr_ref loc) 3137{ 3138 unsigned long size = 1; 3139 3140 switch (loc->dw_loc_opc) 3141 { 3142 case DW_OP_addr: 3143 case INTERNAL_DW_OP_tls_addr: 3144 size += DWARF2_ADDR_SIZE; 3145 break; 3146 case DW_OP_const1u: 3147 case DW_OP_const1s: 3148 size += 1; 3149 break; 3150 case DW_OP_const2u: 3151 case DW_OP_const2s: 3152 size += 2; 3153 break; 3154 case DW_OP_const4u: 3155 case DW_OP_const4s: 3156 size += 4; 3157 break; 3158 case DW_OP_const8u: 3159 case DW_OP_const8s: 3160 size += 8; 3161 break; 3162 case DW_OP_constu: 3163 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 3164 break; 3165 case DW_OP_consts: 3166 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int); 3167 break; 3168 case DW_OP_pick: 3169 size += 1; 3170 break; 3171 case DW_OP_plus_uconst: 3172 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 3173 break; 3174 case DW_OP_skip: 3175 case DW_OP_bra: 3176 size += 2; 3177 break; 3178 case DW_OP_breg0: 3179 case DW_OP_breg1: 3180 case DW_OP_breg2: 3181 case DW_OP_breg3: 3182 case DW_OP_breg4: 3183 case DW_OP_breg5: 3184 case DW_OP_breg6: 3185 case DW_OP_breg7: 3186 case DW_OP_breg8: 3187 case DW_OP_breg9: 3188 case DW_OP_breg10: 3189 case DW_OP_breg11: 3190 case DW_OP_breg12: 3191 case DW_OP_breg13: 3192 case DW_OP_breg14: 3193 case DW_OP_breg15: 3194 case DW_OP_breg16: 3195 case DW_OP_breg17: 3196 case DW_OP_breg18: 3197 case DW_OP_breg19: 3198 case DW_OP_breg20: 3199 case DW_OP_breg21: 3200 case DW_OP_breg22: 3201 case DW_OP_breg23: 3202 case DW_OP_breg24: 3203 case DW_OP_breg25: 3204 case DW_OP_breg26: 3205 case DW_OP_breg27: 3206 case DW_OP_breg28: 3207 case DW_OP_breg29: 3208 case DW_OP_breg30: 3209 case DW_OP_breg31: 3210 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int); 3211 break; 3212 case DW_OP_regx: 3213 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 3214 break; 3215 case DW_OP_fbreg: 3216 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int); 3217 break; 3218 case DW_OP_bregx: 3219 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 3220 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int); 3221 break; 3222 case DW_OP_piece: 3223 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 3224 break; 3225 case DW_OP_deref_size: 3226 case DW_OP_xderef_size: 3227 size += 1; 3228 break; 3229 case DW_OP_call2: 3230 size += 2; 3231 break; 3232 case DW_OP_call4: 3233 size += 4; 3234 break; 3235 case DW_OP_call_ref: 3236 size += DWARF2_ADDR_SIZE; 3237 break; 3238 default: 3239 break; 3240 } 3241 3242 return size; 3243} 3244 3245/* Return the size of a series of location descriptors. */ 3246 3247static unsigned long 3248size_of_locs (dw_loc_descr_ref loc) 3249{ 3250 dw_loc_descr_ref l; 3251 unsigned long size; 3252 3253 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr 3254 field, to avoid writing to a PCH file. */ 3255 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next) 3256 { 3257 if (l->dw_loc_opc == DW_OP_skip || l->dw_loc_opc == DW_OP_bra) 3258 break; 3259 size += size_of_loc_descr (l); 3260 } 3261 if (! l) 3262 return size; 3263 3264 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next) 3265 { 3266 l->dw_loc_addr = size; 3267 size += size_of_loc_descr (l); 3268 } 3269 3270 return size; 3271} 3272 3273/* Output location description stack opcode's operands (if any). */ 3274 3275static void 3276output_loc_operands (dw_loc_descr_ref loc) 3277{ 3278 dw_val_ref val1 = &loc->dw_loc_oprnd1; 3279 dw_val_ref val2 = &loc->dw_loc_oprnd2; 3280 3281 switch (loc->dw_loc_opc) 3282 { 3283#ifdef DWARF2_DEBUGGING_INFO 3284 case DW_OP_addr: 3285 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL); 3286 break; 3287 case DW_OP_const2u: 3288 case DW_OP_const2s: 3289 dw2_asm_output_data (2, val1->v.val_int, NULL); 3290 break; 3291 case DW_OP_const4u: 3292 case DW_OP_const4s: 3293 dw2_asm_output_data (4, val1->v.val_int, NULL); 3294 break; 3295 case DW_OP_const8u: 3296 case DW_OP_const8s: 3297 gcc_assert (HOST_BITS_PER_LONG >= 64); 3298 dw2_asm_output_data (8, val1->v.val_int, NULL); 3299 break; 3300 case DW_OP_skip: 3301 case DW_OP_bra: 3302 { 3303 int offset; 3304 3305 gcc_assert (val1->val_class == dw_val_class_loc); 3306 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3); 3307 3308 dw2_asm_output_data (2, offset, NULL); 3309 } 3310 break; 3311#else 3312 case DW_OP_addr: 3313 case DW_OP_const2u: 3314 case DW_OP_const2s: 3315 case DW_OP_const4u: 3316 case DW_OP_const4s: 3317 case DW_OP_const8u: 3318 case DW_OP_const8s: 3319 case DW_OP_skip: 3320 case DW_OP_bra: 3321 /* We currently don't make any attempt to make sure these are 3322 aligned properly like we do for the main unwind info, so 3323 don't support emitting things larger than a byte if we're 3324 only doing unwinding. */ 3325 gcc_unreachable (); 3326#endif 3327 case DW_OP_const1u: 3328 case DW_OP_const1s: 3329 dw2_asm_output_data (1, val1->v.val_int, NULL); 3330 break; 3331 case DW_OP_constu: 3332 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 3333 break; 3334 case DW_OP_consts: 3335 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL); 3336 break; 3337 case DW_OP_pick: 3338 dw2_asm_output_data (1, val1->v.val_int, NULL); 3339 break; 3340 case DW_OP_plus_uconst: 3341 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 3342 break; 3343 case DW_OP_breg0: 3344 case DW_OP_breg1: 3345 case DW_OP_breg2: 3346 case DW_OP_breg3: 3347 case DW_OP_breg4: 3348 case DW_OP_breg5: 3349 case DW_OP_breg6: 3350 case DW_OP_breg7: 3351 case DW_OP_breg8: 3352 case DW_OP_breg9: 3353 case DW_OP_breg10: 3354 case DW_OP_breg11: 3355 case DW_OP_breg12: 3356 case DW_OP_breg13: 3357 case DW_OP_breg14: 3358 case DW_OP_breg15: 3359 case DW_OP_breg16: 3360 case DW_OP_breg17: 3361 case DW_OP_breg18: 3362 case DW_OP_breg19: 3363 case DW_OP_breg20: 3364 case DW_OP_breg21: 3365 case DW_OP_breg22: 3366 case DW_OP_breg23: 3367 case DW_OP_breg24: 3368 case DW_OP_breg25: 3369 case DW_OP_breg26: 3370 case DW_OP_breg27: 3371 case DW_OP_breg28: 3372 case DW_OP_breg29: 3373 case DW_OP_breg30: 3374 case DW_OP_breg31: 3375 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL); 3376 break; 3377 case DW_OP_regx: 3378 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 3379 break; 3380 case DW_OP_fbreg: 3381 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL); 3382 break; 3383 case DW_OP_bregx: 3384 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 3385 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL); 3386 break; 3387 case DW_OP_piece: 3388 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 3389 break; 3390 case DW_OP_deref_size: 3391 case DW_OP_xderef_size: 3392 dw2_asm_output_data (1, val1->v.val_int, NULL); 3393 break; 3394 3395 case INTERNAL_DW_OP_tls_addr: 3396 if (targetm.asm_out.output_dwarf_dtprel) 3397 { 3398 targetm.asm_out.output_dwarf_dtprel (asm_out_file, 3399 DWARF2_ADDR_SIZE, 3400 val1->v.val_addr); 3401 fputc ('\n', asm_out_file); 3402 } 3403 else 3404 gcc_unreachable (); 3405 break; 3406 3407 default: 3408 /* Other codes have no operands. */ 3409 break; 3410 } 3411} 3412 3413/* Output a sequence of location operations. */ 3414 3415static void 3416output_loc_sequence (dw_loc_descr_ref loc) 3417{ 3418 for (; loc != NULL; loc = loc->dw_loc_next) 3419 { 3420 /* Output the opcode. */ 3421 dw2_asm_output_data (1, loc->dw_loc_opc, 3422 "%s", dwarf_stack_op_name (loc->dw_loc_opc)); 3423 3424 /* Output the operand(s) (if any). */ 3425 output_loc_operands (loc); 3426 } 3427} 3428 3429/* This routine will generate the correct assembly data for a location 3430 description based on a cfi entry with a complex address. */ 3431 3432static void 3433output_cfa_loc (dw_cfi_ref cfi) 3434{ 3435 dw_loc_descr_ref loc; 3436 unsigned long size; 3437 3438 /* Output the size of the block. */ 3439 loc = cfi->dw_cfi_oprnd1.dw_cfi_loc; 3440 size = size_of_locs (loc); 3441 dw2_asm_output_data_uleb128 (size, NULL); 3442 3443 /* Now output the operations themselves. */ 3444 output_loc_sequence (loc); 3445} 3446 3447/* This function builds a dwarf location descriptor sequence from a 3448 dw_cfa_location, adding the given OFFSET to the result of the 3449 expression. */ 3450 3451static struct dw_loc_descr_struct * 3452build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset) 3453{ 3454 struct dw_loc_descr_struct *head, *tmp; 3455 3456 offset += cfa->offset; 3457 3458 if (cfa->indirect) 3459 { 3460 if (cfa->base_offset) 3461 { 3462 if (cfa->reg <= 31) 3463 head = new_loc_descr (DW_OP_breg0 + cfa->reg, cfa->base_offset, 0); 3464 else 3465 head = new_loc_descr (DW_OP_bregx, cfa->reg, cfa->base_offset); 3466 } 3467 else if (cfa->reg <= 31) 3468 head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0); 3469 else 3470 head = new_loc_descr (DW_OP_regx, cfa->reg, 0); 3471 3472 head->dw_loc_oprnd1.val_class = dw_val_class_const; 3473 tmp = new_loc_descr (DW_OP_deref, 0, 0); 3474 add_loc_descr (&head, tmp); 3475 if (offset != 0) 3476 { 3477 tmp = new_loc_descr (DW_OP_plus_uconst, offset, 0); 3478 add_loc_descr (&head, tmp); 3479 } 3480 } 3481 else 3482 { 3483 if (offset == 0) 3484 if (cfa->reg <= 31) 3485 head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0); 3486 else 3487 head = new_loc_descr (DW_OP_regx, cfa->reg, 0); 3488 else if (cfa->reg <= 31) 3489 head = new_loc_descr (DW_OP_breg0 + cfa->reg, offset, 0); 3490 else 3491 head = new_loc_descr (DW_OP_bregx, cfa->reg, offset); 3492 } 3493 3494 return head; 3495} 3496 3497/* This function fills in aa dw_cfa_location structure from a dwarf location 3498 descriptor sequence. */ 3499 3500static void 3501get_cfa_from_loc_descr (dw_cfa_location *cfa, struct dw_loc_descr_struct *loc) 3502{ 3503 struct dw_loc_descr_struct *ptr; 3504 cfa->offset = 0; 3505 cfa->base_offset = 0; 3506 cfa->indirect = 0; 3507 cfa->reg = -1; 3508 3509 for (ptr = loc; ptr != NULL; ptr = ptr->dw_loc_next) 3510 { 3511 enum dwarf_location_atom op = ptr->dw_loc_opc; 3512 3513 switch (op) 3514 { 3515 case DW_OP_reg0: 3516 case DW_OP_reg1: 3517 case DW_OP_reg2: 3518 case DW_OP_reg3: 3519 case DW_OP_reg4: 3520 case DW_OP_reg5: 3521 case DW_OP_reg6: 3522 case DW_OP_reg7: 3523 case DW_OP_reg8: 3524 case DW_OP_reg9: 3525 case DW_OP_reg10: 3526 case DW_OP_reg11: 3527 case DW_OP_reg12: 3528 case DW_OP_reg13: 3529 case DW_OP_reg14: 3530 case DW_OP_reg15: 3531 case DW_OP_reg16: 3532 case DW_OP_reg17: 3533 case DW_OP_reg18: 3534 case DW_OP_reg19: 3535 case DW_OP_reg20: 3536 case DW_OP_reg21: 3537 case DW_OP_reg22: 3538 case DW_OP_reg23: 3539 case DW_OP_reg24: 3540 case DW_OP_reg25: 3541 case DW_OP_reg26: 3542 case DW_OP_reg27: 3543 case DW_OP_reg28: 3544 case DW_OP_reg29: 3545 case DW_OP_reg30: 3546 case DW_OP_reg31: 3547 cfa->reg = op - DW_OP_reg0; 3548 break; 3549 case DW_OP_regx: 3550 cfa->reg = ptr->dw_loc_oprnd1.v.val_int; 3551 break; 3552 case DW_OP_breg0: 3553 case DW_OP_breg1: 3554 case DW_OP_breg2: 3555 case DW_OP_breg3: 3556 case DW_OP_breg4: 3557 case DW_OP_breg5: 3558 case DW_OP_breg6: 3559 case DW_OP_breg7: 3560 case DW_OP_breg8: 3561 case DW_OP_breg9: 3562 case DW_OP_breg10: 3563 case DW_OP_breg11: 3564 case DW_OP_breg12: 3565 case DW_OP_breg13: 3566 case DW_OP_breg14: 3567 case DW_OP_breg15: 3568 case DW_OP_breg16: 3569 case DW_OP_breg17: 3570 case DW_OP_breg18: 3571 case DW_OP_breg19: 3572 case DW_OP_breg20: 3573 case DW_OP_breg21: 3574 case DW_OP_breg22: 3575 case DW_OP_breg23: 3576 case DW_OP_breg24: 3577 case DW_OP_breg25: 3578 case DW_OP_breg26: 3579 case DW_OP_breg27: 3580 case DW_OP_breg28: 3581 case DW_OP_breg29: 3582 case DW_OP_breg30: 3583 case DW_OP_breg31: 3584 cfa->reg = op - DW_OP_breg0; 3585 cfa->base_offset = ptr->dw_loc_oprnd1.v.val_int; 3586 break; 3587 case DW_OP_bregx: 3588 cfa->reg = ptr->dw_loc_oprnd1.v.val_int; 3589 cfa->base_offset = ptr->dw_loc_oprnd2.v.val_int; 3590 break; 3591 case DW_OP_deref: 3592 cfa->indirect = 1; 3593 break; 3594 case DW_OP_plus_uconst: 3595 cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned; 3596 break; 3597 default: 3598 internal_error ("DW_LOC_OP %s not implemented", 3599 dwarf_stack_op_name (ptr->dw_loc_opc)); 3600 } 3601 } 3602} 3603#endif /* .debug_frame support */ 3604 3605/* And now, the support for symbolic debugging information. */ 3606#ifdef DWARF2_DEBUGGING_INFO 3607 3608/* .debug_str support. */ 3609static int output_indirect_string (void **, void *); 3610 3611static void dwarf2out_init (const char *); 3612static void dwarf2out_finish (const char *); 3613static void dwarf2out_define (unsigned int, const char *); 3614static void dwarf2out_undef (unsigned int, const char *); 3615static void dwarf2out_start_source_file (unsigned, const char *); 3616static void dwarf2out_end_source_file (unsigned); 3617static void dwarf2out_begin_block (unsigned, unsigned); 3618static void dwarf2out_end_block (unsigned, unsigned); 3619static bool dwarf2out_ignore_block (tree); 3620static void dwarf2out_global_decl (tree); 3621static void dwarf2out_type_decl (tree, int); 3622static void dwarf2out_imported_module_or_decl (tree, tree); 3623static void dwarf2out_abstract_function (tree); 3624static void dwarf2out_var_location (rtx); 3625static void dwarf2out_begin_function (tree); 3626static void dwarf2out_switch_text_section (void); 3627 3628/* The debug hooks structure. */ 3629 3630const struct gcc_debug_hooks dwarf2_debug_hooks = 3631{ 3632 dwarf2out_init, 3633 dwarf2out_finish, 3634 dwarf2out_define, 3635 dwarf2out_undef, 3636 dwarf2out_start_source_file, 3637 dwarf2out_end_source_file, 3638 dwarf2out_begin_block, 3639 dwarf2out_end_block, 3640 dwarf2out_ignore_block, 3641 dwarf2out_source_line, 3642 dwarf2out_begin_prologue, 3643 debug_nothing_int_charstar, /* end_prologue */ 3644 dwarf2out_end_epilogue, 3645 dwarf2out_begin_function, 3646 debug_nothing_int, /* end_function */ 3647 dwarf2out_decl, /* function_decl */ 3648 dwarf2out_global_decl, 3649 dwarf2out_type_decl, /* type_decl */ 3650 dwarf2out_imported_module_or_decl, 3651 debug_nothing_tree, /* deferred_inline_function */ 3652 /* The DWARF 2 backend tries to reduce debugging bloat by not 3653 emitting the abstract description of inline functions until 3654 something tries to reference them. */ 3655 dwarf2out_abstract_function, /* outlining_inline_function */ 3656 debug_nothing_rtx, /* label */ 3657 debug_nothing_int, /* handle_pch */ 3658 dwarf2out_var_location, 3659 dwarf2out_switch_text_section, 3660 1 /* start_end_main_source_file */ 3661}; 3662#endif 3663 3664/* NOTE: In the comments in this file, many references are made to 3665 "Debugging Information Entries". This term is abbreviated as `DIE' 3666 throughout the remainder of this file. */ 3667 3668/* An internal representation of the DWARF output is built, and then 3669 walked to generate the DWARF debugging info. The walk of the internal 3670 representation is done after the entire program has been compiled. 3671 The types below are used to describe the internal representation. */ 3672 3673/* Various DIE's use offsets relative to the beginning of the 3674 .debug_info section to refer to each other. */ 3675 3676typedef long int dw_offset; 3677 3678/* Define typedefs here to avoid circular dependencies. */ 3679 3680typedef struct dw_attr_struct *dw_attr_ref; 3681typedef struct dw_line_info_struct *dw_line_info_ref; 3682typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref; 3683typedef struct pubname_struct *pubname_ref; 3684typedef struct dw_ranges_struct *dw_ranges_ref; 3685 3686/* Each entry in the line_info_table maintains the file and 3687 line number associated with the label generated for that 3688 entry. The label gives the PC value associated with 3689 the line number entry. */ 3690 3691typedef struct dw_line_info_struct GTY(()) 3692{ 3693 unsigned long dw_file_num; 3694 unsigned long dw_line_num; 3695} 3696dw_line_info_entry; 3697 3698/* Line information for functions in separate sections; each one gets its 3699 own sequence. */ 3700typedef struct dw_separate_line_info_struct GTY(()) 3701{ 3702 unsigned long dw_file_num; 3703 unsigned long dw_line_num; 3704 unsigned long function; 3705} 3706dw_separate_line_info_entry; 3707 3708/* Each DIE attribute has a field specifying the attribute kind, 3709 a link to the next attribute in the chain, and an attribute value. 3710 Attributes are typically linked below the DIE they modify. */ 3711 3712typedef struct dw_attr_struct GTY(()) 3713{ 3714 enum dwarf_attribute dw_attr; 3715 dw_val_node dw_attr_val; 3716} 3717dw_attr_node; 3718 3719DEF_VEC_O(dw_attr_node); 3720DEF_VEC_ALLOC_O(dw_attr_node,gc); 3721 3722/* The Debugging Information Entry (DIE) structure. DIEs form a tree. 3723 The children of each node form a circular list linked by 3724 die_sib. die_child points to the node *before* the "first" child node. */ 3725 3726typedef struct die_struct GTY(()) 3727{ 3728 enum dwarf_tag die_tag; 3729 char *die_symbol; 3730 VEC(dw_attr_node,gc) * die_attr; 3731 dw_die_ref die_parent; 3732 dw_die_ref die_child; 3733 dw_die_ref die_sib; 3734 dw_die_ref die_definition; /* ref from a specification to its definition */ 3735 dw_offset die_offset; 3736 unsigned long die_abbrev; 3737 int die_mark; 3738 /* Die is used and must not be pruned as unused. */ 3739 int die_perennial_p; 3740 unsigned int decl_id; 3741} 3742die_node; 3743 3744/* Evaluate 'expr' while 'c' is set to each child of DIE in order. */ 3745#define FOR_EACH_CHILD(die, c, expr) do { \ 3746 c = die->die_child; \ 3747 if (c) do { \ 3748 c = c->die_sib; \ 3749 expr; \ 3750 } while (c != die->die_child); \ 3751} while (0) 3752 3753/* The pubname structure */ 3754 3755typedef struct pubname_struct GTY(()) 3756{ 3757 dw_die_ref die; 3758 char *name; 3759} 3760pubname_entry; 3761 3762struct dw_ranges_struct GTY(()) 3763{ 3764 int block_num; 3765}; 3766 3767/* The limbo die list structure. */ 3768typedef struct limbo_die_struct GTY(()) 3769{ 3770 dw_die_ref die; 3771 tree created_for; 3772 struct limbo_die_struct *next; 3773} 3774limbo_die_node; 3775 3776/* How to start an assembler comment. */ 3777#ifndef ASM_COMMENT_START 3778#define ASM_COMMENT_START ";#" 3779#endif 3780 3781/* Define a macro which returns nonzero for a TYPE_DECL which was 3782 implicitly generated for a tagged type. 3783 3784 Note that unlike the gcc front end (which generates a NULL named 3785 TYPE_DECL node for each complete tagged type, each array type, and 3786 each function type node created) the g++ front end generates a 3787 _named_ TYPE_DECL node for each tagged type node created. 3788 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to 3789 generate a DW_TAG_typedef DIE for them. */ 3790 3791#define TYPE_DECL_IS_STUB(decl) \ 3792 (DECL_NAME (decl) == NULL_TREE \ 3793 || (DECL_ARTIFICIAL (decl) \ 3794 && is_tagged_type (TREE_TYPE (decl)) \ 3795 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \ 3796 /* This is necessary for stub decls that \ 3797 appear in nested inline functions. */ \ 3798 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \ 3799 && (decl_ultimate_origin (decl) \ 3800 == TYPE_STUB_DECL (TREE_TYPE (decl))))))) 3801 3802/* Information concerning the compilation unit's programming 3803 language, and compiler version. */ 3804 3805/* Fixed size portion of the DWARF compilation unit header. */ 3806#define DWARF_COMPILE_UNIT_HEADER_SIZE \ 3807 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3) 3808 3809/* Fixed size portion of public names info. */ 3810#define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2) 3811 3812/* Fixed size portion of the address range info. */ 3813#define DWARF_ARANGES_HEADER_SIZE \ 3814 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \ 3815 DWARF2_ADDR_SIZE * 2) \ 3816 - DWARF_INITIAL_LENGTH_SIZE) 3817 3818/* Size of padding portion in the address range info. It must be 3819 aligned to twice the pointer size. */ 3820#define DWARF_ARANGES_PAD_SIZE \ 3821 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \ 3822 DWARF2_ADDR_SIZE * 2) \ 3823 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4)) 3824 3825/* Use assembler line directives if available. */ 3826#ifndef DWARF2_ASM_LINE_DEBUG_INFO 3827#ifdef HAVE_AS_DWARF2_DEBUG_LINE 3828#define DWARF2_ASM_LINE_DEBUG_INFO 1 3829#else 3830#define DWARF2_ASM_LINE_DEBUG_INFO 0 3831#endif 3832#endif 3833 3834/* Minimum line offset in a special line info. opcode. 3835 This value was chosen to give a reasonable range of values. */ 3836#define DWARF_LINE_BASE -10 3837 3838/* First special line opcode - leave room for the standard opcodes. */ 3839#define DWARF_LINE_OPCODE_BASE 10 3840 3841/* Range of line offsets in a special line info. opcode. */ 3842#define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1) 3843 3844/* Flag that indicates the initial value of the is_stmt_start flag. 3845 In the present implementation, we do not mark any lines as 3846 the beginning of a source statement, because that information 3847 is not made available by the GCC front-end. */ 3848#define DWARF_LINE_DEFAULT_IS_STMT_START 1 3849 3850#ifdef DWARF2_DEBUGGING_INFO 3851/* This location is used by calc_die_sizes() to keep track 3852 the offset of each DIE within the .debug_info section. */ 3853static unsigned long next_die_offset; 3854#endif 3855 3856/* Record the root of the DIE's built for the current compilation unit. */ 3857static GTY(()) dw_die_ref comp_unit_die; 3858 3859/* A list of DIEs with a NULL parent waiting to be relocated. */ 3860static GTY(()) limbo_die_node *limbo_die_list; 3861 3862/* Filenames referenced by this compilation unit. */ 3863static GTY((param_is (struct dwarf_file_data))) htab_t file_table; 3864 3865/* A hash table of references to DIE's that describe declarations. 3866 The key is a DECL_UID() which is a unique number identifying each decl. */ 3867static GTY ((param_is (struct die_struct))) htab_t decl_die_table; 3868 3869/* Node of the variable location list. */ 3870struct var_loc_node GTY ((chain_next ("%h.next"))) 3871{ 3872 rtx GTY (()) var_loc_note; 3873 const char * GTY (()) label; 3874 const char * GTY (()) section_label; 3875 struct var_loc_node * GTY (()) next; 3876}; 3877 3878/* Variable location list. */ 3879struct var_loc_list_def GTY (()) 3880{ 3881 struct var_loc_node * GTY (()) first; 3882 3883 /* Do not mark the last element of the chained list because 3884 it is marked through the chain. */ 3885 struct var_loc_node * GTY ((skip ("%h"))) last; 3886 3887 /* DECL_UID of the variable decl. */ 3888 unsigned int decl_id; 3889}; 3890typedef struct var_loc_list_def var_loc_list; 3891 3892 3893/* Table of decl location linked lists. */ 3894static GTY ((param_is (var_loc_list))) htab_t decl_loc_table; 3895 3896/* A pointer to the base of a list of references to DIE's that 3897 are uniquely identified by their tag, presence/absence of 3898 children DIE's, and list of attribute/value pairs. */ 3899static GTY((length ("abbrev_die_table_allocated"))) 3900 dw_die_ref *abbrev_die_table; 3901 3902/* Number of elements currently allocated for abbrev_die_table. */ 3903static GTY(()) unsigned abbrev_die_table_allocated; 3904 3905/* Number of elements in type_die_table currently in use. */ 3906static GTY(()) unsigned abbrev_die_table_in_use; 3907 3908/* Size (in elements) of increments by which we may expand the 3909 abbrev_die_table. */ 3910#define ABBREV_DIE_TABLE_INCREMENT 256 3911 3912/* A pointer to the base of a table that contains line information 3913 for each source code line in .text in the compilation unit. */ 3914static GTY((length ("line_info_table_allocated"))) 3915 dw_line_info_ref line_info_table; 3916 3917/* Number of elements currently allocated for line_info_table. */ 3918static GTY(()) unsigned line_info_table_allocated; 3919 3920/* Number of elements in line_info_table currently in use. */ 3921static GTY(()) unsigned line_info_table_in_use; 3922 3923/* True if the compilation unit places functions in more than one section. */ 3924static GTY(()) bool have_multiple_function_sections = false; 3925 3926/* A pointer to the base of a table that contains line information 3927 for each source code line outside of .text in the compilation unit. */ 3928static GTY ((length ("separate_line_info_table_allocated"))) 3929 dw_separate_line_info_ref separate_line_info_table; 3930 3931/* Number of elements currently allocated for separate_line_info_table. */ 3932static GTY(()) unsigned separate_line_info_table_allocated; 3933 3934/* Number of elements in separate_line_info_table currently in use. */ 3935static GTY(()) unsigned separate_line_info_table_in_use; 3936 3937/* Size (in elements) of increments by which we may expand the 3938 line_info_table. */ 3939#define LINE_INFO_TABLE_INCREMENT 1024 3940 3941/* A pointer to the base of a table that contains a list of publicly 3942 accessible names. */ 3943static GTY ((length ("pubname_table_allocated"))) pubname_ref pubname_table; 3944 3945/* Number of elements currently allocated for pubname_table. */ 3946static GTY(()) unsigned pubname_table_allocated; 3947 3948/* Number of elements in pubname_table currently in use. */ 3949static GTY(()) unsigned pubname_table_in_use; 3950 3951/* Size (in elements) of increments by which we may expand the 3952 pubname_table. */ 3953#define PUBNAME_TABLE_INCREMENT 64 3954 3955/* Array of dies for which we should generate .debug_arange info. */ 3956static GTY((length ("arange_table_allocated"))) dw_die_ref *arange_table; 3957 3958/* Number of elements currently allocated for arange_table. */ 3959static GTY(()) unsigned arange_table_allocated; 3960 3961/* Number of elements in arange_table currently in use. */ 3962static GTY(()) unsigned arange_table_in_use; 3963 3964/* Size (in elements) of increments by which we may expand the 3965 arange_table. */ 3966#define ARANGE_TABLE_INCREMENT 64 3967 3968/* Array of dies for which we should generate .debug_ranges info. */ 3969static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table; 3970 3971/* Number of elements currently allocated for ranges_table. */ 3972static GTY(()) unsigned ranges_table_allocated; 3973 3974/* Number of elements in ranges_table currently in use. */ 3975static GTY(()) unsigned ranges_table_in_use; 3976 3977/* Size (in elements) of increments by which we may expand the 3978 ranges_table. */ 3979#define RANGES_TABLE_INCREMENT 64 3980 3981/* Whether we have location lists that need outputting */ 3982static GTY(()) bool have_location_lists; 3983 3984/* Unique label counter. */ 3985static GTY(()) unsigned int loclabel_num; 3986 3987#ifdef DWARF2_DEBUGGING_INFO 3988/* Record whether the function being analyzed contains inlined functions. */ 3989static int current_function_has_inlines; 3990#endif 3991#if 0 && defined (MIPS_DEBUGGING_INFO) 3992static int comp_unit_has_inlines; 3993#endif 3994 3995/* The last file entry emitted by maybe_emit_file(). */ 3996static GTY(()) struct dwarf_file_data * last_emitted_file; 3997 3998/* Number of internal labels generated by gen_internal_sym(). */ 3999static GTY(()) int label_num; 4000 4001/* Cached result of previous call to lookup_filename. */ 4002static GTY(()) struct dwarf_file_data * file_table_last_lookup; 4003 4004#ifdef DWARF2_DEBUGGING_INFO 4005 4006/* Offset from the "steady-state frame pointer" to the frame base, 4007 within the current function. */ 4008static HOST_WIDE_INT frame_pointer_fb_offset; 4009 4010/* Forward declarations for functions defined in this file. */ 4011 4012static int is_pseudo_reg (rtx); 4013static tree type_main_variant (tree); 4014static int is_tagged_type (tree); 4015static const char *dwarf_tag_name (unsigned); 4016static const char *dwarf_attr_name (unsigned); 4017static const char *dwarf_form_name (unsigned); 4018static tree decl_ultimate_origin (tree); 4019static tree block_ultimate_origin (tree); 4020static tree decl_class_context (tree); 4021static void add_dwarf_attr (dw_die_ref, dw_attr_ref); 4022static inline enum dw_val_class AT_class (dw_attr_ref); 4023static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned); 4024static inline unsigned AT_flag (dw_attr_ref); 4025static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT); 4026static inline HOST_WIDE_INT AT_int (dw_attr_ref); 4027static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT); 4028static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref); 4029static void add_AT_long_long (dw_die_ref, enum dwarf_attribute, unsigned long, 4030 unsigned long); 4031static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int, 4032 unsigned int, unsigned char *); 4033static hashval_t debug_str_do_hash (const void *); 4034static int debug_str_eq (const void *, const void *); 4035static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *); 4036static inline const char *AT_string (dw_attr_ref); 4037static int AT_string_form (dw_attr_ref); 4038static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref); 4039static void add_AT_specification (dw_die_ref, dw_die_ref); 4040static inline dw_die_ref AT_ref (dw_attr_ref); 4041static inline int AT_ref_external (dw_attr_ref); 4042static inline void set_AT_ref_external (dw_attr_ref, int); 4043static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned); 4044static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref); 4045static inline dw_loc_descr_ref AT_loc (dw_attr_ref); 4046static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute, 4047 dw_loc_list_ref); 4048static inline dw_loc_list_ref AT_loc_list (dw_attr_ref); 4049static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx); 4050static inline rtx AT_addr (dw_attr_ref); 4051static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *); 4052static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *); 4053static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *); 4054static void add_AT_offset (dw_die_ref, enum dwarf_attribute, 4055 unsigned HOST_WIDE_INT); 4056static void add_AT_range_list (dw_die_ref, enum dwarf_attribute, 4057 unsigned long); 4058static inline const char *AT_lbl (dw_attr_ref); 4059static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute); 4060static const char *get_AT_low_pc (dw_die_ref); 4061static const char *get_AT_hi_pc (dw_die_ref); 4062static const char *get_AT_string (dw_die_ref, enum dwarf_attribute); 4063static int get_AT_flag (dw_die_ref, enum dwarf_attribute); 4064static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute); 4065static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute); 4066static bool is_c_family (void); 4067static bool is_cxx (void); 4068static bool is_java (void); 4069static bool is_fortran (void); 4070static bool is_ada (void); 4071static void remove_AT (dw_die_ref, enum dwarf_attribute); 4072static void remove_child_TAG (dw_die_ref, enum dwarf_tag); 4073static void add_child_die (dw_die_ref, dw_die_ref); 4074static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree); 4075static dw_die_ref lookup_type_die (tree); 4076static void equate_type_number_to_die (tree, dw_die_ref); 4077static hashval_t decl_die_table_hash (const void *); 4078static int decl_die_table_eq (const void *, const void *); 4079static dw_die_ref lookup_decl_die (tree); 4080static hashval_t decl_loc_table_hash (const void *); 4081static int decl_loc_table_eq (const void *, const void *); 4082static var_loc_list *lookup_decl_loc (tree); 4083static void equate_decl_number_to_die (tree, dw_die_ref); 4084static void add_var_loc_to_decl (tree, struct var_loc_node *); 4085static void print_spaces (FILE *); 4086static void print_die (dw_die_ref, FILE *); 4087static void print_dwarf_line_table (FILE *); 4088static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref); 4089static dw_die_ref pop_compile_unit (dw_die_ref); 4090static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *); 4091static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *); 4092static void die_checksum (dw_die_ref, struct md5_ctx *, int *); 4093static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *); 4094static int same_dw_val_p (dw_val_node *, dw_val_node *, int *); 4095static int same_attr_p (dw_attr_ref, dw_attr_ref, int *); 4096static int same_die_p (dw_die_ref, dw_die_ref, int *); 4097static int same_die_p_wrap (dw_die_ref, dw_die_ref); 4098static void compute_section_prefix (dw_die_ref); 4099static int is_type_die (dw_die_ref); 4100static int is_comdat_die (dw_die_ref); 4101static int is_symbol_die (dw_die_ref); 4102static void assign_symbol_names (dw_die_ref); 4103static void break_out_includes (dw_die_ref); 4104static hashval_t htab_cu_hash (const void *); 4105static int htab_cu_eq (const void *, const void *); 4106static void htab_cu_del (void *); 4107static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *); 4108static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned); 4109static void add_sibling_attributes (dw_die_ref); 4110static void build_abbrev_table (dw_die_ref); 4111static void output_location_lists (dw_die_ref); 4112static int constant_size (long unsigned); 4113static unsigned long size_of_die (dw_die_ref); 4114static void calc_die_sizes (dw_die_ref); 4115static void mark_dies (dw_die_ref); 4116static void unmark_dies (dw_die_ref); 4117static void unmark_all_dies (dw_die_ref); 4118static unsigned long size_of_pubnames (void); 4119static unsigned long size_of_aranges (void); 4120static enum dwarf_form value_format (dw_attr_ref); 4121static void output_value_format (dw_attr_ref); 4122static void output_abbrev_section (void); 4123static void output_die_symbol (dw_die_ref); 4124static void output_die (dw_die_ref); 4125static void output_compilation_unit_header (void); 4126static void output_comp_unit (dw_die_ref, int); 4127static const char *dwarf2_name (tree, int); 4128static void add_pubname (tree, dw_die_ref); 4129static void output_pubnames (void); 4130static void add_arange (tree, dw_die_ref); 4131static void output_aranges (void); 4132static unsigned int add_ranges (tree); 4133static void output_ranges (void); 4134static void output_line_info (void); 4135static void output_file_names (void); 4136static dw_die_ref base_type_die (tree); 4137static tree root_type (tree); 4138static int is_base_type (tree); 4139static bool is_subrange_type (tree); 4140static dw_die_ref subrange_type_die (tree, dw_die_ref); 4141static dw_die_ref modified_type_die (tree, int, int, dw_die_ref); 4142static int type_is_enum (tree); 4143static unsigned int dbx_reg_number (rtx); 4144static void add_loc_descr_op_piece (dw_loc_descr_ref *, int); 4145static dw_loc_descr_ref reg_loc_descriptor (rtx); 4146static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int); 4147static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx); 4148static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT); 4149static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT); 4150static int is_based_loc (rtx); 4151static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode); 4152static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx); 4153static dw_loc_descr_ref loc_descriptor (rtx); 4154static dw_loc_descr_ref loc_descriptor_from_tree_1 (tree, int); 4155static dw_loc_descr_ref loc_descriptor_from_tree (tree); 4156static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int); 4157static tree field_type (tree); 4158static unsigned int simple_type_align_in_bits (tree); 4159static unsigned int simple_decl_align_in_bits (tree); 4160static unsigned HOST_WIDE_INT simple_type_size_in_bits (tree); 4161static HOST_WIDE_INT field_byte_offset (tree); 4162static void add_AT_location_description (dw_die_ref, enum dwarf_attribute, 4163 dw_loc_descr_ref); 4164static void add_data_member_location_attribute (dw_die_ref, tree); 4165static void add_const_value_attribute (dw_die_ref, rtx); 4166static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *); 4167static HOST_WIDE_INT extract_int (const unsigned char *, unsigned); 4168static void insert_float (rtx, unsigned char *); 4169static rtx rtl_for_decl_location (tree); 4170static void add_location_or_const_value_attribute (dw_die_ref, tree, 4171 enum dwarf_attribute); 4172static void tree_add_const_value_attribute (dw_die_ref, tree); 4173static void add_name_attribute (dw_die_ref, const char *); 4174static void add_comp_dir_attribute (dw_die_ref); 4175static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree); 4176static void add_subscript_info (dw_die_ref, tree); 4177static void add_byte_size_attribute (dw_die_ref, tree); 4178static void add_bit_offset_attribute (dw_die_ref, tree); 4179static void add_bit_size_attribute (dw_die_ref, tree); 4180static void add_prototyped_attribute (dw_die_ref, tree); 4181static void add_abstract_origin_attribute (dw_die_ref, tree); 4182static void add_pure_or_virtual_attribute (dw_die_ref, tree); 4183static void add_src_coords_attributes (dw_die_ref, tree); 4184static void add_name_and_src_coords_attributes (dw_die_ref, tree); 4185static void push_decl_scope (tree); 4186static void pop_decl_scope (void); 4187static dw_die_ref scope_die_for (tree, dw_die_ref); 4188static inline int local_scope_p (dw_die_ref); 4189static inline int class_or_namespace_scope_p (dw_die_ref); 4190static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref); 4191static void add_calling_convention_attribute (dw_die_ref, tree); 4192static const char *type_tag (tree); 4193static tree member_declared_type (tree); 4194#if 0 4195static const char *decl_start_label (tree); 4196#endif 4197static void gen_array_type_die (tree, dw_die_ref); 4198#if 0 4199static void gen_entry_point_die (tree, dw_die_ref); 4200#endif 4201static void gen_inlined_enumeration_type_die (tree, dw_die_ref); 4202static void gen_inlined_structure_type_die (tree, dw_die_ref); 4203static void gen_inlined_union_type_die (tree, dw_die_ref); 4204static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref); 4205static dw_die_ref gen_formal_parameter_die (tree, dw_die_ref); 4206static void gen_unspecified_parameters_die (tree, dw_die_ref); 4207static void gen_formal_types_die (tree, dw_die_ref); 4208static void gen_subprogram_die (tree, dw_die_ref); 4209static void gen_variable_die (tree, dw_die_ref); 4210static void gen_label_die (tree, dw_die_ref); 4211static void gen_lexical_block_die (tree, dw_die_ref, int); 4212static void gen_inlined_subroutine_die (tree, dw_die_ref, int); 4213static void gen_field_die (tree, dw_die_ref); 4214static void gen_ptr_to_mbr_type_die (tree, dw_die_ref); 4215static dw_die_ref gen_compile_unit_die (const char *); 4216static void gen_inheritance_die (tree, tree, dw_die_ref); 4217static void gen_member_die (tree, dw_die_ref); 4218static void gen_struct_or_union_type_die (tree, dw_die_ref); 4219static void gen_subroutine_type_die (tree, dw_die_ref); 4220static void gen_typedef_die (tree, dw_die_ref); 4221static void gen_type_die (tree, dw_die_ref); 4222static void gen_tagged_type_instantiation_die (tree, dw_die_ref); 4223static void gen_block_die (tree, dw_die_ref, int); 4224static void decls_for_scope (tree, dw_die_ref, int); 4225static int is_redundant_typedef (tree); 4226static void gen_namespace_die (tree); 4227static void gen_decl_die (tree, dw_die_ref); 4228static dw_die_ref force_decl_die (tree); 4229static dw_die_ref force_type_die (tree); 4230static dw_die_ref setup_namespace_context (tree, dw_die_ref); 4231static void declare_in_namespace (tree, dw_die_ref); 4232static struct dwarf_file_data * lookup_filename (const char *); 4233static void retry_incomplete_types (void); 4234static void gen_type_die_for_member (tree, tree, dw_die_ref); 4235static void splice_child_die (dw_die_ref, dw_die_ref); 4236static int file_info_cmp (const void *, const void *); 4237static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *, 4238 const char *, const char *, unsigned); 4239static void add_loc_descr_to_loc_list (dw_loc_list_ref *, dw_loc_descr_ref, 4240 const char *, const char *, 4241 const char *); 4242static void output_loc_list (dw_loc_list_ref); 4243static char *gen_internal_sym (const char *); 4244 4245static void prune_unmark_dies (dw_die_ref); 4246static void prune_unused_types_mark (dw_die_ref, int); 4247static void prune_unused_types_walk (dw_die_ref); 4248static void prune_unused_types_walk_attribs (dw_die_ref); 4249static void prune_unused_types_prune (dw_die_ref); 4250static void prune_unused_types (void); 4251static int maybe_emit_file (struct dwarf_file_data *fd); 4252 4253/* Section names used to hold DWARF debugging information. */ 4254#ifndef DEBUG_INFO_SECTION 4255#define DEBUG_INFO_SECTION ".debug_info" 4256#endif 4257#ifndef DEBUG_ABBREV_SECTION 4258#define DEBUG_ABBREV_SECTION ".debug_abbrev" 4259#endif 4260#ifndef DEBUG_ARANGES_SECTION 4261#define DEBUG_ARANGES_SECTION ".debug_aranges" 4262#endif 4263#ifndef DEBUG_MACINFO_SECTION 4264#define DEBUG_MACINFO_SECTION ".debug_macinfo" 4265#endif 4266#ifndef DEBUG_LINE_SECTION 4267#define DEBUG_LINE_SECTION ".debug_line" 4268#endif 4269#ifndef DEBUG_LOC_SECTION 4270#define DEBUG_LOC_SECTION ".debug_loc" 4271#endif 4272#ifndef DEBUG_PUBNAMES_SECTION 4273#define DEBUG_PUBNAMES_SECTION ".debug_pubnames" 4274#endif 4275#ifndef DEBUG_STR_SECTION 4276#define DEBUG_STR_SECTION ".debug_str" 4277#endif 4278#ifndef DEBUG_RANGES_SECTION 4279#define DEBUG_RANGES_SECTION ".debug_ranges" 4280#endif 4281 4282/* Standard ELF section names for compiled code and data. */ 4283#ifndef TEXT_SECTION_NAME 4284#define TEXT_SECTION_NAME ".text" 4285#endif 4286 4287/* Section flags for .debug_str section. */ 4288#define DEBUG_STR_SECTION_FLAGS \ 4289 (HAVE_GAS_SHF_MERGE && flag_merge_constants \ 4290 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \ 4291 : SECTION_DEBUG) 4292 4293/* Labels we insert at beginning sections we can reference instead of 4294 the section names themselves. */ 4295 4296#ifndef TEXT_SECTION_LABEL 4297#define TEXT_SECTION_LABEL "Ltext" 4298#endif 4299#ifndef COLD_TEXT_SECTION_LABEL 4300#define COLD_TEXT_SECTION_LABEL "Ltext_cold" 4301#endif 4302#ifndef DEBUG_LINE_SECTION_LABEL 4303#define DEBUG_LINE_SECTION_LABEL "Ldebug_line" 4304#endif 4305#ifndef DEBUG_INFO_SECTION_LABEL 4306#define DEBUG_INFO_SECTION_LABEL "Ldebug_info" 4307#endif 4308#ifndef DEBUG_ABBREV_SECTION_LABEL 4309#define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev" 4310#endif 4311#ifndef DEBUG_LOC_SECTION_LABEL 4312#define DEBUG_LOC_SECTION_LABEL "Ldebug_loc" 4313#endif 4314#ifndef DEBUG_RANGES_SECTION_LABEL 4315#define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges" 4316#endif 4317#ifndef DEBUG_MACINFO_SECTION_LABEL 4318#define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo" 4319#endif 4320 4321/* Definitions of defaults for formats and names of various special 4322 (artificial) labels which may be generated within this file (when the -g 4323 options is used and DWARF2_DEBUGGING_INFO is in effect. 4324 If necessary, these may be overridden from within the tm.h file, but 4325 typically, overriding these defaults is unnecessary. */ 4326 4327static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4328static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4329static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4330static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4331static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4332static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4333static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4334static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4335static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4336static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES]; 4337 4338#ifndef TEXT_END_LABEL 4339#define TEXT_END_LABEL "Letext" 4340#endif 4341#ifndef COLD_END_LABEL 4342#define COLD_END_LABEL "Letext_cold" 4343#endif 4344#ifndef BLOCK_BEGIN_LABEL 4345#define BLOCK_BEGIN_LABEL "LBB" 4346#endif 4347#ifndef BLOCK_END_LABEL 4348#define BLOCK_END_LABEL "LBE" 4349#endif 4350#ifndef LINE_CODE_LABEL 4351#define LINE_CODE_LABEL "LM" 4352#endif 4353#ifndef SEPARATE_LINE_CODE_LABEL 4354#define SEPARATE_LINE_CODE_LABEL "LSM" 4355#endif 4356 4357/* We allow a language front-end to designate a function that is to be 4358 called to "demangle" any name before it is put into a DIE. */ 4359 4360static const char *(*demangle_name_func) (const char *); 4361 4362void 4363dwarf2out_set_demangle_name_func (const char *(*func) (const char *)) 4364{ 4365 demangle_name_func = func; 4366} 4367 4368/* Test if rtl node points to a pseudo register. */ 4369 4370static inline int 4371is_pseudo_reg (rtx rtl) 4372{ 4373 return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER) 4374 || (GET_CODE (rtl) == SUBREG 4375 && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER)); 4376} 4377 4378/* Return a reference to a type, with its const and volatile qualifiers 4379 removed. */ 4380 4381static inline tree 4382type_main_variant (tree type) 4383{ 4384 type = TYPE_MAIN_VARIANT (type); 4385 4386 /* ??? There really should be only one main variant among any group of 4387 variants of a given type (and all of the MAIN_VARIANT values for all 4388 members of the group should point to that one type) but sometimes the C 4389 front-end messes this up for array types, so we work around that bug 4390 here. */ 4391 if (TREE_CODE (type) == ARRAY_TYPE) 4392 while (type != TYPE_MAIN_VARIANT (type)) 4393 type = TYPE_MAIN_VARIANT (type); 4394 4395 return type; 4396} 4397 4398/* Return nonzero if the given type node represents a tagged type. */ 4399 4400static inline int 4401is_tagged_type (tree type) 4402{ 4403 enum tree_code code = TREE_CODE (type); 4404 4405 return (code == RECORD_TYPE || code == UNION_TYPE 4406 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE); 4407} 4408 4409/* Convert a DIE tag into its string name. */ 4410 4411static const char * 4412dwarf_tag_name (unsigned int tag) 4413{ 4414 switch (tag) 4415 { 4416 case DW_TAG_padding: 4417 return "DW_TAG_padding"; 4418 case DW_TAG_array_type: 4419 return "DW_TAG_array_type"; 4420 case DW_TAG_class_type: 4421 return "DW_TAG_class_type"; 4422 case DW_TAG_entry_point: 4423 return "DW_TAG_entry_point"; 4424 case DW_TAG_enumeration_type: 4425 return "DW_TAG_enumeration_type"; 4426 case DW_TAG_formal_parameter: 4427 return "DW_TAG_formal_parameter"; 4428 case DW_TAG_imported_declaration: 4429 return "DW_TAG_imported_declaration"; 4430 case DW_TAG_label: 4431 return "DW_TAG_label"; 4432 case DW_TAG_lexical_block: 4433 return "DW_TAG_lexical_block"; 4434 case DW_TAG_member: 4435 return "DW_TAG_member"; 4436 case DW_TAG_pointer_type: 4437 return "DW_TAG_pointer_type"; 4438 case DW_TAG_reference_type: 4439 return "DW_TAG_reference_type"; 4440 case DW_TAG_compile_unit: 4441 return "DW_TAG_compile_unit"; 4442 case DW_TAG_string_type: 4443 return "DW_TAG_string_type"; 4444 case DW_TAG_structure_type: 4445 return "DW_TAG_structure_type"; 4446 case DW_TAG_subroutine_type: 4447 return "DW_TAG_subroutine_type"; 4448 case DW_TAG_typedef: 4449 return "DW_TAG_typedef"; 4450 case DW_TAG_union_type: 4451 return "DW_TAG_union_type"; 4452 case DW_TAG_unspecified_parameters: 4453 return "DW_TAG_unspecified_parameters"; 4454 case DW_TAG_variant: 4455 return "DW_TAG_variant"; 4456 case DW_TAG_common_block: 4457 return "DW_TAG_common_block"; 4458 case DW_TAG_common_inclusion: 4459 return "DW_TAG_common_inclusion"; 4460 case DW_TAG_inheritance: 4461 return "DW_TAG_inheritance"; 4462 case DW_TAG_inlined_subroutine: 4463 return "DW_TAG_inlined_subroutine"; 4464 case DW_TAG_module: 4465 return "DW_TAG_module"; 4466 case DW_TAG_ptr_to_member_type: 4467 return "DW_TAG_ptr_to_member_type"; 4468 case DW_TAG_set_type: 4469 return "DW_TAG_set_type"; 4470 case DW_TAG_subrange_type: 4471 return "DW_TAG_subrange_type"; 4472 case DW_TAG_with_stmt: 4473 return "DW_TAG_with_stmt"; 4474 case DW_TAG_access_declaration: 4475 return "DW_TAG_access_declaration"; 4476 case DW_TAG_base_type: 4477 return "DW_TAG_base_type"; 4478 case DW_TAG_catch_block: 4479 return "DW_TAG_catch_block"; 4480 case DW_TAG_const_type: 4481 return "DW_TAG_const_type"; 4482 case DW_TAG_constant: 4483 return "DW_TAG_constant"; 4484 case DW_TAG_enumerator: 4485 return "DW_TAG_enumerator"; 4486 case DW_TAG_file_type: 4487 return "DW_TAG_file_type"; 4488 case DW_TAG_friend: 4489 return "DW_TAG_friend"; 4490 case DW_TAG_namelist: 4491 return "DW_TAG_namelist"; 4492 case DW_TAG_namelist_item: 4493 return "DW_TAG_namelist_item"; 4494 case DW_TAG_namespace: 4495 return "DW_TAG_namespace"; 4496 case DW_TAG_packed_type: 4497 return "DW_TAG_packed_type"; 4498 case DW_TAG_subprogram: 4499 return "DW_TAG_subprogram"; 4500 case DW_TAG_template_type_param: 4501 return "DW_TAG_template_type_param"; 4502 case DW_TAG_template_value_param: 4503 return "DW_TAG_template_value_param"; 4504 case DW_TAG_thrown_type: 4505 return "DW_TAG_thrown_type"; 4506 case DW_TAG_try_block: 4507 return "DW_TAG_try_block"; 4508 case DW_TAG_variant_part: 4509 return "DW_TAG_variant_part"; 4510 case DW_TAG_variable: 4511 return "DW_TAG_variable"; 4512 case DW_TAG_volatile_type: 4513 return "DW_TAG_volatile_type"; 4514 case DW_TAG_imported_module: 4515 return "DW_TAG_imported_module"; 4516 case DW_TAG_MIPS_loop: 4517 return "DW_TAG_MIPS_loop"; 4518 case DW_TAG_format_label: 4519 return "DW_TAG_format_label"; 4520 case DW_TAG_function_template: 4521 return "DW_TAG_function_template"; 4522 case DW_TAG_class_template: 4523 return "DW_TAG_class_template"; 4524 case DW_TAG_GNU_BINCL: 4525 return "DW_TAG_GNU_BINCL"; 4526 case DW_TAG_GNU_EINCL: 4527 return "DW_TAG_GNU_EINCL"; 4528 default: 4529 return "DW_TAG_<unknown>"; 4530 } 4531} 4532 4533/* Convert a DWARF attribute code into its string name. */ 4534 4535static const char * 4536dwarf_attr_name (unsigned int attr) 4537{ 4538 switch (attr) 4539 { 4540 case DW_AT_sibling: 4541 return "DW_AT_sibling"; 4542 case DW_AT_location: 4543 return "DW_AT_location"; 4544 case DW_AT_name: 4545 return "DW_AT_name"; 4546 case DW_AT_ordering: 4547 return "DW_AT_ordering"; 4548 case DW_AT_subscr_data: 4549 return "DW_AT_subscr_data"; 4550 case DW_AT_byte_size: 4551 return "DW_AT_byte_size"; 4552 case DW_AT_bit_offset: 4553 return "DW_AT_bit_offset"; 4554 case DW_AT_bit_size: 4555 return "DW_AT_bit_size"; 4556 case DW_AT_element_list: 4557 return "DW_AT_element_list"; 4558 case DW_AT_stmt_list: 4559 return "DW_AT_stmt_list"; 4560 case DW_AT_low_pc: 4561 return "DW_AT_low_pc"; 4562 case DW_AT_high_pc: 4563 return "DW_AT_high_pc"; 4564 case DW_AT_language: 4565 return "DW_AT_language"; 4566 case DW_AT_member: 4567 return "DW_AT_member"; 4568 case DW_AT_discr: 4569 return "DW_AT_discr"; 4570 case DW_AT_discr_value: 4571 return "DW_AT_discr_value"; 4572 case DW_AT_visibility: 4573 return "DW_AT_visibility"; 4574 case DW_AT_import: 4575 return "DW_AT_import"; 4576 case DW_AT_string_length: 4577 return "DW_AT_string_length"; 4578 case DW_AT_common_reference: 4579 return "DW_AT_common_reference"; 4580 case DW_AT_comp_dir: 4581 return "DW_AT_comp_dir"; 4582 case DW_AT_const_value: 4583 return "DW_AT_const_value"; 4584 case DW_AT_containing_type: 4585 return "DW_AT_containing_type"; 4586 case DW_AT_default_value: 4587 return "DW_AT_default_value"; 4588 case DW_AT_inline: 4589 return "DW_AT_inline"; 4590 case DW_AT_is_optional: 4591 return "DW_AT_is_optional"; 4592 case DW_AT_lower_bound: 4593 return "DW_AT_lower_bound"; 4594 case DW_AT_producer: 4595 return "DW_AT_producer"; 4596 case DW_AT_prototyped: 4597 return "DW_AT_prototyped"; 4598 case DW_AT_return_addr: 4599 return "DW_AT_return_addr"; 4600 case DW_AT_start_scope: 4601 return "DW_AT_start_scope"; 4602 case DW_AT_stride_size: 4603 return "DW_AT_stride_size"; 4604 case DW_AT_upper_bound: 4605 return "DW_AT_upper_bound"; 4606 case DW_AT_abstract_origin: 4607 return "DW_AT_abstract_origin"; 4608 case DW_AT_accessibility: 4609 return "DW_AT_accessibility"; 4610 case DW_AT_address_class: 4611 return "DW_AT_address_class"; 4612 case DW_AT_artificial: 4613 return "DW_AT_artificial"; 4614 case DW_AT_base_types: 4615 return "DW_AT_base_types"; 4616 case DW_AT_calling_convention: 4617 return "DW_AT_calling_convention"; 4618 case DW_AT_count: 4619 return "DW_AT_count"; 4620 case DW_AT_data_member_location: 4621 return "DW_AT_data_member_location"; 4622 case DW_AT_decl_column: 4623 return "DW_AT_decl_column"; 4624 case DW_AT_decl_file: 4625 return "DW_AT_decl_file"; 4626 case DW_AT_decl_line: 4627 return "DW_AT_decl_line"; 4628 case DW_AT_declaration: 4629 return "DW_AT_declaration"; 4630 case DW_AT_discr_list: 4631 return "DW_AT_discr_list"; 4632 case DW_AT_encoding: 4633 return "DW_AT_encoding"; 4634 case DW_AT_external: 4635 return "DW_AT_external"; 4636 case DW_AT_frame_base: 4637 return "DW_AT_frame_base"; 4638 case DW_AT_friend: 4639 return "DW_AT_friend"; 4640 case DW_AT_identifier_case: 4641 return "DW_AT_identifier_case"; 4642 case DW_AT_macro_info: 4643 return "DW_AT_macro_info"; 4644 case DW_AT_namelist_items: 4645 return "DW_AT_namelist_items"; 4646 case DW_AT_priority: 4647 return "DW_AT_priority"; 4648 case DW_AT_segment: 4649 return "DW_AT_segment"; 4650 case DW_AT_specification: 4651 return "DW_AT_specification"; 4652 case DW_AT_static_link: 4653 return "DW_AT_static_link"; 4654 case DW_AT_type: 4655 return "DW_AT_type"; 4656 case DW_AT_use_location: 4657 return "DW_AT_use_location"; 4658 case DW_AT_variable_parameter: 4659 return "DW_AT_variable_parameter"; 4660 case DW_AT_virtuality: 4661 return "DW_AT_virtuality"; 4662 case DW_AT_vtable_elem_location: 4663 return "DW_AT_vtable_elem_location"; 4664 4665 case DW_AT_allocated: 4666 return "DW_AT_allocated"; 4667 case DW_AT_associated: 4668 return "DW_AT_associated"; 4669 case DW_AT_data_location: 4670 return "DW_AT_data_location"; 4671 case DW_AT_stride: 4672 return "DW_AT_stride"; 4673 case DW_AT_entry_pc: 4674 return "DW_AT_entry_pc"; 4675 case DW_AT_use_UTF8: 4676 return "DW_AT_use_UTF8"; 4677 case DW_AT_extension: 4678 return "DW_AT_extension"; 4679 case DW_AT_ranges: 4680 return "DW_AT_ranges"; 4681 case DW_AT_trampoline: 4682 return "DW_AT_trampoline"; 4683 case DW_AT_call_column: 4684 return "DW_AT_call_column"; 4685 case DW_AT_call_file: 4686 return "DW_AT_call_file"; 4687 case DW_AT_call_line: 4688 return "DW_AT_call_line"; 4689 4690 case DW_AT_MIPS_fde: 4691 return "DW_AT_MIPS_fde"; 4692 case DW_AT_MIPS_loop_begin: 4693 return "DW_AT_MIPS_loop_begin"; 4694 case DW_AT_MIPS_tail_loop_begin: 4695 return "DW_AT_MIPS_tail_loop_begin"; 4696 case DW_AT_MIPS_epilog_begin: 4697 return "DW_AT_MIPS_epilog_begin"; 4698 case DW_AT_MIPS_loop_unroll_factor: 4699 return "DW_AT_MIPS_loop_unroll_factor"; 4700 case DW_AT_MIPS_software_pipeline_depth: 4701 return "DW_AT_MIPS_software_pipeline_depth"; 4702 case DW_AT_MIPS_linkage_name: 4703 return "DW_AT_MIPS_linkage_name"; 4704 case DW_AT_MIPS_stride: 4705 return "DW_AT_MIPS_stride"; 4706 case DW_AT_MIPS_abstract_name: 4707 return "DW_AT_MIPS_abstract_name"; 4708 case DW_AT_MIPS_clone_origin: 4709 return "DW_AT_MIPS_clone_origin"; 4710 case DW_AT_MIPS_has_inlines: 4711 return "DW_AT_MIPS_has_inlines"; 4712 4713 case DW_AT_sf_names: 4714 return "DW_AT_sf_names"; 4715 case DW_AT_src_info: 4716 return "DW_AT_src_info"; 4717 case DW_AT_mac_info: 4718 return "DW_AT_mac_info"; 4719 case DW_AT_src_coords: 4720 return "DW_AT_src_coords"; 4721 case DW_AT_body_begin: 4722 return "DW_AT_body_begin"; 4723 case DW_AT_body_end: 4724 return "DW_AT_body_end"; 4725 case DW_AT_GNU_vector: 4726 return "DW_AT_GNU_vector"; 4727 4728 case DW_AT_VMS_rtnbeg_pd_address: 4729 return "DW_AT_VMS_rtnbeg_pd_address"; 4730 4731 default: 4732 return "DW_AT_<unknown>"; 4733 } 4734} 4735 4736/* Convert a DWARF value form code into its string name. */ 4737 4738static const char * 4739dwarf_form_name (unsigned int form) 4740{ 4741 switch (form) 4742 { 4743 case DW_FORM_addr: 4744 return "DW_FORM_addr"; 4745 case DW_FORM_block2: 4746 return "DW_FORM_block2"; 4747 case DW_FORM_block4: 4748 return "DW_FORM_block4"; 4749 case DW_FORM_data2: 4750 return "DW_FORM_data2"; 4751 case DW_FORM_data4: 4752 return "DW_FORM_data4"; 4753 case DW_FORM_data8: 4754 return "DW_FORM_data8"; 4755 case DW_FORM_string: 4756 return "DW_FORM_string"; 4757 case DW_FORM_block: 4758 return "DW_FORM_block"; 4759 case DW_FORM_block1: 4760 return "DW_FORM_block1"; 4761 case DW_FORM_data1: 4762 return "DW_FORM_data1"; 4763 case DW_FORM_flag: 4764 return "DW_FORM_flag"; 4765 case DW_FORM_sdata: 4766 return "DW_FORM_sdata"; 4767 case DW_FORM_strp: 4768 return "DW_FORM_strp"; 4769 case DW_FORM_udata: 4770 return "DW_FORM_udata"; 4771 case DW_FORM_ref_addr: 4772 return "DW_FORM_ref_addr"; 4773 case DW_FORM_ref1: 4774 return "DW_FORM_ref1"; 4775 case DW_FORM_ref2: 4776 return "DW_FORM_ref2"; 4777 case DW_FORM_ref4: 4778 return "DW_FORM_ref4"; 4779 case DW_FORM_ref8: 4780 return "DW_FORM_ref8"; 4781 case DW_FORM_ref_udata: 4782 return "DW_FORM_ref_udata"; 4783 case DW_FORM_indirect: 4784 return "DW_FORM_indirect"; 4785 default: 4786 return "DW_FORM_<unknown>"; 4787 } 4788} 4789 4790/* Determine the "ultimate origin" of a decl. The decl may be an inlined 4791 instance of an inlined instance of a decl which is local to an inline 4792 function, so we have to trace all of the way back through the origin chain 4793 to find out what sort of node actually served as the original seed for the 4794 given block. */ 4795 4796static tree 4797decl_ultimate_origin (tree decl) 4798{ 4799 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON)) 4800 return NULL_TREE; 4801 4802 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the 4803 nodes in the function to point to themselves; ignore that if 4804 we're trying to output the abstract instance of this function. */ 4805 if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl) 4806 return NULL_TREE; 4807 4808 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the 4809 most distant ancestor, this should never happen. */ 4810 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl))); 4811 4812 return DECL_ABSTRACT_ORIGIN (decl); 4813} 4814 4815/* Determine the "ultimate origin" of a block. The block may be an inlined 4816 instance of an inlined instance of a block which is local to an inline 4817 function, so we have to trace all of the way back through the origin chain 4818 to find out what sort of node actually served as the original seed for the 4819 given block. */ 4820 4821static tree 4822block_ultimate_origin (tree block) 4823{ 4824 tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block); 4825 4826 /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the 4827 nodes in the function to point to themselves; ignore that if 4828 we're trying to output the abstract instance of this function. */ 4829 if (BLOCK_ABSTRACT (block) && immediate_origin == block) 4830 return NULL_TREE; 4831 4832 if (immediate_origin == NULL_TREE) 4833 return NULL_TREE; 4834 else 4835 { 4836 tree ret_val; 4837 tree lookahead = immediate_origin; 4838 4839 do 4840 { 4841 ret_val = lookahead; 4842 lookahead = (TREE_CODE (ret_val) == BLOCK 4843 ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL); 4844 } 4845 while (lookahead != NULL && lookahead != ret_val); 4846 4847 /* The block's abstract origin chain may not be the *ultimate* origin of 4848 the block. It could lead to a DECL that has an abstract origin set. 4849 If so, we want that DECL's abstract origin (which is what DECL_ORIGIN 4850 will give us if it has one). Note that DECL's abstract origins are 4851 supposed to be the most distant ancestor (or so decl_ultimate_origin 4852 claims), so we don't need to loop following the DECL origins. */ 4853 if (DECL_P (ret_val)) 4854 return DECL_ORIGIN (ret_val); 4855 4856 return ret_val; 4857 } 4858} 4859 4860/* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT 4861 of a virtual function may refer to a base class, so we check the 'this' 4862 parameter. */ 4863 4864static tree 4865decl_class_context (tree decl) 4866{ 4867 tree context = NULL_TREE; 4868 4869 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl)) 4870 context = DECL_CONTEXT (decl); 4871 else 4872 context = TYPE_MAIN_VARIANT 4873 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl))))); 4874 4875 if (context && !TYPE_P (context)) 4876 context = NULL_TREE; 4877 4878 return context; 4879} 4880 4881/* Add an attribute/value pair to a DIE. */ 4882 4883static inline void 4884add_dwarf_attr (dw_die_ref die, dw_attr_ref attr) 4885{ 4886 /* Maybe this should be an assert? */ 4887 if (die == NULL) 4888 return; 4889 4890 if (die->die_attr == NULL) 4891 die->die_attr = VEC_alloc (dw_attr_node, gc, 1); 4892 VEC_safe_push (dw_attr_node, gc, die->die_attr, attr); 4893} 4894 4895static inline enum dw_val_class 4896AT_class (dw_attr_ref a) 4897{ 4898 return a->dw_attr_val.val_class; 4899} 4900 4901/* Add a flag value attribute to a DIE. */ 4902 4903static inline void 4904add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag) 4905{ 4906 dw_attr_node attr; 4907 4908 attr.dw_attr = attr_kind; 4909 attr.dw_attr_val.val_class = dw_val_class_flag; 4910 attr.dw_attr_val.v.val_flag = flag; 4911 add_dwarf_attr (die, &attr); 4912} 4913 4914static inline unsigned 4915AT_flag (dw_attr_ref a) 4916{ 4917 gcc_assert (a && AT_class (a) == dw_val_class_flag); 4918 return a->dw_attr_val.v.val_flag; 4919} 4920 4921/* Add a signed integer attribute value to a DIE. */ 4922 4923static inline void 4924add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val) 4925{ 4926 dw_attr_node attr; 4927 4928 attr.dw_attr = attr_kind; 4929 attr.dw_attr_val.val_class = dw_val_class_const; 4930 attr.dw_attr_val.v.val_int = int_val; 4931 add_dwarf_attr (die, &attr); 4932} 4933 4934static inline HOST_WIDE_INT 4935AT_int (dw_attr_ref a) 4936{ 4937 gcc_assert (a && AT_class (a) == dw_val_class_const); 4938 return a->dw_attr_val.v.val_int; 4939} 4940 4941/* Add an unsigned integer attribute value to a DIE. */ 4942 4943static inline void 4944add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind, 4945 unsigned HOST_WIDE_INT unsigned_val) 4946{ 4947 dw_attr_node attr; 4948 4949 attr.dw_attr = attr_kind; 4950 attr.dw_attr_val.val_class = dw_val_class_unsigned_const; 4951 attr.dw_attr_val.v.val_unsigned = unsigned_val; 4952 add_dwarf_attr (die, &attr); 4953} 4954 4955static inline unsigned HOST_WIDE_INT 4956AT_unsigned (dw_attr_ref a) 4957{ 4958 gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const); 4959 return a->dw_attr_val.v.val_unsigned; 4960} 4961 4962/* Add an unsigned double integer attribute value to a DIE. */ 4963 4964static inline void 4965add_AT_long_long (dw_die_ref die, enum dwarf_attribute attr_kind, 4966 long unsigned int val_hi, long unsigned int val_low) 4967{ 4968 dw_attr_node attr; 4969 4970 attr.dw_attr = attr_kind; 4971 attr.dw_attr_val.val_class = dw_val_class_long_long; 4972 attr.dw_attr_val.v.val_long_long.hi = val_hi; 4973 attr.dw_attr_val.v.val_long_long.low = val_low; 4974 add_dwarf_attr (die, &attr); 4975} 4976 4977/* Add a floating point attribute value to a DIE and return it. */ 4978 4979static inline void 4980add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind, 4981 unsigned int length, unsigned int elt_size, unsigned char *array) 4982{ 4983 dw_attr_node attr; 4984 4985 attr.dw_attr = attr_kind; 4986 attr.dw_attr_val.val_class = dw_val_class_vec; 4987 attr.dw_attr_val.v.val_vec.length = length; 4988 attr.dw_attr_val.v.val_vec.elt_size = elt_size; 4989 attr.dw_attr_val.v.val_vec.array = array; 4990 add_dwarf_attr (die, &attr); 4991} 4992 4993/* Hash and equality functions for debug_str_hash. */ 4994 4995static hashval_t 4996debug_str_do_hash (const void *x) 4997{ 4998 return htab_hash_string (((const struct indirect_string_node *)x)->str); 4999} 5000 5001static int 5002debug_str_eq (const void *x1, const void *x2) 5003{ 5004 return strcmp ((((const struct indirect_string_node *)x1)->str), 5005 (const char *)x2) == 0; 5006} 5007 5008/* Add a string attribute value to a DIE. */ 5009 5010static inline void 5011add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str) 5012{ 5013 dw_attr_node attr; 5014 struct indirect_string_node *node; 5015 void **slot; 5016 5017 if (! debug_str_hash) 5018 debug_str_hash = htab_create_ggc (10, debug_str_do_hash, 5019 debug_str_eq, NULL); 5020 5021 slot = htab_find_slot_with_hash (debug_str_hash, str, 5022 htab_hash_string (str), INSERT); 5023 if (*slot == NULL) 5024 *slot = ggc_alloc_cleared (sizeof (struct indirect_string_node)); 5025 node = (struct indirect_string_node *) *slot; 5026 node->str = ggc_strdup (str); 5027 node->refcount++; 5028 5029 attr.dw_attr = attr_kind; 5030 attr.dw_attr_val.val_class = dw_val_class_str; 5031 attr.dw_attr_val.v.val_str = node; 5032 add_dwarf_attr (die, &attr); 5033} 5034 5035static inline const char * 5036AT_string (dw_attr_ref a) 5037{ 5038 gcc_assert (a && AT_class (a) == dw_val_class_str); 5039 return a->dw_attr_val.v.val_str->str; 5040} 5041 5042/* Find out whether a string should be output inline in DIE 5043 or out-of-line in .debug_str section. */ 5044 5045static int 5046AT_string_form (dw_attr_ref a) 5047{ 5048 struct indirect_string_node *node; 5049 unsigned int len; 5050 char label[32]; 5051 5052 gcc_assert (a && AT_class (a) == dw_val_class_str); 5053 5054 node = a->dw_attr_val.v.val_str; 5055 if (node->form) 5056 return node->form; 5057 5058 len = strlen (node->str) + 1; 5059 5060 /* If the string is shorter or equal to the size of the reference, it is 5061 always better to put it inline. */ 5062 if (len <= DWARF_OFFSET_SIZE || node->refcount == 0) 5063 return node->form = DW_FORM_string; 5064 5065 /* If we cannot expect the linker to merge strings in .debug_str 5066 section, only put it into .debug_str if it is worth even in this 5067 single module. */ 5068 if ((debug_str_section->common.flags & SECTION_MERGE) == 0 5069 && (len - DWARF_OFFSET_SIZE) * node->refcount <= len) 5070 return node->form = DW_FORM_string; 5071 5072 ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter); 5073 ++dw2_string_counter; 5074 node->label = xstrdup (label); 5075 5076 return node->form = DW_FORM_strp; 5077} 5078 5079/* Add a DIE reference attribute value to a DIE. */ 5080 5081static inline void 5082add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die) 5083{ 5084 dw_attr_node attr; 5085 5086 attr.dw_attr = attr_kind; 5087 attr.dw_attr_val.val_class = dw_val_class_die_ref; 5088 attr.dw_attr_val.v.val_die_ref.die = targ_die; 5089 attr.dw_attr_val.v.val_die_ref.external = 0; 5090 add_dwarf_attr (die, &attr); 5091} 5092 5093/* Add an AT_specification attribute to a DIE, and also make the back 5094 pointer from the specification to the definition. */ 5095 5096static inline void 5097add_AT_specification (dw_die_ref die, dw_die_ref targ_die) 5098{ 5099 add_AT_die_ref (die, DW_AT_specification, targ_die); 5100 gcc_assert (!targ_die->die_definition); 5101 targ_die->die_definition = die; 5102} 5103 5104static inline dw_die_ref 5105AT_ref (dw_attr_ref a) 5106{ 5107 gcc_assert (a && AT_class (a) == dw_val_class_die_ref); 5108 return a->dw_attr_val.v.val_die_ref.die; 5109} 5110 5111static inline int 5112AT_ref_external (dw_attr_ref a) 5113{ 5114 if (a && AT_class (a) == dw_val_class_die_ref) 5115 return a->dw_attr_val.v.val_die_ref.external; 5116 5117 return 0; 5118} 5119 5120static inline void 5121set_AT_ref_external (dw_attr_ref a, int i) 5122{ 5123 gcc_assert (a && AT_class (a) == dw_val_class_die_ref); 5124 a->dw_attr_val.v.val_die_ref.external = i; 5125} 5126 5127/* Add an FDE reference attribute value to a DIE. */ 5128 5129static inline void 5130add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde) 5131{ 5132 dw_attr_node attr; 5133 5134 attr.dw_attr = attr_kind; 5135 attr.dw_attr_val.val_class = dw_val_class_fde_ref; 5136 attr.dw_attr_val.v.val_fde_index = targ_fde; 5137 add_dwarf_attr (die, &attr); 5138} 5139 5140/* Add a location description attribute value to a DIE. */ 5141 5142static inline void 5143add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc) 5144{ 5145 dw_attr_node attr; 5146 5147 attr.dw_attr = attr_kind; 5148 attr.dw_attr_val.val_class = dw_val_class_loc; 5149 attr.dw_attr_val.v.val_loc = loc; 5150 add_dwarf_attr (die, &attr); 5151} 5152 5153static inline dw_loc_descr_ref 5154AT_loc (dw_attr_ref a) 5155{ 5156 gcc_assert (a && AT_class (a) == dw_val_class_loc); 5157 return a->dw_attr_val.v.val_loc; 5158} 5159 5160static inline void 5161add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list) 5162{ 5163 dw_attr_node attr; 5164 5165 attr.dw_attr = attr_kind; 5166 attr.dw_attr_val.val_class = dw_val_class_loc_list; 5167 attr.dw_attr_val.v.val_loc_list = loc_list; 5168 add_dwarf_attr (die, &attr); 5169 have_location_lists = true; 5170} 5171 5172static inline dw_loc_list_ref 5173AT_loc_list (dw_attr_ref a) 5174{ 5175 gcc_assert (a && AT_class (a) == dw_val_class_loc_list); 5176 return a->dw_attr_val.v.val_loc_list; 5177} 5178 5179/* Add an address constant attribute value to a DIE. */ 5180 5181static inline void 5182add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr) 5183{ 5184 dw_attr_node attr; 5185 5186 attr.dw_attr = attr_kind; 5187 attr.dw_attr_val.val_class = dw_val_class_addr; 5188 attr.dw_attr_val.v.val_addr = addr; 5189 add_dwarf_attr (die, &attr); 5190} 5191 5192/* Get the RTX from to an address DIE attribute. */ 5193 5194static inline rtx 5195AT_addr (dw_attr_ref a) 5196{ 5197 gcc_assert (a && AT_class (a) == dw_val_class_addr); 5198 return a->dw_attr_val.v.val_addr; 5199} 5200 5201/* Add a file attribute value to a DIE. */ 5202 5203static inline void 5204add_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind, 5205 struct dwarf_file_data *fd) 5206{ 5207 dw_attr_node attr; 5208 5209 attr.dw_attr = attr_kind; 5210 attr.dw_attr_val.val_class = dw_val_class_file; 5211 attr.dw_attr_val.v.val_file = fd; 5212 add_dwarf_attr (die, &attr); 5213} 5214 5215/* Get the dwarf_file_data from a file DIE attribute. */ 5216 5217static inline struct dwarf_file_data * 5218AT_file (dw_attr_ref a) 5219{ 5220 gcc_assert (a && AT_class (a) == dw_val_class_file); 5221 return a->dw_attr_val.v.val_file; 5222} 5223 5224/* Add a label identifier attribute value to a DIE. */ 5225 5226static inline void 5227add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id) 5228{ 5229 dw_attr_node attr; 5230 5231 attr.dw_attr = attr_kind; 5232 attr.dw_attr_val.val_class = dw_val_class_lbl_id; 5233 attr.dw_attr_val.v.val_lbl_id = xstrdup (lbl_id); 5234 add_dwarf_attr (die, &attr); 5235} 5236 5237/* Add a section offset attribute value to a DIE, an offset into the 5238 debug_line section. */ 5239 5240static inline void 5241add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind, 5242 const char *label) 5243{ 5244 dw_attr_node attr; 5245 5246 attr.dw_attr = attr_kind; 5247 attr.dw_attr_val.val_class = dw_val_class_lineptr; 5248 attr.dw_attr_val.v.val_lbl_id = xstrdup (label); 5249 add_dwarf_attr (die, &attr); 5250} 5251 5252/* Add a section offset attribute value to a DIE, an offset into the 5253 debug_macinfo section. */ 5254 5255static inline void 5256add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind, 5257 const char *label) 5258{ 5259 dw_attr_node attr; 5260 5261 attr.dw_attr = attr_kind; 5262 attr.dw_attr_val.val_class = dw_val_class_macptr; 5263 attr.dw_attr_val.v.val_lbl_id = xstrdup (label); 5264 add_dwarf_attr (die, &attr); 5265} 5266 5267/* Add an offset attribute value to a DIE. */ 5268 5269static inline void 5270add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind, 5271 unsigned HOST_WIDE_INT offset) 5272{ 5273 dw_attr_node attr; 5274 5275 attr.dw_attr = attr_kind; 5276 attr.dw_attr_val.val_class = dw_val_class_offset; 5277 attr.dw_attr_val.v.val_offset = offset; 5278 add_dwarf_attr (die, &attr); 5279} 5280 5281/* Add an range_list attribute value to a DIE. */ 5282 5283static void 5284add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind, 5285 long unsigned int offset) 5286{ 5287 dw_attr_node attr; 5288 5289 attr.dw_attr = attr_kind; 5290 attr.dw_attr_val.val_class = dw_val_class_range_list; 5291 attr.dw_attr_val.v.val_offset = offset; 5292 add_dwarf_attr (die, &attr); 5293} 5294 5295static inline const char * 5296AT_lbl (dw_attr_ref a) 5297{ 5298 gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id 5299 || AT_class (a) == dw_val_class_lineptr 5300 || AT_class (a) == dw_val_class_macptr)); 5301 return a->dw_attr_val.v.val_lbl_id; 5302} 5303 5304/* Get the attribute of type attr_kind. */ 5305 5306static dw_attr_ref 5307get_AT (dw_die_ref die, enum dwarf_attribute attr_kind) 5308{ 5309 dw_attr_ref a; 5310 unsigned ix; 5311 dw_die_ref spec = NULL; 5312 5313 if (! die) 5314 return NULL; 5315 5316 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 5317 if (a->dw_attr == attr_kind) 5318 return a; 5319 else if (a->dw_attr == DW_AT_specification 5320 || a->dw_attr == DW_AT_abstract_origin) 5321 spec = AT_ref (a); 5322 5323 if (spec) 5324 return get_AT (spec, attr_kind); 5325 5326 return NULL; 5327} 5328 5329/* Return the "low pc" attribute value, typically associated with a subprogram 5330 DIE. Return null if the "low pc" attribute is either not present, or if it 5331 cannot be represented as an assembler label identifier. */ 5332 5333static inline const char * 5334get_AT_low_pc (dw_die_ref die) 5335{ 5336 dw_attr_ref a = get_AT (die, DW_AT_low_pc); 5337 5338 return a ? AT_lbl (a) : NULL; 5339} 5340 5341/* Return the "high pc" attribute value, typically associated with a subprogram 5342 DIE. Return null if the "high pc" attribute is either not present, or if it 5343 cannot be represented as an assembler label identifier. */ 5344 5345static inline const char * 5346get_AT_hi_pc (dw_die_ref die) 5347{ 5348 dw_attr_ref a = get_AT (die, DW_AT_high_pc); 5349 5350 return a ? AT_lbl (a) : NULL; 5351} 5352 5353/* Return the value of the string attribute designated by ATTR_KIND, or 5354 NULL if it is not present. */ 5355 5356static inline const char * 5357get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind) 5358{ 5359 dw_attr_ref a = get_AT (die, attr_kind); 5360 5361 return a ? AT_string (a) : NULL; 5362} 5363 5364/* Return the value of the flag attribute designated by ATTR_KIND, or -1 5365 if it is not present. */ 5366 5367static inline int 5368get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind) 5369{ 5370 dw_attr_ref a = get_AT (die, attr_kind); 5371 5372 return a ? AT_flag (a) : 0; 5373} 5374 5375/* Return the value of the unsigned attribute designated by ATTR_KIND, or 0 5376 if it is not present. */ 5377 5378static inline unsigned 5379get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind) 5380{ 5381 dw_attr_ref a = get_AT (die, attr_kind); 5382 5383 return a ? AT_unsigned (a) : 0; 5384} 5385 5386static inline dw_die_ref 5387get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind) 5388{ 5389 dw_attr_ref a = get_AT (die, attr_kind); 5390 5391 return a ? AT_ref (a) : NULL; 5392} 5393 5394static inline struct dwarf_file_data * 5395get_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind) 5396{ 5397 dw_attr_ref a = get_AT (die, attr_kind); 5398 5399 return a ? AT_file (a) : NULL; 5400} 5401 5402/* Return TRUE if the language is C or C++. */ 5403 5404static inline bool 5405is_c_family (void) 5406{ 5407 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language); 5408 5409 return (lang == DW_LANG_C || lang == DW_LANG_C89 || lang == DW_LANG_ObjC 5410 || lang == DW_LANG_C99 5411 || lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus); 5412} 5413 5414/* Return TRUE if the language is C++. */ 5415 5416static inline bool 5417is_cxx (void) 5418{ 5419 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language); 5420 5421 return lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus; 5422} 5423 5424/* Return TRUE if the language is Fortran. */ 5425 5426static inline bool 5427is_fortran (void) 5428{ 5429 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language); 5430 5431 return (lang == DW_LANG_Fortran77 5432 || lang == DW_LANG_Fortran90 5433 || lang == DW_LANG_Fortran95); 5434} 5435 5436/* Return TRUE if the language is Java. */ 5437 5438static inline bool 5439is_java (void) 5440{ 5441 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language); 5442 5443 return lang == DW_LANG_Java; 5444} 5445 5446/* Return TRUE if the language is Ada. */ 5447 5448static inline bool 5449is_ada (void) 5450{ 5451 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language); 5452 5453 return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83; 5454} 5455 5456/* Remove the specified attribute if present. */ 5457 5458static void 5459remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind) 5460{ 5461 dw_attr_ref a; 5462 unsigned ix; 5463 5464 if (! die) 5465 return; 5466 5467 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 5468 if (a->dw_attr == attr_kind) 5469 { 5470 if (AT_class (a) == dw_val_class_str) 5471 if (a->dw_attr_val.v.val_str->refcount) 5472 a->dw_attr_val.v.val_str->refcount--; 5473 5474 /* VEC_ordered_remove should help reduce the number of abbrevs 5475 that are needed. */ 5476 VEC_ordered_remove (dw_attr_node, die->die_attr, ix); 5477 return; 5478 } 5479} 5480 5481/* Remove CHILD from its parent. PREV must have the property that 5482 PREV->DIE_SIB == CHILD. Does not alter CHILD. */ 5483 5484static void 5485remove_child_with_prev (dw_die_ref child, dw_die_ref prev) 5486{ 5487 gcc_assert (child->die_parent == prev->die_parent); 5488 gcc_assert (prev->die_sib == child); 5489 if (prev == child) 5490 { 5491 gcc_assert (child->die_parent->die_child == child); 5492 prev = NULL; 5493 } 5494 else 5495 prev->die_sib = child->die_sib; 5496 if (child->die_parent->die_child == child) 5497 child->die_parent->die_child = prev; 5498} 5499 5500/* Remove child DIE whose die_tag is TAG. Do nothing if no child 5501 matches TAG. */ 5502 5503static void 5504remove_child_TAG (dw_die_ref die, enum dwarf_tag tag) 5505{ 5506 dw_die_ref c; 5507 5508 c = die->die_child; 5509 if (c) do { 5510 dw_die_ref prev = c; 5511 c = c->die_sib; 5512 while (c->die_tag == tag) 5513 { 5514 remove_child_with_prev (c, prev); 5515 /* Might have removed every child. */ 5516 if (c == c->die_sib) 5517 return; 5518 c = c->die_sib; 5519 } 5520 } while (c != die->die_child); 5521} 5522 5523/* Add a CHILD_DIE as the last child of DIE. */ 5524 5525static void 5526add_child_die (dw_die_ref die, dw_die_ref child_die) 5527{ 5528 /* FIXME this should probably be an assert. */ 5529 if (! die || ! child_die) 5530 return; 5531 gcc_assert (die != child_die); 5532 5533 child_die->die_parent = die; 5534 if (die->die_child) 5535 { 5536 child_die->die_sib = die->die_child->die_sib; 5537 die->die_child->die_sib = child_die; 5538 } 5539 else 5540 child_die->die_sib = child_die; 5541 die->die_child = child_die; 5542} 5543 5544/* Move CHILD, which must be a child of PARENT or the DIE for which PARENT 5545 is the specification, to the end of PARENT's list of children. 5546 This is done by removing and re-adding it. */ 5547 5548static void 5549splice_child_die (dw_die_ref parent, dw_die_ref child) 5550{ 5551 dw_die_ref p; 5552 5553 /* We want the declaration DIE from inside the class, not the 5554 specification DIE at toplevel. */ 5555 if (child->die_parent != parent) 5556 { 5557 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification); 5558 5559 if (tmp) 5560 child = tmp; 5561 } 5562 5563 gcc_assert (child->die_parent == parent 5564 || (child->die_parent 5565 == get_AT_ref (parent, DW_AT_specification))); 5566 5567 for (p = child->die_parent->die_child; ; p = p->die_sib) 5568 if (p->die_sib == child) 5569 { 5570 remove_child_with_prev (child, p); 5571 break; 5572 } 5573 5574 add_child_die (parent, child); 5575} 5576 5577/* Return a pointer to a newly created DIE node. */ 5578 5579static inline dw_die_ref 5580new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t) 5581{ 5582 dw_die_ref die = ggc_alloc_cleared (sizeof (die_node)); 5583 5584 die->die_tag = tag_value; 5585 5586 if (parent_die != NULL) 5587 add_child_die (parent_die, die); 5588 else 5589 { 5590 limbo_die_node *limbo_node; 5591 5592 limbo_node = ggc_alloc_cleared (sizeof (limbo_die_node)); 5593 limbo_node->die = die; 5594 limbo_node->created_for = t; 5595 limbo_node->next = limbo_die_list; 5596 limbo_die_list = limbo_node; 5597 } 5598 5599 return die; 5600} 5601 5602/* Return the DIE associated with the given type specifier. */ 5603 5604static inline dw_die_ref 5605lookup_type_die (tree type) 5606{ 5607 return TYPE_SYMTAB_DIE (type); 5608} 5609 5610/* Equate a DIE to a given type specifier. */ 5611 5612static inline void 5613equate_type_number_to_die (tree type, dw_die_ref type_die) 5614{ 5615 TYPE_SYMTAB_DIE (type) = type_die; 5616} 5617 5618/* Returns a hash value for X (which really is a die_struct). */ 5619 5620static hashval_t 5621decl_die_table_hash (const void *x) 5622{ 5623 return (hashval_t) ((const dw_die_ref) x)->decl_id; 5624} 5625 5626/* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */ 5627 5628static int 5629decl_die_table_eq (const void *x, const void *y) 5630{ 5631 return (((const dw_die_ref) x)->decl_id == DECL_UID ((const tree) y)); 5632} 5633 5634/* Return the DIE associated with a given declaration. */ 5635 5636static inline dw_die_ref 5637lookup_decl_die (tree decl) 5638{ 5639 return htab_find_with_hash (decl_die_table, decl, DECL_UID (decl)); 5640} 5641 5642/* Returns a hash value for X (which really is a var_loc_list). */ 5643 5644static hashval_t 5645decl_loc_table_hash (const void *x) 5646{ 5647 return (hashval_t) ((const var_loc_list *) x)->decl_id; 5648} 5649 5650/* Return nonzero if decl_id of var_loc_list X is the same as 5651 UID of decl *Y. */ 5652 5653static int 5654decl_loc_table_eq (const void *x, const void *y) 5655{ 5656 return (((const var_loc_list *) x)->decl_id == DECL_UID ((const tree) y)); 5657} 5658 5659/* Return the var_loc list associated with a given declaration. */ 5660 5661static inline var_loc_list * 5662lookup_decl_loc (tree decl) 5663{ 5664 return htab_find_with_hash (decl_loc_table, decl, DECL_UID (decl)); 5665} 5666 5667/* Equate a DIE to a particular declaration. */ 5668 5669static void 5670equate_decl_number_to_die (tree decl, dw_die_ref decl_die) 5671{ 5672 unsigned int decl_id = DECL_UID (decl); 5673 void **slot; 5674 5675 slot = htab_find_slot_with_hash (decl_die_table, decl, decl_id, INSERT); 5676 *slot = decl_die; 5677 decl_die->decl_id = decl_id; 5678} 5679 5680/* Add a variable location node to the linked list for DECL. */ 5681 5682static void 5683add_var_loc_to_decl (tree decl, struct var_loc_node *loc) 5684{ 5685 unsigned int decl_id = DECL_UID (decl); 5686 var_loc_list *temp; 5687 void **slot; 5688 5689 slot = htab_find_slot_with_hash (decl_loc_table, decl, decl_id, INSERT); 5690 if (*slot == NULL) 5691 { 5692 temp = ggc_alloc_cleared (sizeof (var_loc_list)); 5693 temp->decl_id = decl_id; 5694 *slot = temp; 5695 } 5696 else 5697 temp = *slot; 5698 5699 if (temp->last) 5700 { 5701 /* If the current location is the same as the end of the list, 5702 we have nothing to do. */ 5703 if (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->last->var_loc_note), 5704 NOTE_VAR_LOCATION_LOC (loc->var_loc_note))) 5705 { 5706 /* Add LOC to the end of list and update LAST. */ 5707 temp->last->next = loc; 5708 temp->last = loc; 5709 } 5710 } 5711 /* Do not add empty location to the beginning of the list. */ 5712 else if (NOTE_VAR_LOCATION_LOC (loc->var_loc_note) != NULL_RTX) 5713 { 5714 temp->first = loc; 5715 temp->last = loc; 5716 } 5717} 5718 5719/* Keep track of the number of spaces used to indent the 5720 output of the debugging routines that print the structure of 5721 the DIE internal representation. */ 5722static int print_indent; 5723 5724/* Indent the line the number of spaces given by print_indent. */ 5725 5726static inline void 5727print_spaces (FILE *outfile) 5728{ 5729 fprintf (outfile, "%*s", print_indent, ""); 5730} 5731 5732/* Print the information associated with a given DIE, and its children. 5733 This routine is a debugging aid only. */ 5734 5735static void 5736print_die (dw_die_ref die, FILE *outfile) 5737{ 5738 dw_attr_ref a; 5739 dw_die_ref c; 5740 unsigned ix; 5741 5742 print_spaces (outfile); 5743 fprintf (outfile, "DIE %4lu: %s\n", 5744 die->die_offset, dwarf_tag_name (die->die_tag)); 5745 print_spaces (outfile); 5746 fprintf (outfile, " abbrev id: %lu", die->die_abbrev); 5747 fprintf (outfile, " offset: %lu\n", die->die_offset); 5748 5749 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 5750 { 5751 print_spaces (outfile); 5752 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr)); 5753 5754 switch (AT_class (a)) 5755 { 5756 case dw_val_class_addr: 5757 fprintf (outfile, "address"); 5758 break; 5759 case dw_val_class_offset: 5760 fprintf (outfile, "offset"); 5761 break; 5762 case dw_val_class_loc: 5763 fprintf (outfile, "location descriptor"); 5764 break; 5765 case dw_val_class_loc_list: 5766 fprintf (outfile, "location list -> label:%s", 5767 AT_loc_list (a)->ll_symbol); 5768 break; 5769 case dw_val_class_range_list: 5770 fprintf (outfile, "range list"); 5771 break; 5772 case dw_val_class_const: 5773 fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, AT_int (a)); 5774 break; 5775 case dw_val_class_unsigned_const: 5776 fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, AT_unsigned (a)); 5777 break; 5778 case dw_val_class_long_long: 5779 fprintf (outfile, "constant (%lu,%lu)", 5780 a->dw_attr_val.v.val_long_long.hi, 5781 a->dw_attr_val.v.val_long_long.low); 5782 break; 5783 case dw_val_class_vec: 5784 fprintf (outfile, "floating-point or vector constant"); 5785 break; 5786 case dw_val_class_flag: 5787 fprintf (outfile, "%u", AT_flag (a)); 5788 break; 5789 case dw_val_class_die_ref: 5790 if (AT_ref (a) != NULL) 5791 { 5792 if (AT_ref (a)->die_symbol) 5793 fprintf (outfile, "die -> label: %s", AT_ref (a)->die_symbol); 5794 else 5795 fprintf (outfile, "die -> %lu", AT_ref (a)->die_offset); 5796 } 5797 else 5798 fprintf (outfile, "die -> <null>"); 5799 break; 5800 case dw_val_class_lbl_id: 5801 case dw_val_class_lineptr: 5802 case dw_val_class_macptr: 5803 fprintf (outfile, "label: %s", AT_lbl (a)); 5804 break; 5805 case dw_val_class_str: 5806 if (AT_string (a) != NULL) 5807 fprintf (outfile, "\"%s\"", AT_string (a)); 5808 else 5809 fprintf (outfile, "<null>"); 5810 break; 5811 case dw_val_class_file: 5812 fprintf (outfile, "\"%s\" (%d)", AT_file (a)->filename, 5813 AT_file (a)->emitted_number); 5814 break; 5815 default: 5816 break; 5817 } 5818 5819 fprintf (outfile, "\n"); 5820 } 5821 5822 if (die->die_child != NULL) 5823 { 5824 print_indent += 4; 5825 FOR_EACH_CHILD (die, c, print_die (c, outfile)); 5826 print_indent -= 4; 5827 } 5828 if (print_indent == 0) 5829 fprintf (outfile, "\n"); 5830} 5831 5832/* Print the contents of the source code line number correspondence table. 5833 This routine is a debugging aid only. */ 5834 5835static void 5836print_dwarf_line_table (FILE *outfile) 5837{ 5838 unsigned i; 5839 dw_line_info_ref line_info; 5840 5841 fprintf (outfile, "\n\nDWARF source line information\n"); 5842 for (i = 1; i < line_info_table_in_use; i++) 5843 { 5844 line_info = &line_info_table[i]; 5845 fprintf (outfile, "%5d: %4ld %6ld\n", i, 5846 line_info->dw_file_num, 5847 line_info->dw_line_num); 5848 } 5849 5850 fprintf (outfile, "\n\n"); 5851} 5852 5853/* Print the information collected for a given DIE. */ 5854 5855void 5856debug_dwarf_die (dw_die_ref die) 5857{ 5858 print_die (die, stderr); 5859} 5860 5861/* Print all DWARF information collected for the compilation unit. 5862 This routine is a debugging aid only. */ 5863 5864void 5865debug_dwarf (void) 5866{ 5867 print_indent = 0; 5868 print_die (comp_unit_die, stderr); 5869 if (! DWARF2_ASM_LINE_DEBUG_INFO) 5870 print_dwarf_line_table (stderr); 5871} 5872 5873/* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU 5874 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL 5875 DIE that marks the start of the DIEs for this include file. */ 5876 5877static dw_die_ref 5878push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die) 5879{ 5880 const char *filename = get_AT_string (bincl_die, DW_AT_name); 5881 dw_die_ref new_unit = gen_compile_unit_die (filename); 5882 5883 new_unit->die_sib = old_unit; 5884 return new_unit; 5885} 5886 5887/* Close an include-file CU and reopen the enclosing one. */ 5888 5889static dw_die_ref 5890pop_compile_unit (dw_die_ref old_unit) 5891{ 5892 dw_die_ref new_unit = old_unit->die_sib; 5893 5894 old_unit->die_sib = NULL; 5895 return new_unit; 5896} 5897 5898#define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx) 5899#define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx) 5900 5901/* Calculate the checksum of a location expression. */ 5902 5903static inline void 5904loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx) 5905{ 5906 CHECKSUM (loc->dw_loc_opc); 5907 CHECKSUM (loc->dw_loc_oprnd1); 5908 CHECKSUM (loc->dw_loc_oprnd2); 5909} 5910 5911/* Calculate the checksum of an attribute. */ 5912 5913static void 5914attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark) 5915{ 5916 dw_loc_descr_ref loc; 5917 rtx r; 5918 5919 CHECKSUM (at->dw_attr); 5920 5921 /* We don't care that this was compiled with a different compiler 5922 snapshot; if the output is the same, that's what matters. */ 5923 if (at->dw_attr == DW_AT_producer) 5924 return; 5925 5926 switch (AT_class (at)) 5927 { 5928 case dw_val_class_const: 5929 CHECKSUM (at->dw_attr_val.v.val_int); 5930 break; 5931 case dw_val_class_unsigned_const: 5932 CHECKSUM (at->dw_attr_val.v.val_unsigned); 5933 break; 5934 case dw_val_class_long_long: 5935 CHECKSUM (at->dw_attr_val.v.val_long_long); 5936 break; 5937 case dw_val_class_vec: 5938 CHECKSUM (at->dw_attr_val.v.val_vec); 5939 break; 5940 case dw_val_class_flag: 5941 CHECKSUM (at->dw_attr_val.v.val_flag); 5942 break; 5943 case dw_val_class_str: 5944 CHECKSUM_STRING (AT_string (at)); 5945 break; 5946 5947 case dw_val_class_addr: 5948 r = AT_addr (at); 5949 gcc_assert (GET_CODE (r) == SYMBOL_REF); 5950 CHECKSUM_STRING (XSTR (r, 0)); 5951 break; 5952 5953 case dw_val_class_offset: 5954 CHECKSUM (at->dw_attr_val.v.val_offset); 5955 break; 5956 5957 case dw_val_class_loc: 5958 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next) 5959 loc_checksum (loc, ctx); 5960 break; 5961 5962 case dw_val_class_die_ref: 5963 die_checksum (AT_ref (at), ctx, mark); 5964 break; 5965 5966 case dw_val_class_fde_ref: 5967 case dw_val_class_lbl_id: 5968 case dw_val_class_lineptr: 5969 case dw_val_class_macptr: 5970 break; 5971 5972 case dw_val_class_file: 5973 CHECKSUM_STRING (AT_file (at)->filename); 5974 break; 5975 5976 default: 5977 break; 5978 } 5979} 5980 5981/* Calculate the checksum of a DIE. */ 5982 5983static void 5984die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark) 5985{ 5986 dw_die_ref c; 5987 dw_attr_ref a; 5988 unsigned ix; 5989 5990 /* To avoid infinite recursion. */ 5991 if (die->die_mark) 5992 { 5993 CHECKSUM (die->die_mark); 5994 return; 5995 } 5996 die->die_mark = ++(*mark); 5997 5998 CHECKSUM (die->die_tag); 5999 6000 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 6001 attr_checksum (a, ctx, mark); 6002 6003 FOR_EACH_CHILD (die, c, die_checksum (c, ctx, mark)); 6004} 6005 6006#undef CHECKSUM 6007#undef CHECKSUM_STRING 6008 6009/* Do the location expressions look same? */ 6010static inline int 6011same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark) 6012{ 6013 return loc1->dw_loc_opc == loc2->dw_loc_opc 6014 && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark) 6015 && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark); 6016} 6017 6018/* Do the values look the same? */ 6019static int 6020same_dw_val_p (dw_val_node *v1, dw_val_node *v2, int *mark) 6021{ 6022 dw_loc_descr_ref loc1, loc2; 6023 rtx r1, r2; 6024 6025 if (v1->val_class != v2->val_class) 6026 return 0; 6027 6028 switch (v1->val_class) 6029 { 6030 case dw_val_class_const: 6031 return v1->v.val_int == v2->v.val_int; 6032 case dw_val_class_unsigned_const: 6033 return v1->v.val_unsigned == v2->v.val_unsigned; 6034 case dw_val_class_long_long: 6035 return v1->v.val_long_long.hi == v2->v.val_long_long.hi 6036 && v1->v.val_long_long.low == v2->v.val_long_long.low; 6037 case dw_val_class_vec: 6038 if (v1->v.val_vec.length != v2->v.val_vec.length 6039 || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size) 6040 return 0; 6041 if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array, 6042 v1->v.val_vec.length * v1->v.val_vec.elt_size)) 6043 return 0; 6044 return 1; 6045 case dw_val_class_flag: 6046 return v1->v.val_flag == v2->v.val_flag; 6047 case dw_val_class_str: 6048 return !strcmp(v1->v.val_str->str, v2->v.val_str->str); 6049 6050 case dw_val_class_addr: 6051 r1 = v1->v.val_addr; 6052 r2 = v2->v.val_addr; 6053 if (GET_CODE (r1) != GET_CODE (r2)) 6054 return 0; 6055 gcc_assert (GET_CODE (r1) == SYMBOL_REF); 6056 return !strcmp (XSTR (r1, 0), XSTR (r2, 0)); 6057 6058 case dw_val_class_offset: 6059 return v1->v.val_offset == v2->v.val_offset; 6060 6061 case dw_val_class_loc: 6062 for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc; 6063 loc1 && loc2; 6064 loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next) 6065 if (!same_loc_p (loc1, loc2, mark)) 6066 return 0; 6067 return !loc1 && !loc2; 6068 6069 case dw_val_class_die_ref: 6070 return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark); 6071 6072 case dw_val_class_fde_ref: 6073 case dw_val_class_lbl_id: 6074 case dw_val_class_lineptr: 6075 case dw_val_class_macptr: 6076 return 1; 6077 6078 case dw_val_class_file: 6079 return v1->v.val_file == v2->v.val_file; 6080 6081 default: 6082 return 1; 6083 } 6084} 6085 6086/* Do the attributes look the same? */ 6087 6088static int 6089same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark) 6090{ 6091 if (at1->dw_attr != at2->dw_attr) 6092 return 0; 6093 6094 /* We don't care that this was compiled with a different compiler 6095 snapshot; if the output is the same, that's what matters. */ 6096 if (at1->dw_attr == DW_AT_producer) 6097 return 1; 6098 6099 return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark); 6100} 6101 6102/* Do the dies look the same? */ 6103 6104static int 6105same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark) 6106{ 6107 dw_die_ref c1, c2; 6108 dw_attr_ref a1; 6109 unsigned ix; 6110 6111 /* To avoid infinite recursion. */ 6112 if (die1->die_mark) 6113 return die1->die_mark == die2->die_mark; 6114 die1->die_mark = die2->die_mark = ++(*mark); 6115 6116 if (die1->die_tag != die2->die_tag) 6117 return 0; 6118 6119 if (VEC_length (dw_attr_node, die1->die_attr) 6120 != VEC_length (dw_attr_node, die2->die_attr)) 6121 return 0; 6122 6123 for (ix = 0; VEC_iterate (dw_attr_node, die1->die_attr, ix, a1); ix++) 6124 if (!same_attr_p (a1, VEC_index (dw_attr_node, die2->die_attr, ix), mark)) 6125 return 0; 6126 6127 c1 = die1->die_child; 6128 c2 = die2->die_child; 6129 if (! c1) 6130 { 6131 if (c2) 6132 return 0; 6133 } 6134 else 6135 for (;;) 6136 { 6137 if (!same_die_p (c1, c2, mark)) 6138 return 0; 6139 c1 = c1->die_sib; 6140 c2 = c2->die_sib; 6141 if (c1 == die1->die_child) 6142 { 6143 if (c2 == die2->die_child) 6144 break; 6145 else 6146 return 0; 6147 } 6148 } 6149 6150 return 1; 6151} 6152 6153/* Do the dies look the same? Wrapper around same_die_p. */ 6154 6155static int 6156same_die_p_wrap (dw_die_ref die1, dw_die_ref die2) 6157{ 6158 int mark = 0; 6159 int ret = same_die_p (die1, die2, &mark); 6160 6161 unmark_all_dies (die1); 6162 unmark_all_dies (die2); 6163 6164 return ret; 6165} 6166 6167/* The prefix to attach to symbols on DIEs in the current comdat debug 6168 info section. */ 6169static char *comdat_symbol_id; 6170 6171/* The index of the current symbol within the current comdat CU. */ 6172static unsigned int comdat_symbol_number; 6173 6174/* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its 6175 children, and set comdat_symbol_id accordingly. */ 6176 6177static void 6178compute_section_prefix (dw_die_ref unit_die) 6179{ 6180 const char *die_name = get_AT_string (unit_die, DW_AT_name); 6181 const char *base = die_name ? lbasename (die_name) : "anonymous"; 6182 char *name = alloca (strlen (base) + 64); 6183 char *p; 6184 int i, mark; 6185 unsigned char checksum[16]; 6186 struct md5_ctx ctx; 6187 6188 /* Compute the checksum of the DIE, then append part of it as hex digits to 6189 the name filename of the unit. */ 6190 6191 md5_init_ctx (&ctx); 6192 mark = 0; 6193 die_checksum (unit_die, &ctx, &mark); 6194 unmark_all_dies (unit_die); 6195 md5_finish_ctx (&ctx, checksum); 6196 6197 sprintf (name, "%s.", base); 6198 clean_symbol_name (name); 6199 6200 p = name + strlen (name); 6201 for (i = 0; i < 4; i++) 6202 { 6203 sprintf (p, "%.2x", checksum[i]); 6204 p += 2; 6205 } 6206 6207 comdat_symbol_id = unit_die->die_symbol = xstrdup (name); 6208 comdat_symbol_number = 0; 6209} 6210 6211/* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */ 6212 6213static int 6214is_type_die (dw_die_ref die) 6215{ 6216 switch (die->die_tag) 6217 { 6218 case DW_TAG_array_type: 6219 case DW_TAG_class_type: 6220 case DW_TAG_enumeration_type: 6221 case DW_TAG_pointer_type: 6222 case DW_TAG_reference_type: 6223 case DW_TAG_string_type: 6224 case DW_TAG_structure_type: 6225 case DW_TAG_subroutine_type: 6226 case DW_TAG_union_type: 6227 case DW_TAG_ptr_to_member_type: 6228 case DW_TAG_set_type: 6229 case DW_TAG_subrange_type: 6230 case DW_TAG_base_type: 6231 case DW_TAG_const_type: 6232 case DW_TAG_file_type: 6233 case DW_TAG_packed_type: 6234 case DW_TAG_volatile_type: 6235 case DW_TAG_typedef: 6236 return 1; 6237 default: 6238 return 0; 6239 } 6240} 6241 6242/* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU. 6243 Basically, we want to choose the bits that are likely to be shared between 6244 compilations (types) and leave out the bits that are specific to individual 6245 compilations (functions). */ 6246 6247static int 6248is_comdat_die (dw_die_ref c) 6249{ 6250 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as 6251 we do for stabs. The advantage is a greater likelihood of sharing between 6252 objects that don't include headers in the same order (and therefore would 6253 put the base types in a different comdat). jason 8/28/00 */ 6254 6255 if (c->die_tag == DW_TAG_base_type) 6256 return 0; 6257 6258 if (c->die_tag == DW_TAG_pointer_type 6259 || c->die_tag == DW_TAG_reference_type 6260 || c->die_tag == DW_TAG_const_type 6261 || c->die_tag == DW_TAG_volatile_type) 6262 { 6263 dw_die_ref t = get_AT_ref (c, DW_AT_type); 6264 6265 return t ? is_comdat_die (t) : 0; 6266 } 6267 6268 return is_type_die (c); 6269} 6270 6271/* Returns 1 iff C is the sort of DIE that might be referred to from another 6272 compilation unit. */ 6273 6274static int 6275is_symbol_die (dw_die_ref c) 6276{ 6277 return (is_type_die (c) 6278 || (get_AT (c, DW_AT_declaration) 6279 && !get_AT (c, DW_AT_specification)) 6280 || c->die_tag == DW_TAG_namespace); 6281} 6282 6283static char * 6284gen_internal_sym (const char *prefix) 6285{ 6286 char buf[256]; 6287 6288 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++); 6289 return xstrdup (buf); 6290} 6291 6292/* Assign symbols to all worthy DIEs under DIE. */ 6293 6294static void 6295assign_symbol_names (dw_die_ref die) 6296{ 6297 dw_die_ref c; 6298 6299 if (is_symbol_die (die)) 6300 { 6301 if (comdat_symbol_id) 6302 { 6303 char *p = alloca (strlen (comdat_symbol_id) + 64); 6304 6305 sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX, 6306 comdat_symbol_id, comdat_symbol_number++); 6307 die->die_symbol = xstrdup (p); 6308 } 6309 else 6310 die->die_symbol = gen_internal_sym ("LDIE"); 6311 } 6312 6313 FOR_EACH_CHILD (die, c, assign_symbol_names (c)); 6314} 6315 6316struct cu_hash_table_entry 6317{ 6318 dw_die_ref cu; 6319 unsigned min_comdat_num, max_comdat_num; 6320 struct cu_hash_table_entry *next; 6321}; 6322 6323/* Routines to manipulate hash table of CUs. */ 6324static hashval_t 6325htab_cu_hash (const void *of) 6326{ 6327 const struct cu_hash_table_entry *entry = of; 6328 6329 return htab_hash_string (entry->cu->die_symbol); 6330} 6331 6332static int 6333htab_cu_eq (const void *of1, const void *of2) 6334{ 6335 const struct cu_hash_table_entry *entry1 = of1; 6336 const struct die_struct *entry2 = of2; 6337 6338 return !strcmp (entry1->cu->die_symbol, entry2->die_symbol); 6339} 6340 6341static void 6342htab_cu_del (void *what) 6343{ 6344 struct cu_hash_table_entry *next, *entry = what; 6345 6346 while (entry) 6347 { 6348 next = entry->next; 6349 free (entry); 6350 entry = next; 6351 } 6352} 6353 6354/* Check whether we have already seen this CU and set up SYM_NUM 6355 accordingly. */ 6356static int 6357check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num) 6358{ 6359 struct cu_hash_table_entry dummy; 6360 struct cu_hash_table_entry **slot, *entry, *last = &dummy; 6361 6362 dummy.max_comdat_num = 0; 6363 6364 slot = (struct cu_hash_table_entry **) 6365 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol), 6366 INSERT); 6367 entry = *slot; 6368 6369 for (; entry; last = entry, entry = entry->next) 6370 { 6371 if (same_die_p_wrap (cu, entry->cu)) 6372 break; 6373 } 6374 6375 if (entry) 6376 { 6377 *sym_num = entry->min_comdat_num; 6378 return 1; 6379 } 6380 6381 entry = XCNEW (struct cu_hash_table_entry); 6382 entry->cu = cu; 6383 entry->min_comdat_num = *sym_num = last->max_comdat_num; 6384 entry->next = *slot; 6385 *slot = entry; 6386 6387 return 0; 6388} 6389 6390/* Record SYM_NUM to record of CU in HTABLE. */ 6391static void 6392record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num) 6393{ 6394 struct cu_hash_table_entry **slot, *entry; 6395 6396 slot = (struct cu_hash_table_entry **) 6397 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol), 6398 NO_INSERT); 6399 entry = *slot; 6400 6401 entry->max_comdat_num = sym_num; 6402} 6403 6404/* Traverse the DIE (which is always comp_unit_die), and set up 6405 additional compilation units for each of the include files we see 6406 bracketed by BINCL/EINCL. */ 6407 6408static void 6409break_out_includes (dw_die_ref die) 6410{ 6411 dw_die_ref c; 6412 dw_die_ref unit = NULL; 6413 limbo_die_node *node, **pnode; 6414 htab_t cu_hash_table; 6415 6416 c = die->die_child; 6417 if (c) do { 6418 dw_die_ref prev = c; 6419 c = c->die_sib; 6420 while (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL 6421 || (unit && is_comdat_die (c))) 6422 { 6423 dw_die_ref next = c->die_sib; 6424 6425 /* This DIE is for a secondary CU; remove it from the main one. */ 6426 remove_child_with_prev (c, prev); 6427 6428 if (c->die_tag == DW_TAG_GNU_BINCL) 6429 unit = push_new_compile_unit (unit, c); 6430 else if (c->die_tag == DW_TAG_GNU_EINCL) 6431 unit = pop_compile_unit (unit); 6432 else 6433 add_child_die (unit, c); 6434 c = next; 6435 if (c == die->die_child) 6436 break; 6437 } 6438 } while (c != die->die_child); 6439 6440#if 0 6441 /* We can only use this in debugging, since the frontend doesn't check 6442 to make sure that we leave every include file we enter. */ 6443 gcc_assert (!unit); 6444#endif 6445 6446 assign_symbol_names (die); 6447 cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del); 6448 for (node = limbo_die_list, pnode = &limbo_die_list; 6449 node; 6450 node = node->next) 6451 { 6452 int is_dupl; 6453 6454 compute_section_prefix (node->die); 6455 is_dupl = check_duplicate_cu (node->die, cu_hash_table, 6456 &comdat_symbol_number); 6457 assign_symbol_names (node->die); 6458 if (is_dupl) 6459 *pnode = node->next; 6460 else 6461 { 6462 pnode = &node->next; 6463 record_comdat_symbol_number (node->die, cu_hash_table, 6464 comdat_symbol_number); 6465 } 6466 } 6467 htab_delete (cu_hash_table); 6468} 6469 6470/* Traverse the DIE and add a sibling attribute if it may have the 6471 effect of speeding up access to siblings. To save some space, 6472 avoid generating sibling attributes for DIE's without children. */ 6473 6474static void 6475add_sibling_attributes (dw_die_ref die) 6476{ 6477 dw_die_ref c; 6478 6479 if (! die->die_child) 6480 return; 6481 6482 if (die->die_parent && die != die->die_parent->die_child) 6483 add_AT_die_ref (die, DW_AT_sibling, die->die_sib); 6484 6485 FOR_EACH_CHILD (die, c, add_sibling_attributes (c)); 6486} 6487 6488/* Output all location lists for the DIE and its children. */ 6489 6490static void 6491output_location_lists (dw_die_ref die) 6492{ 6493 dw_die_ref c; 6494 dw_attr_ref a; 6495 unsigned ix; 6496 6497 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 6498 if (AT_class (a) == dw_val_class_loc_list) 6499 output_loc_list (AT_loc_list (a)); 6500 6501 FOR_EACH_CHILD (die, c, output_location_lists (c)); 6502} 6503 6504/* The format of each DIE (and its attribute value pairs) is encoded in an 6505 abbreviation table. This routine builds the abbreviation table and assigns 6506 a unique abbreviation id for each abbreviation entry. The children of each 6507 die are visited recursively. */ 6508 6509static void 6510build_abbrev_table (dw_die_ref die) 6511{ 6512 unsigned long abbrev_id; 6513 unsigned int n_alloc; 6514 dw_die_ref c; 6515 dw_attr_ref a; 6516 unsigned ix; 6517 6518 /* Scan the DIE references, and mark as external any that refer to 6519 DIEs from other CUs (i.e. those which are not marked). */ 6520 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 6521 if (AT_class (a) == dw_val_class_die_ref 6522 && AT_ref (a)->die_mark == 0) 6523 { 6524 gcc_assert (AT_ref (a)->die_symbol); 6525 6526 set_AT_ref_external (a, 1); 6527 } 6528 6529 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id) 6530 { 6531 dw_die_ref abbrev = abbrev_die_table[abbrev_id]; 6532 dw_attr_ref die_a, abbrev_a; 6533 unsigned ix; 6534 bool ok = true; 6535 6536 if (abbrev->die_tag != die->die_tag) 6537 continue; 6538 if ((abbrev->die_child != NULL) != (die->die_child != NULL)) 6539 continue; 6540 6541 if (VEC_length (dw_attr_node, abbrev->die_attr) 6542 != VEC_length (dw_attr_node, die->die_attr)) 6543 continue; 6544 6545 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, die_a); ix++) 6546 { 6547 abbrev_a = VEC_index (dw_attr_node, abbrev->die_attr, ix); 6548 if ((abbrev_a->dw_attr != die_a->dw_attr) 6549 || (value_format (abbrev_a) != value_format (die_a))) 6550 { 6551 ok = false; 6552 break; 6553 } 6554 } 6555 if (ok) 6556 break; 6557 } 6558 6559 if (abbrev_id >= abbrev_die_table_in_use) 6560 { 6561 if (abbrev_die_table_in_use >= abbrev_die_table_allocated) 6562 { 6563 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT; 6564 abbrev_die_table = ggc_realloc (abbrev_die_table, 6565 sizeof (dw_die_ref) * n_alloc); 6566 6567 memset (&abbrev_die_table[abbrev_die_table_allocated], 0, 6568 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref)); 6569 abbrev_die_table_allocated = n_alloc; 6570 } 6571 6572 ++abbrev_die_table_in_use; 6573 abbrev_die_table[abbrev_id] = die; 6574 } 6575 6576 die->die_abbrev = abbrev_id; 6577 FOR_EACH_CHILD (die, c, build_abbrev_table (c)); 6578} 6579 6580/* Return the power-of-two number of bytes necessary to represent VALUE. */ 6581 6582static int 6583constant_size (long unsigned int value) 6584{ 6585 int log; 6586 6587 if (value == 0) 6588 log = 0; 6589 else 6590 log = floor_log2 (value); 6591 6592 log = log / 8; 6593 log = 1 << (floor_log2 (log) + 1); 6594 6595 return log; 6596} 6597 6598/* Return the size of a DIE as it is represented in the 6599 .debug_info section. */ 6600 6601static unsigned long 6602size_of_die (dw_die_ref die) 6603{ 6604 unsigned long size = 0; 6605 dw_attr_ref a; 6606 unsigned ix; 6607 6608 size += size_of_uleb128 (die->die_abbrev); 6609 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 6610 { 6611 switch (AT_class (a)) 6612 { 6613 case dw_val_class_addr: 6614 size += DWARF2_ADDR_SIZE; 6615 break; 6616 case dw_val_class_offset: 6617 size += DWARF_OFFSET_SIZE; 6618 break; 6619 case dw_val_class_loc: 6620 { 6621 unsigned long lsize = size_of_locs (AT_loc (a)); 6622 6623 /* Block length. */ 6624 size += constant_size (lsize); 6625 size += lsize; 6626 } 6627 break; 6628 case dw_val_class_loc_list: 6629 size += DWARF_OFFSET_SIZE; 6630 break; 6631 case dw_val_class_range_list: 6632 size += DWARF_OFFSET_SIZE; 6633 break; 6634 case dw_val_class_const: 6635 size += size_of_sleb128 (AT_int (a)); 6636 break; 6637 case dw_val_class_unsigned_const: 6638 size += constant_size (AT_unsigned (a)); 6639 break; 6640 case dw_val_class_long_long: 6641 size += 1 + 2*HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR; /* block */ 6642 break; 6643 case dw_val_class_vec: 6644 size += 1 + (a->dw_attr_val.v.val_vec.length 6645 * a->dw_attr_val.v.val_vec.elt_size); /* block */ 6646 break; 6647 case dw_val_class_flag: 6648 size += 1; 6649 break; 6650 case dw_val_class_die_ref: 6651 if (AT_ref_external (a)) 6652 size += DWARF2_ADDR_SIZE; 6653 else 6654 size += DWARF_OFFSET_SIZE; 6655 break; 6656 case dw_val_class_fde_ref: 6657 size += DWARF_OFFSET_SIZE; 6658 break; 6659 case dw_val_class_lbl_id: 6660 size += DWARF2_ADDR_SIZE; 6661 break; 6662 case dw_val_class_lineptr: 6663 case dw_val_class_macptr: 6664 size += DWARF_OFFSET_SIZE; 6665 break; 6666 case dw_val_class_str: 6667 if (AT_string_form (a) == DW_FORM_strp) 6668 size += DWARF_OFFSET_SIZE; 6669 else 6670 size += strlen (a->dw_attr_val.v.val_str->str) + 1; 6671 break; 6672 case dw_val_class_file: 6673 size += constant_size (maybe_emit_file (a->dw_attr_val.v.val_file)); 6674 break; 6675 default: 6676 gcc_unreachable (); 6677 } 6678 } 6679 6680 return size; 6681} 6682 6683/* Size the debugging information associated with a given DIE. Visits the 6684 DIE's children recursively. Updates the global variable next_die_offset, on 6685 each time through. Uses the current value of next_die_offset to update the 6686 die_offset field in each DIE. */ 6687 6688static void 6689calc_die_sizes (dw_die_ref die) 6690{ 6691 dw_die_ref c; 6692 6693 die->die_offset = next_die_offset; 6694 next_die_offset += size_of_die (die); 6695 6696 FOR_EACH_CHILD (die, c, calc_die_sizes (c)); 6697 6698 if (die->die_child != NULL) 6699 /* Count the null byte used to terminate sibling lists. */ 6700 next_die_offset += 1; 6701} 6702 6703/* Set the marks for a die and its children. We do this so 6704 that we know whether or not a reference needs to use FORM_ref_addr; only 6705 DIEs in the same CU will be marked. We used to clear out the offset 6706 and use that as the flag, but ran into ordering problems. */ 6707 6708static void 6709mark_dies (dw_die_ref die) 6710{ 6711 dw_die_ref c; 6712 6713 gcc_assert (!die->die_mark); 6714 6715 die->die_mark = 1; 6716 FOR_EACH_CHILD (die, c, mark_dies (c)); 6717} 6718 6719/* Clear the marks for a die and its children. */ 6720 6721static void 6722unmark_dies (dw_die_ref die) 6723{ 6724 dw_die_ref c; 6725 6726 gcc_assert (die->die_mark); 6727 6728 die->die_mark = 0; 6729 FOR_EACH_CHILD (die, c, unmark_dies (c)); 6730} 6731 6732/* Clear the marks for a die, its children and referred dies. */ 6733 6734static void 6735unmark_all_dies (dw_die_ref die) 6736{ 6737 dw_die_ref c; 6738 dw_attr_ref a; 6739 unsigned ix; 6740 6741 if (!die->die_mark) 6742 return; 6743 die->die_mark = 0; 6744 6745 FOR_EACH_CHILD (die, c, unmark_all_dies (c)); 6746 6747 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 6748 if (AT_class (a) == dw_val_class_die_ref) 6749 unmark_all_dies (AT_ref (a)); 6750} 6751 6752/* Return the size of the .debug_pubnames table generated for the 6753 compilation unit. */ 6754 6755static unsigned long 6756size_of_pubnames (void) 6757{ 6758 unsigned long size; 6759 unsigned i; 6760 6761 size = DWARF_PUBNAMES_HEADER_SIZE; 6762 for (i = 0; i < pubname_table_in_use; i++) 6763 { 6764 pubname_ref p = &pubname_table[i]; 6765 size += DWARF_OFFSET_SIZE + strlen (p->name) + 1; 6766 } 6767 6768 size += DWARF_OFFSET_SIZE; 6769 return size; 6770} 6771 6772/* Return the size of the information in the .debug_aranges section. */ 6773 6774static unsigned long 6775size_of_aranges (void) 6776{ 6777 unsigned long size; 6778 6779 size = DWARF_ARANGES_HEADER_SIZE; 6780 6781 /* Count the address/length pair for this compilation unit. */ 6782 size += 2 * DWARF2_ADDR_SIZE; 6783 size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use; 6784 6785 /* Count the two zero words used to terminated the address range table. */ 6786 size += 2 * DWARF2_ADDR_SIZE; 6787 return size; 6788} 6789 6790/* Select the encoding of an attribute value. */ 6791 6792static enum dwarf_form 6793value_format (dw_attr_ref a) 6794{ 6795 switch (a->dw_attr_val.val_class) 6796 { 6797 case dw_val_class_addr: 6798 return DW_FORM_addr; 6799 case dw_val_class_range_list: 6800 case dw_val_class_offset: 6801 case dw_val_class_loc_list: 6802 switch (DWARF_OFFSET_SIZE) 6803 { 6804 case 4: 6805 return DW_FORM_data4; 6806 case 8: 6807 return DW_FORM_data8; 6808 default: 6809 gcc_unreachable (); 6810 } 6811 case dw_val_class_loc: 6812 switch (constant_size (size_of_locs (AT_loc (a)))) 6813 { 6814 case 1: 6815 return DW_FORM_block1; 6816 case 2: 6817 return DW_FORM_block2; 6818 default: 6819 gcc_unreachable (); 6820 } 6821 case dw_val_class_const: 6822 return DW_FORM_sdata; 6823 case dw_val_class_unsigned_const: 6824 switch (constant_size (AT_unsigned (a))) 6825 { 6826 case 1: 6827 return DW_FORM_data1; 6828 case 2: 6829 return DW_FORM_data2; 6830 case 4: 6831 return DW_FORM_data4; 6832 case 8: 6833 return DW_FORM_data8; 6834 default: 6835 gcc_unreachable (); 6836 } 6837 case dw_val_class_long_long: 6838 return DW_FORM_block1; 6839 case dw_val_class_vec: 6840 return DW_FORM_block1; 6841 case dw_val_class_flag: 6842 return DW_FORM_flag; 6843 case dw_val_class_die_ref: 6844 if (AT_ref_external (a)) 6845 return DW_FORM_ref_addr; 6846 else 6847 return DW_FORM_ref; 6848 case dw_val_class_fde_ref: 6849 return DW_FORM_data; 6850 case dw_val_class_lbl_id: 6851 return DW_FORM_addr; 6852 case dw_val_class_lineptr: 6853 case dw_val_class_macptr: 6854 return DW_FORM_data; 6855 case dw_val_class_str: 6856 return AT_string_form (a); 6857 case dw_val_class_file: 6858 switch (constant_size (maybe_emit_file (a->dw_attr_val.v.val_file))) 6859 { 6860 case 1: 6861 return DW_FORM_data1; 6862 case 2: 6863 return DW_FORM_data2; 6864 case 4: 6865 return DW_FORM_data4; 6866 default: 6867 gcc_unreachable (); 6868 } 6869 6870 default: 6871 gcc_unreachable (); 6872 } 6873} 6874 6875/* Output the encoding of an attribute value. */ 6876 6877static void 6878output_value_format (dw_attr_ref a) 6879{ 6880 enum dwarf_form form = value_format (a); 6881 6882 dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form)); 6883} 6884 6885/* Output the .debug_abbrev section which defines the DIE abbreviation 6886 table. */ 6887 6888static void 6889output_abbrev_section (void) 6890{ 6891 unsigned long abbrev_id; 6892 6893 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id) 6894 { 6895 dw_die_ref abbrev = abbrev_die_table[abbrev_id]; 6896 unsigned ix; 6897 dw_attr_ref a_attr; 6898 6899 dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)"); 6900 dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)", 6901 dwarf_tag_name (abbrev->die_tag)); 6902 6903 if (abbrev->die_child != NULL) 6904 dw2_asm_output_data (1, DW_children_yes, "DW_children_yes"); 6905 else 6906 dw2_asm_output_data (1, DW_children_no, "DW_children_no"); 6907 6908 for (ix = 0; VEC_iterate (dw_attr_node, abbrev->die_attr, ix, a_attr); 6909 ix++) 6910 { 6911 dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)", 6912 dwarf_attr_name (a_attr->dw_attr)); 6913 output_value_format (a_attr); 6914 } 6915 6916 dw2_asm_output_data (1, 0, NULL); 6917 dw2_asm_output_data (1, 0, NULL); 6918 } 6919 6920 /* Terminate the table. */ 6921 dw2_asm_output_data (1, 0, NULL); 6922} 6923 6924/* Output a symbol we can use to refer to this DIE from another CU. */ 6925 6926static inline void 6927output_die_symbol (dw_die_ref die) 6928{ 6929 char *sym = die->die_symbol; 6930 6931 if (sym == 0) 6932 return; 6933 6934 if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0) 6935 /* We make these global, not weak; if the target doesn't support 6936 .linkonce, it doesn't support combining the sections, so debugging 6937 will break. */ 6938 targetm.asm_out.globalize_label (asm_out_file, sym); 6939 6940 ASM_OUTPUT_LABEL (asm_out_file, sym); 6941} 6942 6943/* Return a new location list, given the begin and end range, and the 6944 expression. gensym tells us whether to generate a new internal symbol for 6945 this location list node, which is done for the head of the list only. */ 6946 6947static inline dw_loc_list_ref 6948new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end, 6949 const char *section, unsigned int gensym) 6950{ 6951 dw_loc_list_ref retlist = ggc_alloc_cleared (sizeof (dw_loc_list_node)); 6952 6953 retlist->begin = begin; 6954 retlist->end = end; 6955 retlist->expr = expr; 6956 retlist->section = section; 6957 if (gensym) 6958 retlist->ll_symbol = gen_internal_sym ("LLST"); 6959 6960 return retlist; 6961} 6962 6963/* Add a location description expression to a location list. */ 6964 6965static inline void 6966add_loc_descr_to_loc_list (dw_loc_list_ref *list_head, dw_loc_descr_ref descr, 6967 const char *begin, const char *end, 6968 const char *section) 6969{ 6970 dw_loc_list_ref *d; 6971 6972 /* Find the end of the chain. */ 6973 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next) 6974 ; 6975 6976 /* Add a new location list node to the list. */ 6977 *d = new_loc_list (descr, begin, end, section, 0); 6978} 6979 6980static void 6981dwarf2out_switch_text_section (void) 6982{ 6983 dw_fde_ref fde; 6984 6985 gcc_assert (cfun); 6986 6987 fde = &fde_table[fde_table_in_use - 1]; 6988 fde->dw_fde_switched_sections = true; 6989 fde->dw_fde_hot_section_label = cfun->hot_section_label; 6990 fde->dw_fde_hot_section_end_label = cfun->hot_section_end_label; 6991 fde->dw_fde_unlikely_section_label = cfun->cold_section_label; 6992 fde->dw_fde_unlikely_section_end_label = cfun->cold_section_end_label; 6993 have_multiple_function_sections = true; 6994 6995 /* Reset the current label on switching text sections, so that we 6996 don't attempt to advance_loc4 between labels in different sections. */ 6997 fde->dw_fde_current_label = NULL; 6998} 6999 7000/* Output the location list given to us. */ 7001 7002static void 7003output_loc_list (dw_loc_list_ref list_head) 7004{ 7005 dw_loc_list_ref curr = list_head; 7006 7007 ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol); 7008 7009 /* Walk the location list, and output each range + expression. */ 7010 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next) 7011 { 7012 unsigned long size; 7013 if (!have_multiple_function_sections) 7014 { 7015 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section, 7016 "Location list begin address (%s)", 7017 list_head->ll_symbol); 7018 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section, 7019 "Location list end address (%s)", 7020 list_head->ll_symbol); 7021 } 7022 else 7023 { 7024 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin, 7025 "Location list begin address (%s)", 7026 list_head->ll_symbol); 7027 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end, 7028 "Location list end address (%s)", 7029 list_head->ll_symbol); 7030 } 7031 size = size_of_locs (curr->expr); 7032 7033 /* Output the block length for this list of location operations. */ 7034 gcc_assert (size <= 0xffff); 7035 dw2_asm_output_data (2, size, "%s", "Location expression size"); 7036 7037 output_loc_sequence (curr->expr); 7038 } 7039 7040 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, 7041 "Location list terminator begin (%s)", 7042 list_head->ll_symbol); 7043 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, 7044 "Location list terminator end (%s)", 7045 list_head->ll_symbol); 7046} 7047 7048/* Output the DIE and its attributes. Called recursively to generate 7049 the definitions of each child DIE. */ 7050 7051static void 7052output_die (dw_die_ref die) 7053{ 7054 dw_attr_ref a; 7055 dw_die_ref c; 7056 unsigned long size; 7057 unsigned ix; 7058 7059 /* If someone in another CU might refer to us, set up a symbol for 7060 them to point to. */ 7061 if (die->die_symbol) 7062 output_die_symbol (die); 7063 7064 dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (0x%lx) %s)", 7065 die->die_offset, dwarf_tag_name (die->die_tag)); 7066 7067 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 7068 { 7069 const char *name = dwarf_attr_name (a->dw_attr); 7070 7071 switch (AT_class (a)) 7072 { 7073 case dw_val_class_addr: 7074 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name); 7075 break; 7076 7077 case dw_val_class_offset: 7078 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset, 7079 "%s", name); 7080 break; 7081 7082 case dw_val_class_range_list: 7083 { 7084 char *p = strchr (ranges_section_label, '\0'); 7085 7086 sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX, 7087 a->dw_attr_val.v.val_offset); 7088 dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label, 7089 debug_ranges_section, "%s", name); 7090 *p = '\0'; 7091 } 7092 break; 7093 7094 case dw_val_class_loc: 7095 size = size_of_locs (AT_loc (a)); 7096 7097 /* Output the block length for this list of location operations. */ 7098 dw2_asm_output_data (constant_size (size), size, "%s", name); 7099 7100 output_loc_sequence (AT_loc (a)); 7101 break; 7102 7103 case dw_val_class_const: 7104 /* ??? It would be slightly more efficient to use a scheme like is 7105 used for unsigned constants below, but gdb 4.x does not sign 7106 extend. Gdb 5.x does sign extend. */ 7107 dw2_asm_output_data_sleb128 (AT_int (a), "%s", name); 7108 break; 7109 7110 case dw_val_class_unsigned_const: 7111 dw2_asm_output_data (constant_size (AT_unsigned (a)), 7112 AT_unsigned (a), "%s", name); 7113 break; 7114 7115 case dw_val_class_long_long: 7116 { 7117 unsigned HOST_WIDE_INT first, second; 7118 7119 dw2_asm_output_data (1, 7120 2 * HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR, 7121 "%s", name); 7122 7123 if (WORDS_BIG_ENDIAN) 7124 { 7125 first = a->dw_attr_val.v.val_long_long.hi; 7126 second = a->dw_attr_val.v.val_long_long.low; 7127 } 7128 else 7129 { 7130 first = a->dw_attr_val.v.val_long_long.low; 7131 second = a->dw_attr_val.v.val_long_long.hi; 7132 } 7133 7134 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR, 7135 first, "long long constant"); 7136 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR, 7137 second, NULL); 7138 } 7139 break; 7140 7141 case dw_val_class_vec: 7142 { 7143 unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size; 7144 unsigned int len = a->dw_attr_val.v.val_vec.length; 7145 unsigned int i; 7146 unsigned char *p; 7147 7148 dw2_asm_output_data (1, len * elt_size, "%s", name); 7149 if (elt_size > sizeof (HOST_WIDE_INT)) 7150 { 7151 elt_size /= 2; 7152 len *= 2; 7153 } 7154 for (i = 0, p = a->dw_attr_val.v.val_vec.array; 7155 i < len; 7156 i++, p += elt_size) 7157 dw2_asm_output_data (elt_size, extract_int (p, elt_size), 7158 "fp or vector constant word %u", i); 7159 break; 7160 } 7161 7162 case dw_val_class_flag: 7163 dw2_asm_output_data (1, AT_flag (a), "%s", name); 7164 break; 7165 7166 case dw_val_class_loc_list: 7167 { 7168 char *sym = AT_loc_list (a)->ll_symbol; 7169 7170 gcc_assert (sym); 7171 dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section, 7172 "%s", name); 7173 } 7174 break; 7175 7176 case dw_val_class_die_ref: 7177 if (AT_ref_external (a)) 7178 { 7179 char *sym = AT_ref (a)->die_symbol; 7180 7181 gcc_assert (sym); 7182 dw2_asm_output_offset (DWARF2_ADDR_SIZE, sym, debug_info_section, 7183 "%s", name); 7184 } 7185 else 7186 { 7187 gcc_assert (AT_ref (a)->die_offset); 7188 dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset, 7189 "%s", name); 7190 } 7191 break; 7192 7193 case dw_val_class_fde_ref: 7194 { 7195 char l1[20]; 7196 7197 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL, 7198 a->dw_attr_val.v.val_fde_index * 2); 7199 dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, debug_frame_section, 7200 "%s", name); 7201 } 7202 break; 7203 7204 case dw_val_class_lbl_id: 7205 dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name); 7206 break; 7207 7208 case dw_val_class_lineptr: 7209 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a), 7210 debug_line_section, "%s", name); 7211 break; 7212 7213 case dw_val_class_macptr: 7214 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a), 7215 debug_macinfo_section, "%s", name); 7216 break; 7217 7218 case dw_val_class_str: 7219 if (AT_string_form (a) == DW_FORM_strp) 7220 dw2_asm_output_offset (DWARF_OFFSET_SIZE, 7221 a->dw_attr_val.v.val_str->label, 7222 debug_str_section, 7223 "%s: \"%s\"", name, AT_string (a)); 7224 else 7225 dw2_asm_output_nstring (AT_string (a), -1, "%s", name); 7226 break; 7227 7228 case dw_val_class_file: 7229 { 7230 int f = maybe_emit_file (a->dw_attr_val.v.val_file); 7231 7232 dw2_asm_output_data (constant_size (f), f, "%s (%s)", name, 7233 a->dw_attr_val.v.val_file->filename); 7234 break; 7235 } 7236 7237 default: 7238 gcc_unreachable (); 7239 } 7240 } 7241 7242 FOR_EACH_CHILD (die, c, output_die (c)); 7243 7244 /* Add null byte to terminate sibling list. */ 7245 if (die->die_child != NULL) 7246 dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx", 7247 die->die_offset); 7248} 7249 7250/* Output the compilation unit that appears at the beginning of the 7251 .debug_info section, and precedes the DIE descriptions. */ 7252 7253static void 7254output_compilation_unit_header (void) 7255{ 7256 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4) 7257 dw2_asm_output_data (4, 0xffffffff, 7258 "Initial length escape value indicating 64-bit DWARF extension"); 7259 dw2_asm_output_data (DWARF_OFFSET_SIZE, 7260 next_die_offset - DWARF_INITIAL_LENGTH_SIZE, 7261 "Length of Compilation Unit Info"); 7262 dw2_asm_output_data (2, DWARF_VERSION, "DWARF version number"); 7263 dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label, 7264 debug_abbrev_section, 7265 "Offset Into Abbrev. Section"); 7266 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)"); 7267} 7268 7269/* Output the compilation unit DIE and its children. */ 7270 7271static void 7272output_comp_unit (dw_die_ref die, int output_if_empty) 7273{ 7274 const char *secname; 7275 char *oldsym, *tmp; 7276 7277 /* Unless we are outputting main CU, we may throw away empty ones. */ 7278 if (!output_if_empty && die->die_child == NULL) 7279 return; 7280 7281 /* Even if there are no children of this DIE, we must output the information 7282 about the compilation unit. Otherwise, on an empty translation unit, we 7283 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm' 7284 will then complain when examining the file. First mark all the DIEs in 7285 this CU so we know which get local refs. */ 7286 mark_dies (die); 7287 7288 build_abbrev_table (die); 7289 7290 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */ 7291 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE; 7292 calc_die_sizes (die); 7293 7294 oldsym = die->die_symbol; 7295 if (oldsym) 7296 { 7297 tmp = alloca (strlen (oldsym) + 24); 7298 7299 sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym); 7300 secname = tmp; 7301 die->die_symbol = NULL; 7302 switch_to_section (get_section (secname, SECTION_DEBUG, NULL)); 7303 } 7304 else 7305 switch_to_section (debug_info_section); 7306 7307 /* Output debugging information. */ 7308 output_compilation_unit_header (); 7309 output_die (die); 7310 7311 /* Leave the marks on the main CU, so we can check them in 7312 output_pubnames. */ 7313 if (oldsym) 7314 { 7315 unmark_dies (die); 7316 die->die_symbol = oldsym; 7317 } 7318} 7319 7320/* Return the DWARF2/3 pubname associated with a decl. */ 7321 7322static const char * 7323dwarf2_name (tree decl, int scope) 7324{ 7325 return lang_hooks.dwarf_name (decl, scope ? 1 : 0); 7326} 7327 7328/* Add a new entry to .debug_pubnames if appropriate. */ 7329 7330static void 7331add_pubname (tree decl, dw_die_ref die) 7332{ 7333 pubname_ref p; 7334 7335 if (! TREE_PUBLIC (decl)) 7336 return; 7337 7338 if (pubname_table_in_use == pubname_table_allocated) 7339 { 7340 pubname_table_allocated += PUBNAME_TABLE_INCREMENT; 7341 pubname_table 7342 = ggc_realloc (pubname_table, 7343 (pubname_table_allocated * sizeof (pubname_entry))); 7344 memset (pubname_table + pubname_table_in_use, 0, 7345 PUBNAME_TABLE_INCREMENT * sizeof (pubname_entry)); 7346 } 7347 7348 p = &pubname_table[pubname_table_in_use++]; 7349 p->die = die; 7350 p->name = xstrdup (dwarf2_name (decl, 1)); 7351} 7352 7353/* Output the public names table used to speed up access to externally 7354 visible names. For now, only generate entries for externally 7355 visible procedures. */ 7356 7357static void 7358output_pubnames (void) 7359{ 7360 unsigned i; 7361 unsigned long pubnames_length = size_of_pubnames (); 7362 7363 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4) 7364 dw2_asm_output_data (4, 0xffffffff, 7365 "Initial length escape value indicating 64-bit DWARF extension"); 7366 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length, 7367 "Length of Public Names Info"); 7368 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version"); 7369 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label, 7370 debug_info_section, 7371 "Offset of Compilation Unit Info"); 7372 dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset, 7373 "Compilation Unit Length"); 7374 7375 for (i = 0; i < pubname_table_in_use; i++) 7376 { 7377 pubname_ref pub = &pubname_table[i]; 7378 7379 /* We shouldn't see pubnames for DIEs outside of the main CU. */ 7380 gcc_assert (pub->die->die_mark); 7381 7382 dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset, 7383 "DIE offset"); 7384 7385 dw2_asm_output_nstring (pub->name, -1, "external name"); 7386 } 7387 7388 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL); 7389} 7390 7391/* Add a new entry to .debug_aranges if appropriate. */ 7392 7393static void 7394add_arange (tree decl, dw_die_ref die) 7395{ 7396 if (! DECL_SECTION_NAME (decl)) 7397 return; 7398 7399 if (arange_table_in_use == arange_table_allocated) 7400 { 7401 arange_table_allocated += ARANGE_TABLE_INCREMENT; 7402 arange_table = ggc_realloc (arange_table, 7403 (arange_table_allocated 7404 * sizeof (dw_die_ref))); 7405 memset (arange_table + arange_table_in_use, 0, 7406 ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref)); 7407 } 7408 7409 arange_table[arange_table_in_use++] = die; 7410} 7411 7412/* Output the information that goes into the .debug_aranges table. 7413 Namely, define the beginning and ending address range of the 7414 text section generated for this compilation unit. */ 7415 7416static void 7417output_aranges (void) 7418{ 7419 unsigned i; 7420 unsigned long aranges_length = size_of_aranges (); 7421 7422 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4) 7423 dw2_asm_output_data (4, 0xffffffff, 7424 "Initial length escape value indicating 64-bit DWARF extension"); 7425 dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length, 7426 "Length of Address Ranges Info"); 7427 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version"); 7428 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label, 7429 debug_info_section, 7430 "Offset of Compilation Unit Info"); 7431 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address"); 7432 dw2_asm_output_data (1, 0, "Size of Segment Descriptor"); 7433 7434 /* We need to align to twice the pointer size here. */ 7435 if (DWARF_ARANGES_PAD_SIZE) 7436 { 7437 /* Pad using a 2 byte words so that padding is correct for any 7438 pointer size. */ 7439 dw2_asm_output_data (2, 0, "Pad to %d byte boundary", 7440 2 * DWARF2_ADDR_SIZE); 7441 for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2) 7442 dw2_asm_output_data (2, 0, NULL); 7443 } 7444 7445 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address"); 7446 dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label, 7447 text_section_label, "Length"); 7448 if (flag_reorder_blocks_and_partition) 7449 { 7450 dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label, 7451 "Address"); 7452 dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label, 7453 cold_text_section_label, "Length"); 7454 } 7455 7456 for (i = 0; i < arange_table_in_use; i++) 7457 { 7458 dw_die_ref die = arange_table[i]; 7459 7460 /* We shouldn't see aranges for DIEs outside of the main CU. */ 7461 gcc_assert (die->die_mark); 7462 7463 if (die->die_tag == DW_TAG_subprogram) 7464 { 7465 dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die), 7466 "Address"); 7467 dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die), 7468 get_AT_low_pc (die), "Length"); 7469 } 7470 else 7471 { 7472 /* A static variable; extract the symbol from DW_AT_location. 7473 Note that this code isn't currently hit, as we only emit 7474 aranges for functions (jason 9/23/99). */ 7475 dw_attr_ref a = get_AT (die, DW_AT_location); 7476 dw_loc_descr_ref loc; 7477 7478 gcc_assert (a && AT_class (a) == dw_val_class_loc); 7479 7480 loc = AT_loc (a); 7481 gcc_assert (loc->dw_loc_opc == DW_OP_addr); 7482 7483 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, 7484 loc->dw_loc_oprnd1.v.val_addr, "Address"); 7485 dw2_asm_output_data (DWARF2_ADDR_SIZE, 7486 get_AT_unsigned (die, DW_AT_byte_size), 7487 "Length"); 7488 } 7489 } 7490 7491 /* Output the terminator words. */ 7492 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL); 7493 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL); 7494} 7495 7496/* Add a new entry to .debug_ranges. Return the offset at which it 7497 was placed. */ 7498 7499static unsigned int 7500add_ranges (tree block) 7501{ 7502 unsigned int in_use = ranges_table_in_use; 7503 7504 if (in_use == ranges_table_allocated) 7505 { 7506 ranges_table_allocated += RANGES_TABLE_INCREMENT; 7507 ranges_table 7508 = ggc_realloc (ranges_table, (ranges_table_allocated 7509 * sizeof (struct dw_ranges_struct))); 7510 memset (ranges_table + ranges_table_in_use, 0, 7511 RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct)); 7512 } 7513 7514 ranges_table[in_use].block_num = (block ? BLOCK_NUMBER (block) : 0); 7515 ranges_table_in_use = in_use + 1; 7516 7517 return in_use * 2 * DWARF2_ADDR_SIZE; 7518} 7519 7520static void 7521output_ranges (void) 7522{ 7523 unsigned i; 7524 static const char *const start_fmt = "Offset 0x%x"; 7525 const char *fmt = start_fmt; 7526 7527 for (i = 0; i < ranges_table_in_use; i++) 7528 { 7529 int block_num = ranges_table[i].block_num; 7530 7531 if (block_num) 7532 { 7533 char blabel[MAX_ARTIFICIAL_LABEL_BYTES]; 7534 char elabel[MAX_ARTIFICIAL_LABEL_BYTES]; 7535 7536 ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num); 7537 ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num); 7538 7539 /* If all code is in the text section, then the compilation 7540 unit base address defaults to DW_AT_low_pc, which is the 7541 base of the text section. */ 7542 if (!have_multiple_function_sections) 7543 { 7544 dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel, 7545 text_section_label, 7546 fmt, i * 2 * DWARF2_ADDR_SIZE); 7547 dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel, 7548 text_section_label, NULL); 7549 } 7550 7551 /* Otherwise, we add a DW_AT_entry_pc attribute to force the 7552 compilation unit base address to zero, which allows us to 7553 use absolute addresses, and not worry about whether the 7554 target supports cross-section arithmetic. */ 7555 else 7556 { 7557 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel, 7558 fmt, i * 2 * DWARF2_ADDR_SIZE); 7559 dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL); 7560 } 7561 7562 fmt = NULL; 7563 } 7564 else 7565 { 7566 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL); 7567 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL); 7568 fmt = start_fmt; 7569 } 7570 } 7571} 7572 7573/* Data structure containing information about input files. */ 7574struct file_info 7575{ 7576 const char *path; /* Complete file name. */ 7577 const char *fname; /* File name part. */ 7578 int length; /* Length of entire string. */ 7579 struct dwarf_file_data * file_idx; /* Index in input file table. */ 7580 int dir_idx; /* Index in directory table. */ 7581}; 7582 7583/* Data structure containing information about directories with source 7584 files. */ 7585struct dir_info 7586{ 7587 const char *path; /* Path including directory name. */ 7588 int length; /* Path length. */ 7589 int prefix; /* Index of directory entry which is a prefix. */ 7590 int count; /* Number of files in this directory. */ 7591 int dir_idx; /* Index of directory used as base. */ 7592}; 7593 7594/* Callback function for file_info comparison. We sort by looking at 7595 the directories in the path. */ 7596 7597static int 7598file_info_cmp (const void *p1, const void *p2) 7599{ 7600 const struct file_info *s1 = p1; 7601 const struct file_info *s2 = p2; 7602 unsigned char *cp1; 7603 unsigned char *cp2; 7604 7605 /* Take care of file names without directories. We need to make sure that 7606 we return consistent values to qsort since some will get confused if 7607 we return the same value when identical operands are passed in opposite 7608 orders. So if neither has a directory, return 0 and otherwise return 7609 1 or -1 depending on which one has the directory. */ 7610 if ((s1->path == s1->fname || s2->path == s2->fname)) 7611 return (s2->path == s2->fname) - (s1->path == s1->fname); 7612 7613 cp1 = (unsigned char *) s1->path; 7614 cp2 = (unsigned char *) s2->path; 7615 7616 while (1) 7617 { 7618 ++cp1; 7619 ++cp2; 7620 /* Reached the end of the first path? If so, handle like above. */ 7621 if ((cp1 == (unsigned char *) s1->fname) 7622 || (cp2 == (unsigned char *) s2->fname)) 7623 return ((cp2 == (unsigned char *) s2->fname) 7624 - (cp1 == (unsigned char *) s1->fname)); 7625 7626 /* Character of current path component the same? */ 7627 else if (*cp1 != *cp2) 7628 return *cp1 - *cp2; 7629 } 7630} 7631 7632struct file_name_acquire_data 7633{ 7634 struct file_info *files; 7635 int used_files; 7636 int max_files; 7637}; 7638 7639/* Traversal function for the hash table. */ 7640 7641static int 7642file_name_acquire (void ** slot, void *data) 7643{ 7644 struct file_name_acquire_data *fnad = data; 7645 struct dwarf_file_data *d = *slot; 7646 struct file_info *fi; 7647 const char *f; 7648 7649 gcc_assert (fnad->max_files >= d->emitted_number); 7650 7651 if (! d->emitted_number) 7652 return 1; 7653 7654 gcc_assert (fnad->max_files != fnad->used_files); 7655 7656 fi = fnad->files + fnad->used_files++; 7657 7658 /* Skip all leading "./". */ 7659 f = d->filename; 7660 while (f[0] == '.' && f[1] == '/') 7661 f += 2; 7662 7663 /* Create a new array entry. */ 7664 fi->path = f; 7665 fi->length = strlen (f); 7666 fi->file_idx = d; 7667 7668 /* Search for the file name part. */ 7669 f = strrchr (f, '/'); 7670 fi->fname = f == NULL ? fi->path : f + 1; 7671 return 1; 7672} 7673 7674/* Output the directory table and the file name table. We try to minimize 7675 the total amount of memory needed. A heuristic is used to avoid large 7676 slowdowns with many input files. */ 7677 7678static void 7679output_file_names (void) 7680{ 7681 struct file_name_acquire_data fnad; 7682 int numfiles; 7683 struct file_info *files; 7684 struct dir_info *dirs; 7685 int *saved; 7686 int *savehere; 7687 int *backmap; 7688 int ndirs; 7689 int idx_offset; 7690 int i; 7691 int idx; 7692 7693 if (!last_emitted_file) 7694 { 7695 dw2_asm_output_data (1, 0, "End directory table"); 7696 dw2_asm_output_data (1, 0, "End file name table"); 7697 return; 7698 } 7699 7700 numfiles = last_emitted_file->emitted_number; 7701 7702 /* Allocate the various arrays we need. */ 7703 files = alloca (numfiles * sizeof (struct file_info)); 7704 dirs = alloca (numfiles * sizeof (struct dir_info)); 7705 7706 fnad.files = files; 7707 fnad.used_files = 0; 7708 fnad.max_files = numfiles; 7709 htab_traverse (file_table, file_name_acquire, &fnad); 7710 gcc_assert (fnad.used_files == fnad.max_files); 7711 7712 qsort (files, numfiles, sizeof (files[0]), file_info_cmp); 7713 7714 /* Find all the different directories used. */ 7715 dirs[0].path = files[0].path; 7716 dirs[0].length = files[0].fname - files[0].path; 7717 dirs[0].prefix = -1; 7718 dirs[0].count = 1; 7719 dirs[0].dir_idx = 0; 7720 files[0].dir_idx = 0; 7721 ndirs = 1; 7722 7723 for (i = 1; i < numfiles; i++) 7724 if (files[i].fname - files[i].path == dirs[ndirs - 1].length 7725 && memcmp (dirs[ndirs - 1].path, files[i].path, 7726 dirs[ndirs - 1].length) == 0) 7727 { 7728 /* Same directory as last entry. */ 7729 files[i].dir_idx = ndirs - 1; 7730 ++dirs[ndirs - 1].count; 7731 } 7732 else 7733 { 7734 int j; 7735 7736 /* This is a new directory. */ 7737 dirs[ndirs].path = files[i].path; 7738 dirs[ndirs].length = files[i].fname - files[i].path; 7739 dirs[ndirs].count = 1; 7740 dirs[ndirs].dir_idx = ndirs; 7741 files[i].dir_idx = ndirs; 7742 7743 /* Search for a prefix. */ 7744 dirs[ndirs].prefix = -1; 7745 for (j = 0; j < ndirs; j++) 7746 if (dirs[j].length < dirs[ndirs].length 7747 && dirs[j].length > 1 7748 && (dirs[ndirs].prefix == -1 7749 || dirs[j].length > dirs[dirs[ndirs].prefix].length) 7750 && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0) 7751 dirs[ndirs].prefix = j; 7752 7753 ++ndirs; 7754 } 7755 7756 /* Now to the actual work. We have to find a subset of the directories which 7757 allow expressing the file name using references to the directory table 7758 with the least amount of characters. We do not do an exhaustive search 7759 where we would have to check out every combination of every single 7760 possible prefix. Instead we use a heuristic which provides nearly optimal 7761 results in most cases and never is much off. */ 7762 saved = alloca (ndirs * sizeof (int)); 7763 savehere = alloca (ndirs * sizeof (int)); 7764 7765 memset (saved, '\0', ndirs * sizeof (saved[0])); 7766 for (i = 0; i < ndirs; i++) 7767 { 7768 int j; 7769 int total; 7770 7771 /* We can always save some space for the current directory. But this 7772 does not mean it will be enough to justify adding the directory. */ 7773 savehere[i] = dirs[i].length; 7774 total = (savehere[i] - saved[i]) * dirs[i].count; 7775 7776 for (j = i + 1; j < ndirs; j++) 7777 { 7778 savehere[j] = 0; 7779 if (saved[j] < dirs[i].length) 7780 { 7781 /* Determine whether the dirs[i] path is a prefix of the 7782 dirs[j] path. */ 7783 int k; 7784 7785 k = dirs[j].prefix; 7786 while (k != -1 && k != (int) i) 7787 k = dirs[k].prefix; 7788 7789 if (k == (int) i) 7790 { 7791 /* Yes it is. We can possibly save some memory by 7792 writing the filenames in dirs[j] relative to 7793 dirs[i]. */ 7794 savehere[j] = dirs[i].length; 7795 total += (savehere[j] - saved[j]) * dirs[j].count; 7796 } 7797 } 7798 } 7799 7800 /* Check whether we can save enough to justify adding the dirs[i] 7801 directory. */ 7802 if (total > dirs[i].length + 1) 7803 { 7804 /* It's worthwhile adding. */ 7805 for (j = i; j < ndirs; j++) 7806 if (savehere[j] > 0) 7807 { 7808 /* Remember how much we saved for this directory so far. */ 7809 saved[j] = savehere[j]; 7810 7811 /* Remember the prefix directory. */ 7812 dirs[j].dir_idx = i; 7813 } 7814 } 7815 } 7816 7817 /* Emit the directory name table. */ 7818 idx = 1; 7819 idx_offset = dirs[0].length > 0 ? 1 : 0; 7820 for (i = 1 - idx_offset; i < ndirs; i++) 7821 dw2_asm_output_nstring (dirs[i].path, dirs[i].length - 1, 7822 "Directory Entry: 0x%x", i + idx_offset); 7823 7824 dw2_asm_output_data (1, 0, "End directory table"); 7825 7826 /* We have to emit them in the order of emitted_number since that's 7827 used in the debug info generation. To do this efficiently we 7828 generate a back-mapping of the indices first. */ 7829 backmap = alloca (numfiles * sizeof (int)); 7830 for (i = 0; i < numfiles; i++) 7831 backmap[files[i].file_idx->emitted_number - 1] = i; 7832 7833 /* Now write all the file names. */ 7834 for (i = 0; i < numfiles; i++) 7835 { 7836 int file_idx = backmap[i]; 7837 int dir_idx = dirs[files[file_idx].dir_idx].dir_idx; 7838 7839 dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1, 7840 "File Entry: 0x%x", (unsigned) i + 1); 7841 7842 /* Include directory index. */ 7843 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL); 7844 7845 /* Modification time. */ 7846 dw2_asm_output_data_uleb128 (0, NULL); 7847 7848 /* File length in bytes. */ 7849 dw2_asm_output_data_uleb128 (0, NULL); 7850 } 7851 7852 dw2_asm_output_data (1, 0, "End file name table"); 7853} 7854 7855 7856/* Output the source line number correspondence information. This 7857 information goes into the .debug_line section. */ 7858 7859static void 7860output_line_info (void) 7861{ 7862 char l1[20], l2[20], p1[20], p2[20]; 7863 char line_label[MAX_ARTIFICIAL_LABEL_BYTES]; 7864 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES]; 7865 unsigned opc; 7866 unsigned n_op_args; 7867 unsigned long lt_index; 7868 unsigned long current_line; 7869 long line_offset; 7870 long line_delta; 7871 unsigned long current_file; 7872 unsigned long function; 7873 7874 ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0); 7875 ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0); 7876 ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0); 7877 ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0); 7878 7879 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4) 7880 dw2_asm_output_data (4, 0xffffffff, 7881 "Initial length escape value indicating 64-bit DWARF extension"); 7882 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1, 7883 "Length of Source Line Info"); 7884 ASM_OUTPUT_LABEL (asm_out_file, l1); 7885 7886 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version"); 7887 dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length"); 7888 ASM_OUTPUT_LABEL (asm_out_file, p1); 7889 7890 /* Define the architecture-dependent minimum instruction length (in 7891 bytes). In this implementation of DWARF, this field is used for 7892 information purposes only. Since GCC generates assembly language, 7893 we have no a priori knowledge of how many instruction bytes are 7894 generated for each source line, and therefore can use only the 7895 DW_LNE_set_address and DW_LNS_fixed_advance_pc line information 7896 commands. Accordingly, we fix this as `1', which is "correct 7897 enough" for all architectures, and don't let the target override. */ 7898 dw2_asm_output_data (1, 1, 7899 "Minimum Instruction Length"); 7900 7901 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START, 7902 "Default is_stmt_start flag"); 7903 dw2_asm_output_data (1, DWARF_LINE_BASE, 7904 "Line Base Value (Special Opcodes)"); 7905 dw2_asm_output_data (1, DWARF_LINE_RANGE, 7906 "Line Range Value (Special Opcodes)"); 7907 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE, 7908 "Special Opcode Base"); 7909 7910 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++) 7911 { 7912 switch (opc) 7913 { 7914 case DW_LNS_advance_pc: 7915 case DW_LNS_advance_line: 7916 case DW_LNS_set_file: 7917 case DW_LNS_set_column: 7918 case DW_LNS_fixed_advance_pc: 7919 n_op_args = 1; 7920 break; 7921 default: 7922 n_op_args = 0; 7923 break; 7924 } 7925 7926 dw2_asm_output_data (1, n_op_args, "opcode: 0x%x has %d args", 7927 opc, n_op_args); 7928 } 7929 7930 /* Write out the information about the files we use. */ 7931 output_file_names (); 7932 ASM_OUTPUT_LABEL (asm_out_file, p2); 7933 7934 /* We used to set the address register to the first location in the text 7935 section here, but that didn't accomplish anything since we already 7936 have a line note for the opening brace of the first function. */ 7937 7938 /* Generate the line number to PC correspondence table, encoded as 7939 a series of state machine operations. */ 7940 current_file = 1; 7941 current_line = 1; 7942 7943 if (cfun && in_cold_section_p) 7944 strcpy (prev_line_label, cfun->cold_section_label); 7945 else 7946 strcpy (prev_line_label, text_section_label); 7947 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index) 7948 { 7949 dw_line_info_ref line_info = &line_info_table[lt_index]; 7950 7951#if 0 7952 /* Disable this optimization for now; GDB wants to see two line notes 7953 at the beginning of a function so it can find the end of the 7954 prologue. */ 7955 7956 /* Don't emit anything for redundant notes. Just updating the 7957 address doesn't accomplish anything, because we already assume 7958 that anything after the last address is this line. */ 7959 if (line_info->dw_line_num == current_line 7960 && line_info->dw_file_num == current_file) 7961 continue; 7962#endif 7963 7964 /* Emit debug info for the address of the current line. 7965 7966 Unfortunately, we have little choice here currently, and must always 7967 use the most general form. GCC does not know the address delta 7968 itself, so we can't use DW_LNS_advance_pc. Many ports do have length 7969 attributes which will give an upper bound on the address range. We 7970 could perhaps use length attributes to determine when it is safe to 7971 use DW_LNS_fixed_advance_pc. */ 7972 7973 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index); 7974 if (0) 7975 { 7976 /* This can handle deltas up to 0xffff. This takes 3 bytes. */ 7977 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc, 7978 "DW_LNS_fixed_advance_pc"); 7979 dw2_asm_output_delta (2, line_label, prev_line_label, NULL); 7980 } 7981 else 7982 { 7983 /* This can handle any delta. This takes 7984 4+DWARF2_ADDR_SIZE bytes. */ 7985 dw2_asm_output_data (1, 0, "DW_LNE_set_address"); 7986 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); 7987 dw2_asm_output_data (1, DW_LNE_set_address, NULL); 7988 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL); 7989 } 7990 7991 strcpy (prev_line_label, line_label); 7992 7993 /* Emit debug info for the source file of the current line, if 7994 different from the previous line. */ 7995 if (line_info->dw_file_num != current_file) 7996 { 7997 current_file = line_info->dw_file_num; 7998 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file"); 7999 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file); 8000 } 8001 8002 /* Emit debug info for the current line number, choosing the encoding 8003 that uses the least amount of space. */ 8004 if (line_info->dw_line_num != current_line) 8005 { 8006 line_offset = line_info->dw_line_num - current_line; 8007 line_delta = line_offset - DWARF_LINE_BASE; 8008 current_line = line_info->dw_line_num; 8009 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1)) 8010 /* This can handle deltas from -10 to 234, using the current 8011 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This 8012 takes 1 byte. */ 8013 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta, 8014 "line %lu", current_line); 8015 else 8016 { 8017 /* This can handle any delta. This takes at least 4 bytes, 8018 depending on the value being encoded. */ 8019 dw2_asm_output_data (1, DW_LNS_advance_line, 8020 "advance to line %lu", current_line); 8021 dw2_asm_output_data_sleb128 (line_offset, NULL); 8022 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy"); 8023 } 8024 } 8025 else 8026 /* We still need to start a new row, so output a copy insn. */ 8027 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy"); 8028 } 8029 8030 /* Emit debug info for the address of the end of the function. */ 8031 if (0) 8032 { 8033 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc, 8034 "DW_LNS_fixed_advance_pc"); 8035 dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL); 8036 } 8037 else 8038 { 8039 dw2_asm_output_data (1, 0, "DW_LNE_set_address"); 8040 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); 8041 dw2_asm_output_data (1, DW_LNE_set_address, NULL); 8042 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL); 8043 } 8044 8045 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence"); 8046 dw2_asm_output_data_uleb128 (1, NULL); 8047 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL); 8048 8049 function = 0; 8050 current_file = 1; 8051 current_line = 1; 8052 for (lt_index = 0; lt_index < separate_line_info_table_in_use;) 8053 { 8054 dw_separate_line_info_ref line_info 8055 = &separate_line_info_table[lt_index]; 8056 8057#if 0 8058 /* Don't emit anything for redundant notes. */ 8059 if (line_info->dw_line_num == current_line 8060 && line_info->dw_file_num == current_file 8061 && line_info->function == function) 8062 goto cont; 8063#endif 8064 8065 /* Emit debug info for the address of the current line. If this is 8066 a new function, or the first line of a function, then we need 8067 to handle it differently. */ 8068 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL, 8069 lt_index); 8070 if (function != line_info->function) 8071 { 8072 function = line_info->function; 8073 8074 /* Set the address register to the first line in the function. */ 8075 dw2_asm_output_data (1, 0, "DW_LNE_set_address"); 8076 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); 8077 dw2_asm_output_data (1, DW_LNE_set_address, NULL); 8078 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL); 8079 } 8080 else 8081 { 8082 /* ??? See the DW_LNS_advance_pc comment above. */ 8083 if (0) 8084 { 8085 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc, 8086 "DW_LNS_fixed_advance_pc"); 8087 dw2_asm_output_delta (2, line_label, prev_line_label, NULL); 8088 } 8089 else 8090 { 8091 dw2_asm_output_data (1, 0, "DW_LNE_set_address"); 8092 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); 8093 dw2_asm_output_data (1, DW_LNE_set_address, NULL); 8094 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL); 8095 } 8096 } 8097 8098 strcpy (prev_line_label, line_label); 8099 8100 /* Emit debug info for the source file of the current line, if 8101 different from the previous line. */ 8102 if (line_info->dw_file_num != current_file) 8103 { 8104 current_file = line_info->dw_file_num; 8105 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file"); 8106 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file); 8107 } 8108 8109 /* Emit debug info for the current line number, choosing the encoding 8110 that uses the least amount of space. */ 8111 if (line_info->dw_line_num != current_line) 8112 { 8113 line_offset = line_info->dw_line_num - current_line; 8114 line_delta = line_offset - DWARF_LINE_BASE; 8115 current_line = line_info->dw_line_num; 8116 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1)) 8117 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta, 8118 "line %lu", current_line); 8119 else 8120 { 8121 dw2_asm_output_data (1, DW_LNS_advance_line, 8122 "advance to line %lu", current_line); 8123 dw2_asm_output_data_sleb128 (line_offset, NULL); 8124 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy"); 8125 } 8126 } 8127 else 8128 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy"); 8129 8130#if 0 8131 cont: 8132#endif 8133 8134 lt_index++; 8135 8136 /* If we're done with a function, end its sequence. */ 8137 if (lt_index == separate_line_info_table_in_use 8138 || separate_line_info_table[lt_index].function != function) 8139 { 8140 current_file = 1; 8141 current_line = 1; 8142 8143 /* Emit debug info for the address of the end of the function. */ 8144 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function); 8145 if (0) 8146 { 8147 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc, 8148 "DW_LNS_fixed_advance_pc"); 8149 dw2_asm_output_delta (2, line_label, prev_line_label, NULL); 8150 } 8151 else 8152 { 8153 dw2_asm_output_data (1, 0, "DW_LNE_set_address"); 8154 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); 8155 dw2_asm_output_data (1, DW_LNE_set_address, NULL); 8156 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL); 8157 } 8158 8159 /* Output the marker for the end of this sequence. */ 8160 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence"); 8161 dw2_asm_output_data_uleb128 (1, NULL); 8162 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL); 8163 } 8164 } 8165 8166 /* Output the marker for the end of the line number info. */ 8167 ASM_OUTPUT_LABEL (asm_out_file, l2); 8168} 8169 8170/* Given a pointer to a tree node for some base type, return a pointer to 8171 a DIE that describes the given type. 8172 8173 This routine must only be called for GCC type nodes that correspond to 8174 Dwarf base (fundamental) types. */ 8175 8176static dw_die_ref 8177base_type_die (tree type) 8178{ 8179 dw_die_ref base_type_result; 8180 enum dwarf_type encoding; 8181 8182 if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE) 8183 return 0; 8184 8185 switch (TREE_CODE (type)) 8186 { 8187 case INTEGER_TYPE: 8188 if (TYPE_STRING_FLAG (type)) 8189 { 8190 if (TYPE_UNSIGNED (type)) 8191 encoding = DW_ATE_unsigned_char; 8192 else 8193 encoding = DW_ATE_signed_char; 8194 } 8195 else if (TYPE_UNSIGNED (type)) 8196 encoding = DW_ATE_unsigned; 8197 else 8198 encoding = DW_ATE_signed; 8199 break; 8200 8201 case REAL_TYPE: 8202 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type))) 8203 encoding = DW_ATE_decimal_float; 8204 else 8205 encoding = DW_ATE_float; 8206 break; 8207 8208 /* Dwarf2 doesn't know anything about complex ints, so use 8209 a user defined type for it. */ 8210 case COMPLEX_TYPE: 8211 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE) 8212 encoding = DW_ATE_complex_float; 8213 else 8214 encoding = DW_ATE_lo_user; 8215 break; 8216 8217 case BOOLEAN_TYPE: 8218 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */ 8219 encoding = DW_ATE_boolean; 8220 break; 8221 8222 default: 8223 /* No other TREE_CODEs are Dwarf fundamental types. */ 8224 gcc_unreachable (); 8225 } 8226 8227 base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type); 8228 8229 /* This probably indicates a bug. */ 8230 if (! TYPE_NAME (type)) 8231 add_name_attribute (base_type_result, "__unknown__"); 8232 8233 add_AT_unsigned (base_type_result, DW_AT_byte_size, 8234 int_size_in_bytes (type)); 8235 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding); 8236 8237 return base_type_result; 8238} 8239 8240/* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to 8241 the Dwarf "root" type for the given input type. The Dwarf "root" type of 8242 a given type is generally the same as the given type, except that if the 8243 given type is a pointer or reference type, then the root type of the given 8244 type is the root type of the "basis" type for the pointer or reference 8245 type. (This definition of the "root" type is recursive.) Also, the root 8246 type of a `const' qualified type or a `volatile' qualified type is the 8247 root type of the given type without the qualifiers. */ 8248 8249static tree 8250root_type (tree type) 8251{ 8252 if (TREE_CODE (type) == ERROR_MARK) 8253 return error_mark_node; 8254 8255 switch (TREE_CODE (type)) 8256 { 8257 case ERROR_MARK: 8258 return error_mark_node; 8259 8260 case POINTER_TYPE: 8261 case REFERENCE_TYPE: 8262 return type_main_variant (root_type (TREE_TYPE (type))); 8263 8264 default: 8265 return type_main_variant (type); 8266 } 8267} 8268 8269/* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the 8270 given input type is a Dwarf "fundamental" type. Otherwise return null. */ 8271 8272static inline int 8273is_base_type (tree type) 8274{ 8275 switch (TREE_CODE (type)) 8276 { 8277 case ERROR_MARK: 8278 case VOID_TYPE: 8279 case INTEGER_TYPE: 8280 case REAL_TYPE: 8281 case COMPLEX_TYPE: 8282 case BOOLEAN_TYPE: 8283 return 1; 8284 8285 case ARRAY_TYPE: 8286 case RECORD_TYPE: 8287 case UNION_TYPE: 8288 case QUAL_UNION_TYPE: 8289 case ENUMERAL_TYPE: 8290 case FUNCTION_TYPE: 8291 case METHOD_TYPE: 8292 case POINTER_TYPE: 8293 case REFERENCE_TYPE: 8294 case OFFSET_TYPE: 8295 case LANG_TYPE: 8296 case VECTOR_TYPE: 8297 return 0; 8298 8299 default: 8300 gcc_unreachable (); 8301 } 8302 8303 return 0; 8304} 8305 8306/* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE 8307 node, return the size in bits for the type if it is a constant, or else 8308 return the alignment for the type if the type's size is not constant, or 8309 else return BITS_PER_WORD if the type actually turns out to be an 8310 ERROR_MARK node. */ 8311 8312static inline unsigned HOST_WIDE_INT 8313simple_type_size_in_bits (tree type) 8314{ 8315 if (TREE_CODE (type) == ERROR_MARK) 8316 return BITS_PER_WORD; 8317 else if (TYPE_SIZE (type) == NULL_TREE) 8318 return 0; 8319 else if (host_integerp (TYPE_SIZE (type), 1)) 8320 return tree_low_cst (TYPE_SIZE (type), 1); 8321 else 8322 return TYPE_ALIGN (type); 8323} 8324 8325/* Return true if the debug information for the given type should be 8326 emitted as a subrange type. */ 8327 8328static inline bool 8329is_subrange_type (tree type) 8330{ 8331 tree subtype = TREE_TYPE (type); 8332 8333 /* Subrange types are identified by the fact that they are integer 8334 types, and that they have a subtype which is either an integer type 8335 or an enumeral type. */ 8336 8337 if (TREE_CODE (type) != INTEGER_TYPE 8338 || subtype == NULL_TREE) 8339 return false; 8340 8341 if (TREE_CODE (subtype) != INTEGER_TYPE 8342 && TREE_CODE (subtype) != ENUMERAL_TYPE) 8343 return false; 8344 8345 if (TREE_CODE (type) == TREE_CODE (subtype) 8346 && int_size_in_bytes (type) == int_size_in_bytes (subtype) 8347 && TYPE_MIN_VALUE (type) != NULL 8348 && TYPE_MIN_VALUE (subtype) != NULL 8349 && tree_int_cst_equal (TYPE_MIN_VALUE (type), TYPE_MIN_VALUE (subtype)) 8350 && TYPE_MAX_VALUE (type) != NULL 8351 && TYPE_MAX_VALUE (subtype) != NULL 8352 && tree_int_cst_equal (TYPE_MAX_VALUE (type), TYPE_MAX_VALUE (subtype))) 8353 { 8354 /* The type and its subtype have the same representation. If in 8355 addition the two types also have the same name, then the given 8356 type is not a subrange type, but rather a plain base type. */ 8357 /* FIXME: brobecker/2004-03-22: 8358 Sizetype INTEGER_CSTs nodes are canonicalized. It should 8359 therefore be sufficient to check the TYPE_SIZE node pointers 8360 rather than checking the actual size. Unfortunately, we have 8361 found some cases, such as in the Ada "integer" type, where 8362 this is not the case. Until this problem is solved, we need to 8363 keep checking the actual size. */ 8364 tree type_name = TYPE_NAME (type); 8365 tree subtype_name = TYPE_NAME (subtype); 8366 8367 if (type_name != NULL && TREE_CODE (type_name) == TYPE_DECL) 8368 type_name = DECL_NAME (type_name); 8369 8370 if (subtype_name != NULL && TREE_CODE (subtype_name) == TYPE_DECL) 8371 subtype_name = DECL_NAME (subtype_name); 8372 8373 if (type_name == subtype_name) 8374 return false; 8375 } 8376 8377 return true; 8378} 8379 8380/* Given a pointer to a tree node for a subrange type, return a pointer 8381 to a DIE that describes the given type. */ 8382 8383static dw_die_ref 8384subrange_type_die (tree type, dw_die_ref context_die) 8385{ 8386 dw_die_ref subrange_die; 8387 const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type); 8388 8389 if (context_die == NULL) 8390 context_die = comp_unit_die; 8391 8392 subrange_die = new_die (DW_TAG_subrange_type, context_die, type); 8393 8394 if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes) 8395 { 8396 /* The size of the subrange type and its base type do not match, 8397 so we need to generate a size attribute for the subrange type. */ 8398 add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes); 8399 } 8400 8401 if (TYPE_MIN_VALUE (type) != NULL) 8402 add_bound_info (subrange_die, DW_AT_lower_bound, 8403 TYPE_MIN_VALUE (type)); 8404 if (TYPE_MAX_VALUE (type) != NULL) 8405 add_bound_info (subrange_die, DW_AT_upper_bound, 8406 TYPE_MAX_VALUE (type)); 8407 8408 return subrange_die; 8409} 8410 8411/* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging 8412 entry that chains various modifiers in front of the given type. */ 8413 8414static dw_die_ref 8415modified_type_die (tree type, int is_const_type, int is_volatile_type, 8416 dw_die_ref context_die) 8417{ 8418 enum tree_code code = TREE_CODE (type); 8419 dw_die_ref mod_type_die; 8420 dw_die_ref sub_die = NULL; 8421 tree item_type = NULL; 8422 tree qualified_type; 8423 tree name; 8424 8425 if (code == ERROR_MARK) 8426 return NULL; 8427 8428 /* See if we already have the appropriately qualified variant of 8429 this type. */ 8430 qualified_type 8431 = get_qualified_type (type, 8432 ((is_const_type ? TYPE_QUAL_CONST : 0) 8433 | (is_volatile_type ? TYPE_QUAL_VOLATILE : 0))); 8434 8435 /* If we do, then we can just use its DIE, if it exists. */ 8436 if (qualified_type) 8437 { 8438 mod_type_die = lookup_type_die (qualified_type); 8439 if (mod_type_die) 8440 return mod_type_die; 8441 } 8442 8443 name = qualified_type ? TYPE_NAME (qualified_type) : NULL; 8444 8445 /* Handle C typedef types. */ 8446 if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name)) 8447 { 8448 tree dtype = TREE_TYPE (name); 8449 8450 if (qualified_type == dtype) 8451 { 8452 /* For a named type, use the typedef. */ 8453 gen_type_die (qualified_type, context_die); 8454 return lookup_type_die (qualified_type); 8455 } 8456 else if (is_const_type < TYPE_READONLY (dtype) 8457 || is_volatile_type < TYPE_VOLATILE (dtype) 8458 || (is_const_type <= TYPE_READONLY (dtype) 8459 && is_volatile_type <= TYPE_VOLATILE (dtype) 8460 && DECL_ORIGINAL_TYPE (name) != type)) 8461 /* cv-unqualified version of named type. Just use the unnamed 8462 type to which it refers. */ 8463 return modified_type_die (DECL_ORIGINAL_TYPE (name), 8464 is_const_type, is_volatile_type, 8465 context_die); 8466 /* Else cv-qualified version of named type; fall through. */ 8467 } 8468 8469 if (is_const_type) 8470 { 8471 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type); 8472 sub_die = modified_type_die (type, 0, is_volatile_type, context_die); 8473 } 8474 else if (is_volatile_type) 8475 { 8476 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type); 8477 sub_die = modified_type_die (type, 0, 0, context_die); 8478 } 8479 else if (code == POINTER_TYPE) 8480 { 8481 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type); 8482 add_AT_unsigned (mod_type_die, DW_AT_byte_size, 8483 simple_type_size_in_bits (type) / BITS_PER_UNIT); 8484 item_type = TREE_TYPE (type); 8485 } 8486 else if (code == REFERENCE_TYPE) 8487 { 8488 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type); 8489 add_AT_unsigned (mod_type_die, DW_AT_byte_size, 8490 simple_type_size_in_bits (type) / BITS_PER_UNIT); 8491 item_type = TREE_TYPE (type); 8492 } 8493 else if (is_subrange_type (type)) 8494 { 8495 mod_type_die = subrange_type_die (type, context_die); 8496 item_type = TREE_TYPE (type); 8497 } 8498 else if (is_base_type (type)) 8499 mod_type_die = base_type_die (type); 8500 else 8501 { 8502 gen_type_die (type, context_die); 8503 8504 /* We have to get the type_main_variant here (and pass that to the 8505 `lookup_type_die' routine) because the ..._TYPE node we have 8506 might simply be a *copy* of some original type node (where the 8507 copy was created to help us keep track of typedef names) and 8508 that copy might have a different TYPE_UID from the original 8509 ..._TYPE node. */ 8510 if (TREE_CODE (type) != VECTOR_TYPE) 8511 return lookup_type_die (type_main_variant (type)); 8512 else 8513 /* Vectors have the debugging information in the type, 8514 not the main variant. */ 8515 return lookup_type_die (type); 8516 } 8517 8518 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those, 8519 don't output a DW_TAG_typedef, since there isn't one in the 8520 user's program; just attach a DW_AT_name to the type. */ 8521 if (name 8522 && (TREE_CODE (name) != TYPE_DECL || TREE_TYPE (name) == qualified_type)) 8523 { 8524 if (TREE_CODE (name) == TYPE_DECL) 8525 /* Could just call add_name_and_src_coords_attributes here, 8526 but since this is a builtin type it doesn't have any 8527 useful source coordinates anyway. */ 8528 name = DECL_NAME (name); 8529 add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name)); 8530 } 8531 8532 if (qualified_type) 8533 equate_type_number_to_die (qualified_type, mod_type_die); 8534 8535 if (item_type) 8536 /* We must do this after the equate_type_number_to_die call, in case 8537 this is a recursive type. This ensures that the modified_type_die 8538 recursion will terminate even if the type is recursive. Recursive 8539 types are possible in Ada. */ 8540 sub_die = modified_type_die (item_type, 8541 TYPE_READONLY (item_type), 8542 TYPE_VOLATILE (item_type), 8543 context_die); 8544 8545 if (sub_die != NULL) 8546 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die); 8547 8548 return mod_type_die; 8549} 8550 8551/* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is 8552 an enumerated type. */ 8553 8554static inline int 8555type_is_enum (tree type) 8556{ 8557 return TREE_CODE (type) == ENUMERAL_TYPE; 8558} 8559 8560/* Return the DBX register number described by a given RTL node. */ 8561 8562static unsigned int 8563dbx_reg_number (rtx rtl) 8564{ 8565 unsigned regno = REGNO (rtl); 8566 8567 gcc_assert (regno < FIRST_PSEUDO_REGISTER); 8568 8569#ifdef LEAF_REG_REMAP 8570 if (current_function_uses_only_leaf_regs) 8571 { 8572 int leaf_reg = LEAF_REG_REMAP (regno); 8573 if (leaf_reg != -1) 8574 regno = (unsigned) leaf_reg; 8575 } 8576#endif 8577 8578 return DBX_REGISTER_NUMBER (regno); 8579} 8580 8581/* Optionally add a DW_OP_piece term to a location description expression. 8582 DW_OP_piece is only added if the location description expression already 8583 doesn't end with DW_OP_piece. */ 8584 8585static void 8586add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size) 8587{ 8588 dw_loc_descr_ref loc; 8589 8590 if (*list_head != NULL) 8591 { 8592 /* Find the end of the chain. */ 8593 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next) 8594 ; 8595 8596 if (loc->dw_loc_opc != DW_OP_piece) 8597 loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0); 8598 } 8599} 8600 8601/* Return a location descriptor that designates a machine register or 8602 zero if there is none. */ 8603 8604static dw_loc_descr_ref 8605reg_loc_descriptor (rtx rtl) 8606{ 8607 rtx regs; 8608 8609 if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER) 8610 return 0; 8611 8612 regs = targetm.dwarf_register_span (rtl); 8613 8614 if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs) 8615 return multiple_reg_loc_descriptor (rtl, regs); 8616 else 8617 return one_reg_loc_descriptor (dbx_reg_number (rtl)); 8618} 8619 8620/* Return a location descriptor that designates a machine register for 8621 a given hard register number. */ 8622 8623static dw_loc_descr_ref 8624one_reg_loc_descriptor (unsigned int regno) 8625{ 8626 if (regno <= 31) 8627 return new_loc_descr (DW_OP_reg0 + regno, 0, 0); 8628 else 8629 return new_loc_descr (DW_OP_regx, regno, 0); 8630} 8631 8632/* Given an RTL of a register, return a location descriptor that 8633 designates a value that spans more than one register. */ 8634 8635static dw_loc_descr_ref 8636multiple_reg_loc_descriptor (rtx rtl, rtx regs) 8637{ 8638 int nregs, size, i; 8639 unsigned reg; 8640 dw_loc_descr_ref loc_result = NULL; 8641 8642 reg = REGNO (rtl); 8643#ifdef LEAF_REG_REMAP 8644 if (current_function_uses_only_leaf_regs) 8645 { 8646 int leaf_reg = LEAF_REG_REMAP (reg); 8647 if (leaf_reg != -1) 8648 reg = (unsigned) leaf_reg; 8649 } 8650#endif 8651 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl)); 8652 nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)]; 8653 8654 /* Simple, contiguous registers. */ 8655 if (regs == NULL_RTX) 8656 { 8657 size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs; 8658 8659 loc_result = NULL; 8660 while (nregs--) 8661 { 8662 dw_loc_descr_ref t; 8663 8664 t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg)); 8665 add_loc_descr (&loc_result, t); 8666 add_loc_descr_op_piece (&loc_result, size); 8667 ++reg; 8668 } 8669 return loc_result; 8670 } 8671 8672 /* Now onto stupid register sets in non contiguous locations. */ 8673 8674 gcc_assert (GET_CODE (regs) == PARALLEL); 8675 8676 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0))); 8677 loc_result = NULL; 8678 8679 for (i = 0; i < XVECLEN (regs, 0); ++i) 8680 { 8681 dw_loc_descr_ref t; 8682 8683 t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i))); 8684 add_loc_descr (&loc_result, t); 8685 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0))); 8686 add_loc_descr_op_piece (&loc_result, size); 8687 } 8688 return loc_result; 8689} 8690 8691/* Return a location descriptor that designates a constant. */ 8692 8693static dw_loc_descr_ref 8694int_loc_descriptor (HOST_WIDE_INT i) 8695{ 8696 enum dwarf_location_atom op; 8697 8698 /* Pick the smallest representation of a constant, rather than just 8699 defaulting to the LEB encoding. */ 8700 if (i >= 0) 8701 { 8702 if (i <= 31) 8703 op = DW_OP_lit0 + i; 8704 else if (i <= 0xff) 8705 op = DW_OP_const1u; 8706 else if (i <= 0xffff) 8707 op = DW_OP_const2u; 8708 else if (HOST_BITS_PER_WIDE_INT == 32 8709 || i <= 0xffffffff) 8710 op = DW_OP_const4u; 8711 else 8712 op = DW_OP_constu; 8713 } 8714 else 8715 { 8716 if (i >= -0x80) 8717 op = DW_OP_const1s; 8718 else if (i >= -0x8000) 8719 op = DW_OP_const2s; 8720 else if (HOST_BITS_PER_WIDE_INT == 32 8721 || i >= -0x80000000) 8722 op = DW_OP_const4s; 8723 else 8724 op = DW_OP_consts; 8725 } 8726 8727 return new_loc_descr (op, i, 0); 8728} 8729 8730/* Return a location descriptor that designates a base+offset location. */ 8731 8732static dw_loc_descr_ref 8733based_loc_descr (rtx reg, HOST_WIDE_INT offset) 8734{ 8735 unsigned int regno; 8736 8737 /* We only use "frame base" when we're sure we're talking about the 8738 post-prologue local stack frame. We do this by *not* running 8739 register elimination until this point, and recognizing the special 8740 argument pointer and soft frame pointer rtx's. */ 8741 if (reg == arg_pointer_rtx || reg == frame_pointer_rtx) 8742 { 8743 rtx elim = eliminate_regs (reg, VOIDmode, NULL_RTX); 8744 8745 if (elim != reg) 8746 { 8747 if (GET_CODE (elim) == PLUS) 8748 { 8749 offset += INTVAL (XEXP (elim, 1)); 8750 elim = XEXP (elim, 0); 8751 } 8752 gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx 8753 : stack_pointer_rtx)); 8754 offset += frame_pointer_fb_offset; 8755 8756 return new_loc_descr (DW_OP_fbreg, offset, 0); 8757 } 8758 } 8759 8760 regno = dbx_reg_number (reg); 8761 if (regno <= 31) 8762 return new_loc_descr (DW_OP_breg0 + regno, offset, 0); 8763 else 8764 return new_loc_descr (DW_OP_bregx, regno, offset); 8765} 8766 8767/* Return true if this RTL expression describes a base+offset calculation. */ 8768 8769static inline int 8770is_based_loc (rtx rtl) 8771{ 8772 return (GET_CODE (rtl) == PLUS 8773 && ((REG_P (XEXP (rtl, 0)) 8774 && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER 8775 && GET_CODE (XEXP (rtl, 1)) == CONST_INT))); 8776} 8777 8778/* The following routine converts the RTL for a variable or parameter 8779 (resident in memory) into an equivalent Dwarf representation of a 8780 mechanism for getting the address of that same variable onto the top of a 8781 hypothetical "address evaluation" stack. 8782 8783 When creating memory location descriptors, we are effectively transforming 8784 the RTL for a memory-resident object into its Dwarf postfix expression 8785 equivalent. This routine recursively descends an RTL tree, turning 8786 it into Dwarf postfix code as it goes. 8787 8788 MODE is the mode of the memory reference, needed to handle some 8789 autoincrement addressing modes. 8790 8791 CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the 8792 location list for RTL. 8793 8794 Return 0 if we can't represent the location. */ 8795 8796static dw_loc_descr_ref 8797mem_loc_descriptor (rtx rtl, enum machine_mode mode) 8798{ 8799 dw_loc_descr_ref mem_loc_result = NULL; 8800 enum dwarf_location_atom op; 8801 8802 /* Note that for a dynamically sized array, the location we will generate a 8803 description of here will be the lowest numbered location which is 8804 actually within the array. That's *not* necessarily the same as the 8805 zeroth element of the array. */ 8806 8807 rtl = targetm.delegitimize_address (rtl); 8808 8809 switch (GET_CODE (rtl)) 8810 { 8811 case POST_INC: 8812 case POST_DEC: 8813 case POST_MODIFY: 8814 /* POST_INC and POST_DEC can be handled just like a SUBREG. So we 8815 just fall into the SUBREG code. */ 8816 8817 /* ... fall through ... */ 8818 8819 case SUBREG: 8820 /* The case of a subreg may arise when we have a local (register) 8821 variable or a formal (register) parameter which doesn't quite fill 8822 up an entire register. For now, just assume that it is 8823 legitimate to make the Dwarf info refer to the whole register which 8824 contains the given subreg. */ 8825 rtl = XEXP (rtl, 0); 8826 8827 /* ... fall through ... */ 8828 8829 case REG: 8830 /* Whenever a register number forms a part of the description of the 8831 method for calculating the (dynamic) address of a memory resident 8832 object, DWARF rules require the register number be referred to as 8833 a "base register". This distinction is not based in any way upon 8834 what category of register the hardware believes the given register 8835 belongs to. This is strictly DWARF terminology we're dealing with 8836 here. Note that in cases where the location of a memory-resident 8837 data object could be expressed as: OP_ADD (OP_BASEREG (basereg), 8838 OP_CONST (0)) the actual DWARF location descriptor that we generate 8839 may just be OP_BASEREG (basereg). This may look deceptively like 8840 the object in question was allocated to a register (rather than in 8841 memory) so DWARF consumers need to be aware of the subtle 8842 distinction between OP_REG and OP_BASEREG. */ 8843 if (REGNO (rtl) < FIRST_PSEUDO_REGISTER) 8844 mem_loc_result = based_loc_descr (rtl, 0); 8845 break; 8846 8847 case MEM: 8848 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl)); 8849 if (mem_loc_result != 0) 8850 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0)); 8851 break; 8852 8853 case LO_SUM: 8854 rtl = XEXP (rtl, 1); 8855 8856 /* ... fall through ... */ 8857 8858 case LABEL_REF: 8859 /* Some ports can transform a symbol ref into a label ref, because 8860 the symbol ref is too far away and has to be dumped into a constant 8861 pool. */ 8862 case CONST: 8863 case SYMBOL_REF: 8864 /* Alternatively, the symbol in the constant pool might be referenced 8865 by a different symbol. */ 8866 if (GET_CODE (rtl) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (rtl)) 8867 { 8868 bool marked; 8869 rtx tmp = get_pool_constant_mark (rtl, &marked); 8870 8871 if (GET_CODE (tmp) == SYMBOL_REF) 8872 { 8873 rtl = tmp; 8874 if (CONSTANT_POOL_ADDRESS_P (tmp)) 8875 get_pool_constant_mark (tmp, &marked); 8876 else 8877 marked = true; 8878 } 8879 8880 /* If all references to this pool constant were optimized away, 8881 it was not output and thus we can't represent it. 8882 FIXME: might try to use DW_OP_const_value here, though 8883 DW_OP_piece complicates it. */ 8884 if (!marked) 8885 return 0; 8886 } 8887 8888 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0); 8889 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr; 8890 mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl; 8891 VEC_safe_push (rtx, gc, used_rtx_array, rtl); 8892 break; 8893 8894 case PRE_MODIFY: 8895 /* Extract the PLUS expression nested inside and fall into 8896 PLUS code below. */ 8897 rtl = XEXP (rtl, 1); 8898 goto plus; 8899 8900 case PRE_INC: 8901 case PRE_DEC: 8902 /* Turn these into a PLUS expression and fall into the PLUS code 8903 below. */ 8904 rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0), 8905 GEN_INT (GET_CODE (rtl) == PRE_INC 8906 ? GET_MODE_UNIT_SIZE (mode) 8907 : -GET_MODE_UNIT_SIZE (mode))); 8908 8909 /* ... fall through ... */ 8910 8911 case PLUS: 8912 plus: 8913 if (is_based_loc (rtl)) 8914 mem_loc_result = based_loc_descr (XEXP (rtl, 0), 8915 INTVAL (XEXP (rtl, 1))); 8916 else 8917 { 8918 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode); 8919 if (mem_loc_result == 0) 8920 break; 8921 8922 if (GET_CODE (XEXP (rtl, 1)) == CONST_INT 8923 && INTVAL (XEXP (rtl, 1)) >= 0) 8924 add_loc_descr (&mem_loc_result, 8925 new_loc_descr (DW_OP_plus_uconst, 8926 INTVAL (XEXP (rtl, 1)), 0)); 8927 else 8928 { 8929 add_loc_descr (&mem_loc_result, 8930 mem_loc_descriptor (XEXP (rtl, 1), mode)); 8931 add_loc_descr (&mem_loc_result, 8932 new_loc_descr (DW_OP_plus, 0, 0)); 8933 } 8934 } 8935 break; 8936 8937 /* If a pseudo-reg is optimized away, it is possible for it to 8938 be replaced with a MEM containing a multiply or shift. */ 8939 case MULT: 8940 op = DW_OP_mul; 8941 goto do_binop; 8942 8943 case ASHIFT: 8944 op = DW_OP_shl; 8945 goto do_binop; 8946 8947 case ASHIFTRT: 8948 op = DW_OP_shra; 8949 goto do_binop; 8950 8951 case LSHIFTRT: 8952 op = DW_OP_shr; 8953 goto do_binop; 8954 8955 do_binop: 8956 { 8957 dw_loc_descr_ref op0 = mem_loc_descriptor (XEXP (rtl, 0), mode); 8958 dw_loc_descr_ref op1 = mem_loc_descriptor (XEXP (rtl, 1), mode); 8959 8960 if (op0 == 0 || op1 == 0) 8961 break; 8962 8963 mem_loc_result = op0; 8964 add_loc_descr (&mem_loc_result, op1); 8965 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0)); 8966 break; 8967 } 8968 8969 case CONST_INT: 8970 mem_loc_result = int_loc_descriptor (INTVAL (rtl)); 8971 break; 8972 8973 default: 8974 gcc_unreachable (); 8975 } 8976 8977 return mem_loc_result; 8978} 8979 8980/* Return a descriptor that describes the concatenation of two locations. 8981 This is typically a complex variable. */ 8982 8983static dw_loc_descr_ref 8984concat_loc_descriptor (rtx x0, rtx x1) 8985{ 8986 dw_loc_descr_ref cc_loc_result = NULL; 8987 dw_loc_descr_ref x0_ref = loc_descriptor (x0); 8988 dw_loc_descr_ref x1_ref = loc_descriptor (x1); 8989 8990 if (x0_ref == 0 || x1_ref == 0) 8991 return 0; 8992 8993 cc_loc_result = x0_ref; 8994 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0))); 8995 8996 add_loc_descr (&cc_loc_result, x1_ref); 8997 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1))); 8998 8999 return cc_loc_result; 9000} 9001 9002/* Output a proper Dwarf location descriptor for a variable or parameter 9003 which is either allocated in a register or in a memory location. For a 9004 register, we just generate an OP_REG and the register number. For a 9005 memory location we provide a Dwarf postfix expression describing how to 9006 generate the (dynamic) address of the object onto the address stack. 9007 9008 If we don't know how to describe it, return 0. */ 9009 9010static dw_loc_descr_ref 9011loc_descriptor (rtx rtl) 9012{ 9013 dw_loc_descr_ref loc_result = NULL; 9014 9015 switch (GET_CODE (rtl)) 9016 { 9017 case SUBREG: 9018 /* The case of a subreg may arise when we have a local (register) 9019 variable or a formal (register) parameter which doesn't quite fill 9020 up an entire register. For now, just assume that it is 9021 legitimate to make the Dwarf info refer to the whole register which 9022 contains the given subreg. */ 9023 rtl = SUBREG_REG (rtl); 9024 9025 /* ... fall through ... */ 9026 9027 case REG: 9028 loc_result = reg_loc_descriptor (rtl); 9029 break; 9030 9031 case MEM: 9032 loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl)); 9033 break; 9034 9035 case CONCAT: 9036 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1)); 9037 break; 9038 9039 case VAR_LOCATION: 9040 /* Single part. */ 9041 if (GET_CODE (XEXP (rtl, 1)) != PARALLEL) 9042 { 9043 loc_result = loc_descriptor (XEXP (XEXP (rtl, 1), 0)); 9044 break; 9045 } 9046 9047 rtl = XEXP (rtl, 1); 9048 /* FALLTHRU */ 9049 9050 case PARALLEL: 9051 { 9052 rtvec par_elems = XVEC (rtl, 0); 9053 int num_elem = GET_NUM_ELEM (par_elems); 9054 enum machine_mode mode; 9055 int i; 9056 9057 /* Create the first one, so we have something to add to. */ 9058 loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0)); 9059 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0)); 9060 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode)); 9061 for (i = 1; i < num_elem; i++) 9062 { 9063 dw_loc_descr_ref temp; 9064 9065 temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0)); 9066 add_loc_descr (&loc_result, temp); 9067 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0)); 9068 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode)); 9069 } 9070 } 9071 break; 9072 9073 default: 9074 gcc_unreachable (); 9075 } 9076 9077 return loc_result; 9078} 9079 9080/* Similar, but generate the descriptor from trees instead of rtl. This comes 9081 up particularly with variable length arrays. WANT_ADDRESS is 2 if this is 9082 a top-level invocation of loc_descriptor_from_tree; is 1 if this is not a 9083 top-level invocation, and we require the address of LOC; is 0 if we require 9084 the value of LOC. */ 9085 9086static dw_loc_descr_ref 9087loc_descriptor_from_tree_1 (tree loc, int want_address) 9088{ 9089 dw_loc_descr_ref ret, ret1; 9090 int have_address = 0; 9091 enum dwarf_location_atom op; 9092 9093 /* ??? Most of the time we do not take proper care for sign/zero 9094 extending the values properly. Hopefully this won't be a real 9095 problem... */ 9096 9097 switch (TREE_CODE (loc)) 9098 { 9099 case ERROR_MARK: 9100 return 0; 9101 9102 case PLACEHOLDER_EXPR: 9103 /* This case involves extracting fields from an object to determine the 9104 position of other fields. We don't try to encode this here. The 9105 only user of this is Ada, which encodes the needed information using 9106 the names of types. */ 9107 return 0; 9108 9109 case CALL_EXPR: 9110 return 0; 9111 9112 case PREINCREMENT_EXPR: 9113 case PREDECREMENT_EXPR: 9114 case POSTINCREMENT_EXPR: 9115 case POSTDECREMENT_EXPR: 9116 /* There are no opcodes for these operations. */ 9117 return 0; 9118 9119 case ADDR_EXPR: 9120 /* If we already want an address, there's nothing we can do. */ 9121 if (want_address) 9122 return 0; 9123 9124 /* Otherwise, process the argument and look for the address. */ 9125 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 1); 9126 9127 case VAR_DECL: 9128 if (DECL_THREAD_LOCAL_P (loc)) 9129 { 9130 rtx rtl; 9131 9132 /* If this is not defined, we have no way to emit the data. */ 9133 if (!targetm.asm_out.output_dwarf_dtprel) 9134 return 0; 9135 9136 /* The way DW_OP_GNU_push_tls_address is specified, we can only 9137 look up addresses of objects in the current module. */ 9138 if (DECL_EXTERNAL (loc)) 9139 return 0; 9140 9141 rtl = rtl_for_decl_location (loc); 9142 if (rtl == NULL_RTX) 9143 return 0; 9144 9145 if (!MEM_P (rtl)) 9146 return 0; 9147 rtl = XEXP (rtl, 0); 9148 if (! CONSTANT_P (rtl)) 9149 return 0; 9150 9151 ret = new_loc_descr (INTERNAL_DW_OP_tls_addr, 0, 0); 9152 ret->dw_loc_oprnd1.val_class = dw_val_class_addr; 9153 ret->dw_loc_oprnd1.v.val_addr = rtl; 9154 9155 ret1 = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0); 9156 add_loc_descr (&ret, ret1); 9157 9158 have_address = 1; 9159 break; 9160 } 9161 /* FALLTHRU */ 9162 9163 case PARM_DECL: 9164 if (DECL_HAS_VALUE_EXPR_P (loc)) 9165 return loc_descriptor_from_tree_1 (DECL_VALUE_EXPR (loc), 9166 want_address); 9167 /* FALLTHRU */ 9168 9169 case RESULT_DECL: 9170 case FUNCTION_DECL: 9171 { 9172 rtx rtl = rtl_for_decl_location (loc); 9173 9174 if (rtl == NULL_RTX) 9175 return 0; 9176 else if (GET_CODE (rtl) == CONST_INT) 9177 { 9178 HOST_WIDE_INT val = INTVAL (rtl); 9179 if (TYPE_UNSIGNED (TREE_TYPE (loc))) 9180 val &= GET_MODE_MASK (DECL_MODE (loc)); 9181 ret = int_loc_descriptor (val); 9182 } 9183 else if (GET_CODE (rtl) == CONST_STRING) 9184 return 0; 9185 else if (CONSTANT_P (rtl)) 9186 { 9187 ret = new_loc_descr (DW_OP_addr, 0, 0); 9188 ret->dw_loc_oprnd1.val_class = dw_val_class_addr; 9189 ret->dw_loc_oprnd1.v.val_addr = rtl; 9190 } 9191 else 9192 { 9193 enum machine_mode mode; 9194 9195 /* Certain constructs can only be represented at top-level. */ 9196 if (want_address == 2) 9197 return loc_descriptor (rtl); 9198 9199 mode = GET_MODE (rtl); 9200 if (MEM_P (rtl)) 9201 { 9202 rtl = XEXP (rtl, 0); 9203 have_address = 1; 9204 } 9205 ret = mem_loc_descriptor (rtl, mode); 9206 } 9207 } 9208 break; 9209 9210 case INDIRECT_REF: 9211 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0); 9212 have_address = 1; 9213 break; 9214 9215 case COMPOUND_EXPR: 9216 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), want_address); 9217 9218 case NOP_EXPR: 9219 case CONVERT_EXPR: 9220 case NON_LVALUE_EXPR: 9221 case VIEW_CONVERT_EXPR: 9222 case SAVE_EXPR: 9223 case MODIFY_EXPR: 9224 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), want_address); 9225 9226 case COMPONENT_REF: 9227 case BIT_FIELD_REF: 9228 case ARRAY_REF: 9229 case ARRAY_RANGE_REF: 9230 { 9231 tree obj, offset; 9232 HOST_WIDE_INT bitsize, bitpos, bytepos; 9233 enum machine_mode mode; 9234 int volatilep; 9235 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc)); 9236 9237 obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode, 9238 &unsignedp, &volatilep, false); 9239 9240 if (obj == loc) 9241 return 0; 9242 9243 ret = loc_descriptor_from_tree_1 (obj, 1); 9244 if (ret == 0 9245 || bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0) 9246 return 0; 9247 9248 if (offset != NULL_TREE) 9249 { 9250 /* Variable offset. */ 9251 add_loc_descr (&ret, loc_descriptor_from_tree_1 (offset, 0)); 9252 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0)); 9253 } 9254 9255 bytepos = bitpos / BITS_PER_UNIT; 9256 if (bytepos > 0) 9257 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0)); 9258 else if (bytepos < 0) 9259 { 9260 add_loc_descr (&ret, int_loc_descriptor (bytepos)); 9261 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0)); 9262 } 9263 9264 have_address = 1; 9265 break; 9266 } 9267 9268 case INTEGER_CST: 9269 if (host_integerp (loc, 0)) 9270 ret = int_loc_descriptor (tree_low_cst (loc, 0)); 9271 else 9272 return 0; 9273 break; 9274 9275 case CONSTRUCTOR: 9276 { 9277 /* Get an RTL for this, if something has been emitted. */ 9278 rtx rtl = lookup_constant_def (loc); 9279 enum machine_mode mode; 9280 9281 if (!rtl || !MEM_P (rtl)) 9282 return 0; 9283 mode = GET_MODE (rtl); 9284 rtl = XEXP (rtl, 0); 9285 ret = mem_loc_descriptor (rtl, mode); 9286 have_address = 1; 9287 break; 9288 } 9289 9290 case TRUTH_AND_EXPR: 9291 case TRUTH_ANDIF_EXPR: 9292 case BIT_AND_EXPR: 9293 op = DW_OP_and; 9294 goto do_binop; 9295 9296 case TRUTH_XOR_EXPR: 9297 case BIT_XOR_EXPR: 9298 op = DW_OP_xor; 9299 goto do_binop; 9300 9301 case TRUTH_OR_EXPR: 9302 case TRUTH_ORIF_EXPR: 9303 case BIT_IOR_EXPR: 9304 op = DW_OP_or; 9305 goto do_binop; 9306 9307 case FLOOR_DIV_EXPR: 9308 case CEIL_DIV_EXPR: 9309 case ROUND_DIV_EXPR: 9310 case TRUNC_DIV_EXPR: 9311 op = DW_OP_div; 9312 goto do_binop; 9313 9314 case MINUS_EXPR: 9315 op = DW_OP_minus; 9316 goto do_binop; 9317 9318 case FLOOR_MOD_EXPR: 9319 case CEIL_MOD_EXPR: 9320 case ROUND_MOD_EXPR: 9321 case TRUNC_MOD_EXPR: 9322 op = DW_OP_mod; 9323 goto do_binop; 9324 9325 case MULT_EXPR: 9326 op = DW_OP_mul; 9327 goto do_binop; 9328 9329 case LSHIFT_EXPR: 9330 op = DW_OP_shl; 9331 goto do_binop; 9332 9333 case RSHIFT_EXPR: 9334 op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra); 9335 goto do_binop; 9336 9337 case PLUS_EXPR: 9338 if (TREE_CODE (TREE_OPERAND (loc, 1)) == INTEGER_CST 9339 && host_integerp (TREE_OPERAND (loc, 1), 0)) 9340 { 9341 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0); 9342 if (ret == 0) 9343 return 0; 9344 9345 add_loc_descr (&ret, 9346 new_loc_descr (DW_OP_plus_uconst, 9347 tree_low_cst (TREE_OPERAND (loc, 1), 9348 0), 9349 0)); 9350 break; 9351 } 9352 9353 op = DW_OP_plus; 9354 goto do_binop; 9355 9356 case LE_EXPR: 9357 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0)))) 9358 return 0; 9359 9360 op = DW_OP_le; 9361 goto do_binop; 9362 9363 case GE_EXPR: 9364 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0)))) 9365 return 0; 9366 9367 op = DW_OP_ge; 9368 goto do_binop; 9369 9370 case LT_EXPR: 9371 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0)))) 9372 return 0; 9373 9374 op = DW_OP_lt; 9375 goto do_binop; 9376 9377 case GT_EXPR: 9378 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0)))) 9379 return 0; 9380 9381 op = DW_OP_gt; 9382 goto do_binop; 9383 9384 case EQ_EXPR: 9385 op = DW_OP_eq; 9386 goto do_binop; 9387 9388 case NE_EXPR: 9389 op = DW_OP_ne; 9390 goto do_binop; 9391 9392 do_binop: 9393 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0); 9394 ret1 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0); 9395 if (ret == 0 || ret1 == 0) 9396 return 0; 9397 9398 add_loc_descr (&ret, ret1); 9399 add_loc_descr (&ret, new_loc_descr (op, 0, 0)); 9400 break; 9401 9402 case TRUTH_NOT_EXPR: 9403 case BIT_NOT_EXPR: 9404 op = DW_OP_not; 9405 goto do_unop; 9406 9407 case ABS_EXPR: 9408 op = DW_OP_abs; 9409 goto do_unop; 9410 9411 case NEGATE_EXPR: 9412 op = DW_OP_neg; 9413 goto do_unop; 9414 9415 do_unop: 9416 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0); 9417 if (ret == 0) 9418 return 0; 9419 9420 add_loc_descr (&ret, new_loc_descr (op, 0, 0)); 9421 break; 9422 9423 case MIN_EXPR: 9424 case MAX_EXPR: 9425 { 9426 const enum tree_code code = 9427 TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR; 9428 9429 loc = build3 (COND_EXPR, TREE_TYPE (loc), 9430 build2 (code, integer_type_node, 9431 TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)), 9432 TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0)); 9433 } 9434 9435 /* ... fall through ... */ 9436 9437 case COND_EXPR: 9438 { 9439 dw_loc_descr_ref lhs 9440 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0); 9441 dw_loc_descr_ref rhs 9442 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 2), 0); 9443 dw_loc_descr_ref bra_node, jump_node, tmp; 9444 9445 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0); 9446 if (ret == 0 || lhs == 0 || rhs == 0) 9447 return 0; 9448 9449 bra_node = new_loc_descr (DW_OP_bra, 0, 0); 9450 add_loc_descr (&ret, bra_node); 9451 9452 add_loc_descr (&ret, rhs); 9453 jump_node = new_loc_descr (DW_OP_skip, 0, 0); 9454 add_loc_descr (&ret, jump_node); 9455 9456 add_loc_descr (&ret, lhs); 9457 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc; 9458 bra_node->dw_loc_oprnd1.v.val_loc = lhs; 9459 9460 /* ??? Need a node to point the skip at. Use a nop. */ 9461 tmp = new_loc_descr (DW_OP_nop, 0, 0); 9462 add_loc_descr (&ret, tmp); 9463 jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc; 9464 jump_node->dw_loc_oprnd1.v.val_loc = tmp; 9465 } 9466 break; 9467 9468 case FIX_TRUNC_EXPR: 9469 case FIX_CEIL_EXPR: 9470 case FIX_FLOOR_EXPR: 9471 case FIX_ROUND_EXPR: 9472 return 0; 9473 9474 default: 9475 /* Leave front-end specific codes as simply unknown. This comes 9476 up, for instance, with the C STMT_EXPR. */ 9477 if ((unsigned int) TREE_CODE (loc) 9478 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE) 9479 return 0; 9480 9481#ifdef ENABLE_CHECKING 9482 /* Otherwise this is a generic code; we should just lists all of 9483 these explicitly. We forgot one. */ 9484 gcc_unreachable (); 9485#else 9486 /* In a release build, we want to degrade gracefully: better to 9487 generate incomplete debugging information than to crash. */ 9488 return NULL; 9489#endif 9490 } 9491 9492 /* Show if we can't fill the request for an address. */ 9493 if (want_address && !have_address) 9494 return 0; 9495 9496 /* If we've got an address and don't want one, dereference. */ 9497 if (!want_address && have_address && ret) 9498 { 9499 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc)); 9500 9501 if (size > DWARF2_ADDR_SIZE || size == -1) 9502 return 0; 9503 else if (size == DWARF2_ADDR_SIZE) 9504 op = DW_OP_deref; 9505 else 9506 op = DW_OP_deref_size; 9507 9508 add_loc_descr (&ret, new_loc_descr (op, size, 0)); 9509 } 9510 9511 return ret; 9512} 9513 9514static inline dw_loc_descr_ref 9515loc_descriptor_from_tree (tree loc) 9516{ 9517 return loc_descriptor_from_tree_1 (loc, 2); 9518} 9519 9520/* Given a value, round it up to the lowest multiple of `boundary' 9521 which is not less than the value itself. */ 9522 9523static inline HOST_WIDE_INT 9524ceiling (HOST_WIDE_INT value, unsigned int boundary) 9525{ 9526 return (((value + boundary - 1) / boundary) * boundary); 9527} 9528 9529/* Given a pointer to what is assumed to be a FIELD_DECL node, return a 9530 pointer to the declared type for the relevant field variable, or return 9531 `integer_type_node' if the given node turns out to be an 9532 ERROR_MARK node. */ 9533 9534static inline tree 9535field_type (tree decl) 9536{ 9537 tree type; 9538 9539 if (TREE_CODE (decl) == ERROR_MARK) 9540 return integer_type_node; 9541 9542 type = DECL_BIT_FIELD_TYPE (decl); 9543 if (type == NULL_TREE) 9544 type = TREE_TYPE (decl); 9545 9546 return type; 9547} 9548 9549/* Given a pointer to a tree node, return the alignment in bits for 9550 it, or else return BITS_PER_WORD if the node actually turns out to 9551 be an ERROR_MARK node. */ 9552 9553static inline unsigned 9554simple_type_align_in_bits (tree type) 9555{ 9556 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD; 9557} 9558 9559static inline unsigned 9560simple_decl_align_in_bits (tree decl) 9561{ 9562 return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD; 9563} 9564 9565/* Given a pointer to a FIELD_DECL, compute and return the byte offset of the 9566 lowest addressed byte of the "containing object" for the given FIELD_DECL, 9567 or return 0 if we are unable to determine what that offset is, either 9568 because the argument turns out to be a pointer to an ERROR_MARK node, or 9569 because the offset is actually variable. (We can't handle the latter case 9570 just yet). */ 9571 9572static HOST_WIDE_INT 9573field_byte_offset (tree decl) 9574{ 9575 unsigned int type_align_in_bits; 9576 unsigned int decl_align_in_bits; 9577 unsigned HOST_WIDE_INT type_size_in_bits; 9578 HOST_WIDE_INT object_offset_in_bits; 9579 tree type; 9580 tree field_size_tree; 9581 HOST_WIDE_INT bitpos_int; 9582 HOST_WIDE_INT deepest_bitpos; 9583 unsigned HOST_WIDE_INT field_size_in_bits; 9584 9585 if (TREE_CODE (decl) == ERROR_MARK) 9586 return 0; 9587 9588 gcc_assert (TREE_CODE (decl) == FIELD_DECL); 9589 9590 type = field_type (decl); 9591 field_size_tree = DECL_SIZE (decl); 9592 9593 /* The size could be unspecified if there was an error, or for 9594 a flexible array member. */ 9595 if (! field_size_tree) 9596 field_size_tree = bitsize_zero_node; 9597 9598 /* We cannot yet cope with fields whose positions are variable, so 9599 for now, when we see such things, we simply return 0. Someday, we may 9600 be able to handle such cases, but it will be damn difficult. */ 9601 if (! host_integerp (bit_position (decl), 0)) 9602 return 0; 9603 9604 bitpos_int = int_bit_position (decl); 9605 9606 /* If we don't know the size of the field, pretend it's a full word. */ 9607 if (host_integerp (field_size_tree, 1)) 9608 field_size_in_bits = tree_low_cst (field_size_tree, 1); 9609 else 9610 field_size_in_bits = BITS_PER_WORD; 9611 9612 type_size_in_bits = simple_type_size_in_bits (type); 9613 type_align_in_bits = simple_type_align_in_bits (type); 9614 decl_align_in_bits = simple_decl_align_in_bits (decl); 9615 9616 /* The GCC front-end doesn't make any attempt to keep track of the starting 9617 bit offset (relative to the start of the containing structure type) of the 9618 hypothetical "containing object" for a bit-field. Thus, when computing 9619 the byte offset value for the start of the "containing object" of a 9620 bit-field, we must deduce this information on our own. This can be rather 9621 tricky to do in some cases. For example, handling the following structure 9622 type definition when compiling for an i386/i486 target (which only aligns 9623 long long's to 32-bit boundaries) can be very tricky: 9624 9625 struct S { int field1; long long field2:31; }; 9626 9627 Fortunately, there is a simple rule-of-thumb which can be used in such 9628 cases. When compiling for an i386/i486, GCC will allocate 8 bytes for the 9629 structure shown above. It decides to do this based upon one simple rule 9630 for bit-field allocation. GCC allocates each "containing object" for each 9631 bit-field at the first (i.e. lowest addressed) legitimate alignment 9632 boundary (based upon the required minimum alignment for the declared type 9633 of the field) which it can possibly use, subject to the condition that 9634 there is still enough available space remaining in the containing object 9635 (when allocated at the selected point) to fully accommodate all of the 9636 bits of the bit-field itself. 9637 9638 This simple rule makes it obvious why GCC allocates 8 bytes for each 9639 object of the structure type shown above. When looking for a place to 9640 allocate the "containing object" for `field2', the compiler simply tries 9641 to allocate a 64-bit "containing object" at each successive 32-bit 9642 boundary (starting at zero) until it finds a place to allocate that 64- 9643 bit field such that at least 31 contiguous (and previously unallocated) 9644 bits remain within that selected 64 bit field. (As it turns out, for the 9645 example above, the compiler finds it is OK to allocate the "containing 9646 object" 64-bit field at bit-offset zero within the structure type.) 9647 9648 Here we attempt to work backwards from the limited set of facts we're 9649 given, and we try to deduce from those facts, where GCC must have believed 9650 that the containing object started (within the structure type). The value 9651 we deduce is then used (by the callers of this routine) to generate 9652 DW_AT_location and DW_AT_bit_offset attributes for fields (both bit-fields 9653 and, in the case of DW_AT_location, regular fields as well). */ 9654 9655 /* Figure out the bit-distance from the start of the structure to the 9656 "deepest" bit of the bit-field. */ 9657 deepest_bitpos = bitpos_int + field_size_in_bits; 9658 9659 /* This is the tricky part. Use some fancy footwork to deduce where the 9660 lowest addressed bit of the containing object must be. */ 9661 object_offset_in_bits = deepest_bitpos - type_size_in_bits; 9662 9663 /* Round up to type_align by default. This works best for bitfields. */ 9664 object_offset_in_bits += type_align_in_bits - 1; 9665 object_offset_in_bits /= type_align_in_bits; 9666 object_offset_in_bits *= type_align_in_bits; 9667 9668 if (object_offset_in_bits > bitpos_int) 9669 { 9670 /* Sigh, the decl must be packed. */ 9671 object_offset_in_bits = deepest_bitpos - type_size_in_bits; 9672 9673 /* Round up to decl_align instead. */ 9674 object_offset_in_bits += decl_align_in_bits - 1; 9675 object_offset_in_bits /= decl_align_in_bits; 9676 object_offset_in_bits *= decl_align_in_bits; 9677 } 9678 9679 return object_offset_in_bits / BITS_PER_UNIT; 9680} 9681 9682/* The following routines define various Dwarf attributes and any data 9683 associated with them. */ 9684 9685/* Add a location description attribute value to a DIE. 9686 9687 This emits location attributes suitable for whole variables and 9688 whole parameters. Note that the location attributes for struct fields are 9689 generated by the routine `data_member_location_attribute' below. */ 9690 9691static inline void 9692add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind, 9693 dw_loc_descr_ref descr) 9694{ 9695 if (descr != 0) 9696 add_AT_loc (die, attr_kind, descr); 9697} 9698 9699/* Attach the specialized form of location attribute used for data members of 9700 struct and union types. In the special case of a FIELD_DECL node which 9701 represents a bit-field, the "offset" part of this special location 9702 descriptor must indicate the distance in bytes from the lowest-addressed 9703 byte of the containing struct or union type to the lowest-addressed byte of 9704 the "containing object" for the bit-field. (See the `field_byte_offset' 9705 function above). 9706 9707 For any given bit-field, the "containing object" is a hypothetical object 9708 (of some integral or enum type) within which the given bit-field lives. The 9709 type of this hypothetical "containing object" is always the same as the 9710 declared type of the individual bit-field itself (for GCC anyway... the 9711 DWARF spec doesn't actually mandate this). Note that it is the size (in 9712 bytes) of the hypothetical "containing object" which will be given in the 9713 DW_AT_byte_size attribute for this bit-field. (See the 9714 `byte_size_attribute' function below.) It is also used when calculating the 9715 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute' 9716 function below.) */ 9717 9718static void 9719add_data_member_location_attribute (dw_die_ref die, tree decl) 9720{ 9721 HOST_WIDE_INT offset; 9722 dw_loc_descr_ref loc_descr = 0; 9723 9724 if (TREE_CODE (decl) == TREE_BINFO) 9725 { 9726 /* We're working on the TAG_inheritance for a base class. */ 9727 if (BINFO_VIRTUAL_P (decl) && is_cxx ()) 9728 { 9729 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they 9730 aren't at a fixed offset from all (sub)objects of the same 9731 type. We need to extract the appropriate offset from our 9732 vtable. The following dwarf expression means 9733 9734 BaseAddr = ObAddr + *((*ObAddr) - Offset) 9735 9736 This is specific to the V3 ABI, of course. */ 9737 9738 dw_loc_descr_ref tmp; 9739 9740 /* Make a copy of the object address. */ 9741 tmp = new_loc_descr (DW_OP_dup, 0, 0); 9742 add_loc_descr (&loc_descr, tmp); 9743 9744 /* Extract the vtable address. */ 9745 tmp = new_loc_descr (DW_OP_deref, 0, 0); 9746 add_loc_descr (&loc_descr, tmp); 9747 9748 /* Calculate the address of the offset. */ 9749 offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0); 9750 gcc_assert (offset < 0); 9751 9752 tmp = int_loc_descriptor (-offset); 9753 add_loc_descr (&loc_descr, tmp); 9754 tmp = new_loc_descr (DW_OP_minus, 0, 0); 9755 add_loc_descr (&loc_descr, tmp); 9756 9757 /* Extract the offset. */ 9758 tmp = new_loc_descr (DW_OP_deref, 0, 0); 9759 add_loc_descr (&loc_descr, tmp); 9760 9761 /* Add it to the object address. */ 9762 tmp = new_loc_descr (DW_OP_plus, 0, 0); 9763 add_loc_descr (&loc_descr, tmp); 9764 } 9765 else 9766 offset = tree_low_cst (BINFO_OFFSET (decl), 0); 9767 } 9768 else 9769 offset = field_byte_offset (decl); 9770 9771 if (! loc_descr) 9772 { 9773 enum dwarf_location_atom op; 9774 9775 /* The DWARF2 standard says that we should assume that the structure 9776 address is already on the stack, so we can specify a structure field 9777 address by using DW_OP_plus_uconst. */ 9778 9779#ifdef MIPS_DEBUGGING_INFO 9780 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst 9781 operator correctly. It works only if we leave the offset on the 9782 stack. */ 9783 op = DW_OP_constu; 9784#else 9785 op = DW_OP_plus_uconst; 9786#endif 9787 9788 loc_descr = new_loc_descr (op, offset, 0); 9789 } 9790 9791 add_AT_loc (die, DW_AT_data_member_location, loc_descr); 9792} 9793 9794/* Writes integer values to dw_vec_const array. */ 9795 9796static void 9797insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest) 9798{ 9799 while (size != 0) 9800 { 9801 *dest++ = val & 0xff; 9802 val >>= 8; 9803 --size; 9804 } 9805} 9806 9807/* Reads integers from dw_vec_const array. Inverse of insert_int. */ 9808 9809static HOST_WIDE_INT 9810extract_int (const unsigned char *src, unsigned int size) 9811{ 9812 HOST_WIDE_INT val = 0; 9813 9814 src += size; 9815 while (size != 0) 9816 { 9817 val <<= 8; 9818 val |= *--src & 0xff; 9819 --size; 9820 } 9821 return val; 9822} 9823 9824/* Writes floating point values to dw_vec_const array. */ 9825 9826static void 9827insert_float (rtx rtl, unsigned char *array) 9828{ 9829 REAL_VALUE_TYPE rv; 9830 long val[4]; 9831 int i; 9832 9833 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl); 9834 real_to_target (val, &rv, GET_MODE (rtl)); 9835 9836 /* real_to_target puts 32-bit pieces in each long. Pack them. */ 9837 for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++) 9838 { 9839 insert_int (val[i], 4, array); 9840 array += 4; 9841 } 9842} 9843 9844/* Attach a DW_AT_const_value attribute for a variable or a parameter which 9845 does not have a "location" either in memory or in a register. These 9846 things can arise in GNU C when a constant is passed as an actual parameter 9847 to an inlined function. They can also arise in C++ where declared 9848 constants do not necessarily get memory "homes". */ 9849 9850static void 9851add_const_value_attribute (dw_die_ref die, rtx rtl) 9852{ 9853 switch (GET_CODE (rtl)) 9854 { 9855 case CONST_INT: 9856 { 9857 HOST_WIDE_INT val = INTVAL (rtl); 9858 9859 if (val < 0) 9860 add_AT_int (die, DW_AT_const_value, val); 9861 else 9862 add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val); 9863 } 9864 break; 9865 9866 case CONST_DOUBLE: 9867 /* Note that a CONST_DOUBLE rtx could represent either an integer or a 9868 floating-point constant. A CONST_DOUBLE is used whenever the 9869 constant requires more than one word in order to be adequately 9870 represented. We output CONST_DOUBLEs as blocks. */ 9871 { 9872 enum machine_mode mode = GET_MODE (rtl); 9873 9874 if (SCALAR_FLOAT_MODE_P (mode)) 9875 { 9876 unsigned int length = GET_MODE_SIZE (mode); 9877 unsigned char *array = ggc_alloc (length); 9878 9879 insert_float (rtl, array); 9880 add_AT_vec (die, DW_AT_const_value, length / 4, 4, array); 9881 } 9882 else 9883 { 9884 /* ??? We really should be using HOST_WIDE_INT throughout. */ 9885 gcc_assert (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT); 9886 9887 add_AT_long_long (die, DW_AT_const_value, 9888 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl)); 9889 } 9890 } 9891 break; 9892 9893 case CONST_VECTOR: 9894 { 9895 enum machine_mode mode = GET_MODE (rtl); 9896 unsigned int elt_size = GET_MODE_UNIT_SIZE (mode); 9897 unsigned int length = CONST_VECTOR_NUNITS (rtl); 9898 unsigned char *array = ggc_alloc (length * elt_size); 9899 unsigned int i; 9900 unsigned char *p; 9901 9902 switch (GET_MODE_CLASS (mode)) 9903 { 9904 case MODE_VECTOR_INT: 9905 for (i = 0, p = array; i < length; i++, p += elt_size) 9906 { 9907 rtx elt = CONST_VECTOR_ELT (rtl, i); 9908 HOST_WIDE_INT lo, hi; 9909 9910 switch (GET_CODE (elt)) 9911 { 9912 case CONST_INT: 9913 lo = INTVAL (elt); 9914 hi = -(lo < 0); 9915 break; 9916 9917 case CONST_DOUBLE: 9918 lo = CONST_DOUBLE_LOW (elt); 9919 hi = CONST_DOUBLE_HIGH (elt); 9920 break; 9921 9922 default: 9923 gcc_unreachable (); 9924 } 9925 9926 if (elt_size <= sizeof (HOST_WIDE_INT)) 9927 insert_int (lo, elt_size, p); 9928 else 9929 { 9930 unsigned char *p0 = p; 9931 unsigned char *p1 = p + sizeof (HOST_WIDE_INT); 9932 9933 gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT)); 9934 if (WORDS_BIG_ENDIAN) 9935 { 9936 p0 = p1; 9937 p1 = p; 9938 } 9939 insert_int (lo, sizeof (HOST_WIDE_INT), p0); 9940 insert_int (hi, sizeof (HOST_WIDE_INT), p1); 9941 } 9942 } 9943 break; 9944 9945 case MODE_VECTOR_FLOAT: 9946 for (i = 0, p = array; i < length; i++, p += elt_size) 9947 { 9948 rtx elt = CONST_VECTOR_ELT (rtl, i); 9949 insert_float (elt, p); 9950 } 9951 break; 9952 9953 default: 9954 gcc_unreachable (); 9955 } 9956 9957 add_AT_vec (die, DW_AT_const_value, length, elt_size, array); 9958 } 9959 break; 9960 9961 case CONST_STRING: 9962 add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0)); 9963 break; 9964 9965 case SYMBOL_REF: 9966 case LABEL_REF: 9967 case CONST: 9968 add_AT_addr (die, DW_AT_const_value, rtl); 9969 VEC_safe_push (rtx, gc, used_rtx_array, rtl); 9970 break; 9971 9972 case PLUS: 9973 /* In cases where an inlined instance of an inline function is passed 9974 the address of an `auto' variable (which is local to the caller) we 9975 can get a situation where the DECL_RTL of the artificial local 9976 variable (for the inlining) which acts as a stand-in for the 9977 corresponding formal parameter (of the inline function) will look 9978 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not 9979 exactly a compile-time constant expression, but it isn't the address 9980 of the (artificial) local variable either. Rather, it represents the 9981 *value* which the artificial local variable always has during its 9982 lifetime. We currently have no way to represent such quasi-constant 9983 values in Dwarf, so for now we just punt and generate nothing. */ 9984 break; 9985 9986 default: 9987 /* No other kinds of rtx should be possible here. */ 9988 gcc_unreachable (); 9989 } 9990 9991} 9992 9993/* Determine whether the evaluation of EXPR references any variables 9994 or functions which aren't otherwise used (and therefore may not be 9995 output). */ 9996static tree 9997reference_to_unused (tree * tp, int * walk_subtrees, 9998 void * data ATTRIBUTE_UNUSED) 9999{ 10000 if (! EXPR_P (*tp) && ! CONSTANT_CLASS_P (*tp)) 10001 *walk_subtrees = 0; 10002 10003 if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp) 10004 && ! TREE_ASM_WRITTEN (*tp)) 10005 return *tp; 10006 else if (!flag_unit_at_a_time) 10007 return NULL_TREE; 10008 else if (!cgraph_global_info_ready 10009 && (TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == FUNCTION_DECL)) 10010 return *tp; 10011 else if (DECL_P (*tp) && TREE_CODE (*tp) == VAR_DECL) 10012 { 10013 struct cgraph_varpool_node *node = cgraph_varpool_node (*tp); 10014 if (!node->needed) 10015 return *tp; 10016 } 10017 else if (DECL_P (*tp) && TREE_CODE (*tp) == FUNCTION_DECL 10018 && (!DECL_EXTERNAL (*tp) || DECL_DECLARED_INLINE_P (*tp))) 10019 { 10020 struct cgraph_node *node = cgraph_node (*tp); 10021 if (!node->output) 10022 return *tp; 10023 } 10024 10025 return NULL_TREE; 10026} 10027 10028/* Generate an RTL constant from a decl initializer INIT with decl type TYPE, 10029 for use in a later add_const_value_attribute call. */ 10030 10031static rtx 10032rtl_for_decl_init (tree init, tree type) 10033{ 10034 rtx rtl = NULL_RTX; 10035 10036 /* If a variable is initialized with a string constant without embedded 10037 zeros, build CONST_STRING. */ 10038 if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE) 10039 { 10040 tree enttype = TREE_TYPE (type); 10041 tree domain = TYPE_DOMAIN (type); 10042 enum machine_mode mode = TYPE_MODE (enttype); 10043 10044 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1 10045 && domain 10046 && integer_zerop (TYPE_MIN_VALUE (domain)) 10047 && compare_tree_int (TYPE_MAX_VALUE (domain), 10048 TREE_STRING_LENGTH (init) - 1) == 0 10049 && ((size_t) TREE_STRING_LENGTH (init) 10050 == strlen (TREE_STRING_POINTER (init)) + 1)) 10051 rtl = gen_rtx_CONST_STRING (VOIDmode, 10052 ggc_strdup (TREE_STRING_POINTER (init))); 10053 } 10054 /* Other aggregates, and complex values, could be represented using 10055 CONCAT: FIXME! */ 10056 else if (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == COMPLEX_TYPE) 10057 ; 10058 /* Vectors only work if their mode is supported by the target. 10059 FIXME: generic vectors ought to work too. */ 10060 else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_MODE (type) == BLKmode) 10061 ; 10062 /* If the initializer is something that we know will expand into an 10063 immediate RTL constant, expand it now. We must be careful not to 10064 reference variables which won't be output. */ 10065 else if (initializer_constant_valid_p (init, type) 10066 && ! walk_tree (&init, reference_to_unused, NULL, NULL)) 10067 { 10068 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if 10069 possible. */ 10070 if (TREE_CODE (type) == VECTOR_TYPE) 10071 switch (TREE_CODE (init)) 10072 { 10073 case VECTOR_CST: 10074 break; 10075 case CONSTRUCTOR: 10076 if (TREE_CONSTANT (init)) 10077 { 10078 VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (init); 10079 bool constant_p = true; 10080 tree value; 10081 unsigned HOST_WIDE_INT ix; 10082 10083 /* Even when ctor is constant, it might contain non-*_CST 10084 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't 10085 belong into VECTOR_CST nodes. */ 10086 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value) 10087 if (!CONSTANT_CLASS_P (value)) 10088 { 10089 constant_p = false; 10090 break; 10091 } 10092 10093 if (constant_p) 10094 { 10095 init = build_vector_from_ctor (type, elts); 10096 break; 10097 } 10098 } 10099 /* FALLTHRU */ 10100 10101 default: 10102 return NULL; 10103 } 10104 10105 rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER); 10106 10107 /* If expand_expr returns a MEM, it wasn't immediate. */ 10108 gcc_assert (!rtl || !MEM_P (rtl)); 10109 } 10110 10111 return rtl; 10112} 10113 10114/* Generate RTL for the variable DECL to represent its location. */ 10115 10116static rtx 10117rtl_for_decl_location (tree decl) 10118{ 10119 rtx rtl; 10120 10121 /* Here we have to decide where we are going to say the parameter "lives" 10122 (as far as the debugger is concerned). We only have a couple of 10123 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL. 10124 10125 DECL_RTL normally indicates where the parameter lives during most of the 10126 activation of the function. If optimization is enabled however, this 10127 could be either NULL or else a pseudo-reg. Both of those cases indicate 10128 that the parameter doesn't really live anywhere (as far as the code 10129 generation parts of GCC are concerned) during most of the function's 10130 activation. That will happen (for example) if the parameter is never 10131 referenced within the function. 10132 10133 We could just generate a location descriptor here for all non-NULL 10134 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be 10135 a little nicer than that if we also consider DECL_INCOMING_RTL in cases 10136 where DECL_RTL is NULL or is a pseudo-reg. 10137 10138 Note however that we can only get away with using DECL_INCOMING_RTL as 10139 a backup substitute for DECL_RTL in certain limited cases. In cases 10140 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl), 10141 we can be sure that the parameter was passed using the same type as it is 10142 declared to have within the function, and that its DECL_INCOMING_RTL 10143 points us to a place where a value of that type is passed. 10144 10145 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different, 10146 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL 10147 because in these cases DECL_INCOMING_RTL points us to a value of some 10148 type which is *different* from the type of the parameter itself. Thus, 10149 if we tried to use DECL_INCOMING_RTL to generate a location attribute in 10150 such cases, the debugger would end up (for example) trying to fetch a 10151 `float' from a place which actually contains the first part of a 10152 `double'. That would lead to really incorrect and confusing 10153 output at debug-time. 10154 10155 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL 10156 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There 10157 are a couple of exceptions however. On little-endian machines we can 10158 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is 10159 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is 10160 an integral type that is smaller than TREE_TYPE (decl). These cases arise 10161 when (on a little-endian machine) a non-prototyped function has a 10162 parameter declared to be of type `short' or `char'. In such cases, 10163 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will 10164 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the 10165 passed `int' value. If the debugger then uses that address to fetch 10166 a `short' or a `char' (on a little-endian machine) the result will be 10167 the correct data, so we allow for such exceptional cases below. 10168 10169 Note that our goal here is to describe the place where the given formal 10170 parameter lives during most of the function's activation (i.e. between the 10171 end of the prologue and the start of the epilogue). We'll do that as best 10172 as we can. Note however that if the given formal parameter is modified 10173 sometime during the execution of the function, then a stack backtrace (at 10174 debug-time) will show the function as having been called with the *new* 10175 value rather than the value which was originally passed in. This happens 10176 rarely enough that it is not a major problem, but it *is* a problem, and 10177 I'd like to fix it. 10178 10179 A future version of dwarf2out.c may generate two additional attributes for 10180 any given DW_TAG_formal_parameter DIE which will describe the "passed 10181 type" and the "passed location" for the given formal parameter in addition 10182 to the attributes we now generate to indicate the "declared type" and the 10183 "active location" for each parameter. This additional set of attributes 10184 could be used by debuggers for stack backtraces. Separately, note that 10185 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also. 10186 This happens (for example) for inlined-instances of inline function formal 10187 parameters which are never referenced. This really shouldn't be 10188 happening. All PARM_DECL nodes should get valid non-NULL 10189 DECL_INCOMING_RTL values. FIXME. */ 10190 10191 /* Use DECL_RTL as the "location" unless we find something better. */ 10192 rtl = DECL_RTL_IF_SET (decl); 10193 10194 /* When generating abstract instances, ignore everything except 10195 constants, symbols living in memory, and symbols living in 10196 fixed registers. */ 10197 if (! reload_completed) 10198 { 10199 if (rtl 10200 && (CONSTANT_P (rtl) 10201 || (MEM_P (rtl) 10202 && CONSTANT_P (XEXP (rtl, 0))) 10203 || (REG_P (rtl) 10204 && TREE_CODE (decl) == VAR_DECL 10205 && TREE_STATIC (decl)))) 10206 { 10207 rtl = targetm.delegitimize_address (rtl); 10208 return rtl; 10209 } 10210 rtl = NULL_RTX; 10211 } 10212 else if (TREE_CODE (decl) == PARM_DECL) 10213 { 10214 if (rtl == NULL_RTX || is_pseudo_reg (rtl)) 10215 { 10216 tree declared_type = TREE_TYPE (decl); 10217 tree passed_type = DECL_ARG_TYPE (decl); 10218 enum machine_mode dmode = TYPE_MODE (declared_type); 10219 enum machine_mode pmode = TYPE_MODE (passed_type); 10220 10221 /* This decl represents a formal parameter which was optimized out. 10222 Note that DECL_INCOMING_RTL may be NULL in here, but we handle 10223 all cases where (rtl == NULL_RTX) just below. */ 10224 if (dmode == pmode) 10225 rtl = DECL_INCOMING_RTL (decl); 10226 else if (SCALAR_INT_MODE_P (dmode) 10227 && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode) 10228 && DECL_INCOMING_RTL (decl)) 10229 { 10230 rtx inc = DECL_INCOMING_RTL (decl); 10231 if (REG_P (inc)) 10232 rtl = inc; 10233 else if (MEM_P (inc)) 10234 { 10235 if (BYTES_BIG_ENDIAN) 10236 rtl = adjust_address_nv (inc, dmode, 10237 GET_MODE_SIZE (pmode) 10238 - GET_MODE_SIZE (dmode)); 10239 else 10240 rtl = inc; 10241 } 10242 } 10243 } 10244 10245 /* If the parm was passed in registers, but lives on the stack, then 10246 make a big endian correction if the mode of the type of the 10247 parameter is not the same as the mode of the rtl. */ 10248 /* ??? This is the same series of checks that are made in dbxout.c before 10249 we reach the big endian correction code there. It isn't clear if all 10250 of these checks are necessary here, but keeping them all is the safe 10251 thing to do. */ 10252 else if (MEM_P (rtl) 10253 && XEXP (rtl, 0) != const0_rtx 10254 && ! CONSTANT_P (XEXP (rtl, 0)) 10255 /* Not passed in memory. */ 10256 && !MEM_P (DECL_INCOMING_RTL (decl)) 10257 /* Not passed by invisible reference. */ 10258 && (!REG_P (XEXP (rtl, 0)) 10259 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM 10260 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM 10261#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM 10262 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM 10263#endif 10264 ) 10265 /* Big endian correction check. */ 10266 && BYTES_BIG_ENDIAN 10267 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl) 10268 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))) 10269 < UNITS_PER_WORD)) 10270 { 10271 int offset = (UNITS_PER_WORD 10272 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))); 10273 10274 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)), 10275 plus_constant (XEXP (rtl, 0), offset)); 10276 } 10277 } 10278 else if (TREE_CODE (decl) == VAR_DECL 10279 && rtl 10280 && MEM_P (rtl) 10281 && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl)) 10282 && BYTES_BIG_ENDIAN) 10283 { 10284 int rsize = GET_MODE_SIZE (GET_MODE (rtl)); 10285 int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))); 10286 10287 /* If a variable is declared "register" yet is smaller than 10288 a register, then if we store the variable to memory, it 10289 looks like we're storing a register-sized value, when in 10290 fact we are not. We need to adjust the offset of the 10291 storage location to reflect the actual value's bytes, 10292 else gdb will not be able to display it. */ 10293 if (rsize > dsize) 10294 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)), 10295 plus_constant (XEXP (rtl, 0), rsize-dsize)); 10296 } 10297 10298 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant, 10299 and will have been substituted directly into all expressions that use it. 10300 C does not have such a concept, but C++ and other languages do. */ 10301 if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl)) 10302 rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl)); 10303 10304 if (rtl) 10305 rtl = targetm.delegitimize_address (rtl); 10306 10307 /* If we don't look past the constant pool, we risk emitting a 10308 reference to a constant pool entry that isn't referenced from 10309 code, and thus is not emitted. */ 10310 if (rtl) 10311 rtl = avoid_constant_pool_reference (rtl); 10312 10313 return rtl; 10314} 10315 10316/* We need to figure out what section we should use as the base for the 10317 address ranges where a given location is valid. 10318 1. If this particular DECL has a section associated with it, use that. 10319 2. If this function has a section associated with it, use that. 10320 3. Otherwise, use the text section. 10321 XXX: If you split a variable across multiple sections, we won't notice. */ 10322 10323static const char * 10324secname_for_decl (tree decl) 10325{ 10326 const char *secname; 10327 10328 if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_SECTION_NAME (decl)) 10329 { 10330 tree sectree = DECL_SECTION_NAME (decl); 10331 secname = TREE_STRING_POINTER (sectree); 10332 } 10333 else if (current_function_decl && DECL_SECTION_NAME (current_function_decl)) 10334 { 10335 tree sectree = DECL_SECTION_NAME (current_function_decl); 10336 secname = TREE_STRING_POINTER (sectree); 10337 } 10338 else if (cfun && in_cold_section_p) 10339 secname = cfun->cold_section_label; 10340 else 10341 secname = text_section_label; 10342 10343 return secname; 10344} 10345 10346/* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value 10347 data attribute for a variable or a parameter. We generate the 10348 DW_AT_const_value attribute only in those cases where the given variable 10349 or parameter does not have a true "location" either in memory or in a 10350 register. This can happen (for example) when a constant is passed as an 10351 actual argument in a call to an inline function. (It's possible that 10352 these things can crop up in other ways also.) Note that one type of 10353 constant value which can be passed into an inlined function is a constant 10354 pointer. This can happen for example if an actual argument in an inlined 10355 function call evaluates to a compile-time constant address. */ 10356 10357static void 10358add_location_or_const_value_attribute (dw_die_ref die, tree decl, 10359 enum dwarf_attribute attr) 10360{ 10361 rtx rtl; 10362 dw_loc_descr_ref descr; 10363 var_loc_list *loc_list; 10364 struct var_loc_node *node; 10365 if (TREE_CODE (decl) == ERROR_MARK) 10366 return; 10367 10368 gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL 10369 || TREE_CODE (decl) == RESULT_DECL); 10370 10371 /* See if we possibly have multiple locations for this variable. */ 10372 loc_list = lookup_decl_loc (decl); 10373 10374 /* If it truly has multiple locations, the first and last node will 10375 differ. */ 10376 if (loc_list && loc_list->first != loc_list->last) 10377 { 10378 const char *endname, *secname; 10379 dw_loc_list_ref list; 10380 rtx varloc; 10381 10382 /* Now that we know what section we are using for a base, 10383 actually construct the list of locations. 10384 The first location information is what is passed to the 10385 function that creates the location list, and the remaining 10386 locations just get added on to that list. 10387 Note that we only know the start address for a location 10388 (IE location changes), so to build the range, we use 10389 the range [current location start, next location start]. 10390 This means we have to special case the last node, and generate 10391 a range of [last location start, end of function label]. */ 10392 10393 node = loc_list->first; 10394 varloc = NOTE_VAR_LOCATION (node->var_loc_note); 10395 secname = secname_for_decl (decl); 10396 10397 list = new_loc_list (loc_descriptor (varloc), 10398 node->label, node->next->label, secname, 1); 10399 node = node->next; 10400 10401 for (; node->next; node = node->next) 10402 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX) 10403 { 10404 /* The variable has a location between NODE->LABEL and 10405 NODE->NEXT->LABEL. */ 10406 varloc = NOTE_VAR_LOCATION (node->var_loc_note); 10407 add_loc_descr_to_loc_list (&list, loc_descriptor (varloc), 10408 node->label, node->next->label, secname); 10409 } 10410 10411 /* If the variable has a location at the last label 10412 it keeps its location until the end of function. */ 10413 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX) 10414 { 10415 char label_id[MAX_ARTIFICIAL_LABEL_BYTES]; 10416 10417 varloc = NOTE_VAR_LOCATION (node->var_loc_note); 10418 if (!current_function_decl) 10419 endname = text_end_label; 10420 else 10421 { 10422 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL, 10423 current_function_funcdef_no); 10424 endname = ggc_strdup (label_id); 10425 } 10426 add_loc_descr_to_loc_list (&list, loc_descriptor (varloc), 10427 node->label, endname, secname); 10428 } 10429 10430 /* Finally, add the location list to the DIE, and we are done. */ 10431 add_AT_loc_list (die, attr, list); 10432 return; 10433 } 10434 10435 /* Try to get some constant RTL for this decl, and use that as the value of 10436 the location. */ 10437 10438 rtl = rtl_for_decl_location (decl); 10439 if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING)) 10440 { 10441 add_const_value_attribute (die, rtl); 10442 return; 10443 } 10444 10445 /* If we have tried to generate the location otherwise, and it 10446 didn't work out (we wouldn't be here if we did), and we have a one entry 10447 location list, try generating a location from that. */ 10448 if (loc_list && loc_list->first) 10449 { 10450 node = loc_list->first; 10451 descr = loc_descriptor (NOTE_VAR_LOCATION (node->var_loc_note)); 10452 if (descr) 10453 { 10454 add_AT_location_description (die, attr, descr); 10455 return; 10456 } 10457 } 10458 10459 /* We couldn't get any rtl, so try directly generating the location 10460 description from the tree. */ 10461 descr = loc_descriptor_from_tree (decl); 10462 if (descr) 10463 { 10464 add_AT_location_description (die, attr, descr); 10465 return; 10466 } 10467 /* None of that worked, so it must not really have a location; 10468 try adding a constant value attribute from the DECL_INITIAL. */ 10469 tree_add_const_value_attribute (die, decl); 10470} 10471 10472/* If we don't have a copy of this variable in memory for some reason (such 10473 as a C++ member constant that doesn't have an out-of-line definition), 10474 we should tell the debugger about the constant value. */ 10475 10476static void 10477tree_add_const_value_attribute (dw_die_ref var_die, tree decl) 10478{ 10479 tree init = DECL_INITIAL (decl); 10480 tree type = TREE_TYPE (decl); 10481 rtx rtl; 10482 10483 if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl) && init) 10484 /* OK */; 10485 else 10486 return; 10487 10488 rtl = rtl_for_decl_init (init, type); 10489 if (rtl) 10490 add_const_value_attribute (var_die, rtl); 10491} 10492 10493/* Convert the CFI instructions for the current function into a 10494 location list. This is used for DW_AT_frame_base when we targeting 10495 a dwarf2 consumer that does not support the dwarf3 10496 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA 10497 expressions. */ 10498 10499static dw_loc_list_ref 10500convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset) 10501{ 10502 dw_fde_ref fde; 10503 dw_loc_list_ref list, *list_tail; 10504 dw_cfi_ref cfi; 10505 dw_cfa_location last_cfa, next_cfa; 10506 const char *start_label, *last_label, *section; 10507 10508 fde = &fde_table[fde_table_in_use - 1]; 10509 10510 section = secname_for_decl (current_function_decl); 10511 list_tail = &list; 10512 list = NULL; 10513 10514 next_cfa.reg = INVALID_REGNUM; 10515 next_cfa.offset = 0; 10516 next_cfa.indirect = 0; 10517 next_cfa.base_offset = 0; 10518 10519 start_label = fde->dw_fde_begin; 10520 10521 /* ??? Bald assumption that the CIE opcode list does not contain 10522 advance opcodes. */ 10523 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next) 10524 lookup_cfa_1 (cfi, &next_cfa); 10525 10526 last_cfa = next_cfa; 10527 last_label = start_label; 10528 10529 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next) 10530 switch (cfi->dw_cfi_opc) 10531 { 10532 case DW_CFA_set_loc: 10533 case DW_CFA_advance_loc1: 10534 case DW_CFA_advance_loc2: 10535 case DW_CFA_advance_loc4: 10536 if (!cfa_equal_p (&last_cfa, &next_cfa)) 10537 { 10538 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset), 10539 start_label, last_label, section, 10540 list == NULL); 10541 10542 list_tail = &(*list_tail)->dw_loc_next; 10543 last_cfa = next_cfa; 10544 start_label = last_label; 10545 } 10546 last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 10547 break; 10548 10549 case DW_CFA_advance_loc: 10550 /* The encoding is complex enough that we should never emit this. */ 10551 case DW_CFA_remember_state: 10552 case DW_CFA_restore_state: 10553 /* We don't handle these two in this function. It would be possible 10554 if it were to be required. */ 10555 gcc_unreachable (); 10556 10557 default: 10558 lookup_cfa_1 (cfi, &next_cfa); 10559 break; 10560 } 10561 10562 if (!cfa_equal_p (&last_cfa, &next_cfa)) 10563 { 10564 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset), 10565 start_label, last_label, section, 10566 list == NULL); 10567 list_tail = &(*list_tail)->dw_loc_next; 10568 start_label = last_label; 10569 } 10570 *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset), 10571 start_label, fde->dw_fde_end, section, 10572 list == NULL); 10573 10574 return list; 10575} 10576 10577/* Compute a displacement from the "steady-state frame pointer" to the 10578 frame base (often the same as the CFA), and store it in 10579 frame_pointer_fb_offset. OFFSET is added to the displacement 10580 before the latter is negated. */ 10581 10582static void 10583compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset) 10584{ 10585 rtx reg, elim; 10586 10587#ifdef FRAME_POINTER_CFA_OFFSET 10588 reg = frame_pointer_rtx; 10589 offset += FRAME_POINTER_CFA_OFFSET (current_function_decl); 10590#else 10591 reg = arg_pointer_rtx; 10592 offset += ARG_POINTER_CFA_OFFSET (current_function_decl); 10593#endif 10594 10595 elim = eliminate_regs (reg, VOIDmode, NULL_RTX); 10596 if (GET_CODE (elim) == PLUS) 10597 { 10598 offset += INTVAL (XEXP (elim, 1)); 10599 elim = XEXP (elim, 0); 10600 } 10601 gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx 10602 : stack_pointer_rtx)); 10603 10604 frame_pointer_fb_offset = -offset; 10605} 10606 10607/* Generate a DW_AT_name attribute given some string value to be included as 10608 the value of the attribute. */ 10609 10610static void 10611add_name_attribute (dw_die_ref die, const char *name_string) 10612{ 10613 if (name_string != NULL && *name_string != 0) 10614 { 10615 if (demangle_name_func) 10616 name_string = (*demangle_name_func) (name_string); 10617 10618 add_AT_string (die, DW_AT_name, name_string); 10619 } 10620} 10621 10622/* Generate a DW_AT_comp_dir attribute for DIE. */ 10623 10624static void 10625add_comp_dir_attribute (dw_die_ref die) 10626{ 10627 const char *wd = get_src_pwd (); 10628 if (wd != NULL) 10629 add_AT_string (die, DW_AT_comp_dir, wd); 10630} 10631 10632/* Given a tree node describing an array bound (either lower or upper) output 10633 a representation for that bound. */ 10634 10635static void 10636add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound) 10637{ 10638 switch (TREE_CODE (bound)) 10639 { 10640 case ERROR_MARK: 10641 return; 10642 10643 /* All fixed-bounds are represented by INTEGER_CST nodes. */ 10644 case INTEGER_CST: 10645 if (! host_integerp (bound, 0) 10646 || (bound_attr == DW_AT_lower_bound 10647 && (((is_c_family () || is_java ()) && integer_zerop (bound)) 10648 || (is_fortran () && integer_onep (bound))))) 10649 /* Use the default. */ 10650 ; 10651 else 10652 add_AT_unsigned (subrange_die, bound_attr, tree_low_cst (bound, 0)); 10653 break; 10654 10655 case CONVERT_EXPR: 10656 case NOP_EXPR: 10657 case NON_LVALUE_EXPR: 10658 case VIEW_CONVERT_EXPR: 10659 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0)); 10660 break; 10661 10662 case SAVE_EXPR: 10663 break; 10664 10665 case VAR_DECL: 10666 case PARM_DECL: 10667 case RESULT_DECL: 10668 { 10669 dw_die_ref decl_die = lookup_decl_die (bound); 10670 10671 /* ??? Can this happen, or should the variable have been bound 10672 first? Probably it can, since I imagine that we try to create 10673 the types of parameters in the order in which they exist in 10674 the list, and won't have created a forward reference to a 10675 later parameter. */ 10676 if (decl_die != NULL) 10677 add_AT_die_ref (subrange_die, bound_attr, decl_die); 10678 break; 10679 } 10680 10681 default: 10682 { 10683 /* Otherwise try to create a stack operation procedure to 10684 evaluate the value of the array bound. */ 10685 10686 dw_die_ref ctx, decl_die; 10687 dw_loc_descr_ref loc; 10688 10689 loc = loc_descriptor_from_tree (bound); 10690 if (loc == NULL) 10691 break; 10692 10693 if (current_function_decl == 0) 10694 ctx = comp_unit_die; 10695 else 10696 ctx = lookup_decl_die (current_function_decl); 10697 10698 decl_die = new_die (DW_TAG_variable, ctx, bound); 10699 add_AT_flag (decl_die, DW_AT_artificial, 1); 10700 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx); 10701 add_AT_loc (decl_die, DW_AT_location, loc); 10702 10703 add_AT_die_ref (subrange_die, bound_attr, decl_die); 10704 break; 10705 } 10706 } 10707} 10708 10709/* Note that the block of subscript information for an array type also 10710 includes information about the element type of type given array type. */ 10711 10712static void 10713add_subscript_info (dw_die_ref type_die, tree type) 10714{ 10715#ifndef MIPS_DEBUGGING_INFO 10716 unsigned dimension_number; 10717#endif 10718 tree lower, upper; 10719 dw_die_ref subrange_die; 10720 10721 /* The GNU compilers represent multidimensional array types as sequences of 10722 one dimensional array types whose element types are themselves array 10723 types. Here we squish that down, so that each multidimensional array 10724 type gets only one array_type DIE in the Dwarf debugging info. The draft 10725 Dwarf specification say that we are allowed to do this kind of 10726 compression in C (because there is no difference between an array or 10727 arrays and a multidimensional array in C) but for other source languages 10728 (e.g. Ada) we probably shouldn't do this. */ 10729 10730 /* ??? The SGI dwarf reader fails for multidimensional arrays with a 10731 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10]. 10732 We work around this by disabling this feature. See also 10733 gen_array_type_die. */ 10734#ifndef MIPS_DEBUGGING_INFO 10735 for (dimension_number = 0; 10736 TREE_CODE (type) == ARRAY_TYPE; 10737 type = TREE_TYPE (type), dimension_number++) 10738#endif 10739 { 10740 tree domain = TYPE_DOMAIN (type); 10741 10742 /* Arrays come in three flavors: Unspecified bounds, fixed bounds, 10743 and (in GNU C only) variable bounds. Handle all three forms 10744 here. */ 10745 subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL); 10746 if (domain) 10747 { 10748 /* We have an array type with specified bounds. */ 10749 lower = TYPE_MIN_VALUE (domain); 10750 upper = TYPE_MAX_VALUE (domain); 10751 10752 /* Define the index type. */ 10753 if (TREE_TYPE (domain)) 10754 { 10755 /* ??? This is probably an Ada unnamed subrange type. Ignore the 10756 TREE_TYPE field. We can't emit debug info for this 10757 because it is an unnamed integral type. */ 10758 if (TREE_CODE (domain) == INTEGER_TYPE 10759 && TYPE_NAME (domain) == NULL_TREE 10760 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE 10761 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE) 10762 ; 10763 else 10764 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0, 10765 type_die); 10766 } 10767 10768 /* ??? If upper is NULL, the array has unspecified length, 10769 but it does have a lower bound. This happens with Fortran 10770 dimension arr(N:*) 10771 Since the debugger is definitely going to need to know N 10772 to produce useful results, go ahead and output the lower 10773 bound solo, and hope the debugger can cope. */ 10774 10775 add_bound_info (subrange_die, DW_AT_lower_bound, lower); 10776 if (upper) 10777 add_bound_info (subrange_die, DW_AT_upper_bound, upper); 10778 } 10779 10780 /* Otherwise we have an array type with an unspecified length. The 10781 DWARF-2 spec does not say how to handle this; let's just leave out the 10782 bounds. */ 10783 } 10784} 10785 10786static void 10787add_byte_size_attribute (dw_die_ref die, tree tree_node) 10788{ 10789 unsigned size; 10790 10791 switch (TREE_CODE (tree_node)) 10792 { 10793 case ERROR_MARK: 10794 size = 0; 10795 break; 10796 case ENUMERAL_TYPE: 10797 case RECORD_TYPE: 10798 case UNION_TYPE: 10799 case QUAL_UNION_TYPE: 10800 size = int_size_in_bytes (tree_node); 10801 break; 10802 case FIELD_DECL: 10803 /* For a data member of a struct or union, the DW_AT_byte_size is 10804 generally given as the number of bytes normally allocated for an 10805 object of the *declared* type of the member itself. This is true 10806 even for bit-fields. */ 10807 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT; 10808 break; 10809 default: 10810 gcc_unreachable (); 10811 } 10812 10813 /* Note that `size' might be -1 when we get to this point. If it is, that 10814 indicates that the byte size of the entity in question is variable. We 10815 have no good way of expressing this fact in Dwarf at the present time, 10816 so just let the -1 pass on through. */ 10817 add_AT_unsigned (die, DW_AT_byte_size, size); 10818} 10819 10820/* For a FIELD_DECL node which represents a bit-field, output an attribute 10821 which specifies the distance in bits from the highest order bit of the 10822 "containing object" for the bit-field to the highest order bit of the 10823 bit-field itself. 10824 10825 For any given bit-field, the "containing object" is a hypothetical object 10826 (of some integral or enum type) within which the given bit-field lives. The 10827 type of this hypothetical "containing object" is always the same as the 10828 declared type of the individual bit-field itself. The determination of the 10829 exact location of the "containing object" for a bit-field is rather 10830 complicated. It's handled by the `field_byte_offset' function (above). 10831 10832 Note that it is the size (in bytes) of the hypothetical "containing object" 10833 which will be given in the DW_AT_byte_size attribute for this bit-field. 10834 (See `byte_size_attribute' above). */ 10835 10836static inline void 10837add_bit_offset_attribute (dw_die_ref die, tree decl) 10838{ 10839 HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl); 10840 tree type = DECL_BIT_FIELD_TYPE (decl); 10841 HOST_WIDE_INT bitpos_int; 10842 HOST_WIDE_INT highest_order_object_bit_offset; 10843 HOST_WIDE_INT highest_order_field_bit_offset; 10844 HOST_WIDE_INT unsigned bit_offset; 10845 10846 /* Must be a field and a bit field. */ 10847 gcc_assert (type && TREE_CODE (decl) == FIELD_DECL); 10848 10849 /* We can't yet handle bit-fields whose offsets are variable, so if we 10850 encounter such things, just return without generating any attribute 10851 whatsoever. Likewise for variable or too large size. */ 10852 if (! host_integerp (bit_position (decl), 0) 10853 || ! host_integerp (DECL_SIZE (decl), 1)) 10854 return; 10855 10856 bitpos_int = int_bit_position (decl); 10857 10858 /* Note that the bit offset is always the distance (in bits) from the 10859 highest-order bit of the "containing object" to the highest-order bit of 10860 the bit-field itself. Since the "high-order end" of any object or field 10861 is different on big-endian and little-endian machines, the computation 10862 below must take account of these differences. */ 10863 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT; 10864 highest_order_field_bit_offset = bitpos_int; 10865 10866 if (! BYTES_BIG_ENDIAN) 10867 { 10868 highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0); 10869 highest_order_object_bit_offset += simple_type_size_in_bits (type); 10870 } 10871 10872 bit_offset 10873 = (! BYTES_BIG_ENDIAN 10874 ? highest_order_object_bit_offset - highest_order_field_bit_offset 10875 : highest_order_field_bit_offset - highest_order_object_bit_offset); 10876 10877 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset); 10878} 10879 10880/* For a FIELD_DECL node which represents a bit field, output an attribute 10881 which specifies the length in bits of the given field. */ 10882 10883static inline void 10884add_bit_size_attribute (dw_die_ref die, tree decl) 10885{ 10886 /* Must be a field and a bit field. */ 10887 gcc_assert (TREE_CODE (decl) == FIELD_DECL 10888 && DECL_BIT_FIELD_TYPE (decl)); 10889 10890 if (host_integerp (DECL_SIZE (decl), 1)) 10891 add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1)); 10892} 10893 10894/* If the compiled language is ANSI C, then add a 'prototyped' 10895 attribute, if arg types are given for the parameters of a function. */ 10896 10897static inline void 10898add_prototyped_attribute (dw_die_ref die, tree func_type) 10899{ 10900 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89 10901 && TYPE_ARG_TYPES (func_type) != NULL) 10902 add_AT_flag (die, DW_AT_prototyped, 1); 10903} 10904 10905/* Add an 'abstract_origin' attribute below a given DIE. The DIE is found 10906 by looking in either the type declaration or object declaration 10907 equate table. */ 10908 10909static inline void 10910add_abstract_origin_attribute (dw_die_ref die, tree origin) 10911{ 10912 dw_die_ref origin_die = NULL; 10913 10914 if (TREE_CODE (origin) != FUNCTION_DECL) 10915 { 10916 /* We may have gotten separated from the block for the inlined 10917 function, if we're in an exception handler or some such; make 10918 sure that the abstract function has been written out. 10919 10920 Doing this for nested functions is wrong, however; functions are 10921 distinct units, and our context might not even be inline. */ 10922 tree fn = origin; 10923 10924 if (TYPE_P (fn)) 10925 fn = TYPE_STUB_DECL (fn); 10926 10927 fn = decl_function_context (fn); 10928 if (fn) 10929 dwarf2out_abstract_function (fn); 10930 } 10931 10932 if (DECL_P (origin)) 10933 origin_die = lookup_decl_die (origin); 10934 else if (TYPE_P (origin)) 10935 origin_die = lookup_type_die (origin); 10936 10937 /* XXX: Functions that are never lowered don't always have correct block 10938 trees (in the case of java, they simply have no block tree, in some other 10939 languages). For these functions, there is nothing we can really do to 10940 output correct debug info for inlined functions in all cases. Rather 10941 than die, we'll just produce deficient debug info now, in that we will 10942 have variables without a proper abstract origin. In the future, when all 10943 functions are lowered, we should re-add a gcc_assert (origin_die) 10944 here. */ 10945 10946 if (origin_die) 10947 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die); 10948} 10949 10950/* We do not currently support the pure_virtual attribute. */ 10951 10952static inline void 10953add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl) 10954{ 10955 if (DECL_VINDEX (func_decl)) 10956 { 10957 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual); 10958 10959 if (host_integerp (DECL_VINDEX (func_decl), 0)) 10960 add_AT_loc (die, DW_AT_vtable_elem_location, 10961 new_loc_descr (DW_OP_constu, 10962 tree_low_cst (DECL_VINDEX (func_decl), 0), 10963 0)); 10964 10965 /* GNU extension: Record what type this method came from originally. */ 10966 if (debug_info_level > DINFO_LEVEL_TERSE) 10967 add_AT_die_ref (die, DW_AT_containing_type, 10968 lookup_type_die (DECL_CONTEXT (func_decl))); 10969 } 10970} 10971 10972/* Add source coordinate attributes for the given decl. */ 10973 10974static void 10975add_src_coords_attributes (dw_die_ref die, tree decl) 10976{ 10977 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl)); 10978 10979 add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file)); 10980 add_AT_unsigned (die, DW_AT_decl_line, s.line); 10981} 10982 10983/* Add a DW_AT_name attribute and source coordinate attribute for the 10984 given decl, but only if it actually has a name. */ 10985 10986static void 10987add_name_and_src_coords_attributes (dw_die_ref die, tree decl) 10988{ 10989 tree decl_name; 10990 10991 decl_name = DECL_NAME (decl); 10992 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL) 10993 { 10994 add_name_attribute (die, dwarf2_name (decl, 0)); 10995 if (! DECL_ARTIFICIAL (decl)) 10996 add_src_coords_attributes (die, decl); 10997 10998 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL) 10999 && TREE_PUBLIC (decl) 11000 && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl) 11001 && !DECL_ABSTRACT (decl) 11002 && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))) 11003 add_AT_string (die, DW_AT_MIPS_linkage_name, 11004 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))); 11005 } 11006 11007#ifdef VMS_DEBUGGING_INFO 11008 /* Get the function's name, as described by its RTL. This may be different 11009 from the DECL_NAME name used in the source file. */ 11010 if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl)) 11011 { 11012 add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address, 11013 XEXP (DECL_RTL (decl), 0)); 11014 VEC_safe_push (tree, gc, used_rtx_array, XEXP (DECL_RTL (decl), 0)); 11015 } 11016#endif 11017} 11018 11019/* Push a new declaration scope. */ 11020 11021static void 11022push_decl_scope (tree scope) 11023{ 11024 VEC_safe_push (tree, gc, decl_scope_table, scope); 11025} 11026 11027/* Pop a declaration scope. */ 11028 11029static inline void 11030pop_decl_scope (void) 11031{ 11032 VEC_pop (tree, decl_scope_table); 11033} 11034 11035/* Return the DIE for the scope that immediately contains this type. 11036 Non-named types get global scope. Named types nested in other 11037 types get their containing scope if it's open, or global scope 11038 otherwise. All other types (i.e. function-local named types) get 11039 the current active scope. */ 11040 11041static dw_die_ref 11042scope_die_for (tree t, dw_die_ref context_die) 11043{ 11044 dw_die_ref scope_die = NULL; 11045 tree containing_scope; 11046 int i; 11047 11048 /* Non-types always go in the current scope. */ 11049 gcc_assert (TYPE_P (t)); 11050 11051 containing_scope = TYPE_CONTEXT (t); 11052 11053 /* Use the containing namespace if it was passed in (for a declaration). */ 11054 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL) 11055 { 11056 if (context_die == lookup_decl_die (containing_scope)) 11057 /* OK */; 11058 else 11059 containing_scope = NULL_TREE; 11060 } 11061 11062 /* Ignore function type "scopes" from the C frontend. They mean that 11063 a tagged type is local to a parmlist of a function declarator, but 11064 that isn't useful to DWARF. */ 11065 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE) 11066 containing_scope = NULL_TREE; 11067 11068 if (containing_scope == NULL_TREE) 11069 scope_die = comp_unit_die; 11070 else if (TYPE_P (containing_scope)) 11071 { 11072 /* For types, we can just look up the appropriate DIE. But 11073 first we check to see if we're in the middle of emitting it 11074 so we know where the new DIE should go. */ 11075 for (i = VEC_length (tree, decl_scope_table) - 1; i >= 0; --i) 11076 if (VEC_index (tree, decl_scope_table, i) == containing_scope) 11077 break; 11078 11079 if (i < 0) 11080 { 11081 gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE 11082 || TREE_ASM_WRITTEN (containing_scope)); 11083 11084 /* If none of the current dies are suitable, we get file scope. */ 11085 scope_die = comp_unit_die; 11086 } 11087 else 11088 scope_die = lookup_type_die (containing_scope); 11089 } 11090 else 11091 scope_die = context_die; 11092 11093 return scope_die; 11094} 11095 11096/* Returns nonzero if CONTEXT_DIE is internal to a function. */ 11097 11098static inline int 11099local_scope_p (dw_die_ref context_die) 11100{ 11101 for (; context_die; context_die = context_die->die_parent) 11102 if (context_die->die_tag == DW_TAG_inlined_subroutine 11103 || context_die->die_tag == DW_TAG_subprogram) 11104 return 1; 11105 11106 return 0; 11107} 11108 11109/* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding 11110 whether or not to treat a DIE in this context as a declaration. */ 11111 11112static inline int 11113class_or_namespace_scope_p (dw_die_ref context_die) 11114{ 11115 return (context_die 11116 && (context_die->die_tag == DW_TAG_structure_type 11117 || context_die->die_tag == DW_TAG_union_type 11118 || context_die->die_tag == DW_TAG_namespace)); 11119} 11120 11121/* Many forms of DIEs require a "type description" attribute. This 11122 routine locates the proper "type descriptor" die for the type given 11123 by 'type', and adds a DW_AT_type attribute below the given die. */ 11124 11125static void 11126add_type_attribute (dw_die_ref object_die, tree type, int decl_const, 11127 int decl_volatile, dw_die_ref context_die) 11128{ 11129 enum tree_code code = TREE_CODE (type); 11130 dw_die_ref type_die = NULL; 11131 11132 /* ??? If this type is an unnamed subrange type of an integral or 11133 floating-point type, use the inner type. This is because we have no 11134 support for unnamed types in base_type_die. This can happen if this is 11135 an Ada subrange type. Correct solution is emit a subrange type die. */ 11136 if ((code == INTEGER_TYPE || code == REAL_TYPE) 11137 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0) 11138 type = TREE_TYPE (type), code = TREE_CODE (type); 11139 11140 if (code == ERROR_MARK 11141 /* Handle a special case. For functions whose return type is void, we 11142 generate *no* type attribute. (Note that no object may have type 11143 `void', so this only applies to function return types). */ 11144 || code == VOID_TYPE) 11145 return; 11146 11147 type_die = modified_type_die (type, 11148 decl_const || TYPE_READONLY (type), 11149 decl_volatile || TYPE_VOLATILE (type), 11150 context_die); 11151 11152 if (type_die != NULL) 11153 add_AT_die_ref (object_die, DW_AT_type, type_die); 11154} 11155 11156/* Given an object die, add the calling convention attribute for the 11157 function call type. */ 11158static void 11159add_calling_convention_attribute (dw_die_ref subr_die, tree type) 11160{ 11161 enum dwarf_calling_convention value = DW_CC_normal; 11162 11163 value = targetm.dwarf_calling_convention (type); 11164 11165 /* Only add the attribute if the backend requests it, and 11166 is not DW_CC_normal. */ 11167 if (value && (value != DW_CC_normal)) 11168 add_AT_unsigned (subr_die, DW_AT_calling_convention, value); 11169} 11170 11171/* Given a tree pointer to a struct, class, union, or enum type node, return 11172 a pointer to the (string) tag name for the given type, or zero if the type 11173 was declared without a tag. */ 11174 11175static const char * 11176type_tag (tree type) 11177{ 11178 const char *name = 0; 11179 11180 if (TYPE_NAME (type) != 0) 11181 { 11182 tree t = 0; 11183 11184 /* Find the IDENTIFIER_NODE for the type name. */ 11185 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE) 11186 t = TYPE_NAME (type); 11187 11188 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to 11189 a TYPE_DECL node, regardless of whether or not a `typedef' was 11190 involved. */ 11191 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 11192 && ! DECL_IGNORED_P (TYPE_NAME (type))) 11193 t = DECL_NAME (TYPE_NAME (type)); 11194 11195 /* Now get the name as a string, or invent one. */ 11196 if (t != 0) 11197 name = IDENTIFIER_POINTER (t); 11198 } 11199 11200 return (name == 0 || *name == '\0') ? 0 : name; 11201} 11202 11203/* Return the type associated with a data member, make a special check 11204 for bit field types. */ 11205 11206static inline tree 11207member_declared_type (tree member) 11208{ 11209 return (DECL_BIT_FIELD_TYPE (member) 11210 ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member)); 11211} 11212 11213/* Get the decl's label, as described by its RTL. This may be different 11214 from the DECL_NAME name used in the source file. */ 11215 11216#if 0 11217static const char * 11218decl_start_label (tree decl) 11219{ 11220 rtx x; 11221 const char *fnname; 11222 11223 x = DECL_RTL (decl); 11224 gcc_assert (MEM_P (x)); 11225 11226 x = XEXP (x, 0); 11227 gcc_assert (GET_CODE (x) == SYMBOL_REF); 11228 11229 fnname = XSTR (x, 0); 11230 return fnname; 11231} 11232#endif 11233 11234/* These routines generate the internal representation of the DIE's for 11235 the compilation unit. Debugging information is collected by walking 11236 the declaration trees passed in from dwarf2out_decl(). */ 11237 11238static void 11239gen_array_type_die (tree type, dw_die_ref context_die) 11240{ 11241 dw_die_ref scope_die = scope_die_for (type, context_die); 11242 dw_die_ref array_die; 11243 tree element_type; 11244 11245 /* ??? The SGI dwarf reader fails for array of array of enum types unless 11246 the inner array type comes before the outer array type. Thus we must 11247 call gen_type_die before we call new_die. See below also. */ 11248#ifdef MIPS_DEBUGGING_INFO 11249 gen_type_die (TREE_TYPE (type), context_die); 11250#endif 11251 11252 array_die = new_die (DW_TAG_array_type, scope_die, type); 11253 add_name_attribute (array_die, type_tag (type)); 11254 equate_type_number_to_die (type, array_die); 11255 11256 if (TREE_CODE (type) == VECTOR_TYPE) 11257 { 11258 /* The frontend feeds us a representation for the vector as a struct 11259 containing an array. Pull out the array type. */ 11260 type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type))); 11261 add_AT_flag (array_die, DW_AT_GNU_vector, 1); 11262 } 11263 11264#if 0 11265 /* We default the array ordering. SDB will probably do 11266 the right things even if DW_AT_ordering is not present. It's not even 11267 an issue until we start to get into multidimensional arrays anyway. If 11268 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays, 11269 then we'll have to put the DW_AT_ordering attribute back in. (But if 11270 and when we find out that we need to put these in, we will only do so 11271 for multidimensional arrays. */ 11272 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major); 11273#endif 11274 11275#ifdef MIPS_DEBUGGING_INFO 11276 /* The SGI compilers handle arrays of unknown bound by setting 11277 AT_declaration and not emitting any subrange DIEs. */ 11278 if (! TYPE_DOMAIN (type)) 11279 add_AT_flag (array_die, DW_AT_declaration, 1); 11280 else 11281#endif 11282 add_subscript_info (array_die, type); 11283 11284 /* Add representation of the type of the elements of this array type. */ 11285 element_type = TREE_TYPE (type); 11286 11287 /* ??? The SGI dwarf reader fails for multidimensional arrays with a 11288 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10]. 11289 We work around this by disabling this feature. See also 11290 add_subscript_info. */ 11291#ifndef MIPS_DEBUGGING_INFO 11292 while (TREE_CODE (element_type) == ARRAY_TYPE) 11293 element_type = TREE_TYPE (element_type); 11294 11295 gen_type_die (element_type, context_die); 11296#endif 11297 11298 add_type_attribute (array_die, element_type, 0, 0, context_die); 11299} 11300 11301#if 0 11302static void 11303gen_entry_point_die (tree decl, dw_die_ref context_die) 11304{ 11305 tree origin = decl_ultimate_origin (decl); 11306 dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl); 11307 11308 if (origin != NULL) 11309 add_abstract_origin_attribute (decl_die, origin); 11310 else 11311 { 11312 add_name_and_src_coords_attributes (decl_die, decl); 11313 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)), 11314 0, 0, context_die); 11315 } 11316 11317 if (DECL_ABSTRACT (decl)) 11318 equate_decl_number_to_die (decl, decl_die); 11319 else 11320 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl)); 11321} 11322#endif 11323 11324/* Walk through the list of incomplete types again, trying once more to 11325 emit full debugging info for them. */ 11326 11327static void 11328retry_incomplete_types (void) 11329{ 11330 int i; 11331 11332 for (i = VEC_length (tree, incomplete_types) - 1; i >= 0; i--) 11333 gen_type_die (VEC_index (tree, incomplete_types, i), comp_unit_die); 11334} 11335 11336/* Generate a DIE to represent an inlined instance of an enumeration type. */ 11337 11338static void 11339gen_inlined_enumeration_type_die (tree type, dw_die_ref context_die) 11340{ 11341 dw_die_ref type_die = new_die (DW_TAG_enumeration_type, context_die, type); 11342 11343 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may 11344 be incomplete and such types are not marked. */ 11345 add_abstract_origin_attribute (type_die, type); 11346} 11347 11348/* Generate a DIE to represent an inlined instance of a structure type. */ 11349 11350static void 11351gen_inlined_structure_type_die (tree type, dw_die_ref context_die) 11352{ 11353 dw_die_ref type_die = new_die (DW_TAG_structure_type, context_die, type); 11354 11355 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may 11356 be incomplete and such types are not marked. */ 11357 add_abstract_origin_attribute (type_die, type); 11358} 11359 11360/* Generate a DIE to represent an inlined instance of a union type. */ 11361 11362static void 11363gen_inlined_union_type_die (tree type, dw_die_ref context_die) 11364{ 11365 dw_die_ref type_die = new_die (DW_TAG_union_type, context_die, type); 11366 11367 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may 11368 be incomplete and such types are not marked. */ 11369 add_abstract_origin_attribute (type_die, type); 11370} 11371 11372/* Generate a DIE to represent an enumeration type. Note that these DIEs 11373 include all of the information about the enumeration values also. Each 11374 enumerated type name/value is listed as a child of the enumerated type 11375 DIE. */ 11376 11377static dw_die_ref 11378gen_enumeration_type_die (tree type, dw_die_ref context_die) 11379{ 11380 dw_die_ref type_die = lookup_type_die (type); 11381 11382 if (type_die == NULL) 11383 { 11384 type_die = new_die (DW_TAG_enumeration_type, 11385 scope_die_for (type, context_die), type); 11386 equate_type_number_to_die (type, type_die); 11387 add_name_attribute (type_die, type_tag (type)); 11388 } 11389 else if (! TYPE_SIZE (type)) 11390 return type_die; 11391 else 11392 remove_AT (type_die, DW_AT_declaration); 11393 11394 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the 11395 given enum type is incomplete, do not generate the DW_AT_byte_size 11396 attribute or the DW_AT_element_list attribute. */ 11397 if (TYPE_SIZE (type)) 11398 { 11399 tree link; 11400 11401 TREE_ASM_WRITTEN (type) = 1; 11402 add_byte_size_attribute (type_die, type); 11403 if (TYPE_STUB_DECL (type) != NULL_TREE) 11404 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type)); 11405 11406 /* If the first reference to this type was as the return type of an 11407 inline function, then it may not have a parent. Fix this now. */ 11408 if (type_die->die_parent == NULL) 11409 add_child_die (scope_die_for (type, context_die), type_die); 11410 11411 for (link = TYPE_VALUES (type); 11412 link != NULL; link = TREE_CHAIN (link)) 11413 { 11414 dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link); 11415 tree value = TREE_VALUE (link); 11416 11417 add_name_attribute (enum_die, 11418 IDENTIFIER_POINTER (TREE_PURPOSE (link))); 11419 11420 if (host_integerp (value, TYPE_UNSIGNED (TREE_TYPE (value)))) 11421 /* DWARF2 does not provide a way of indicating whether or 11422 not enumeration constants are signed or unsigned. GDB 11423 always assumes the values are signed, so we output all 11424 values as if they were signed. That means that 11425 enumeration constants with very large unsigned values 11426 will appear to have negative values in the debugger. */ 11427 add_AT_int (enum_die, DW_AT_const_value, 11428 tree_low_cst (value, tree_int_cst_sgn (value) > 0)); 11429 } 11430 } 11431 else 11432 add_AT_flag (type_die, DW_AT_declaration, 1); 11433 11434 return type_die; 11435} 11436 11437/* Generate a DIE to represent either a real live formal parameter decl or to 11438 represent just the type of some formal parameter position in some function 11439 type. 11440 11441 Note that this routine is a bit unusual because its argument may be a 11442 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which 11443 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE 11444 node. If it's the former then this function is being called to output a 11445 DIE to represent a formal parameter object (or some inlining thereof). If 11446 it's the latter, then this function is only being called to output a 11447 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal 11448 argument type of some subprogram type. */ 11449 11450static dw_die_ref 11451gen_formal_parameter_die (tree node, dw_die_ref context_die) 11452{ 11453 dw_die_ref parm_die 11454 = new_die (DW_TAG_formal_parameter, context_die, node); 11455 tree origin; 11456 11457 switch (TREE_CODE_CLASS (TREE_CODE (node))) 11458 { 11459 case tcc_declaration: 11460 origin = decl_ultimate_origin (node); 11461 if (origin != NULL) 11462 add_abstract_origin_attribute (parm_die, origin); 11463 else 11464 { 11465 add_name_and_src_coords_attributes (parm_die, node); 11466 add_type_attribute (parm_die, TREE_TYPE (node), 11467 TREE_READONLY (node), 11468 TREE_THIS_VOLATILE (node), 11469 context_die); 11470 if (DECL_ARTIFICIAL (node)) 11471 add_AT_flag (parm_die, DW_AT_artificial, 1); 11472 } 11473 11474 equate_decl_number_to_die (node, parm_die); 11475 if (! DECL_ABSTRACT (node)) 11476 add_location_or_const_value_attribute (parm_die, node, DW_AT_location); 11477 11478 break; 11479 11480 case tcc_type: 11481 /* We were called with some kind of a ..._TYPE node. */ 11482 add_type_attribute (parm_die, node, 0, 0, context_die); 11483 break; 11484 11485 default: 11486 gcc_unreachable (); 11487 } 11488 11489 return parm_die; 11490} 11491 11492/* Generate a special type of DIE used as a stand-in for a trailing ellipsis 11493 at the end of an (ANSI prototyped) formal parameters list. */ 11494 11495static void 11496gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die) 11497{ 11498 new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type); 11499} 11500 11501/* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a 11502 DW_TAG_unspecified_parameters DIE) to represent the types of the formal 11503 parameters as specified in some function type specification (except for 11504 those which appear as part of a function *definition*). */ 11505 11506static void 11507gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die) 11508{ 11509 tree link; 11510 tree formal_type = NULL; 11511 tree first_parm_type; 11512 tree arg; 11513 11514 if (TREE_CODE (function_or_method_type) == FUNCTION_DECL) 11515 { 11516 arg = DECL_ARGUMENTS (function_or_method_type); 11517 function_or_method_type = TREE_TYPE (function_or_method_type); 11518 } 11519 else 11520 arg = NULL_TREE; 11521 11522 first_parm_type = TYPE_ARG_TYPES (function_or_method_type); 11523 11524 /* Make our first pass over the list of formal parameter types and output a 11525 DW_TAG_formal_parameter DIE for each one. */ 11526 for (link = first_parm_type; link; ) 11527 { 11528 dw_die_ref parm_die; 11529 11530 formal_type = TREE_VALUE (link); 11531 if (formal_type == void_type_node) 11532 break; 11533 11534 /* Output a (nameless) DIE to represent the formal parameter itself. */ 11535 parm_die = gen_formal_parameter_die (formal_type, context_die); 11536 if ((TREE_CODE (function_or_method_type) == METHOD_TYPE 11537 && link == first_parm_type) 11538 || (arg && DECL_ARTIFICIAL (arg))) 11539 add_AT_flag (parm_die, DW_AT_artificial, 1); 11540 11541 link = TREE_CHAIN (link); 11542 if (arg) 11543 arg = TREE_CHAIN (arg); 11544 } 11545 11546 /* If this function type has an ellipsis, add a 11547 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */ 11548 if (formal_type != void_type_node) 11549 gen_unspecified_parameters_die (function_or_method_type, context_die); 11550 11551 /* Make our second (and final) pass over the list of formal parameter types 11552 and output DIEs to represent those types (as necessary). */ 11553 for (link = TYPE_ARG_TYPES (function_or_method_type); 11554 link && TREE_VALUE (link); 11555 link = TREE_CHAIN (link)) 11556 gen_type_die (TREE_VALUE (link), context_die); 11557} 11558 11559/* We want to generate the DIE for TYPE so that we can generate the 11560 die for MEMBER, which has been defined; we will need to refer back 11561 to the member declaration nested within TYPE. If we're trying to 11562 generate minimal debug info for TYPE, processing TYPE won't do the 11563 trick; we need to attach the member declaration by hand. */ 11564 11565static void 11566gen_type_die_for_member (tree type, tree member, dw_die_ref context_die) 11567{ 11568 gen_type_die (type, context_die); 11569 11570 /* If we're trying to avoid duplicate debug info, we may not have 11571 emitted the member decl for this function. Emit it now. */ 11572 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type)) 11573 && ! lookup_decl_die (member)) 11574 { 11575 dw_die_ref type_die; 11576 gcc_assert (!decl_ultimate_origin (member)); 11577 11578 push_decl_scope (type); 11579 type_die = lookup_type_die (type); 11580 if (TREE_CODE (member) == FUNCTION_DECL) 11581 gen_subprogram_die (member, type_die); 11582 else if (TREE_CODE (member) == FIELD_DECL) 11583 { 11584 /* Ignore the nameless fields that are used to skip bits but handle 11585 C++ anonymous unions and structs. */ 11586 if (DECL_NAME (member) != NULL_TREE 11587 || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE 11588 || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE) 11589 { 11590 gen_type_die (member_declared_type (member), type_die); 11591 gen_field_die (member, type_die); 11592 } 11593 } 11594 else 11595 gen_variable_die (member, type_die); 11596 11597 pop_decl_scope (); 11598 } 11599} 11600 11601/* Generate the DWARF2 info for the "abstract" instance of a function which we 11602 may later generate inlined and/or out-of-line instances of. */ 11603 11604static void 11605dwarf2out_abstract_function (tree decl) 11606{ 11607 dw_die_ref old_die; 11608 tree save_fn; 11609 struct function *save_cfun; 11610 tree context; 11611 int was_abstract = DECL_ABSTRACT (decl); 11612 11613 /* Make sure we have the actual abstract inline, not a clone. */ 11614 decl = DECL_ORIGIN (decl); 11615 11616 old_die = lookup_decl_die (decl); 11617 if (old_die && get_AT (old_die, DW_AT_inline)) 11618 /* We've already generated the abstract instance. */ 11619 return; 11620 11621 /* Be sure we've emitted the in-class declaration DIE (if any) first, so 11622 we don't get confused by DECL_ABSTRACT. */ 11623 if (debug_info_level > DINFO_LEVEL_TERSE) 11624 { 11625 context = decl_class_context (decl); 11626 if (context) 11627 gen_type_die_for_member 11628 (context, decl, decl_function_context (decl) ? NULL : comp_unit_die); 11629 } 11630 11631 /* Pretend we've just finished compiling this function. */ 11632 save_fn = current_function_decl; 11633 save_cfun = cfun; 11634 current_function_decl = decl; 11635 cfun = DECL_STRUCT_FUNCTION (decl); 11636 11637 set_decl_abstract_flags (decl, 1); 11638 dwarf2out_decl (decl); 11639 if (! was_abstract) 11640 set_decl_abstract_flags (decl, 0); 11641 11642 current_function_decl = save_fn; 11643 cfun = save_cfun; 11644} 11645 11646/* Helper function of premark_used_types() which gets called through 11647 htab_traverse_resize(). 11648 11649 Marks the DIE of a given type in *SLOT as perennial, so it never gets 11650 marked as unused by prune_unused_types. */ 11651static int 11652premark_used_types_helper (void **slot, void *data ATTRIBUTE_UNUSED) 11653{ 11654 tree type; 11655 dw_die_ref die; 11656 11657 type = *slot; 11658 die = lookup_type_die (type); 11659 if (die != NULL) 11660 die->die_perennial_p = 1; 11661 return 1; 11662} 11663 11664/* Mark all members of used_types_hash as perennial. */ 11665static void 11666premark_used_types (void) 11667{ 11668 if (cfun && cfun->used_types_hash) 11669 htab_traverse (cfun->used_types_hash, premark_used_types_helper, NULL); 11670} 11671 11672/* Generate a DIE to represent a declared function (either file-scope or 11673 block-local). */ 11674 11675static void 11676gen_subprogram_die (tree decl, dw_die_ref context_die) 11677{ 11678 char label_id[MAX_ARTIFICIAL_LABEL_BYTES]; 11679 tree origin = decl_ultimate_origin (decl); 11680 dw_die_ref subr_die; 11681 tree fn_arg_types; 11682 tree outer_scope; 11683 dw_die_ref old_die = lookup_decl_die (decl); 11684 int declaration = (current_function_decl != decl 11685 || class_or_namespace_scope_p (context_die)); 11686 11687 premark_used_types (); 11688 11689 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we 11690 started to generate the abstract instance of an inline, decided to output 11691 its containing class, and proceeded to emit the declaration of the inline 11692 from the member list for the class. If so, DECLARATION takes priority; 11693 we'll get back to the abstract instance when done with the class. */ 11694 11695 /* The class-scope declaration DIE must be the primary DIE. */ 11696 if (origin && declaration && class_or_namespace_scope_p (context_die)) 11697 { 11698 origin = NULL; 11699 gcc_assert (!old_die); 11700 } 11701 11702 /* Now that the C++ front end lazily declares artificial member fns, we 11703 might need to retrofit the declaration into its class. */ 11704 if (!declaration && !origin && !old_die 11705 && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl)) 11706 && !class_or_namespace_scope_p (context_die) 11707 && debug_info_level > DINFO_LEVEL_TERSE) 11708 old_die = force_decl_die (decl); 11709 11710 if (origin != NULL) 11711 { 11712 gcc_assert (!declaration || local_scope_p (context_die)); 11713 11714 /* Fixup die_parent for the abstract instance of a nested 11715 inline function. */ 11716 if (old_die && old_die->die_parent == NULL) 11717 add_child_die (context_die, old_die); 11718 11719 subr_die = new_die (DW_TAG_subprogram, context_die, decl); 11720 add_abstract_origin_attribute (subr_die, origin); 11721 } 11722 else if (old_die) 11723 { 11724 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl)); 11725 struct dwarf_file_data * file_index = lookup_filename (s.file); 11726 11727 if (!get_AT_flag (old_die, DW_AT_declaration) 11728 /* We can have a normal definition following an inline one in the 11729 case of redefinition of GNU C extern inlines. 11730 It seems reasonable to use AT_specification in this case. */ 11731 && !get_AT (old_die, DW_AT_inline)) 11732 { 11733 /* Detect and ignore this case, where we are trying to output 11734 something we have already output. */ 11735 return; 11736 } 11737 11738 /* If the definition comes from the same place as the declaration, 11739 maybe use the old DIE. We always want the DIE for this function 11740 that has the *_pc attributes to be under comp_unit_die so the 11741 debugger can find it. We also need to do this for abstract 11742 instances of inlines, since the spec requires the out-of-line copy 11743 to have the same parent. For local class methods, this doesn't 11744 apply; we just use the old DIE. */ 11745 if ((old_die->die_parent == comp_unit_die || context_die == NULL) 11746 && (DECL_ARTIFICIAL (decl) 11747 || (get_AT_file (old_die, DW_AT_decl_file) == file_index 11748 && (get_AT_unsigned (old_die, DW_AT_decl_line) 11749 == (unsigned) s.line)))) 11750 { 11751 subr_die = old_die; 11752 11753 /* Clear out the declaration attribute and the formal parameters. 11754 Do not remove all children, because it is possible that this 11755 declaration die was forced using force_decl_die(). In such 11756 cases die that forced declaration die (e.g. TAG_imported_module) 11757 is one of the children that we do not want to remove. */ 11758 remove_AT (subr_die, DW_AT_declaration); 11759 remove_child_TAG (subr_die, DW_TAG_formal_parameter); 11760 } 11761 else 11762 { 11763 subr_die = new_die (DW_TAG_subprogram, context_die, decl); 11764 add_AT_specification (subr_die, old_die); 11765 if (get_AT_file (old_die, DW_AT_decl_file) != file_index) 11766 add_AT_file (subr_die, DW_AT_decl_file, file_index); 11767 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line) 11768 add_AT_unsigned (subr_die, DW_AT_decl_line, s.line); 11769 } 11770 } 11771 else 11772 { 11773 subr_die = new_die (DW_TAG_subprogram, context_die, decl); 11774 11775 if (TREE_PUBLIC (decl)) 11776 add_AT_flag (subr_die, DW_AT_external, 1); 11777 11778 add_name_and_src_coords_attributes (subr_die, decl); 11779 if (debug_info_level > DINFO_LEVEL_TERSE) 11780 { 11781 add_prototyped_attribute (subr_die, TREE_TYPE (decl)); 11782 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)), 11783 0, 0, context_die); 11784 } 11785 11786 add_pure_or_virtual_attribute (subr_die, decl); 11787 if (DECL_ARTIFICIAL (decl)) 11788 add_AT_flag (subr_die, DW_AT_artificial, 1); 11789 11790 if (TREE_PROTECTED (decl)) 11791 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected); 11792 else if (TREE_PRIVATE (decl)) 11793 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private); 11794 } 11795 11796 if (declaration) 11797 { 11798 if (!old_die || !get_AT (old_die, DW_AT_inline)) 11799 { 11800 add_AT_flag (subr_die, DW_AT_declaration, 1); 11801 11802 /* The first time we see a member function, it is in the context of 11803 the class to which it belongs. We make sure of this by emitting 11804 the class first. The next time is the definition, which is 11805 handled above. The two may come from the same source text. 11806 11807 Note that force_decl_die() forces function declaration die. It is 11808 later reused to represent definition. */ 11809 equate_decl_number_to_die (decl, subr_die); 11810 } 11811 } 11812 else if (DECL_ABSTRACT (decl)) 11813 { 11814 if (DECL_DECLARED_INLINE_P (decl)) 11815 { 11816 if (cgraph_function_possibly_inlined_p (decl)) 11817 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined); 11818 else 11819 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined); 11820 } 11821 else 11822 { 11823 if (cgraph_function_possibly_inlined_p (decl)) 11824 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined); 11825 else 11826 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined); 11827 } 11828 11829 equate_decl_number_to_die (decl, subr_die); 11830 } 11831 else if (!DECL_EXTERNAL (decl)) 11832 { 11833 HOST_WIDE_INT cfa_fb_offset; 11834 11835 if (!old_die || !get_AT (old_die, DW_AT_inline)) 11836 equate_decl_number_to_die (decl, subr_die); 11837 11838 if (!flag_reorder_blocks_and_partition) 11839 { 11840 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL, 11841 current_function_funcdef_no); 11842 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id); 11843 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL, 11844 current_function_funcdef_no); 11845 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id); 11846 11847 add_pubname (decl, subr_die); 11848 add_arange (decl, subr_die); 11849 } 11850 else 11851 { /* Do nothing for now; maybe need to duplicate die, one for 11852 hot section and ond for cold section, then use the hot/cold 11853 section begin/end labels to generate the aranges... */ 11854 /* 11855 add_AT_lbl_id (subr_die, DW_AT_low_pc, hot_section_label); 11856 add_AT_lbl_id (subr_die, DW_AT_high_pc, hot_section_end_label); 11857 add_AT_lbl_id (subr_die, DW_AT_lo_user, unlikely_section_label); 11858 add_AT_lbl_id (subr_die, DW_AT_hi_user, cold_section_end_label); 11859 11860 add_pubname (decl, subr_die); 11861 add_arange (decl, subr_die); 11862 add_arange (decl, subr_die); 11863 */ 11864 } 11865 11866#ifdef MIPS_DEBUGGING_INFO 11867 /* Add a reference to the FDE for this routine. */ 11868 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde); 11869#endif 11870 11871 cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl); 11872 11873 /* We define the "frame base" as the function's CFA. This is more 11874 convenient for several reasons: (1) It's stable across the prologue 11875 and epilogue, which makes it better than just a frame pointer, 11876 (2) With dwarf3, there exists a one-byte encoding that allows us 11877 to reference the .debug_frame data by proxy, but failing that, 11878 (3) We can at least reuse the code inspection and interpretation 11879 code that determines the CFA position at various points in the 11880 function. */ 11881 /* ??? Use some command-line or configury switch to enable the use 11882 of dwarf3 DW_OP_call_frame_cfa. At present there are no dwarf 11883 consumers that understand it; fall back to "pure" dwarf2 and 11884 convert the CFA data into a location list. */ 11885 { 11886 dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset); 11887 if (list->dw_loc_next) 11888 add_AT_loc_list (subr_die, DW_AT_frame_base, list); 11889 else 11890 add_AT_loc (subr_die, DW_AT_frame_base, list->expr); 11891 } 11892 11893 /* Compute a displacement from the "steady-state frame pointer" to 11894 the CFA. The former is what all stack slots and argument slots 11895 will reference in the rtl; the later is what we've told the 11896 debugger about. We'll need to adjust all frame_base references 11897 by this displacement. */ 11898 compute_frame_pointer_to_fb_displacement (cfa_fb_offset); 11899 11900 if (cfun->static_chain_decl) 11901 add_AT_location_description (subr_die, DW_AT_static_link, 11902 loc_descriptor_from_tree (cfun->static_chain_decl)); 11903 } 11904 11905 /* Now output descriptions of the arguments for this function. This gets 11906 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list 11907 for a FUNCTION_DECL doesn't indicate cases where there was a trailing 11908 `...' at the end of the formal parameter list. In order to find out if 11909 there was a trailing ellipsis or not, we must instead look at the type 11910 associated with the FUNCTION_DECL. This will be a node of type 11911 FUNCTION_TYPE. If the chain of type nodes hanging off of this 11912 FUNCTION_TYPE node ends with a void_type_node then there should *not* be 11913 an ellipsis at the end. */ 11914 11915 /* In the case where we are describing a mere function declaration, all we 11916 need to do here (and all we *can* do here) is to describe the *types* of 11917 its formal parameters. */ 11918 if (debug_info_level <= DINFO_LEVEL_TERSE) 11919 ; 11920 else if (declaration) 11921 gen_formal_types_die (decl, subr_die); 11922 else 11923 { 11924 /* Generate DIEs to represent all known formal parameters. */ 11925 tree arg_decls = DECL_ARGUMENTS (decl); 11926 tree parm; 11927 11928 /* When generating DIEs, generate the unspecified_parameters DIE 11929 instead if we come across the arg "__builtin_va_alist" */ 11930 for (parm = arg_decls; parm; parm = TREE_CHAIN (parm)) 11931 if (TREE_CODE (parm) == PARM_DECL) 11932 { 11933 if (DECL_NAME (parm) 11934 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)), 11935 "__builtin_va_alist")) 11936 gen_unspecified_parameters_die (parm, subr_die); 11937 else 11938 gen_decl_die (parm, subr_die); 11939 } 11940 11941 /* Decide whether we need an unspecified_parameters DIE at the end. 11942 There are 2 more cases to do this for: 1) the ansi ... declaration - 11943 this is detectable when the end of the arg list is not a 11944 void_type_node 2) an unprototyped function declaration (not a 11945 definition). This just means that we have no info about the 11946 parameters at all. */ 11947 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl)); 11948 if (fn_arg_types != NULL) 11949 { 11950 /* This is the prototyped case, check for.... */ 11951 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node) 11952 gen_unspecified_parameters_die (decl, subr_die); 11953 } 11954 else if (DECL_INITIAL (decl) == NULL_TREE) 11955 gen_unspecified_parameters_die (decl, subr_die); 11956 } 11957 11958 /* Output Dwarf info for all of the stuff within the body of the function 11959 (if it has one - it may be just a declaration). */ 11960 outer_scope = DECL_INITIAL (decl); 11961 11962 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent 11963 a function. This BLOCK actually represents the outermost binding contour 11964 for the function, i.e. the contour in which the function's formal 11965 parameters and labels get declared. Curiously, it appears that the front 11966 end doesn't actually put the PARM_DECL nodes for the current function onto 11967 the BLOCK_VARS list for this outer scope, but are strung off of the 11968 DECL_ARGUMENTS list for the function instead. 11969 11970 The BLOCK_VARS list for the `outer_scope' does provide us with a list of 11971 the LABEL_DECL nodes for the function however, and we output DWARF info 11972 for those in decls_for_scope. Just within the `outer_scope' there will be 11973 a BLOCK node representing the function's outermost pair of curly braces, 11974 and any blocks used for the base and member initializers of a C++ 11975 constructor function. */ 11976 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK) 11977 { 11978 /* Emit a DW_TAG_variable DIE for a named return value. */ 11979 if (DECL_NAME (DECL_RESULT (decl))) 11980 gen_decl_die (DECL_RESULT (decl), subr_die); 11981 11982 current_function_has_inlines = 0; 11983 decls_for_scope (outer_scope, subr_die, 0); 11984 11985#if 0 && defined (MIPS_DEBUGGING_INFO) 11986 if (current_function_has_inlines) 11987 { 11988 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1); 11989 if (! comp_unit_has_inlines) 11990 { 11991 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1); 11992 comp_unit_has_inlines = 1; 11993 } 11994 } 11995#endif 11996 } 11997 /* Add the calling convention attribute if requested. */ 11998 add_calling_convention_attribute (subr_die, TREE_TYPE (decl)); 11999 12000} 12001 12002/* Generate a DIE to represent a declared data object. */ 12003 12004static void 12005gen_variable_die (tree decl, dw_die_ref context_die) 12006{ 12007 tree origin = decl_ultimate_origin (decl); 12008 dw_die_ref var_die = new_die (DW_TAG_variable, context_die, decl); 12009 12010 dw_die_ref old_die = lookup_decl_die (decl); 12011 int declaration = (DECL_EXTERNAL (decl) 12012 /* If DECL is COMDAT and has not actually been 12013 emitted, we cannot take its address; there 12014 might end up being no definition anywhere in 12015 the program. For example, consider the C++ 12016 test case: 12017 12018 template <class T> 12019 struct S { static const int i = 7; }; 12020 12021 template <class T> 12022 const int S<T>::i; 12023 12024 int f() { return S<int>::i; } 12025 12026 Here, S<int>::i is not DECL_EXTERNAL, but no 12027 definition is required, so the compiler will 12028 not emit a definition. */ 12029 || (TREE_CODE (decl) == VAR_DECL 12030 && DECL_COMDAT (decl) && !TREE_ASM_WRITTEN (decl)) 12031 || class_or_namespace_scope_p (context_die)); 12032 12033 if (origin != NULL) 12034 add_abstract_origin_attribute (var_die, origin); 12035 12036 /* Loop unrolling can create multiple blocks that refer to the same 12037 static variable, so we must test for the DW_AT_declaration flag. 12038 12039 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to 12040 copy decls and set the DECL_ABSTRACT flag on them instead of 12041 sharing them. 12042 12043 ??? Duplicated blocks have been rewritten to use .debug_ranges. 12044 12045 ??? The declare_in_namespace support causes us to get two DIEs for one 12046 variable, both of which are declarations. We want to avoid considering 12047 one to be a specification, so we must test that this DIE is not a 12048 declaration. */ 12049 else if (old_die && TREE_STATIC (decl) && ! declaration 12050 && get_AT_flag (old_die, DW_AT_declaration) == 1) 12051 { 12052 /* This is a definition of a C++ class level static. */ 12053 add_AT_specification (var_die, old_die); 12054 if (DECL_NAME (decl)) 12055 { 12056 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl)); 12057 struct dwarf_file_data * file_index = lookup_filename (s.file); 12058 12059 if (get_AT_file (old_die, DW_AT_decl_file) != file_index) 12060 add_AT_file (var_die, DW_AT_decl_file, file_index); 12061 12062 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line) 12063 12064 add_AT_unsigned (var_die, DW_AT_decl_line, s.line); 12065 } 12066 } 12067 else 12068 { 12069 add_name_and_src_coords_attributes (var_die, decl); 12070 add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl), 12071 TREE_THIS_VOLATILE (decl), context_die); 12072 12073 if (TREE_PUBLIC (decl)) 12074 add_AT_flag (var_die, DW_AT_external, 1); 12075 12076 if (DECL_ARTIFICIAL (decl)) 12077 add_AT_flag (var_die, DW_AT_artificial, 1); 12078 12079 if (TREE_PROTECTED (decl)) 12080 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected); 12081 else if (TREE_PRIVATE (decl)) 12082 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private); 12083 } 12084 12085 if (declaration) 12086 add_AT_flag (var_die, DW_AT_declaration, 1); 12087 12088 if (DECL_ABSTRACT (decl) || declaration) 12089 equate_decl_number_to_die (decl, var_die); 12090 12091 if (! declaration && ! DECL_ABSTRACT (decl)) 12092 { 12093 add_location_or_const_value_attribute (var_die, decl, DW_AT_location); 12094 add_pubname (decl, var_die); 12095 } 12096 else 12097 tree_add_const_value_attribute (var_die, decl); 12098} 12099 12100/* Generate a DIE to represent a label identifier. */ 12101 12102static void 12103gen_label_die (tree decl, dw_die_ref context_die) 12104{ 12105 tree origin = decl_ultimate_origin (decl); 12106 dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl); 12107 rtx insn; 12108 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 12109 12110 if (origin != NULL) 12111 add_abstract_origin_attribute (lbl_die, origin); 12112 else 12113 add_name_and_src_coords_attributes (lbl_die, decl); 12114 12115 if (DECL_ABSTRACT (decl)) 12116 equate_decl_number_to_die (decl, lbl_die); 12117 else 12118 { 12119 insn = DECL_RTL_IF_SET (decl); 12120 12121 /* Deleted labels are programmer specified labels which have been 12122 eliminated because of various optimizations. We still emit them 12123 here so that it is possible to put breakpoints on them. */ 12124 if (insn 12125 && (LABEL_P (insn) 12126 || ((NOTE_P (insn) 12127 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL)))) 12128 { 12129 /* When optimization is enabled (via -O) some parts of the compiler 12130 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which 12131 represent source-level labels which were explicitly declared by 12132 the user. This really shouldn't be happening though, so catch 12133 it if it ever does happen. */ 12134 gcc_assert (!INSN_DELETED_P (insn)); 12135 12136 ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn)); 12137 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label); 12138 } 12139 } 12140} 12141 12142/* A helper function for gen_inlined_subroutine_die. Add source coordinate 12143 attributes to the DIE for a block STMT, to describe where the inlined 12144 function was called from. This is similar to add_src_coords_attributes. */ 12145 12146static inline void 12147add_call_src_coords_attributes (tree stmt, dw_die_ref die) 12148{ 12149 expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt)); 12150 12151 add_AT_file (die, DW_AT_call_file, lookup_filename (s.file)); 12152 add_AT_unsigned (die, DW_AT_call_line, s.line); 12153} 12154 12155/* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die. 12156 Add low_pc and high_pc attributes to the DIE for a block STMT. */ 12157 12158static inline void 12159add_high_low_attributes (tree stmt, dw_die_ref die) 12160{ 12161 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 12162 12163 if (BLOCK_FRAGMENT_CHAIN (stmt)) 12164 { 12165 tree chain; 12166 12167 add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt)); 12168 12169 chain = BLOCK_FRAGMENT_CHAIN (stmt); 12170 do 12171 { 12172 add_ranges (chain); 12173 chain = BLOCK_FRAGMENT_CHAIN (chain); 12174 } 12175 while (chain); 12176 add_ranges (NULL); 12177 } 12178 else 12179 { 12180 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL, 12181 BLOCK_NUMBER (stmt)); 12182 add_AT_lbl_id (die, DW_AT_low_pc, label); 12183 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, 12184 BLOCK_NUMBER (stmt)); 12185 add_AT_lbl_id (die, DW_AT_high_pc, label); 12186 } 12187} 12188 12189/* Generate a DIE for a lexical block. */ 12190 12191static void 12192gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth) 12193{ 12194 dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt); 12195 12196 if (! BLOCK_ABSTRACT (stmt)) 12197 add_high_low_attributes (stmt, stmt_die); 12198 12199 decls_for_scope (stmt, stmt_die, depth); 12200} 12201 12202/* Generate a DIE for an inlined subprogram. */ 12203 12204static void 12205gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth) 12206{ 12207 tree decl = block_ultimate_origin (stmt); 12208 12209 /* Emit info for the abstract instance first, if we haven't yet. We 12210 must emit this even if the block is abstract, otherwise when we 12211 emit the block below (or elsewhere), we may end up trying to emit 12212 a die whose origin die hasn't been emitted, and crashing. */ 12213 dwarf2out_abstract_function (decl); 12214 12215 if (! BLOCK_ABSTRACT (stmt)) 12216 { 12217 dw_die_ref subr_die 12218 = new_die (DW_TAG_inlined_subroutine, context_die, stmt); 12219 12220 add_abstract_origin_attribute (subr_die, decl); 12221 add_high_low_attributes (stmt, subr_die); 12222 add_call_src_coords_attributes (stmt, subr_die); 12223 12224 decls_for_scope (stmt, subr_die, depth); 12225 current_function_has_inlines = 1; 12226 } 12227 else 12228 /* We may get here if we're the outer block of function A that was 12229 inlined into function B that was inlined into function C. When 12230 generating debugging info for C, dwarf2out_abstract_function(B) 12231 would mark all inlined blocks as abstract, including this one. 12232 So, we wouldn't (and shouldn't) expect labels to be generated 12233 for this one. Instead, just emit debugging info for 12234 declarations within the block. This is particularly important 12235 in the case of initializers of arguments passed from B to us: 12236 if they're statement expressions containing declarations, we 12237 wouldn't generate dies for their abstract variables, and then, 12238 when generating dies for the real variables, we'd die (pun 12239 intended :-) */ 12240 gen_lexical_block_die (stmt, context_die, depth); 12241} 12242 12243/* Generate a DIE for a field in a record, or structure. */ 12244 12245static void 12246gen_field_die (tree decl, dw_die_ref context_die) 12247{ 12248 dw_die_ref decl_die; 12249 12250 if (TREE_TYPE (decl) == error_mark_node) 12251 return; 12252 12253 decl_die = new_die (DW_TAG_member, context_die, decl); 12254 add_name_and_src_coords_attributes (decl_die, decl); 12255 add_type_attribute (decl_die, member_declared_type (decl), 12256 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl), 12257 context_die); 12258 12259 if (DECL_BIT_FIELD_TYPE (decl)) 12260 { 12261 add_byte_size_attribute (decl_die, decl); 12262 add_bit_size_attribute (decl_die, decl); 12263 add_bit_offset_attribute (decl_die, decl); 12264 } 12265 12266 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE) 12267 add_data_member_location_attribute (decl_die, decl); 12268 12269 if (DECL_ARTIFICIAL (decl)) 12270 add_AT_flag (decl_die, DW_AT_artificial, 1); 12271 12272 if (TREE_PROTECTED (decl)) 12273 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected); 12274 else if (TREE_PRIVATE (decl)) 12275 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private); 12276 12277 /* Equate decl number to die, so that we can look up this decl later on. */ 12278 equate_decl_number_to_die (decl, decl_die); 12279} 12280 12281#if 0 12282/* Don't generate either pointer_type DIEs or reference_type DIEs here. 12283 Use modified_type_die instead. 12284 We keep this code here just in case these types of DIEs may be needed to 12285 represent certain things in other languages (e.g. Pascal) someday. */ 12286 12287static void 12288gen_pointer_type_die (tree type, dw_die_ref context_die) 12289{ 12290 dw_die_ref ptr_die 12291 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type); 12292 12293 equate_type_number_to_die (type, ptr_die); 12294 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die); 12295 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE); 12296} 12297 12298/* Don't generate either pointer_type DIEs or reference_type DIEs here. 12299 Use modified_type_die instead. 12300 We keep this code here just in case these types of DIEs may be needed to 12301 represent certain things in other languages (e.g. Pascal) someday. */ 12302 12303static void 12304gen_reference_type_die (tree type, dw_die_ref context_die) 12305{ 12306 dw_die_ref ref_die 12307 = new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type); 12308 12309 equate_type_number_to_die (type, ref_die); 12310 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die); 12311 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE); 12312} 12313#endif 12314 12315/* Generate a DIE for a pointer to a member type. */ 12316 12317static void 12318gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die) 12319{ 12320 dw_die_ref ptr_die 12321 = new_die (DW_TAG_ptr_to_member_type, 12322 scope_die_for (type, context_die), type); 12323 12324 equate_type_number_to_die (type, ptr_die); 12325 add_AT_die_ref (ptr_die, DW_AT_containing_type, 12326 lookup_type_die (TYPE_OFFSET_BASETYPE (type))); 12327 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die); 12328} 12329 12330/* Generate the DIE for the compilation unit. */ 12331 12332static dw_die_ref 12333gen_compile_unit_die (const char *filename) 12334{ 12335 dw_die_ref die; 12336 char producer[250]; 12337 const char *language_string = lang_hooks.name; 12338 int language; 12339 12340 die = new_die (DW_TAG_compile_unit, NULL, NULL); 12341 12342 if (filename) 12343 { 12344 add_name_attribute (die, filename); 12345 /* Don't add cwd for <built-in>. */ 12346 if (filename[0] != DIR_SEPARATOR && filename[0] != '<') 12347 add_comp_dir_attribute (die); 12348 } 12349 12350 sprintf (producer, "%s %s", language_string, version_string); 12351 12352#ifdef MIPS_DEBUGGING_INFO 12353 /* The MIPS/SGI compilers place the 'cc' command line options in the producer 12354 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do 12355 not appear in the producer string, the debugger reaches the conclusion 12356 that the object file is stripped and has no debugging information. 12357 To get the MIPS/SGI debugger to believe that there is debugging 12358 information in the object file, we add a -g to the producer string. */ 12359 if (debug_info_level > DINFO_LEVEL_TERSE) 12360 strcat (producer, " -g"); 12361#endif 12362 12363 add_AT_string (die, DW_AT_producer, producer); 12364 12365 if (strcmp (language_string, "GNU C++") == 0) 12366 language = DW_LANG_C_plus_plus; 12367 else if (strcmp (language_string, "GNU Ada") == 0) 12368 language = DW_LANG_Ada95; 12369 else if (strcmp (language_string, "GNU F77") == 0) 12370 language = DW_LANG_Fortran77; 12371 else if (strcmp (language_string, "GNU F95") == 0) 12372 language = DW_LANG_Fortran95; 12373 else if (strcmp (language_string, "GNU Pascal") == 0) 12374 language = DW_LANG_Pascal83; 12375 else if (strcmp (language_string, "GNU Java") == 0) 12376 language = DW_LANG_Java; 12377 else if (strcmp (language_string, "GNU Objective-C") == 0) 12378 language = DW_LANG_ObjC; 12379 else if (strcmp (language_string, "GNU Objective-C++") == 0) 12380 language = DW_LANG_ObjC_plus_plus; 12381 else 12382 language = DW_LANG_C89; 12383 12384 add_AT_unsigned (die, DW_AT_language, language); 12385 return die; 12386} 12387 12388/* Generate the DIE for a base class. */ 12389 12390static void 12391gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die) 12392{ 12393 dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo); 12394 12395 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die); 12396 add_data_member_location_attribute (die, binfo); 12397 12398 if (BINFO_VIRTUAL_P (binfo)) 12399 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual); 12400 12401 if (access == access_public_node) 12402 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public); 12403 else if (access == access_protected_node) 12404 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected); 12405} 12406 12407/* Generate a DIE for a class member. */ 12408 12409static void 12410gen_member_die (tree type, dw_die_ref context_die) 12411{ 12412 tree member; 12413 tree binfo = TYPE_BINFO (type); 12414 dw_die_ref child; 12415 12416 /* If this is not an incomplete type, output descriptions of each of its 12417 members. Note that as we output the DIEs necessary to represent the 12418 members of this record or union type, we will also be trying to output 12419 DIEs to represent the *types* of those members. However the `type' 12420 function (above) will specifically avoid generating type DIEs for member 12421 types *within* the list of member DIEs for this (containing) type except 12422 for those types (of members) which are explicitly marked as also being 12423 members of this (containing) type themselves. The g++ front- end can 12424 force any given type to be treated as a member of some other (containing) 12425 type by setting the TYPE_CONTEXT of the given (member) type to point to 12426 the TREE node representing the appropriate (containing) type. */ 12427 12428 /* First output info about the base classes. */ 12429 if (binfo) 12430 { 12431 VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo); 12432 int i; 12433 tree base; 12434 12435 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++) 12436 gen_inheritance_die (base, 12437 (accesses ? VEC_index (tree, accesses, i) 12438 : access_public_node), context_die); 12439 } 12440 12441 /* Now output info about the data members and type members. */ 12442 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member)) 12443 { 12444 /* If we thought we were generating minimal debug info for TYPE 12445 and then changed our minds, some of the member declarations 12446 may have already been defined. Don't define them again, but 12447 do put them in the right order. */ 12448 12449 child = lookup_decl_die (member); 12450 if (child) 12451 splice_child_die (context_die, child); 12452 else 12453 gen_decl_die (member, context_die); 12454 } 12455 12456 /* Now output info about the function members (if any). */ 12457 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member)) 12458 { 12459 /* Don't include clones in the member list. */ 12460 if (DECL_ABSTRACT_ORIGIN (member)) 12461 continue; 12462 12463 child = lookup_decl_die (member); 12464 if (child) 12465 splice_child_die (context_die, child); 12466 else 12467 gen_decl_die (member, context_die); 12468 } 12469} 12470 12471/* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG 12472 is set, we pretend that the type was never defined, so we only get the 12473 member DIEs needed by later specification DIEs. */ 12474 12475static void 12476gen_struct_or_union_type_die (tree type, dw_die_ref context_die) 12477{ 12478 dw_die_ref type_die = lookup_type_die (type); 12479 dw_die_ref scope_die = 0; 12480 int nested = 0; 12481 int complete = (TYPE_SIZE (type) 12482 && (! TYPE_STUB_DECL (type) 12483 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type)))); 12484 int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace); 12485 12486 if (type_die && ! complete) 12487 return; 12488 12489 if (TYPE_CONTEXT (type) != NULL_TREE 12490 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type)) 12491 || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL)) 12492 nested = 1; 12493 12494 scope_die = scope_die_for (type, context_die); 12495 12496 if (! type_die || (nested && scope_die == comp_unit_die)) 12497 /* First occurrence of type or toplevel definition of nested class. */ 12498 { 12499 dw_die_ref old_die = type_die; 12500 12501 type_die = new_die (TREE_CODE (type) == RECORD_TYPE 12502 ? DW_TAG_structure_type : DW_TAG_union_type, 12503 scope_die, type); 12504 equate_type_number_to_die (type, type_die); 12505 if (old_die) 12506 add_AT_specification (type_die, old_die); 12507 else 12508 add_name_attribute (type_die, type_tag (type)); 12509 } 12510 else 12511 remove_AT (type_die, DW_AT_declaration); 12512 12513 /* If this type has been completed, then give it a byte_size attribute and 12514 then give a list of members. */ 12515 if (complete && !ns_decl) 12516 { 12517 /* Prevent infinite recursion in cases where the type of some member of 12518 this type is expressed in terms of this type itself. */ 12519 TREE_ASM_WRITTEN (type) = 1; 12520 add_byte_size_attribute (type_die, type); 12521 if (TYPE_STUB_DECL (type) != NULL_TREE) 12522 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type)); 12523 12524 /* If the first reference to this type was as the return type of an 12525 inline function, then it may not have a parent. Fix this now. */ 12526 if (type_die->die_parent == NULL) 12527 add_child_die (scope_die, type_die); 12528 12529 push_decl_scope (type); 12530 gen_member_die (type, type_die); 12531 pop_decl_scope (); 12532 12533 /* GNU extension: Record what type our vtable lives in. */ 12534 if (TYPE_VFIELD (type)) 12535 { 12536 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type)); 12537 12538 gen_type_die (vtype, context_die); 12539 add_AT_die_ref (type_die, DW_AT_containing_type, 12540 lookup_type_die (vtype)); 12541 } 12542 } 12543 else 12544 { 12545 add_AT_flag (type_die, DW_AT_declaration, 1); 12546 12547 /* We don't need to do this for function-local types. */ 12548 if (TYPE_STUB_DECL (type) 12549 && ! decl_function_context (TYPE_STUB_DECL (type))) 12550 VEC_safe_push (tree, gc, incomplete_types, type); 12551 } 12552} 12553 12554/* Generate a DIE for a subroutine _type_. */ 12555 12556static void 12557gen_subroutine_type_die (tree type, dw_die_ref context_die) 12558{ 12559 tree return_type = TREE_TYPE (type); 12560 dw_die_ref subr_die 12561 = new_die (DW_TAG_subroutine_type, 12562 scope_die_for (type, context_die), type); 12563 12564 equate_type_number_to_die (type, subr_die); 12565 add_prototyped_attribute (subr_die, type); 12566 add_type_attribute (subr_die, return_type, 0, 0, context_die); 12567 gen_formal_types_die (type, subr_die); 12568} 12569 12570/* Generate a DIE for a type definition. */ 12571 12572static void 12573gen_typedef_die (tree decl, dw_die_ref context_die) 12574{ 12575 dw_die_ref type_die; 12576 tree origin; 12577 12578 if (TREE_ASM_WRITTEN (decl)) 12579 return; 12580 12581 TREE_ASM_WRITTEN (decl) = 1; 12582 type_die = new_die (DW_TAG_typedef, context_die, decl); 12583 origin = decl_ultimate_origin (decl); 12584 if (origin != NULL) 12585 add_abstract_origin_attribute (type_die, origin); 12586 else 12587 { 12588 tree type; 12589 12590 add_name_and_src_coords_attributes (type_die, decl); 12591 if (DECL_ORIGINAL_TYPE (decl)) 12592 { 12593 type = DECL_ORIGINAL_TYPE (decl); 12594 12595 gcc_assert (type != TREE_TYPE (decl)); 12596 equate_type_number_to_die (TREE_TYPE (decl), type_die); 12597 } 12598 else 12599 type = TREE_TYPE (decl); 12600 12601 add_type_attribute (type_die, type, TREE_READONLY (decl), 12602 TREE_THIS_VOLATILE (decl), context_die); 12603 } 12604 12605 if (DECL_ABSTRACT (decl)) 12606 equate_decl_number_to_die (decl, type_die); 12607} 12608 12609/* Generate a type description DIE. */ 12610 12611static void 12612gen_type_die (tree type, dw_die_ref context_die) 12613{ 12614 int need_pop; 12615 12616 if (type == NULL_TREE || type == error_mark_node) 12617 return; 12618 12619 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 12620 && DECL_ORIGINAL_TYPE (TYPE_NAME (type))) 12621 { 12622 if (TREE_ASM_WRITTEN (type)) 12623 return; 12624 12625 /* Prevent broken recursion; we can't hand off to the same type. */ 12626 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type); 12627 12628 TREE_ASM_WRITTEN (type) = 1; 12629 gen_decl_die (TYPE_NAME (type), context_die); 12630 return; 12631 } 12632 12633 /* We are going to output a DIE to represent the unqualified version 12634 of this type (i.e. without any const or volatile qualifiers) so 12635 get the main variant (i.e. the unqualified version) of this type 12636 now. (Vectors are special because the debugging info is in the 12637 cloned type itself). */ 12638 if (TREE_CODE (type) != VECTOR_TYPE) 12639 type = type_main_variant (type); 12640 12641 if (TREE_ASM_WRITTEN (type)) 12642 return; 12643 12644 switch (TREE_CODE (type)) 12645 { 12646 case ERROR_MARK: 12647 break; 12648 12649 case POINTER_TYPE: 12650 case REFERENCE_TYPE: 12651 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This 12652 ensures that the gen_type_die recursion will terminate even if the 12653 type is recursive. Recursive types are possible in Ada. */ 12654 /* ??? We could perhaps do this for all types before the switch 12655 statement. */ 12656 TREE_ASM_WRITTEN (type) = 1; 12657 12658 /* For these types, all that is required is that we output a DIE (or a 12659 set of DIEs) to represent the "basis" type. */ 12660 gen_type_die (TREE_TYPE (type), context_die); 12661 break; 12662 12663 case OFFSET_TYPE: 12664 /* This code is used for C++ pointer-to-data-member types. 12665 Output a description of the relevant class type. */ 12666 gen_type_die (TYPE_OFFSET_BASETYPE (type), context_die); 12667 12668 /* Output a description of the type of the object pointed to. */ 12669 gen_type_die (TREE_TYPE (type), context_die); 12670 12671 /* Now output a DIE to represent this pointer-to-data-member type 12672 itself. */ 12673 gen_ptr_to_mbr_type_die (type, context_die); 12674 break; 12675 12676 case FUNCTION_TYPE: 12677 /* Force out return type (in case it wasn't forced out already). */ 12678 gen_type_die (TREE_TYPE (type), context_die); 12679 gen_subroutine_type_die (type, context_die); 12680 break; 12681 12682 case METHOD_TYPE: 12683 /* Force out return type (in case it wasn't forced out already). */ 12684 gen_type_die (TREE_TYPE (type), context_die); 12685 gen_subroutine_type_die (type, context_die); 12686 break; 12687 12688 case ARRAY_TYPE: 12689 gen_array_type_die (type, context_die); 12690 break; 12691 12692 case VECTOR_TYPE: 12693 gen_array_type_die (type, context_die); 12694 break; 12695 12696 case ENUMERAL_TYPE: 12697 case RECORD_TYPE: 12698 case UNION_TYPE: 12699 case QUAL_UNION_TYPE: 12700 /* If this is a nested type whose containing class hasn't been written 12701 out yet, writing it out will cover this one, too. This does not apply 12702 to instantiations of member class templates; they need to be added to 12703 the containing class as they are generated. FIXME: This hurts the 12704 idea of combining type decls from multiple TUs, since we can't predict 12705 what set of template instantiations we'll get. */ 12706 if (TYPE_CONTEXT (type) 12707 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type)) 12708 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type))) 12709 { 12710 gen_type_die (TYPE_CONTEXT (type), context_die); 12711 12712 if (TREE_ASM_WRITTEN (type)) 12713 return; 12714 12715 /* If that failed, attach ourselves to the stub. */ 12716 push_decl_scope (TYPE_CONTEXT (type)); 12717 context_die = lookup_type_die (TYPE_CONTEXT (type)); 12718 need_pop = 1; 12719 } 12720 else 12721 { 12722 declare_in_namespace (type, context_die); 12723 need_pop = 0; 12724 } 12725 12726 if (TREE_CODE (type) == ENUMERAL_TYPE) 12727 { 12728 /* This might have been written out by the call to 12729 declare_in_namespace. */ 12730 if (!TREE_ASM_WRITTEN (type)) 12731 gen_enumeration_type_die (type, context_die); 12732 } 12733 else 12734 gen_struct_or_union_type_die (type, context_die); 12735 12736 if (need_pop) 12737 pop_decl_scope (); 12738 12739 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix 12740 it up if it is ever completed. gen_*_type_die will set it for us 12741 when appropriate. */ 12742 return; 12743 12744 case VOID_TYPE: 12745 case INTEGER_TYPE: 12746 case REAL_TYPE: 12747 case COMPLEX_TYPE: 12748 case BOOLEAN_TYPE: 12749 /* No DIEs needed for fundamental types. */ 12750 break; 12751 12752 case LANG_TYPE: 12753 /* No Dwarf representation currently defined. */ 12754 break; 12755 12756 default: 12757 gcc_unreachable (); 12758 } 12759 12760 TREE_ASM_WRITTEN (type) = 1; 12761} 12762 12763/* Generate a DIE for a tagged type instantiation. */ 12764 12765static void 12766gen_tagged_type_instantiation_die (tree type, dw_die_ref context_die) 12767{ 12768 if (type == NULL_TREE || type == error_mark_node) 12769 return; 12770 12771 /* We are going to output a DIE to represent the unqualified version of 12772 this type (i.e. without any const or volatile qualifiers) so make sure 12773 that we have the main variant (i.e. the unqualified version) of this 12774 type now. */ 12775 gcc_assert (type == type_main_variant (type)); 12776 12777 /* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is 12778 an instance of an unresolved type. */ 12779 12780 switch (TREE_CODE (type)) 12781 { 12782 case ERROR_MARK: 12783 break; 12784 12785 case ENUMERAL_TYPE: 12786 gen_inlined_enumeration_type_die (type, context_die); 12787 break; 12788 12789 case RECORD_TYPE: 12790 gen_inlined_structure_type_die (type, context_die); 12791 break; 12792 12793 case UNION_TYPE: 12794 case QUAL_UNION_TYPE: 12795 gen_inlined_union_type_die (type, context_die); 12796 break; 12797 12798 default: 12799 gcc_unreachable (); 12800 } 12801} 12802 12803/* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the 12804 things which are local to the given block. */ 12805 12806static void 12807gen_block_die (tree stmt, dw_die_ref context_die, int depth) 12808{ 12809 int must_output_die = 0; 12810 tree origin; 12811 tree decl; 12812 enum tree_code origin_code; 12813 12814 /* Ignore blocks that are NULL. */ 12815 if (stmt == NULL_TREE) 12816 return; 12817 12818 /* If the block is one fragment of a non-contiguous block, do not 12819 process the variables, since they will have been done by the 12820 origin block. Do process subblocks. */ 12821 if (BLOCK_FRAGMENT_ORIGIN (stmt)) 12822 { 12823 tree sub; 12824 12825 for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub)) 12826 gen_block_die (sub, context_die, depth + 1); 12827 12828 return; 12829 } 12830 12831 /* Determine the "ultimate origin" of this block. This block may be an 12832 inlined instance of an inlined instance of inline function, so we have 12833 to trace all of the way back through the origin chain to find out what 12834 sort of node actually served as the original seed for the creation of 12835 the current block. */ 12836 origin = block_ultimate_origin (stmt); 12837 origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK; 12838 12839 /* Determine if we need to output any Dwarf DIEs at all to represent this 12840 block. */ 12841 if (origin_code == FUNCTION_DECL) 12842 /* The outer scopes for inlinings *must* always be represented. We 12843 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */ 12844 must_output_die = 1; 12845 else 12846 { 12847 /* In the case where the current block represents an inlining of the 12848 "body block" of an inline function, we must *NOT* output any DIE for 12849 this block because we have already output a DIE to represent the whole 12850 inlined function scope and the "body block" of any function doesn't 12851 really represent a different scope according to ANSI C rules. So we 12852 check here to make sure that this block does not represent a "body 12853 block inlining" before trying to set the MUST_OUTPUT_DIE flag. */ 12854 if (! is_body_block (origin ? origin : stmt)) 12855 { 12856 /* Determine if this block directly contains any "significant" 12857 local declarations which we will need to output DIEs for. */ 12858 if (debug_info_level > DINFO_LEVEL_TERSE) 12859 /* We are not in terse mode so *any* local declaration counts 12860 as being a "significant" one. */ 12861 must_output_die = (BLOCK_VARS (stmt) != NULL 12862 && (TREE_USED (stmt) 12863 || TREE_ASM_WRITTEN (stmt) 12864 || BLOCK_ABSTRACT (stmt))); 12865 else 12866 /* We are in terse mode, so only local (nested) function 12867 definitions count as "significant" local declarations. */ 12868 for (decl = BLOCK_VARS (stmt); 12869 decl != NULL; decl = TREE_CHAIN (decl)) 12870 if (TREE_CODE (decl) == FUNCTION_DECL 12871 && DECL_INITIAL (decl)) 12872 { 12873 must_output_die = 1; 12874 break; 12875 } 12876 } 12877 } 12878 12879 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block 12880 DIE for any block which contains no significant local declarations at 12881 all. Rather, in such cases we just call `decls_for_scope' so that any 12882 needed Dwarf info for any sub-blocks will get properly generated. Note 12883 that in terse mode, our definition of what constitutes a "significant" 12884 local declaration gets restricted to include only inlined function 12885 instances and local (nested) function definitions. */ 12886 if (must_output_die) 12887 { 12888 if (origin_code == FUNCTION_DECL) 12889 gen_inlined_subroutine_die (stmt, context_die, depth); 12890 else 12891 gen_lexical_block_die (stmt, context_die, depth); 12892 } 12893 else 12894 decls_for_scope (stmt, context_die, depth); 12895} 12896 12897/* Generate all of the decls declared within a given scope and (recursively) 12898 all of its sub-blocks. */ 12899 12900static void 12901decls_for_scope (tree stmt, dw_die_ref context_die, int depth) 12902{ 12903 tree decl; 12904 tree subblocks; 12905 12906 /* Ignore NULL blocks. */ 12907 if (stmt == NULL_TREE) 12908 return; 12909 12910 if (TREE_USED (stmt)) 12911 { 12912 /* Output the DIEs to represent all of the data objects and typedefs 12913 declared directly within this block but not within any nested 12914 sub-blocks. Also, nested function and tag DIEs have been 12915 generated with a parent of NULL; fix that up now. */ 12916 for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl)) 12917 { 12918 dw_die_ref die; 12919 12920 if (TREE_CODE (decl) == FUNCTION_DECL) 12921 die = lookup_decl_die (decl); 12922 else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)) 12923 die = lookup_type_die (TREE_TYPE (decl)); 12924 else 12925 die = NULL; 12926 12927 if (die != NULL && die->die_parent == NULL) 12928 add_child_die (context_die, die); 12929 /* Do not produce debug information for static variables since 12930 these might be optimized out. We are called for these later 12931 in cgraph_varpool_analyze_pending_decls. */ 12932 if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)) 12933 ; 12934 else 12935 gen_decl_die (decl, context_die); 12936 } 12937 } 12938 12939 /* If we're at -g1, we're not interested in subblocks. */ 12940 if (debug_info_level <= DINFO_LEVEL_TERSE) 12941 return; 12942 12943 /* Output the DIEs to represent all sub-blocks (and the items declared 12944 therein) of this block. */ 12945 for (subblocks = BLOCK_SUBBLOCKS (stmt); 12946 subblocks != NULL; 12947 subblocks = BLOCK_CHAIN (subblocks)) 12948 gen_block_die (subblocks, context_die, depth + 1); 12949} 12950 12951/* Is this a typedef we can avoid emitting? */ 12952 12953static inline int 12954is_redundant_typedef (tree decl) 12955{ 12956 if (TYPE_DECL_IS_STUB (decl)) 12957 return 1; 12958 12959 if (DECL_ARTIFICIAL (decl) 12960 && DECL_CONTEXT (decl) 12961 && is_tagged_type (DECL_CONTEXT (decl)) 12962 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL 12963 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))) 12964 /* Also ignore the artificial member typedef for the class name. */ 12965 return 1; 12966 12967 return 0; 12968} 12969 12970/* Returns the DIE for decl. A DIE will always be returned. */ 12971 12972static dw_die_ref 12973force_decl_die (tree decl) 12974{ 12975 dw_die_ref decl_die; 12976 unsigned saved_external_flag; 12977 tree save_fn = NULL_TREE; 12978 decl_die = lookup_decl_die (decl); 12979 if (!decl_die) 12980 { 12981 dw_die_ref context_die; 12982 tree decl_context = DECL_CONTEXT (decl); 12983 if (decl_context) 12984 { 12985 /* Find die that represents this context. */ 12986 if (TYPE_P (decl_context)) 12987 context_die = force_type_die (decl_context); 12988 else 12989 context_die = force_decl_die (decl_context); 12990 } 12991 else 12992 context_die = comp_unit_die; 12993 12994 decl_die = lookup_decl_die (decl); 12995 if (decl_die) 12996 return decl_die; 12997 12998 switch (TREE_CODE (decl)) 12999 { 13000 case FUNCTION_DECL: 13001 /* Clear current_function_decl, so that gen_subprogram_die thinks 13002 that this is a declaration. At this point, we just want to force 13003 declaration die. */ 13004 save_fn = current_function_decl; 13005 current_function_decl = NULL_TREE; 13006 gen_subprogram_die (decl, context_die); 13007 current_function_decl = save_fn; 13008 break; 13009 13010 case VAR_DECL: 13011 /* Set external flag to force declaration die. Restore it after 13012 gen_decl_die() call. */ 13013 saved_external_flag = DECL_EXTERNAL (decl); 13014 DECL_EXTERNAL (decl) = 1; 13015 gen_decl_die (decl, context_die); 13016 DECL_EXTERNAL (decl) = saved_external_flag; 13017 break; 13018 13019 case NAMESPACE_DECL: 13020 dwarf2out_decl (decl); 13021 break; 13022 13023 default: 13024 gcc_unreachable (); 13025 } 13026 13027 /* We should be able to find the DIE now. */ 13028 if (!decl_die) 13029 decl_die = lookup_decl_die (decl); 13030 gcc_assert (decl_die); 13031 } 13032 13033 return decl_die; 13034} 13035 13036/* Returns the DIE for TYPE, that must not be a base type. A DIE is 13037 always returned. */ 13038 13039static dw_die_ref 13040force_type_die (tree type) 13041{ 13042 dw_die_ref type_die; 13043 13044 type_die = lookup_type_die (type); 13045 if (!type_die) 13046 { 13047 dw_die_ref context_die; 13048 if (TYPE_CONTEXT (type)) 13049 { 13050 if (TYPE_P (TYPE_CONTEXT (type))) 13051 context_die = force_type_die (TYPE_CONTEXT (type)); 13052 else 13053 context_die = force_decl_die (TYPE_CONTEXT (type)); 13054 } 13055 else 13056 context_die = comp_unit_die; 13057 13058 type_die = lookup_type_die (type); 13059 if (type_die) 13060 return type_die; 13061 gen_type_die (type, context_die); 13062 type_die = lookup_type_die (type); 13063 gcc_assert (type_die); 13064 } 13065 return type_die; 13066} 13067 13068/* Force out any required namespaces to be able to output DECL, 13069 and return the new context_die for it, if it's changed. */ 13070 13071static dw_die_ref 13072setup_namespace_context (tree thing, dw_die_ref context_die) 13073{ 13074 tree context = (DECL_P (thing) 13075 ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing)); 13076 if (context && TREE_CODE (context) == NAMESPACE_DECL) 13077 /* Force out the namespace. */ 13078 context_die = force_decl_die (context); 13079 13080 return context_die; 13081} 13082 13083/* Emit a declaration DIE for THING (which is either a DECL or a tagged 13084 type) within its namespace, if appropriate. 13085 13086 For compatibility with older debuggers, namespace DIEs only contain 13087 declarations; all definitions are emitted at CU scope. */ 13088 13089static void 13090declare_in_namespace (tree thing, dw_die_ref context_die) 13091{ 13092 dw_die_ref ns_context; 13093 13094 if (debug_info_level <= DINFO_LEVEL_TERSE) 13095 return; 13096 13097 /* If this decl is from an inlined function, then don't try to emit it in its 13098 namespace, as we will get confused. It would have already been emitted 13099 when the abstract instance of the inline function was emitted anyways. */ 13100 if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing)) 13101 return; 13102 13103 ns_context = setup_namespace_context (thing, context_die); 13104 13105 if (ns_context != context_die) 13106 { 13107 if (DECL_P (thing)) 13108 gen_decl_die (thing, ns_context); 13109 else 13110 gen_type_die (thing, ns_context); 13111 } 13112} 13113 13114/* Generate a DIE for a namespace or namespace alias. */ 13115 13116static void 13117gen_namespace_die (tree decl) 13118{ 13119 dw_die_ref context_die = setup_namespace_context (decl, comp_unit_die); 13120 13121 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace 13122 they are an alias of. */ 13123 if (DECL_ABSTRACT_ORIGIN (decl) == NULL) 13124 { 13125 /* Output a real namespace. */ 13126 dw_die_ref namespace_die 13127 = new_die (DW_TAG_namespace, context_die, decl); 13128 add_name_and_src_coords_attributes (namespace_die, decl); 13129 equate_decl_number_to_die (decl, namespace_die); 13130 } 13131 else 13132 { 13133 /* Output a namespace alias. */ 13134 13135 /* Force out the namespace we are an alias of, if necessary. */ 13136 dw_die_ref origin_die 13137 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl)); 13138 13139 /* Now create the namespace alias DIE. */ 13140 dw_die_ref namespace_die 13141 = new_die (DW_TAG_imported_declaration, context_die, decl); 13142 add_name_and_src_coords_attributes (namespace_die, decl); 13143 add_AT_die_ref (namespace_die, DW_AT_import, origin_die); 13144 equate_decl_number_to_die (decl, namespace_die); 13145 } 13146} 13147 13148/* Generate Dwarf debug information for a decl described by DECL. */ 13149 13150static void 13151gen_decl_die (tree decl, dw_die_ref context_die) 13152{ 13153 tree origin; 13154 13155 if (DECL_P (decl) && DECL_IGNORED_P (decl)) 13156 return; 13157 13158 switch (TREE_CODE (decl)) 13159 { 13160 case ERROR_MARK: 13161 break; 13162 13163 case CONST_DECL: 13164 /* The individual enumerators of an enum type get output when we output 13165 the Dwarf representation of the relevant enum type itself. */ 13166 break; 13167 13168 case FUNCTION_DECL: 13169 /* Don't output any DIEs to represent mere function declarations, 13170 unless they are class members or explicit block externs. */ 13171 if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE 13172 && (current_function_decl == NULL_TREE || DECL_ARTIFICIAL (decl))) 13173 break; 13174 13175#if 0 13176 /* FIXME */ 13177 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN 13178 on local redeclarations of global functions. That seems broken. */ 13179 if (current_function_decl != decl) 13180 /* This is only a declaration. */; 13181#endif 13182 13183 /* If we're emitting a clone, emit info for the abstract instance. */ 13184 if (DECL_ORIGIN (decl) != decl) 13185 dwarf2out_abstract_function (DECL_ABSTRACT_ORIGIN (decl)); 13186 13187 /* If we're emitting an out-of-line copy of an inline function, 13188 emit info for the abstract instance and set up to refer to it. */ 13189 else if (cgraph_function_possibly_inlined_p (decl) 13190 && ! DECL_ABSTRACT (decl) 13191 && ! class_or_namespace_scope_p (context_die) 13192 /* dwarf2out_abstract_function won't emit a die if this is just 13193 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in 13194 that case, because that works only if we have a die. */ 13195 && DECL_INITIAL (decl) != NULL_TREE) 13196 { 13197 dwarf2out_abstract_function (decl); 13198 set_decl_origin_self (decl); 13199 } 13200 13201 /* Otherwise we're emitting the primary DIE for this decl. */ 13202 else if (debug_info_level > DINFO_LEVEL_TERSE) 13203 { 13204 /* Before we describe the FUNCTION_DECL itself, make sure that we 13205 have described its return type. */ 13206 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die); 13207 13208 /* And its virtual context. */ 13209 if (DECL_VINDEX (decl) != NULL_TREE) 13210 gen_type_die (DECL_CONTEXT (decl), context_die); 13211 13212 /* And its containing type. */ 13213 origin = decl_class_context (decl); 13214 if (origin != NULL_TREE) 13215 gen_type_die_for_member (origin, decl, context_die); 13216 13217 /* And its containing namespace. */ 13218 declare_in_namespace (decl, context_die); 13219 } 13220 13221 /* Now output a DIE to represent the function itself. */ 13222 gen_subprogram_die (decl, context_die); 13223 break; 13224 13225 case TYPE_DECL: 13226 /* If we are in terse mode, don't generate any DIEs to represent any 13227 actual typedefs. */ 13228 if (debug_info_level <= DINFO_LEVEL_TERSE) 13229 break; 13230 13231 /* In the special case of a TYPE_DECL node representing the declaration 13232 of some type tag, if the given TYPE_DECL is marked as having been 13233 instantiated from some other (original) TYPE_DECL node (e.g. one which 13234 was generated within the original definition of an inline function) we 13235 have to generate a special (abbreviated) DW_TAG_structure_type, 13236 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. */ 13237 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE 13238 && is_tagged_type (TREE_TYPE (decl))) 13239 { 13240 gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die); 13241 break; 13242 } 13243 13244 if (is_redundant_typedef (decl)) 13245 gen_type_die (TREE_TYPE (decl), context_die); 13246 else 13247 /* Output a DIE to represent the typedef itself. */ 13248 gen_typedef_die (decl, context_die); 13249 break; 13250 13251 case LABEL_DECL: 13252 if (debug_info_level >= DINFO_LEVEL_NORMAL) 13253 gen_label_die (decl, context_die); 13254 break; 13255 13256 case VAR_DECL: 13257 case RESULT_DECL: 13258 /* If we are in terse mode, don't generate any DIEs to represent any 13259 variable declarations or definitions. */ 13260 if (debug_info_level <= DINFO_LEVEL_TERSE) 13261 break; 13262 13263 /* Output any DIEs that are needed to specify the type of this data 13264 object. */ 13265 gen_type_die (TREE_TYPE (decl), context_die); 13266 13267 /* And its containing type. */ 13268 origin = decl_class_context (decl); 13269 if (origin != NULL_TREE) 13270 gen_type_die_for_member (origin, decl, context_die); 13271 13272 /* And its containing namespace. */ 13273 declare_in_namespace (decl, context_die); 13274 13275 /* Now output the DIE to represent the data object itself. This gets 13276 complicated because of the possibility that the VAR_DECL really 13277 represents an inlined instance of a formal parameter for an inline 13278 function. */ 13279 origin = decl_ultimate_origin (decl); 13280 if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL) 13281 gen_formal_parameter_die (decl, context_die); 13282 else 13283 gen_variable_die (decl, context_die); 13284 break; 13285 13286 case FIELD_DECL: 13287 /* Ignore the nameless fields that are used to skip bits but handle C++ 13288 anonymous unions and structs. */ 13289 if (DECL_NAME (decl) != NULL_TREE 13290 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE 13291 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE) 13292 { 13293 gen_type_die (member_declared_type (decl), context_die); 13294 gen_field_die (decl, context_die); 13295 } 13296 break; 13297 13298 case PARM_DECL: 13299 gen_type_die (TREE_TYPE (decl), context_die); 13300 gen_formal_parameter_die (decl, context_die); 13301 break; 13302 13303 case NAMESPACE_DECL: 13304 gen_namespace_die (decl); 13305 break; 13306 13307 default: 13308 /* Probably some frontend-internal decl. Assume we don't care. */ 13309 gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES); 13310 break; 13311 } 13312} 13313 13314/* Output debug information for global decl DECL. Called from toplev.c after 13315 compilation proper has finished. */ 13316 13317static void 13318dwarf2out_global_decl (tree decl) 13319{ 13320 /* Output DWARF2 information for file-scope tentative data object 13321 declarations, file-scope (extern) function declarations (which had no 13322 corresponding body) and file-scope tagged type declarations and 13323 definitions which have not yet been forced out. */ 13324 if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl)) 13325 dwarf2out_decl (decl); 13326} 13327 13328/* Output debug information for type decl DECL. Called from toplev.c 13329 and from language front ends (to record built-in types). */ 13330static void 13331dwarf2out_type_decl (tree decl, int local) 13332{ 13333 if (!local) 13334 dwarf2out_decl (decl); 13335} 13336 13337/* Output debug information for imported module or decl. */ 13338 13339static void 13340dwarf2out_imported_module_or_decl (tree decl, tree context) 13341{ 13342 dw_die_ref imported_die, at_import_die; 13343 dw_die_ref scope_die; 13344 expanded_location xloc; 13345 13346 if (debug_info_level <= DINFO_LEVEL_TERSE) 13347 return; 13348 13349 gcc_assert (decl); 13350 13351 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs. 13352 We need decl DIE for reference and scope die. First, get DIE for the decl 13353 itself. */ 13354 13355 /* Get the scope die for decl context. Use comp_unit_die for global module 13356 or decl. If die is not found for non globals, force new die. */ 13357 if (!context) 13358 scope_die = comp_unit_die; 13359 else if (TYPE_P (context)) 13360 scope_die = force_type_die (context); 13361 else 13362 scope_die = force_decl_die (context); 13363 13364 /* For TYPE_DECL or CONST_DECL, lookup TREE_TYPE. */ 13365 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL) 13366 { 13367 if (is_base_type (TREE_TYPE (decl))) 13368 at_import_die = base_type_die (TREE_TYPE (decl)); 13369 else 13370 at_import_die = force_type_die (TREE_TYPE (decl)); 13371 } 13372 else 13373 { 13374 at_import_die = lookup_decl_die (decl); 13375 if (!at_import_die) 13376 { 13377 /* If we're trying to avoid duplicate debug info, we may not have 13378 emitted the member decl for this field. Emit it now. */ 13379 if (TREE_CODE (decl) == FIELD_DECL) 13380 { 13381 tree type = DECL_CONTEXT (decl); 13382 dw_die_ref type_context_die; 13383 13384 if (TYPE_CONTEXT (type)) 13385 if (TYPE_P (TYPE_CONTEXT (type))) 13386 type_context_die = force_type_die (TYPE_CONTEXT (type)); 13387 else 13388 type_context_die = force_decl_die (TYPE_CONTEXT (type)); 13389 else 13390 type_context_die = comp_unit_die; 13391 gen_type_die_for_member (type, decl, type_context_die); 13392 } 13393 at_import_die = force_decl_die (decl); 13394 } 13395 } 13396 13397 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */ 13398 if (TREE_CODE (decl) == NAMESPACE_DECL) 13399 imported_die = new_die (DW_TAG_imported_module, scope_die, context); 13400 else 13401 imported_die = new_die (DW_TAG_imported_declaration, scope_die, context); 13402 13403 xloc = expand_location (input_location); 13404 add_AT_file (imported_die, DW_AT_decl_file, lookup_filename (xloc.file)); 13405 add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line); 13406 add_AT_die_ref (imported_die, DW_AT_import, at_import_die); 13407} 13408 13409/* Write the debugging output for DECL. */ 13410 13411void 13412dwarf2out_decl (tree decl) 13413{ 13414 dw_die_ref context_die = comp_unit_die; 13415 13416 switch (TREE_CODE (decl)) 13417 { 13418 case ERROR_MARK: 13419 return; 13420 13421 case FUNCTION_DECL: 13422 /* What we would really like to do here is to filter out all mere 13423 file-scope declarations of file-scope functions which are never 13424 referenced later within this translation unit (and keep all of ones 13425 that *are* referenced later on) but we aren't clairvoyant, so we have 13426 no idea which functions will be referenced in the future (i.e. later 13427 on within the current translation unit). So here we just ignore all 13428 file-scope function declarations which are not also definitions. If 13429 and when the debugger needs to know something about these functions, 13430 it will have to hunt around and find the DWARF information associated 13431 with the definition of the function. 13432 13433 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL 13434 nodes represent definitions and which ones represent mere 13435 declarations. We have to check DECL_INITIAL instead. That's because 13436 the C front-end supports some weird semantics for "extern inline" 13437 function definitions. These can get inlined within the current 13438 translation unit (and thus, we need to generate Dwarf info for their 13439 abstract instances so that the Dwarf info for the concrete inlined 13440 instances can have something to refer to) but the compiler never 13441 generates any out-of-lines instances of such things (despite the fact 13442 that they *are* definitions). 13443 13444 The important point is that the C front-end marks these "extern 13445 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for 13446 them anyway. Note that the C++ front-end also plays some similar games 13447 for inline function definitions appearing within include files which 13448 also contain `#pragma interface' pragmas. */ 13449 if (DECL_INITIAL (decl) == NULL_TREE) 13450 return; 13451 13452 /* If we're a nested function, initially use a parent of NULL; if we're 13453 a plain function, this will be fixed up in decls_for_scope. If 13454 we're a method, it will be ignored, since we already have a DIE. */ 13455 if (decl_function_context (decl) 13456 /* But if we're in terse mode, we don't care about scope. */ 13457 && debug_info_level > DINFO_LEVEL_TERSE) 13458 context_die = NULL; 13459 break; 13460 13461 case VAR_DECL: 13462 /* Ignore this VAR_DECL if it refers to a file-scope extern data object 13463 declaration and if the declaration was never even referenced from 13464 within this entire compilation unit. We suppress these DIEs in 13465 order to save space in the .debug section (by eliminating entries 13466 which are probably useless). Note that we must not suppress 13467 block-local extern declarations (whether used or not) because that 13468 would screw-up the debugger's name lookup mechanism and cause it to 13469 miss things which really ought to be in scope at a given point. */ 13470 if (DECL_EXTERNAL (decl) && !TREE_USED (decl)) 13471 return; 13472 13473 /* For local statics lookup proper context die. */ 13474 if (TREE_STATIC (decl) && decl_function_context (decl)) 13475 context_die = lookup_decl_die (DECL_CONTEXT (decl)); 13476 13477 /* If we are in terse mode, don't generate any DIEs to represent any 13478 variable declarations or definitions. */ 13479 if (debug_info_level <= DINFO_LEVEL_TERSE) 13480 return; 13481 break; 13482 13483 case NAMESPACE_DECL: 13484 if (debug_info_level <= DINFO_LEVEL_TERSE) 13485 return; 13486 if (lookup_decl_die (decl) != NULL) 13487 return; 13488 break; 13489 13490 case TYPE_DECL: 13491 /* Don't emit stubs for types unless they are needed by other DIEs. */ 13492 if (TYPE_DECL_SUPPRESS_DEBUG (decl)) 13493 return; 13494 13495 /* Don't bother trying to generate any DIEs to represent any of the 13496 normal built-in types for the language we are compiling. */ 13497 if (DECL_IS_BUILTIN (decl)) 13498 { 13499 /* OK, we need to generate one for `bool' so GDB knows what type 13500 comparisons have. */ 13501 if (is_cxx () 13502 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE 13503 && ! DECL_IGNORED_P (decl)) 13504 modified_type_die (TREE_TYPE (decl), 0, 0, NULL); 13505 13506 return; 13507 } 13508 13509 /* If we are in terse mode, don't generate any DIEs for types. */ 13510 if (debug_info_level <= DINFO_LEVEL_TERSE) 13511 return; 13512 13513 /* If we're a function-scope tag, initially use a parent of NULL; 13514 this will be fixed up in decls_for_scope. */ 13515 if (decl_function_context (decl)) 13516 context_die = NULL; 13517 13518 break; 13519 13520 default: 13521 return; 13522 } 13523 13524 gen_decl_die (decl, context_die); 13525} 13526 13527/* Output a marker (i.e. a label) for the beginning of the generated code for 13528 a lexical block. */ 13529 13530static void 13531dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED, 13532 unsigned int blocknum) 13533{ 13534 switch_to_section (current_function_section ()); 13535 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum); 13536} 13537 13538/* Output a marker (i.e. a label) for the end of the generated code for a 13539 lexical block. */ 13540 13541static void 13542dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum) 13543{ 13544 switch_to_section (current_function_section ()); 13545 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum); 13546} 13547 13548/* Returns nonzero if it is appropriate not to emit any debugging 13549 information for BLOCK, because it doesn't contain any instructions. 13550 13551 Don't allow this for blocks with nested functions or local classes 13552 as we would end up with orphans, and in the presence of scheduling 13553 we may end up calling them anyway. */ 13554 13555static bool 13556dwarf2out_ignore_block (tree block) 13557{ 13558 tree decl; 13559 13560 for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl)) 13561 if (TREE_CODE (decl) == FUNCTION_DECL 13562 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))) 13563 return 0; 13564 13565 return 1; 13566} 13567 13568/* Hash table routines for file_hash. */ 13569 13570static int 13571file_table_eq (const void *p1_p, const void *p2_p) 13572{ 13573 const struct dwarf_file_data * p1 = p1_p; 13574 const char * p2 = p2_p; 13575 return strcmp (p1->filename, p2) == 0; 13576} 13577 13578static hashval_t 13579file_table_hash (const void *p_p) 13580{ 13581 const struct dwarf_file_data * p = p_p; 13582 return htab_hash_string (p->filename); 13583} 13584 13585/* Lookup FILE_NAME (in the list of filenames that we know about here in 13586 dwarf2out.c) and return its "index". The index of each (known) filename is 13587 just a unique number which is associated with only that one filename. We 13588 need such numbers for the sake of generating labels (in the .debug_sfnames 13589 section) and references to those files numbers (in the .debug_srcinfo 13590 and.debug_macinfo sections). If the filename given as an argument is not 13591 found in our current list, add it to the list and assign it the next 13592 available unique index number. In order to speed up searches, we remember 13593 the index of the filename was looked up last. This handles the majority of 13594 all searches. */ 13595 13596static struct dwarf_file_data * 13597lookup_filename (const char *file_name) 13598{ 13599 void ** slot; 13600 struct dwarf_file_data * created; 13601 13602 /* Check to see if the file name that was searched on the previous 13603 call matches this file name. If so, return the index. */ 13604 if (file_table_last_lookup 13605 && (file_name == file_table_last_lookup->filename 13606 || strcmp (file_table_last_lookup->filename, file_name) == 0)) 13607 return file_table_last_lookup; 13608 13609 /* Didn't match the previous lookup, search the table. */ 13610 slot = htab_find_slot_with_hash (file_table, file_name, 13611 htab_hash_string (file_name), INSERT); 13612 if (*slot) 13613 return *slot; 13614 13615 created = ggc_alloc (sizeof (struct dwarf_file_data)); 13616 created->filename = file_name; 13617 created->emitted_number = 0; 13618 *slot = created; 13619 return created; 13620} 13621 13622/* If the assembler will construct the file table, then translate the compiler 13623 internal file table number into the assembler file table number, and emit 13624 a .file directive if we haven't already emitted one yet. The file table 13625 numbers are different because we prune debug info for unused variables and 13626 types, which may include filenames. */ 13627 13628static int 13629maybe_emit_file (struct dwarf_file_data * fd) 13630{ 13631 if (! fd->emitted_number) 13632 { 13633 if (last_emitted_file) 13634 fd->emitted_number = last_emitted_file->emitted_number + 1; 13635 else 13636 fd->emitted_number = 1; 13637 last_emitted_file = fd; 13638 13639 if (DWARF2_ASM_LINE_DEBUG_INFO) 13640 { 13641 fprintf (asm_out_file, "\t.file %u ", fd->emitted_number); 13642 output_quoted_string (asm_out_file, fd->filename); 13643 fputc ('\n', asm_out_file); 13644 } 13645 } 13646 13647 return fd->emitted_number; 13648} 13649 13650/* Called by the final INSN scan whenever we see a var location. We 13651 use it to drop labels in the right places, and throw the location in 13652 our lookup table. */ 13653 13654static void 13655dwarf2out_var_location (rtx loc_note) 13656{ 13657 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES]; 13658 struct var_loc_node *newloc; 13659 rtx prev_insn; 13660 static rtx last_insn; 13661 static const char *last_label; 13662 tree decl; 13663 13664 if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note))) 13665 return; 13666 prev_insn = PREV_INSN (loc_note); 13667 13668 newloc = ggc_alloc_cleared (sizeof (struct var_loc_node)); 13669 /* If the insn we processed last time is the previous insn 13670 and it is also a var location note, use the label we emitted 13671 last time. */ 13672 if (last_insn != NULL_RTX 13673 && last_insn == prev_insn 13674 && NOTE_P (prev_insn) 13675 && NOTE_LINE_NUMBER (prev_insn) == NOTE_INSN_VAR_LOCATION) 13676 { 13677 newloc->label = last_label; 13678 } 13679 else 13680 { 13681 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num); 13682 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num); 13683 loclabel_num++; 13684 newloc->label = ggc_strdup (loclabel); 13685 } 13686 newloc->var_loc_note = loc_note; 13687 newloc->next = NULL; 13688 13689 if (cfun && in_cold_section_p) 13690 newloc->section_label = cfun->cold_section_label; 13691 else 13692 newloc->section_label = text_section_label; 13693 13694 last_insn = loc_note; 13695 last_label = newloc->label; 13696 decl = NOTE_VAR_LOCATION_DECL (loc_note); 13697 add_var_loc_to_decl (decl, newloc); 13698} 13699 13700/* We need to reset the locations at the beginning of each 13701 function. We can't do this in the end_function hook, because the 13702 declarations that use the locations won't have been output when 13703 that hook is called. Also compute have_multiple_function_sections here. */ 13704 13705static void 13706dwarf2out_begin_function (tree fun) 13707{ 13708 htab_empty (decl_loc_table); 13709 13710 if (function_section (fun) != text_section) 13711 have_multiple_function_sections = true; 13712} 13713 13714/* Output a label to mark the beginning of a source code line entry 13715 and record information relating to this source line, in 13716 'line_info_table' for later output of the .debug_line section. */ 13717 13718static void 13719dwarf2out_source_line (unsigned int line, const char *filename) 13720{ 13721 if (debug_info_level >= DINFO_LEVEL_NORMAL 13722 && line != 0) 13723 { 13724 int file_num = maybe_emit_file (lookup_filename (filename)); 13725 13726 switch_to_section (current_function_section ()); 13727 13728 /* If requested, emit something human-readable. */ 13729 if (flag_debug_asm) 13730 fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START, 13731 filename, line); 13732 13733 if (DWARF2_ASM_LINE_DEBUG_INFO) 13734 { 13735 /* Emit the .loc directive understood by GNU as. */ 13736 fprintf (asm_out_file, "\t.loc %d %d 0\n", file_num, line); 13737 13738 /* Indicate that line number info exists. */ 13739 line_info_table_in_use++; 13740 } 13741 else if (function_section (current_function_decl) != text_section) 13742 { 13743 dw_separate_line_info_ref line_info; 13744 targetm.asm_out.internal_label (asm_out_file, 13745 SEPARATE_LINE_CODE_LABEL, 13746 separate_line_info_table_in_use); 13747 13748 /* Expand the line info table if necessary. */ 13749 if (separate_line_info_table_in_use 13750 == separate_line_info_table_allocated) 13751 { 13752 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT; 13753 separate_line_info_table 13754 = ggc_realloc (separate_line_info_table, 13755 separate_line_info_table_allocated 13756 * sizeof (dw_separate_line_info_entry)); 13757 memset (separate_line_info_table 13758 + separate_line_info_table_in_use, 13759 0, 13760 (LINE_INFO_TABLE_INCREMENT 13761 * sizeof (dw_separate_line_info_entry))); 13762 } 13763 13764 /* Add the new entry at the end of the line_info_table. */ 13765 line_info 13766 = &separate_line_info_table[separate_line_info_table_in_use++]; 13767 line_info->dw_file_num = file_num; 13768 line_info->dw_line_num = line; 13769 line_info->function = current_function_funcdef_no; 13770 } 13771 else 13772 { 13773 dw_line_info_ref line_info; 13774 13775 targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL, 13776 line_info_table_in_use); 13777 13778 /* Expand the line info table if necessary. */ 13779 if (line_info_table_in_use == line_info_table_allocated) 13780 { 13781 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT; 13782 line_info_table 13783 = ggc_realloc (line_info_table, 13784 (line_info_table_allocated 13785 * sizeof (dw_line_info_entry))); 13786 memset (line_info_table + line_info_table_in_use, 0, 13787 LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry)); 13788 } 13789 13790 /* Add the new entry at the end of the line_info_table. */ 13791 line_info = &line_info_table[line_info_table_in_use++]; 13792 line_info->dw_file_num = file_num; 13793 line_info->dw_line_num = line; 13794 } 13795 } 13796} 13797 13798/* Record the beginning of a new source file. */ 13799 13800static void 13801dwarf2out_start_source_file (unsigned int lineno, const char *filename) 13802{ 13803 if (flag_eliminate_dwarf2_dups) 13804 { 13805 /* Record the beginning of the file for break_out_includes. */ 13806 dw_die_ref bincl_die; 13807 13808 bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL); 13809 add_AT_string (bincl_die, DW_AT_name, filename); 13810 } 13811 13812 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 13813 { 13814 int file_num = maybe_emit_file (lookup_filename (filename)); 13815 13816 switch_to_section (debug_macinfo_section); 13817 dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file"); 13818 dw2_asm_output_data_uleb128 (lineno, "Included from line number %d", 13819 lineno); 13820 13821 dw2_asm_output_data_uleb128 (file_num, "file %s", filename); 13822 } 13823} 13824 13825/* Record the end of a source file. */ 13826 13827static void 13828dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED) 13829{ 13830 if (flag_eliminate_dwarf2_dups) 13831 /* Record the end of the file for break_out_includes. */ 13832 new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL); 13833 13834 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 13835 { 13836 switch_to_section (debug_macinfo_section); 13837 dw2_asm_output_data (1, DW_MACINFO_end_file, "End file"); 13838 } 13839} 13840 13841/* Called from debug_define in toplev.c. The `buffer' parameter contains 13842 the tail part of the directive line, i.e. the part which is past the 13843 initial whitespace, #, whitespace, directive-name, whitespace part. */ 13844 13845static void 13846dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED, 13847 const char *buffer ATTRIBUTE_UNUSED) 13848{ 13849 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 13850 { 13851 switch_to_section (debug_macinfo_section); 13852 dw2_asm_output_data (1, DW_MACINFO_define, "Define macro"); 13853 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno); 13854 dw2_asm_output_nstring (buffer, -1, "The macro"); 13855 } 13856} 13857 13858/* Called from debug_undef in toplev.c. The `buffer' parameter contains 13859 the tail part of the directive line, i.e. the part which is past the 13860 initial whitespace, #, whitespace, directive-name, whitespace part. */ 13861 13862static void 13863dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED, 13864 const char *buffer ATTRIBUTE_UNUSED) 13865{ 13866 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 13867 { 13868 switch_to_section (debug_macinfo_section); 13869 dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro"); 13870 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno); 13871 dw2_asm_output_nstring (buffer, -1, "The macro"); 13872 } 13873} 13874 13875/* Set up for Dwarf output at the start of compilation. */ 13876 13877static void 13878dwarf2out_init (const char *filename ATTRIBUTE_UNUSED) 13879{ 13880 /* Allocate the file_table. */ 13881 file_table = htab_create_ggc (50, file_table_hash, 13882 file_table_eq, NULL); 13883 13884 /* Allocate the decl_die_table. */ 13885 decl_die_table = htab_create_ggc (10, decl_die_table_hash, 13886 decl_die_table_eq, NULL); 13887 13888 /* Allocate the decl_loc_table. */ 13889 decl_loc_table = htab_create_ggc (10, decl_loc_table_hash, 13890 decl_loc_table_eq, NULL); 13891 13892 /* Allocate the initial hunk of the decl_scope_table. */ 13893 decl_scope_table = VEC_alloc (tree, gc, 256); 13894 13895 /* Allocate the initial hunk of the abbrev_die_table. */ 13896 abbrev_die_table = ggc_alloc_cleared (ABBREV_DIE_TABLE_INCREMENT 13897 * sizeof (dw_die_ref)); 13898 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT; 13899 /* Zero-th entry is allocated, but unused. */ 13900 abbrev_die_table_in_use = 1; 13901 13902 /* Allocate the initial hunk of the line_info_table. */ 13903 line_info_table = ggc_alloc_cleared (LINE_INFO_TABLE_INCREMENT 13904 * sizeof (dw_line_info_entry)); 13905 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT; 13906 13907 /* Zero-th entry is allocated, but unused. */ 13908 line_info_table_in_use = 1; 13909 13910 /* Generate the initial DIE for the .debug section. Note that the (string) 13911 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE 13912 will (typically) be a relative pathname and that this pathname should be 13913 taken as being relative to the directory from which the compiler was 13914 invoked when the given (base) source file was compiled. We will fill 13915 in this value in dwarf2out_finish. */ 13916 comp_unit_die = gen_compile_unit_die (NULL); 13917 13918 incomplete_types = VEC_alloc (tree, gc, 64); 13919 13920 used_rtx_array = VEC_alloc (rtx, gc, 32); 13921 13922 debug_info_section = get_section (DEBUG_INFO_SECTION, 13923 SECTION_DEBUG, NULL); 13924 debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION, 13925 SECTION_DEBUG, NULL); 13926 debug_aranges_section = get_section (DEBUG_ARANGES_SECTION, 13927 SECTION_DEBUG, NULL); 13928 debug_macinfo_section = get_section (DEBUG_MACINFO_SECTION, 13929 SECTION_DEBUG, NULL); 13930 debug_line_section = get_section (DEBUG_LINE_SECTION, 13931 SECTION_DEBUG, NULL); 13932 debug_loc_section = get_section (DEBUG_LOC_SECTION, 13933 SECTION_DEBUG, NULL); 13934 debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION, 13935 SECTION_DEBUG, NULL); 13936 debug_str_section = get_section (DEBUG_STR_SECTION, 13937 DEBUG_STR_SECTION_FLAGS, NULL); 13938 debug_ranges_section = get_section (DEBUG_RANGES_SECTION, 13939 SECTION_DEBUG, NULL); 13940 debug_frame_section = get_section (DEBUG_FRAME_SECTION, 13941 SECTION_DEBUG, NULL); 13942 13943 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0); 13944 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label, 13945 DEBUG_ABBREV_SECTION_LABEL, 0); 13946 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0); 13947 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label, 13948 COLD_TEXT_SECTION_LABEL, 0); 13949 ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0); 13950 13951 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label, 13952 DEBUG_INFO_SECTION_LABEL, 0); 13953 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label, 13954 DEBUG_LINE_SECTION_LABEL, 0); 13955 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label, 13956 DEBUG_RANGES_SECTION_LABEL, 0); 13957 switch_to_section (debug_abbrev_section); 13958 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label); 13959 switch_to_section (debug_info_section); 13960 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label); 13961 switch_to_section (debug_line_section); 13962 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label); 13963 13964 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 13965 { 13966 switch_to_section (debug_macinfo_section); 13967 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label, 13968 DEBUG_MACINFO_SECTION_LABEL, 0); 13969 ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label); 13970 } 13971 13972 switch_to_section (text_section); 13973 ASM_OUTPUT_LABEL (asm_out_file, text_section_label); 13974 if (flag_reorder_blocks_and_partition) 13975 { 13976 switch_to_section (unlikely_text_section ()); 13977 ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label); 13978 } 13979} 13980 13981/* A helper function for dwarf2out_finish called through 13982 ht_forall. Emit one queued .debug_str string. */ 13983 13984static int 13985output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED) 13986{ 13987 struct indirect_string_node *node = (struct indirect_string_node *) *h; 13988 13989 if (node->form == DW_FORM_strp) 13990 { 13991 switch_to_section (debug_str_section); 13992 ASM_OUTPUT_LABEL (asm_out_file, node->label); 13993 assemble_string (node->str, strlen (node->str) + 1); 13994 } 13995 13996 return 1; 13997} 13998 13999#if ENABLE_ASSERT_CHECKING 14000/* Verify that all marks are clear. */ 14001 14002static void 14003verify_marks_clear (dw_die_ref die) 14004{ 14005 dw_die_ref c; 14006 14007 gcc_assert (! die->die_mark); 14008 FOR_EACH_CHILD (die, c, verify_marks_clear (c)); 14009} 14010#endif /* ENABLE_ASSERT_CHECKING */ 14011 14012/* Clear the marks for a die and its children. 14013 Be cool if the mark isn't set. */ 14014 14015static void 14016prune_unmark_dies (dw_die_ref die) 14017{ 14018 dw_die_ref c; 14019 14020 if (die->die_mark) 14021 die->die_mark = 0; 14022 FOR_EACH_CHILD (die, c, prune_unmark_dies (c)); 14023} 14024 14025/* Given DIE that we're marking as used, find any other dies 14026 it references as attributes and mark them as used. */ 14027 14028static void 14029prune_unused_types_walk_attribs (dw_die_ref die) 14030{ 14031 dw_attr_ref a; 14032 unsigned ix; 14033 14034 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 14035 { 14036 if (a->dw_attr_val.val_class == dw_val_class_die_ref) 14037 { 14038 /* A reference to another DIE. 14039 Make sure that it will get emitted. */ 14040 prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1); 14041 } 14042 /* Set the string's refcount to 0 so that prune_unused_types_mark 14043 accounts properly for it. */ 14044 if (AT_class (a) == dw_val_class_str) 14045 a->dw_attr_val.v.val_str->refcount = 0; 14046 } 14047} 14048 14049 14050/* Mark DIE as being used. If DOKIDS is true, then walk down 14051 to DIE's children. */ 14052 14053static void 14054prune_unused_types_mark (dw_die_ref die, int dokids) 14055{ 14056 dw_die_ref c; 14057 14058 if (die->die_mark == 0) 14059 { 14060 /* We haven't done this node yet. Mark it as used. */ 14061 die->die_mark = 1; 14062 14063 /* We also have to mark its parents as used. 14064 (But we don't want to mark our parents' kids due to this.) */ 14065 if (die->die_parent) 14066 prune_unused_types_mark (die->die_parent, 0); 14067 14068 /* Mark any referenced nodes. */ 14069 prune_unused_types_walk_attribs (die); 14070 14071 /* If this node is a specification, 14072 also mark the definition, if it exists. */ 14073 if (get_AT_flag (die, DW_AT_declaration) && die->die_definition) 14074 prune_unused_types_mark (die->die_definition, 1); 14075 } 14076 14077 if (dokids && die->die_mark != 2) 14078 { 14079 /* We need to walk the children, but haven't done so yet. 14080 Remember that we've walked the kids. */ 14081 die->die_mark = 2; 14082 14083 /* If this is an array type, we need to make sure our 14084 kids get marked, even if they're types. */ 14085 if (die->die_tag == DW_TAG_array_type) 14086 FOR_EACH_CHILD (die, c, prune_unused_types_mark (c, 1)); 14087 else 14088 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c)); 14089 } 14090} 14091 14092 14093/* Walk the tree DIE and mark types that we actually use. */ 14094 14095static void 14096prune_unused_types_walk (dw_die_ref die) 14097{ 14098 dw_die_ref c; 14099 14100 /* Don't do anything if this node is already marked. */ 14101 if (die->die_mark) 14102 return; 14103 14104 switch (die->die_tag) { 14105 case DW_TAG_const_type: 14106 case DW_TAG_packed_type: 14107 case DW_TAG_pointer_type: 14108 case DW_TAG_reference_type: 14109 case DW_TAG_volatile_type: 14110 case DW_TAG_typedef: 14111 case DW_TAG_array_type: 14112 case DW_TAG_structure_type: 14113 case DW_TAG_union_type: 14114 case DW_TAG_class_type: 14115 case DW_TAG_friend: 14116 case DW_TAG_variant_part: 14117 case DW_TAG_enumeration_type: 14118 case DW_TAG_subroutine_type: 14119 case DW_TAG_string_type: 14120 case DW_TAG_set_type: 14121 case DW_TAG_subrange_type: 14122 case DW_TAG_ptr_to_member_type: 14123 case DW_TAG_file_type: 14124 if (die->die_perennial_p) 14125 break; 14126 14127 /* It's a type node --- don't mark it. */ 14128 return; 14129 14130 default: 14131 /* Mark everything else. */ 14132 break; 14133 } 14134 14135 die->die_mark = 1; 14136 14137 /* Now, mark any dies referenced from here. */ 14138 prune_unused_types_walk_attribs (die); 14139 14140 /* Mark children. */ 14141 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c)); 14142} 14143 14144/* Increment the string counts on strings referred to from DIE's 14145 attributes. */ 14146 14147static void 14148prune_unused_types_update_strings (dw_die_ref die) 14149{ 14150 dw_attr_ref a; 14151 unsigned ix; 14152 14153 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 14154 if (AT_class (a) == dw_val_class_str) 14155 { 14156 struct indirect_string_node *s = a->dw_attr_val.v.val_str; 14157 s->refcount++; 14158 /* Avoid unnecessarily putting strings that are used less than 14159 twice in the hash table. */ 14160 if (s->refcount 14161 == ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) ? 1 : 2)) 14162 { 14163 void ** slot; 14164 slot = htab_find_slot_with_hash (debug_str_hash, s->str, 14165 htab_hash_string (s->str), 14166 INSERT); 14167 gcc_assert (*slot == NULL); 14168 *slot = s; 14169 } 14170 } 14171} 14172 14173/* Remove from the tree DIE any dies that aren't marked. */ 14174 14175static void 14176prune_unused_types_prune (dw_die_ref die) 14177{ 14178 dw_die_ref c; 14179 14180 gcc_assert (die->die_mark); 14181 prune_unused_types_update_strings (die); 14182 14183 if (! die->die_child) 14184 return; 14185 14186 c = die->die_child; 14187 do { 14188 dw_die_ref prev = c; 14189 for (c = c->die_sib; ! c->die_mark; c = c->die_sib) 14190 if (c == die->die_child) 14191 { 14192 /* No marked children between 'prev' and the end of the list. */ 14193 if (prev == c) 14194 /* No marked children at all. */ 14195 die->die_child = NULL; 14196 else 14197 { 14198 prev->die_sib = c->die_sib; 14199 die->die_child = prev; 14200 } 14201 return; 14202 } 14203 14204 if (c != prev->die_sib) 14205 prev->die_sib = c; 14206 prune_unused_types_prune (c); 14207 } while (c != die->die_child); 14208} 14209 14210 14211/* Remove dies representing declarations that we never use. */ 14212 14213static void 14214prune_unused_types (void) 14215{ 14216 unsigned int i; 14217 limbo_die_node *node; 14218 14219#if ENABLE_ASSERT_CHECKING 14220 /* All the marks should already be clear. */ 14221 verify_marks_clear (comp_unit_die); 14222 for (node = limbo_die_list; node; node = node->next) 14223 verify_marks_clear (node->die); 14224#endif /* ENABLE_ASSERT_CHECKING */ 14225 14226 /* Set the mark on nodes that are actually used. */ 14227 prune_unused_types_walk (comp_unit_die); 14228 for (node = limbo_die_list; node; node = node->next) 14229 prune_unused_types_walk (node->die); 14230 14231 /* Also set the mark on nodes referenced from the 14232 pubname_table or arange_table. */ 14233 for (i = 0; i < pubname_table_in_use; i++) 14234 prune_unused_types_mark (pubname_table[i].die, 1); 14235 for (i = 0; i < arange_table_in_use; i++) 14236 prune_unused_types_mark (arange_table[i], 1); 14237 14238 /* Get rid of nodes that aren't marked; and update the string counts. */ 14239 if (debug_str_hash) 14240 htab_empty (debug_str_hash); 14241 prune_unused_types_prune (comp_unit_die); 14242 for (node = limbo_die_list; node; node = node->next) 14243 prune_unused_types_prune (node->die); 14244 14245 /* Leave the marks clear. */ 14246 prune_unmark_dies (comp_unit_die); 14247 for (node = limbo_die_list; node; node = node->next) 14248 prune_unmark_dies (node->die); 14249} 14250 14251/* Set the parameter to true if there are any relative pathnames in 14252 the file table. */ 14253static int 14254file_table_relative_p (void ** slot, void *param) 14255{ 14256 bool *p = param; 14257 struct dwarf_file_data *d = *slot; 14258 if (d->emitted_number && d->filename[0] != DIR_SEPARATOR) 14259 { 14260 *p = true; 14261 return 0; 14262 } 14263 return 1; 14264} 14265 14266/* Output stuff that dwarf requires at the end of every file, 14267 and generate the DWARF-2 debugging info. */ 14268 14269static void 14270dwarf2out_finish (const char *filename) 14271{ 14272 limbo_die_node *node, *next_node; 14273 dw_die_ref die = 0; 14274 14275 /* Add the name for the main input file now. We delayed this from 14276 dwarf2out_init to avoid complications with PCH. */ 14277 add_name_attribute (comp_unit_die, filename); 14278 if (filename[0] != DIR_SEPARATOR) 14279 add_comp_dir_attribute (comp_unit_die); 14280 else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL) 14281 { 14282 bool p = false; 14283 htab_traverse (file_table, file_table_relative_p, &p); 14284 if (p) 14285 add_comp_dir_attribute (comp_unit_die); 14286 } 14287 14288 /* Traverse the limbo die list, and add parent/child links. The only 14289 dies without parents that should be here are concrete instances of 14290 inline functions, and the comp_unit_die. We can ignore the comp_unit_die. 14291 For concrete instances, we can get the parent die from the abstract 14292 instance. */ 14293 for (node = limbo_die_list; node; node = next_node) 14294 { 14295 next_node = node->next; 14296 die = node->die; 14297 14298 if (die->die_parent == NULL) 14299 { 14300 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin); 14301 14302 if (origin) 14303 add_child_die (origin->die_parent, die); 14304 else if (die == comp_unit_die) 14305 ; 14306 else if (errorcount > 0 || sorrycount > 0) 14307 /* It's OK to be confused by errors in the input. */ 14308 add_child_die (comp_unit_die, die); 14309 else 14310 { 14311 /* In certain situations, the lexical block containing a 14312 nested function can be optimized away, which results 14313 in the nested function die being orphaned. Likewise 14314 with the return type of that nested function. Force 14315 this to be a child of the containing function. 14316 14317 It may happen that even the containing function got fully 14318 inlined and optimized out. In that case we are lost and 14319 assign the empty child. This should not be big issue as 14320 the function is likely unreachable too. */ 14321 tree context = NULL_TREE; 14322 14323 gcc_assert (node->created_for); 14324 14325 if (DECL_P (node->created_for)) 14326 context = DECL_CONTEXT (node->created_for); 14327 else if (TYPE_P (node->created_for)) 14328 context = TYPE_CONTEXT (node->created_for); 14329 14330 gcc_assert (context 14331 && (TREE_CODE (context) == FUNCTION_DECL 14332 || TREE_CODE (context) == NAMESPACE_DECL)); 14333 14334 origin = lookup_decl_die (context); 14335 if (origin) 14336 add_child_die (origin, die); 14337 else 14338 add_child_die (comp_unit_die, die); 14339 } 14340 } 14341 } 14342 14343 limbo_die_list = NULL; 14344 14345 /* Walk through the list of incomplete types again, trying once more to 14346 emit full debugging info for them. */ 14347 retry_incomplete_types (); 14348 14349 if (flag_eliminate_unused_debug_types) 14350 prune_unused_types (); 14351 14352 /* Generate separate CUs for each of the include files we've seen. 14353 They will go into limbo_die_list. */ 14354 if (flag_eliminate_dwarf2_dups) 14355 break_out_includes (comp_unit_die); 14356 14357 /* Traverse the DIE's and add add sibling attributes to those DIE's 14358 that have children. */ 14359 add_sibling_attributes (comp_unit_die); 14360 for (node = limbo_die_list; node; node = node->next) 14361 add_sibling_attributes (node->die); 14362 14363 /* Output a terminator label for the .text section. */ 14364 switch_to_section (text_section); 14365 targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0); 14366 if (flag_reorder_blocks_and_partition) 14367 { 14368 switch_to_section (unlikely_text_section ()); 14369 targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0); 14370 } 14371 14372 /* We can only use the low/high_pc attributes if all of the code was 14373 in .text. */ 14374 if (!have_multiple_function_sections) 14375 { 14376 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label); 14377 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label); 14378 } 14379 14380 /* If it wasn't, we need to give .debug_loc and .debug_ranges an appropriate 14381 "base address". Use zero so that these addresses become absolute. */ 14382 else if (have_location_lists || ranges_table_in_use) 14383 add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx); 14384 14385 /* Output location list section if necessary. */ 14386 if (have_location_lists) 14387 { 14388 /* Output the location lists info. */ 14389 switch_to_section (debug_loc_section); 14390 ASM_GENERATE_INTERNAL_LABEL (loc_section_label, 14391 DEBUG_LOC_SECTION_LABEL, 0); 14392 ASM_OUTPUT_LABEL (asm_out_file, loc_section_label); 14393 output_location_lists (die); 14394 } 14395 14396 if (debug_info_level >= DINFO_LEVEL_NORMAL) 14397 add_AT_lineptr (comp_unit_die, DW_AT_stmt_list, 14398 debug_line_section_label); 14399 14400 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 14401 add_AT_macptr (comp_unit_die, DW_AT_macro_info, macinfo_section_label); 14402 14403 /* Output all of the compilation units. We put the main one last so that 14404 the offsets are available to output_pubnames. */ 14405 for (node = limbo_die_list; node; node = node->next) 14406 output_comp_unit (node->die, 0); 14407 14408 output_comp_unit (comp_unit_die, 0); 14409 14410 /* Output the abbreviation table. */ 14411 switch_to_section (debug_abbrev_section); 14412 output_abbrev_section (); 14413 14414 /* Output public names table if necessary. */ 14415 if (pubname_table_in_use) 14416 { 14417 switch_to_section (debug_pubnames_section); 14418 output_pubnames (); 14419 } 14420 14421 /* Output the address range information. We only put functions in the arange 14422 table, so don't write it out if we don't have any. */ 14423 if (fde_table_in_use) 14424 { 14425 switch_to_section (debug_aranges_section); 14426 output_aranges (); 14427 } 14428 14429 /* Output ranges section if necessary. */ 14430 if (ranges_table_in_use) 14431 { 14432 switch_to_section (debug_ranges_section); 14433 ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label); 14434 output_ranges (); 14435 } 14436 14437 /* Output the source line correspondence table. We must do this 14438 even if there is no line information. Otherwise, on an empty 14439 translation unit, we will generate a present, but empty, 14440 .debug_info section. IRIX 6.5 `nm' will then complain when 14441 examining the file. This is done late so that any filenames 14442 used by the debug_info section are marked as 'used'. */ 14443 if (! DWARF2_ASM_LINE_DEBUG_INFO) 14444 { 14445 switch_to_section (debug_line_section); 14446 output_line_info (); 14447 } 14448 14449 /* Have to end the macro section. */ 14450 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 14451 { 14452 switch_to_section (debug_macinfo_section); 14453 dw2_asm_output_data (1, 0, "End compilation unit"); 14454 } 14455 14456 /* If we emitted any DW_FORM_strp form attribute, output the string 14457 table too. */ 14458 if (debug_str_hash) 14459 htab_traverse (debug_str_hash, output_indirect_string, NULL); 14460} 14461#else 14462 14463/* This should never be used, but its address is needed for comparisons. */ 14464const struct gcc_debug_hooks dwarf2_debug_hooks; 14465 14466#endif /* DWARF2_DEBUGGING_INFO */ 14467 14468#include "gt-dwarf2out.h" 14469