gcc/dwarf2out.c

   1 /* Output Dwarf2 format symbol table information from GCC.
   2    Copyright (C) 1992, 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
   3    2003, 2004, 2005 Free Software Foundation, Inc.
   4    Contributed by Gary Funck (gary@intrepid.com).
   5    Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
   6    Extensively modified by Jason Merrill (jason@cygnus.com).
   7
   8 This file is part of GCC.
   9
  10 GCC is free software; you can redistribute it and/or modify it under
  11 the terms of the GNU General Public License as published by the Free
  12 Software Foundation; either version 2, or (at your option) any later
  13 version.
  14
  15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  17 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  18 for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with GCC; see the file COPYING.  If not, write to the Free
  22 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  23 02111-1307, USA.  */
  24
  25 /* TODO: Emit .debug_line header even when there are no functions, since
  26            the file numbers are used by .debug_info.  Alternately, leave
  27            out locations for types and decls.
  28          Avoid talking about ctors and op= for PODs.
  29          Factor out common prologue sequences into multiple CIEs.  */
  30
  31 /* The first part of this file deals with the DWARF 2 frame unwind
  32    information, which is also used by the GCC efficient exception handling
  33    mechanism.  The second part, controlled only by an #ifdef
  34    DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
  35    information.  */
  36
  37 #include "config.h"
  38 #include "system.h"
  39 #include "coretypes.h"
  40 #include "tm.h"
  41 #include "tree.h"
  42 #include "version.h"
  43 #include "flags.h"
  44 #include "real.h"
  45 #include "rtl.h"
  46 #include "hard-reg-set.h"
  47 #include "regs.h"
  48 #include "insn-config.h"
  49 #include "reload.h"
  50 #include "function.h"
  51 #include "output.h"
  52 #include "expr.h"
  53 #include "libfuncs.h"
  54 #include "except.h"
  55 #include "dwarf2.h"
  56 #include "dwarf2out.h"
  57 #include "dwarf2asm.h"
  58 #include "toplev.h"
  59 #include "varray.h"
  60 #include "ggc.h"
  61 #include "md5.h"
  62 #include "tm_p.h"
  63 #include "diagnostic.h"
  64 #include "debug.h"
  65 #include "target.h"
  66 #include "langhooks.h"
  67 #include "hashtab.h"
  68 #include "cgraph.h"
  69 #include "input.h"
  70
  71 #ifdef DWARF2_DEBUGGING_INFO
  72 static void dwarf2out_source_line (unsigned int, const char *);
  73 #endif
  74
  75 /* DWARF2 Abbreviation Glossary:
  76    CFA = Canonical Frame Address
  77            a fixed address on the stack which identifies a call frame.
  78            We define it to be the value of SP just before the call insn.
  79            The CFA register and offset, which may change during the course
  80            of the function, are used to calculate its value at runtime.
  81    CFI = Call Frame Instruction
  82            an instruction for the DWARF2 abstract machine
  83    CIE = Common Information Entry
  84            information describing information common to one or more FDEs
  85    DIE = Debugging Information Entry
  86    FDE = Frame Description Entry
  87            information describing the stack call frame, in particular,
  88            how to restore registers
  89
  90    DW_CFA_... = DWARF2 CFA call frame instruction
  91    DW_TAG_... = DWARF2 DIE tag */
  92
  93 /* Decide whether we want to emit frame unwind information for the current
  94    translation unit.  */
  95
  96 int
  97 dwarf2out_do_frame (void)
  98 {
  99   return (write_symbols == DWARF2_DEBUG
 100           || write_symbols == VMS_AND_DWARF2_DEBUG
 101 #ifdef DWARF2_FRAME_INFO
 102           || DWARF2_FRAME_INFO
 103 #endif
 104 #ifdef DWARF2_UNWIND_INFO
 105           || flag_unwind_tables
 106           || (flag_exceptions && ! USING_SJLJ_EXCEPTIONS)
 107 #endif
 108           );
 109 }
 110
 111 /* The size of the target's pointer type.  */
 112 #ifndef PTR_SIZE
 113 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
 114 #endif
 115
 116 /* Various versions of targetm.eh_frame_section.  Note these must appear
 117    outside the DWARF2_DEBUGGING_INFO || DWARF2_UNWIND_INFO macro guards.  */
 118
 119 /* Version of targetm.eh_frame_section for systems with named sections.  */
 120 void
 121 named_section_eh_frame_section (void)
 122 {
 123 #ifdef EH_FRAME_SECTION_NAME
 124   int flags;
 125
 126   if (EH_TABLES_CAN_BE_READ_ONLY)
 127     {
 128       int fde_encoding;
 129       int per_encoding;
 130       int lsda_encoding;
 131
 132       fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
 133       per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
 134       lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
 135       flags = (! flag_pic
 136                || ((fde_encoding & 0x70) != DW_EH_PE_absptr
 137                    && (fde_encoding & 0x70) != DW_EH_PE_aligned
 138                    && (per_encoding & 0x70) != DW_EH_PE_absptr
 139                    && (per_encoding & 0x70) != DW_EH_PE_aligned
 140                    && (lsda_encoding & 0x70) != DW_EH_PE_absptr
 141                    && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
 142               ? 0 : SECTION_WRITE;
 143     }
 144   else
 145     flags = SECTION_WRITE;
 146   named_section_flags (EH_FRAME_SECTION_NAME, flags);
 147 #endif
 148 }
 149
 150 /* Version of targetm.eh_frame_section for systems using collect2.  */
 151 void
 152 collect2_eh_frame_section (void)
 153 {
 154   tree label = get_file_function_name ('F');
 155
 156   data_section ();
 157   ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
 158   targetm.asm_out.globalize_label (asm_out_file, IDENTIFIER_POINTER (label));
 159   ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
 160 }
 161
 162 /* Default version of targetm.eh_frame_section.  */
 163 void
 164 default_eh_frame_section (void)
 165 {
 166 #ifdef EH_FRAME_SECTION_NAME
 167   named_section_eh_frame_section ();
 168 #else
 169   collect2_eh_frame_section ();
 170 #endif
 171 }
 172
 173 /* Array of RTXes referenced by the debugging information, which therefore
 174    must be kept around forever.  */
 175 static GTY(()) varray_type used_rtx_varray;
 176
 177 /* A pointer to the base of a list of incomplete types which might be
 178    completed at some later time.  incomplete_types_list needs to be a VARRAY
 179    because we want to tell the garbage collector about it.  */
 180 static GTY(()) varray_type incomplete_types;
 181
 182 /* A pointer to the base of a table of references to declaration
 183    scopes.  This table is a display which tracks the nesting
 184    of declaration scopes at the current scope and containing
 185    scopes.  This table is used to find the proper place to
 186    define type declaration DIE's.  */
 187 static GTY(()) varray_type decl_scope_table;
 188
 189 /* How to start an assembler comment.  */
 190 #ifndef ASM_COMMENT_START
 191 #define ASM_COMMENT_START ";#"
 192 #endif
 193
 194 typedef struct dw_cfi_struct *dw_cfi_ref;
 195 typedef struct dw_fde_struct *dw_fde_ref;
 196 typedef union  dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
 197
 198 /* Call frames are described using a sequence of Call Frame
 199    Information instructions.  The register number, offset
 200    and address fields are provided as possible operands;
 201    their use is selected by the opcode field.  */
 202
 203 enum dw_cfi_oprnd_type {
 204   dw_cfi_oprnd_unused,
 205   dw_cfi_oprnd_reg_num,
 206   dw_cfi_oprnd_offset,
 207   dw_cfi_oprnd_addr,
 208   dw_cfi_oprnd_loc
 209 };
 210
 211 typedef union dw_cfi_oprnd_struct GTY(())
 212 {
 213   unsigned long GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
 214   HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
 215   const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;
 216   struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
 217 }
 218 dw_cfi_oprnd;
 219
 220 typedef struct dw_cfi_struct GTY(())
 221 {
 222   dw_cfi_ref dw_cfi_next;
 223   enum dwarf_call_frame_info dw_cfi_opc;
 224   dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
 225     dw_cfi_oprnd1;
 226   dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
 227     dw_cfi_oprnd2;
 228 }
 229 dw_cfi_node;
 230
 231 /* This is how we define the location of the CFA. We use to handle it
 232    as REG + OFFSET all the time,  but now it can be more complex.
 233    It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
 234    Instead of passing around REG and OFFSET, we pass a copy
 235    of this structure.  */
 236 typedef struct cfa_loc GTY(())
 237 {
 238   unsigned long reg;
 239   HOST_WIDE_INT offset;
 240   HOST_WIDE_INT base_offset;
 241   int indirect;            /* 1 if CFA is accessed via a dereference.  */
 242 } dw_cfa_location;
 243
 244 /* All call frame descriptions (FDE's) in the GCC generated DWARF
 245    refer to a single Common Information Entry (CIE), defined at
 246    the beginning of the .debug_frame section.  This use of a single
 247    CIE obviates the need to keep track of multiple CIE's
 248    in the DWARF generation routines below.  */
 249
 250 typedef struct dw_fde_struct GTY(())
 251 {
 252   tree decl;
 253   const char *dw_fde_begin;
 254   const char *dw_fde_current_label;
 255   const char *dw_fde_end;
 256   const char *dw_fde_hot_section_label;
 257   const char *dw_fde_hot_section_end_label;
 258   const char *dw_fde_unlikely_section_label;
 259   const char *dw_fde_unlikely_section_end_label;
 260   bool dw_fde_switched_sections;
 261   dw_cfi_ref dw_fde_cfi;
 262   unsigned funcdef_number;
 263   unsigned all_throwers_are_sibcalls : 1;
 264   unsigned nothrow : 1;
 265   unsigned uses_eh_lsda : 1;
 266 }
 267 dw_fde_node;
 268
 269 /* Maximum size (in bytes) of an artificially generated label.  */
 270 #define MAX_ARTIFICIAL_LABEL_BYTES      30
 271
 272 /* The size of addresses as they appear in the Dwarf 2 data.
 273    Some architectures use word addresses to refer to code locations,
 274    but Dwarf 2 info always uses byte addresses.  On such machines,
 275    Dwarf 2 addresses need to be larger than the architecture's
 276    pointers.  */
 277 #ifndef DWARF2_ADDR_SIZE
 278 #define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
 279 #endif
 280
 281 /* The size in bytes of a DWARF field indicating an offset or length
 282    relative to a debug info section, specified to be 4 bytes in the
 283    DWARF-2 specification.  The SGI/MIPS ABI defines it to be the same
 284    as PTR_SIZE.  */
 285
 286 #ifndef DWARF_OFFSET_SIZE
 287 #define DWARF_OFFSET_SIZE 4
 288 #endif
 289
 290 /* According to the (draft) DWARF 3 specification, the initial length
 291    should either be 4 or 12 bytes.  When it's 12 bytes, the first 4
 292    bytes are 0xffffffff, followed by the length stored in the next 8
 293    bytes.
 294
 295    However, the SGI/MIPS ABI uses an initial length which is equal to
 296    DWARF_OFFSET_SIZE.  It is defined (elsewhere) accordingly.  */
 297
 298 #ifndef DWARF_INITIAL_LENGTH_SIZE
 299 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
 300 #endif
 301
 302 #define DWARF_VERSION 2
 303
 304 /* Round SIZE up to the nearest BOUNDARY.  */
 305 #define DWARF_ROUND(SIZE,BOUNDARY) \
 306   ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
 307
 308 /* Offsets recorded in opcodes are a multiple of this alignment factor.  */
 309 #ifndef DWARF_CIE_DATA_ALIGNMENT
 310 #ifdef STACK_GROWS_DOWNWARD
 311 #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
 312 #else
 313 #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
 314 #endif
 315 #endif
 316
 317 /* A pointer to the base of a table that contains frame description
 318    information for each routine.  */
 319 static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table;
 320
 321 /* Number of elements currently allocated for fde_table.  */
 322 static GTY(()) unsigned fde_table_allocated;
 323
 324 /* Number of elements in fde_table currently in use.  */
 325 static GTY(()) unsigned fde_table_in_use;
 326
 327 /* Size (in elements) of increments by which we may expand the
 328    fde_table.  */
 329 #define FDE_TABLE_INCREMENT 256
 330
 331 /* A list of call frame insns for the CIE.  */
 332 static GTY(()) dw_cfi_ref cie_cfi_head;
 333
 334 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
 335 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
 336    attribute that accelerates the lookup of the FDE associated
 337    with the subprogram.  This variable holds the table index of the FDE
 338    associated with the current function (body) definition.  */
 339 static unsigned current_funcdef_fde;
 340 #endif
 341
 342 struct indirect_string_node GTY(())
 343 {
 344   const char *str;
 345   unsigned int refcount;
 346   unsigned int form;
 347   char *label;
 348 };
 349
 350 static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;
 351
 352 static GTY(()) int dw2_string_counter;
 353 static GTY(()) unsigned long dwarf2out_cfi_label_num;
 354
 355 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
 356
 357 /* Forward declarations for functions defined in this file.  */
 358
 359 static char *stripattributes (const char *);
 360 static const char *dwarf_cfi_name (unsigned);
 361 static dw_cfi_ref new_cfi (void);
 362 static void add_cfi (dw_cfi_ref *, dw_cfi_ref);
 363 static void add_fde_cfi (const char *, dw_cfi_ref);
 364 static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *);
 365 static void lookup_cfa (dw_cfa_location *);
 366 static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT);
 367 static void initial_return_save (rtx);
 368 static HOST_WIDE_INT stack_adjust_offset (rtx);
 369 static void output_cfi (dw_cfi_ref, dw_fde_ref, int);
 370 static void output_call_frame_info (int);
 371 static void dwarf2out_stack_adjust (rtx, bool);
 372 static void flush_queued_reg_saves (void);
 373 static bool clobbers_queued_reg_save (rtx);
 374 static void dwarf2out_frame_debug_expr (rtx, const char *);
 375
 376 /* Support for complex CFA locations.  */
 377 static void output_cfa_loc (dw_cfi_ref);
 378 static void get_cfa_from_loc_descr (dw_cfa_location *,
 379                                     struct dw_loc_descr_struct *);
 380 static struct dw_loc_descr_struct *build_cfa_loc
 381  (dw_cfa_location *);
 382 static void def_cfa_1 (const char *, dw_cfa_location *);
 383
 384 /* How to start an assembler comment.  */
 385 #ifndef ASM_COMMENT_START
 386 #define ASM_COMMENT_START ";#"
 387 #endif
 388
 389 /* Data and reference forms for relocatable data.  */
 390 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
 391 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
 392
 393 #ifndef DEBUG_FRAME_SECTION
 394 #define DEBUG_FRAME_SECTION     ".debug_frame"
 395 #endif
 396
 397 #ifndef FUNC_BEGIN_LABEL
 398 #define FUNC_BEGIN_LABEL        "LFB"
 399 #endif
 400
 401 #ifndef FUNC_END_LABEL
 402 #define FUNC_END_LABEL          "LFE"
 403 #endif
 404
 405 #ifndef FRAME_BEGIN_LABEL
 406 #define FRAME_BEGIN_LABEL       "Lframe"
 407 #endif
 408 #define CIE_AFTER_SIZE_LABEL    "LSCIE"
 409 #define CIE_END_LABEL           "LECIE"
 410 #define FDE_LABEL               "LSFDE"
 411 #define FDE_AFTER_SIZE_LABEL    "LASFDE"
 412 #define FDE_END_LABEL           "LEFDE"
 413 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
 414 #define LINE_NUMBER_END_LABEL   "LELT"
 415 #define LN_PROLOG_AS_LABEL      "LASLTP"
 416 #define LN_PROLOG_END_LABEL     "LELTP"
 417 #define DIE_LABEL_PREFIX        "DW"
 418
 419 /* The DWARF 2 CFA column which tracks the return address.  Normally this
 420    is the column for PC, or the first column after all of the hard
 421    registers.  */
 422 #ifndef DWARF_FRAME_RETURN_COLUMN
 423 #ifdef PC_REGNUM
 424 #define DWARF_FRAME_RETURN_COLUMN       DWARF_FRAME_REGNUM (PC_REGNUM)
 425 #else
 426 #define DWARF_FRAME_RETURN_COLUMN       DWARF_FRAME_REGISTERS
 427 #endif
 428 #endif
 429
 430 /* The mapping from gcc register number to DWARF 2 CFA column number.  By
 431    default, we just provide columns for all registers.  */
 432 #ifndef DWARF_FRAME_REGNUM
 433 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
 434 #endif
 435
 436 /* The offset from the incoming value of %sp to the top of the stack frame
 437    for the current function.  */
 438 #ifndef INCOMING_FRAME_SP_OFFSET
 439 #define INCOMING_FRAME_SP_OFFSET 0
 440 #endif
 441 \f
 442 /* Hook used by __throw.  */
 443
 444 rtx
 445 expand_builtin_dwarf_sp_column (void)
 446 {
 447   return GEN_INT (DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
 448 }
 449
 450 /* Return a pointer to a copy of the section string name S with all
 451    attributes stripped off, and an asterisk prepended (for assemble_name).  */
 452
 453 static inline char *
 454 stripattributes (const char *s)
 455 {
 456   char *stripped = xmalloc (strlen (s) + 2);
 457   char *p = stripped;
 458
 459   *p++ = '*';
 460
 461   while (*s && *s != ',')
 462     *p++ = *s++;
 463
 464   *p = '\0';
 465   return stripped;
 466 }
 467
 468 /* Generate code to initialize the register size table.  */
 469
 470 void
 471 expand_builtin_init_dwarf_reg_sizes (tree address)
 472 {
 473   int i;
 474   enum machine_mode mode = TYPE_MODE (char_type_node);
 475   rtx addr = expand_expr (address, NULL_RTX, VOIDmode, 0);
 476   rtx mem = gen_rtx_MEM (BLKmode, addr);
 477   bool wrote_return_column = false;
 478
 479   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 480     if (DWARF_FRAME_REGNUM (i) < DWARF_FRAME_REGISTERS)
 481       {
 482         HOST_WIDE_INT offset = DWARF_FRAME_REGNUM (i) * GET_MODE_SIZE (mode);
 483         enum machine_mode save_mode = reg_raw_mode[i];
 484         HOST_WIDE_INT size;
 485
 486         if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode))
 487           save_mode = choose_hard_reg_mode (i, 1, true);
 488         if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
 489           {
 490             if (save_mode == VOIDmode)
 491               continue;
 492             wrote_return_column = true;
 493           }
 494         size = GET_MODE_SIZE (save_mode);
 495         if (offset < 0)
 496           continue;
 497
 498         emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size));
 499       }
 500
 501 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
 502   gcc_assert (wrote_return_column);
 503   i = DWARF_ALT_FRAME_RETURN_COLUMN;
 504   wrote_return_column = false;
 505 #else
 506   i = DWARF_FRAME_RETURN_COLUMN;
 507 #endif
 508
 509   if (! wrote_return_column)
 510     {
 511       enum machine_mode save_mode = Pmode;
 512       HOST_WIDE_INT offset = i * GET_MODE_SIZE (mode);
 513       HOST_WIDE_INT size = GET_MODE_SIZE (save_mode);
 514       emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size));
 515     }
 516 }
 517
 518 /* Convert a DWARF call frame info. operation to its string name */
 519
 520 static const char *
 521 dwarf_cfi_name (unsigned int cfi_opc)
 522 {
 523   switch (cfi_opc)
 524     {
 525     case DW_CFA_advance_loc:
 526       return "DW_CFA_advance_loc";
 527     case DW_CFA_offset:
 528       return "DW_CFA_offset";
 529     case DW_CFA_restore:
 530       return "DW_CFA_restore";
 531     case DW_CFA_nop:
 532       return "DW_CFA_nop";
 533     case DW_CFA_set_loc:
 534       return "DW_CFA_set_loc";
 535     case DW_CFA_advance_loc1:
 536       return "DW_CFA_advance_loc1";
 537     case DW_CFA_advance_loc2:
 538       return "DW_CFA_advance_loc2";
 539     case DW_CFA_advance_loc4:
 540       return "DW_CFA_advance_loc4";
 541     case DW_CFA_offset_extended:
 542       return "DW_CFA_offset_extended";
 543     case DW_CFA_restore_extended:
 544       return "DW_CFA_restore_extended";
 545     case DW_CFA_undefined:
 546       return "DW_CFA_undefined";
 547     case DW_CFA_same_value:
 548       return "DW_CFA_same_value";
 549     case DW_CFA_register:
 550       return "DW_CFA_register";
 551     case DW_CFA_remember_state:
 552       return "DW_CFA_remember_state";
 553     case DW_CFA_restore_state:
 554       return "DW_CFA_restore_state";
 555     case DW_CFA_def_cfa:
 556       return "DW_CFA_def_cfa";
 557     case DW_CFA_def_cfa_register:
 558       return "DW_CFA_def_cfa_register";
 559     case DW_CFA_def_cfa_offset:
 560       return "DW_CFA_def_cfa_offset";
 561
 562     /* DWARF 3 */
 563     case DW_CFA_def_cfa_expression:
 564       return "DW_CFA_def_cfa_expression";
 565     case DW_CFA_expression:
 566       return "DW_CFA_expression";
 567     case DW_CFA_offset_extended_sf:
 568       return "DW_CFA_offset_extended_sf";
 569     case DW_CFA_def_cfa_sf:
 570       return "DW_CFA_def_cfa_sf";
 571     case DW_CFA_def_cfa_offset_sf:
 572       return "DW_CFA_def_cfa_offset_sf";
 573
 574     /* SGI/MIPS specific */
 575     case DW_CFA_MIPS_advance_loc8:
 576       return "DW_CFA_MIPS_advance_loc8";
 577
 578     /* GNU extensions */
 579     case DW_CFA_GNU_window_save:
 580       return "DW_CFA_GNU_window_save";
 581     case DW_CFA_GNU_args_size:
 582       return "DW_CFA_GNU_args_size";
 583     case DW_CFA_GNU_negative_offset_extended:
 584       return "DW_CFA_GNU_negative_offset_extended";
 585
 586     default:
 587       return "DW_CFA_<unknown>";
 588     }
 589 }
 590
 591 /* Return a pointer to a newly allocated Call Frame Instruction.  */
 592
 593 static inline dw_cfi_ref
 594 new_cfi (void)
 595 {
 596   dw_cfi_ref cfi = ggc_alloc (sizeof (dw_cfi_node));
 597
 598   cfi->dw_cfi_next = NULL;
 599   cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
 600   cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
 601
 602   return cfi;
 603 }
 604
 605 /* Add a Call Frame Instruction to list of instructions.  */
 606
 607 static inline void
 608 add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi)
 609 {
 610   dw_cfi_ref *p;
 611
 612   /* Find the end of the chain.  */
 613   for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
 614     ;
 615
 616   *p = cfi;
 617 }
 618
 619 /* Generate a new label for the CFI info to refer to.  */
 620
 621 char *
 622 dwarf2out_cfi_label (void)
 623 {
 624   static char label[20];
 625
 626   ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", dwarf2out_cfi_label_num++);
 627   ASM_OUTPUT_LABEL (asm_out_file, label);
 628   return label;
 629 }
 630
 631 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
 632    or to the CIE if LABEL is NULL.  */
 633
 634 static void
 635 add_fde_cfi (const char *label, dw_cfi_ref cfi)
 636 {
 637   if (label)
 638     {
 639       dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
 640
 641       if (*label == 0)
 642         label = dwarf2out_cfi_label ();
 643
 644       if (fde->dw_fde_current_label == NULL
 645           || strcmp (label, fde->dw_fde_current_label) != 0)
 646         {
 647           dw_cfi_ref xcfi;
 648
 649           fde->dw_fde_current_label = label = xstrdup (label);
 650
 651           /* Set the location counter to the new label.  */
 652           xcfi = new_cfi ();
 653           xcfi->dw_cfi_opc = DW_CFA_advance_loc4;
 654           xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
 655           add_cfi (&fde->dw_fde_cfi, xcfi);
 656         }
 657
 658       add_cfi (&fde->dw_fde_cfi, cfi);
 659     }
 660
 661   else
 662     add_cfi (&cie_cfi_head, cfi);
 663 }
 664
 665 /* Subroutine of lookup_cfa.  */
 666
 667 static inline void
 668 lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc)
 669 {
 670   switch (cfi->dw_cfi_opc)
 671     {
 672     case DW_CFA_def_cfa_offset:
 673       loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset;
 674       break;
 675     case DW_CFA_def_cfa_register:
 676       loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
 677       break;
 678     case DW_CFA_def_cfa:
 679       loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
 680       loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset;
 681       break;
 682     case DW_CFA_def_cfa_expression:
 683       get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc);
 684       break;
 685     default:
 686       break;
 687     }
 688 }
 689
 690 /* Find the previous value for the CFA.  */
 691
 692 static void
 693 lookup_cfa (dw_cfa_location *loc)
 694 {
 695   dw_cfi_ref cfi;
 696
 697   loc->reg = (unsigned long) -1;
 698   loc->offset = 0;
 699   loc->indirect = 0;
 700   loc->base_offset = 0;
 701
 702   for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
 703     lookup_cfa_1 (cfi, loc);
 704
 705   if (fde_table_in_use)
 706     {
 707       dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
 708       for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
 709         lookup_cfa_1 (cfi, loc);
 710     }
 711 }
 712
 713 /* The current rule for calculating the DWARF2 canonical frame address.  */
 714 static dw_cfa_location cfa;
 715
 716 /* The register used for saving registers to the stack, and its offset
 717    from the CFA.  */
 718 static dw_cfa_location cfa_store;
 719
 720 /* The running total of the size of arguments pushed onto the stack.  */
 721 static HOST_WIDE_INT args_size;
 722
 723 /* The last args_size we actually output.  */
 724 static HOST_WIDE_INT old_args_size;
 725
 726 /* Entry point to update the canonical frame address (CFA).
 727    LABEL is passed to add_fde_cfi.  The value of CFA is now to be
 728    calculated from REG+OFFSET.  */
 729
 730 void
 731 dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset)
 732 {
 733   dw_cfa_location loc;
 734   loc.indirect = 0;
 735   loc.base_offset = 0;
 736   loc.reg = reg;
 737   loc.offset = offset;
 738   def_cfa_1 (label, &loc);
 739 }
 740
 741 /* This routine does the actual work.  The CFA is now calculated from
 742    the dw_cfa_location structure.  */
 743
 744 static void
 745 def_cfa_1 (const char *label, dw_cfa_location *loc_p)
 746 {
 747   dw_cfi_ref cfi;
 748   dw_cfa_location old_cfa, loc;
 749
 750   cfa = *loc_p;
 751   loc = *loc_p;
 752
 753   if (cfa_store.reg == loc.reg && loc.indirect == 0)
 754     cfa_store.offset = loc.offset;
 755
 756   loc.reg = DWARF_FRAME_REGNUM (loc.reg);
 757   lookup_cfa (&old_cfa);
 758
 759   /* If nothing changed, no need to issue any call frame instructions.  */
 760   if (loc.reg == old_cfa.reg && loc.offset == old_cfa.offset
 761       && loc.indirect == old_cfa.indirect
 762       && (loc.indirect == 0 || loc.base_offset == old_cfa.base_offset))
 763     return;
 764
 765   cfi = new_cfi ();
 766
 767   if (loc.reg == old_cfa.reg && !loc.indirect)
 768     {
 769       /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction,
 770          indicating the CFA register did not change but the offset
 771          did.  */
 772       cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
 773       cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset;
 774     }
 775
 776 #ifndef MIPS_DEBUGGING_INFO  /* SGI dbx thinks this means no offset.  */
 777   else if (loc.offset == old_cfa.offset && old_cfa.reg != (unsigned long) -1
 778            && !loc.indirect)
 779     {
 780       /* Construct a "DW_CFA_def_cfa_register <register>" instruction,
 781          indicating the CFA register has changed to <register> but the
 782          offset has not changed.  */
 783       cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
 784       cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
 785     }
 786 #endif
 787
 788   else if (loc.indirect == 0)
 789     {
 790       /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
 791          indicating the CFA register has changed to <register> with
 792          the specified offset.  */
 793       cfi->dw_cfi_opc = DW_CFA_def_cfa;
 794       cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
 795       cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset;
 796     }
 797   else
 798     {
 799       /* Construct a DW_CFA_def_cfa_expression instruction to
 800          calculate the CFA using a full location expression since no
 801          register-offset pair is available.  */
 802       struct dw_loc_descr_struct *loc_list;
 803
 804       cfi->dw_cfi_opc = DW_CFA_def_cfa_expression;
 805       loc_list = build_cfa_loc (&loc);
 806       cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list;
 807     }
 808
 809   add_fde_cfi (label, cfi);
 810 }
 811
 812 /* Add the CFI for saving a register.  REG is the CFA column number.
 813    LABEL is passed to add_fde_cfi.
 814    If SREG is -1, the register is saved at OFFSET from the CFA;
 815    otherwise it is saved in SREG.  */
 816
 817 static void
 818 reg_save (const char *label, unsigned int reg, unsigned int sreg, HOST_WIDE_INT offset)
 819 {
 820   dw_cfi_ref cfi = new_cfi ();
 821
 822   cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
 823
 824   if (sreg == INVALID_REGNUM)
 825     {
 826       if (reg & ~0x3f)
 827         /* The register number won't fit in 6 bits, so we have to use
 828            the long form.  */
 829         cfi->dw_cfi_opc = DW_CFA_offset_extended;
 830       else
 831         cfi->dw_cfi_opc = DW_CFA_offset;
 832
 833 #ifdef ENABLE_CHECKING
 834       {
 835         /* If we get an offset that is not a multiple of
 836            DWARF_CIE_DATA_ALIGNMENT, there is either a bug in the
 837            definition of DWARF_CIE_DATA_ALIGNMENT, or a bug in the machine
 838            description.  */
 839         HOST_WIDE_INT check_offset = offset / DWARF_CIE_DATA_ALIGNMENT;
 840
 841         gcc_assert (check_offset * DWARF_CIE_DATA_ALIGNMENT == offset);
 842       }
 843 #endif
 844       offset /= DWARF_CIE_DATA_ALIGNMENT;
 845       if (offset < 0)
 846         cfi->dw_cfi_opc = DW_CFA_offset_extended_sf;
 847
 848       cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
 849     }
 850   else if (sreg == reg)
 851     cfi->dw_cfi_opc = DW_CFA_same_value;
 852   else
 853     {
 854       cfi->dw_cfi_opc = DW_CFA_register;
 855       cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
 856     }
 857
 858   add_fde_cfi (label, cfi);
 859 }
 860
 861 /* Add the CFI for saving a register window.  LABEL is passed to reg_save.
 862    This CFI tells the unwinder that it needs to restore the window registers
 863    from the previous frame's window save area.
 864
 865    ??? Perhaps we should note in the CIE where windows are saved (instead of
 866    assuming 0(cfa)) and what registers are in the window.  */
 867
 868 void
 869 dwarf2out_window_save (const char *label)
 870 {
 871   dw_cfi_ref cfi = new_cfi ();
 872
 873   cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
 874   add_fde_cfi (label, cfi);
 875 }
 876
 877 /* Add a CFI to update the running total of the size of arguments
 878    pushed onto the stack.  */
 879
 880 void
 881 dwarf2out_args_size (const char *label, HOST_WIDE_INT size)
 882 {
 883   dw_cfi_ref cfi;
 884
 885   if (size == old_args_size)
 886     return;
 887
 888   old_args_size = size;
 889
 890   cfi = new_cfi ();
 891   cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
 892   cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
 893   add_fde_cfi (label, cfi);
 894 }
 895
 896 /* Entry point for saving a register to the stack.  REG is the GCC register
 897    number.  LABEL and OFFSET are passed to reg_save.  */
 898
 899 void
 900 dwarf2out_reg_save (const char *label, unsigned int reg, HOST_WIDE_INT offset)
 901 {
 902   reg_save (label, DWARF_FRAME_REGNUM (reg), INVALID_REGNUM, offset);
 903 }
 904
 905 /* Entry point for saving the return address in the stack.
 906    LABEL and OFFSET are passed to reg_save.  */
 907
 908 void
 909 dwarf2out_return_save (const char *label, HOST_WIDE_INT offset)
 910 {
 911   reg_save (label, DWARF_FRAME_RETURN_COLUMN, INVALID_REGNUM, offset);
 912 }
 913
 914 /* Entry point for saving the return address in a register.
 915    LABEL and SREG are passed to reg_save.  */
 916
 917 void
 918 dwarf2out_return_reg (const char *label, unsigned int sreg)
 919 {
 920   reg_save (label, DWARF_FRAME_RETURN_COLUMN, DWARF_FRAME_REGNUM (sreg), 0);
 921 }
 922
 923 /* Record the initial position of the return address.  RTL is
 924    INCOMING_RETURN_ADDR_RTX.  */
 925
 926 static void
 927 initial_return_save (rtx rtl)
 928 {
 929   unsigned int reg = INVALID_REGNUM;
 930   HOST_WIDE_INT offset = 0;
 931
 932   switch (GET_CODE (rtl))
 933     {
 934     case REG:
 935       /* RA is in a register.  */
 936       reg = DWARF_FRAME_REGNUM (REGNO (rtl));
 937       break;
 938
 939     case MEM:
 940       /* RA is on the stack.  */
 941       rtl = XEXP (rtl, 0);
 942       switch (GET_CODE (rtl))
 943         {
 944         case REG:
 945           gcc_assert (REGNO (rtl) == STACK_POINTER_REGNUM);
 946           offset = 0;
 947           break;
 948
 949         case PLUS:
 950           gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
 951           offset = INTVAL (XEXP (rtl, 1));
 952           break;
 953
 954         case MINUS:
 955           gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
 956           offset = -INTVAL (XEXP (rtl, 1));
 957           break;
 958
 959         default:
 960           gcc_unreachable ();
 961         }
 962
 963       break;
 964
 965     case PLUS:
 966       /* The return address is at some offset from any value we can
 967          actually load.  For instance, on the SPARC it is in %i7+8. Just
 968          ignore the offset for now; it doesn't matter for unwinding frames.  */
 969       gcc_assert (GET_CODE (XEXP (rtl, 1)) == CONST_INT);
 970       initial_return_save (XEXP (rtl, 0));
 971       return;
 972
 973     default:
 974       gcc_unreachable ();
 975     }
 976
 977   if (reg != DWARF_FRAME_RETURN_COLUMN)
 978     reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset);
 979 }
 980
 981 /* Given a SET, calculate the amount of stack adjustment it
 982    contains.  */
 983
 984 static HOST_WIDE_INT
 985 stack_adjust_offset (rtx pattern)
 986 {
 987   rtx src = SET_SRC (pattern);
 988   rtx dest = SET_DEST (pattern);
 989   HOST_WIDE_INT offset = 0;
 990   enum rtx_code code;
 991
 992   if (dest == stack_pointer_rtx)
 993     {
 994       /* (set (reg sp) (plus (reg sp) (const_int))) */
 995       code = GET_CODE (src);
 996       if (! (code == PLUS || code == MINUS)
 997           || XEXP (src, 0) != stack_pointer_rtx
 998           || GET_CODE (XEXP (src, 1)) != CONST_INT)
 999         return 0;
1000
1001       offset = INTVAL (XEXP (src, 1));
1002       if (code == PLUS)
1003         offset = -offset;
1004     }
1005   else if (MEM_P (dest))
1006     {
1007       /* (set (mem (pre_dec (reg sp))) (foo)) */
1008       src = XEXP (dest, 0);
1009       code = GET_CODE (src);
1010
1011       switch (code)
1012         {
1013         case PRE_MODIFY:
1014         case POST_MODIFY:
1015           if (XEXP (src, 0) == stack_pointer_rtx)
1016             {
1017               rtx val = XEXP (XEXP (src, 1), 1);
1018               /* We handle only adjustments by constant amount.  */
1019               gcc_assert (GET_CODE (XEXP (src, 1)) == PLUS
1020                           && GET_CODE (val) == CONST_INT);
1021               offset = -INTVAL (val);
1022               break;
1023             }
1024           return 0;
1025
1026         case PRE_DEC:
1027         case POST_DEC:
1028           if (XEXP (src, 0) == stack_pointer_rtx)
1029             {
1030               offset = GET_MODE_SIZE (GET_MODE (dest));
1031               break;
1032             }
1033           return 0;
1034
1035         case PRE_INC:
1036         case POST_INC:
1037           if (XEXP (src, 0) == stack_pointer_rtx)
1038             {
1039               offset = -GET_MODE_SIZE (GET_MODE (dest));
1040               break;
1041             }
1042           return 0;
1043
1044         default:
1045           return 0;
1046         }
1047     }
1048   else
1049     return 0;
1050
1051   return offset;
1052 }
1053
1054 /* Check INSN to see if it looks like a push or a stack adjustment, and
1055    make a note of it if it does.  EH uses this information to find out how
1056    much extra space it needs to pop off the stack.  */
1057
1058 static void
1059 dwarf2out_stack_adjust (rtx insn, bool after_p)
1060 {
1061   HOST_WIDE_INT offset;
1062   const char *label;
1063   int i;
1064
1065   /* Don't handle epilogues at all.  Certainly it would be wrong to do so
1066      with this function.  Proper support would require all frame-related
1067      insns to be marked, and to be able to handle saving state around
1068      epilogues textually in the middle of the function.  */
1069   if (prologue_epilogue_contains (insn) || sibcall_epilogue_contains (insn))
1070     return;
1071
1072   /* If only calls can throw, and we have a frame pointer,
1073      save up adjustments until we see the CALL_INSN.  */
1074   if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM)
1075     {
1076       if (CALL_P (insn) && !after_p)
1077         {
1078           /* Extract the size of the args from the CALL rtx itself.  */
1079           insn = PATTERN (insn);
1080           if (GET_CODE (insn) == PARALLEL)
1081             insn = XVECEXP (insn, 0, 0);
1082           if (GET_CODE (insn) == SET)
1083             insn = SET_SRC (insn);
1084           gcc_assert (GET_CODE (insn) == CALL);
1085           dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1086         }
1087       return;
1088     }
1089
1090   if (CALL_P (insn) && !after_p)
1091     {
1092       if (!flag_asynchronous_unwind_tables)
1093         dwarf2out_args_size ("", args_size);
1094       return;
1095     }
1096   else if (BARRIER_P (insn))
1097     {
1098       /* When we see a BARRIER, we know to reset args_size to 0.  Usually
1099          the compiler will have already emitted a stack adjustment, but
1100          doesn't bother for calls to noreturn functions.  */
1101 #ifdef STACK_GROWS_DOWNWARD
1102       offset = -args_size;
1103 #else
1104       offset = args_size;
1105 #endif
1106     }
1107   else if (GET_CODE (PATTERN (insn)) == SET)
1108     offset = stack_adjust_offset (PATTERN (insn));
1109   else if (GET_CODE (PATTERN (insn)) == PARALLEL
1110            || GET_CODE (PATTERN (insn)) == SEQUENCE)
1111     {
1112       /* There may be stack adjustments inside compound insns.  Search
1113          for them.  */
1114       for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1115         if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1116           offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i));
1117     }
1118   else
1119     return;
1120
1121   if (offset == 0)
1122     return;
1123
1124   if (cfa.reg == STACK_POINTER_REGNUM)
1125     cfa.offset += offset;
1126
1127 #ifndef STACK_GROWS_DOWNWARD
1128   offset = -offset;
1129 #endif
1130
1131   args_size += offset;
1132   if (args_size < 0)
1133     args_size = 0;
1134
1135   label = dwarf2out_cfi_label ();
1136   def_cfa_1 (label, &cfa);
1137   if (flag_asynchronous_unwind_tables)
1138     dwarf2out_args_size (label, args_size);
1139 }
1140
1141 #endif
1142
1143 /* We delay emitting a register save until either (a) we reach the end
1144    of the prologue or (b) the register is clobbered.  This clusters
1145    register saves so that there are fewer pc advances.  */
1146
1147 struct queued_reg_save GTY(())
1148 {
1149   struct queued_reg_save *next;
1150   rtx reg;
1151   HOST_WIDE_INT cfa_offset;
1152   rtx saved_reg;
1153 };
1154
1155 static GTY(()) struct queued_reg_save *queued_reg_saves;
1156
1157 /* The caller's ORIG_REG is saved in SAVED_IN_REG.  */
1158 struct reg_saved_in_data GTY(()) {
1159   rtx orig_reg;
1160   rtx saved_in_reg;
1161 };
1162
1163 /* A list of registers saved in other registers.
1164    The list intentionally has a small maximum capacity of 4; if your
1165    port needs more than that, you might consider implementing a
1166    more efficient data structure.  */
1167 static GTY(()) struct reg_saved_in_data regs_saved_in_regs[4];
1168 static GTY(()) size_t num_regs_saved_in_regs;
1169
1170 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1171 static const char *last_reg_save_label;
1172
1173 /* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at
1174    SREG, or if SREG is NULL then it is saved at OFFSET to the CFA.  */
1175
1176 static void
1177 queue_reg_save (const char *label, rtx reg, rtx sreg, HOST_WIDE_INT offset)
1178 {
1179   struct queued_reg_save *q;
1180
1181   /* Duplicates waste space, but it's also necessary to remove them
1182      for correctness, since the queue gets output in reverse
1183      order.  */
1184   for (q = queued_reg_saves; q != NULL; q = q->next)
1185     if (REGNO (q->reg) == REGNO (reg))
1186       break;
1187
1188   if (q == NULL)
1189     {
1190       q = ggc_alloc (sizeof (*q));
1191       q->next = queued_reg_saves;
1192       queued_reg_saves = q;
1193     }
1194
1195   q->reg = reg;
1196   q->cfa_offset = offset;
1197   q->saved_reg = sreg;
1198
1199   last_reg_save_label = label;
1200 }
1201
1202 /* Output all the entries in QUEUED_REG_SAVES.  */
1203
1204 static void
1205 flush_queued_reg_saves (void)
1206 {
1207   struct queued_reg_save *q;
1208
1209   for (q = queued_reg_saves; q; q = q->next)
1210     {
1211       size_t i;
1212       unsigned int reg, sreg;
1213
1214       for (i = 0; i < num_regs_saved_in_regs; i++)
1215         if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (q->reg))
1216           break;
1217       if (q->saved_reg && i == num_regs_saved_in_regs)
1218         {
1219           gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1220           num_regs_saved_in_regs++;
1221         }
1222       if (i != num_regs_saved_in_regs)
1223         {
1224           regs_saved_in_regs[i].orig_reg = q->reg;
1225           regs_saved_in_regs[i].saved_in_reg = q->saved_reg;
1226         }
1227
1228       reg = DWARF_FRAME_REGNUM (REGNO (q->reg));
1229       if (q->saved_reg)
1230         sreg = DWARF_FRAME_REGNUM (REGNO (q->saved_reg));
1231       else
1232         sreg = INVALID_REGNUM;
1233       reg_save (last_reg_save_label, reg, sreg, q->cfa_offset);
1234     }
1235
1236   queued_reg_saves = NULL;
1237   last_reg_save_label = NULL;
1238 }
1239
1240 /* Does INSN clobber any register which QUEUED_REG_SAVES lists a saved
1241    location for?  Or, does it clobber a register which we've previously
1242    said that some other register is saved in, and for which we now
1243    have a new location for?  */
1244
1245 static bool
1246 clobbers_queued_reg_save (rtx insn)
1247 {
1248   struct queued_reg_save *q;
1249
1250   for (q = queued_reg_saves; q; q = q->next)
1251     {
1252       size_t i;
1253       if (modified_in_p (q->reg, insn))
1254         return true;
1255       for (i = 0; i < num_regs_saved_in_regs; i++)
1256         if (REGNO (q->reg) == REGNO (regs_saved_in_regs[i].orig_reg)
1257             && modified_in_p (regs_saved_in_regs[i].saved_in_reg, insn))
1258           return true;
1259     }
1260
1261   return false;
1262 }
1263
1264 /* What register, if any, is currently saved in REG?  */
1265
1266 static rtx
1267 reg_saved_in (rtx reg)
1268 {
1269   unsigned int regn = REGNO (reg);
1270   size_t i;
1271   struct queued_reg_save *q;
1272
1273   for (q = queued_reg_saves; q; q = q->next)
1274     if (q->saved_reg && regn == REGNO (q->saved_reg))
1275       return q->reg;
1276
1277   for (i = 0; i < num_regs_saved_in_regs; i++)
1278     if (regs_saved_in_regs[i].saved_in_reg
1279         && regn == REGNO (regs_saved_in_regs[i].saved_in_reg))
1280       return regs_saved_in_regs[i].orig_reg;
1281
1282   return NULL_RTX;
1283 }
1284
1285
1286 /* A temporary register holding an integral value used in adjusting SP
1287    or setting up the store_reg.  The "offset" field holds the integer
1288    value, not an offset.  */
1289 static dw_cfa_location cfa_temp;
1290
1291 /* Record call frame debugging information for an expression EXPR,
1292    which either sets SP or FP (adjusting how we calculate the frame
1293    address) or saves a register to the stack or another register.
1294    LABEL indicates the address of EXPR.
1295
1296    This function encodes a state machine mapping rtxes to actions on
1297    cfa, cfa_store, and cfa_temp.reg.  We describe these rules so
1298    users need not read the source code.
1299
1300   The High-Level Picture
1301
1302   Changes in the register we use to calculate the CFA: Currently we
1303   assume that if you copy the CFA register into another register, we
1304   should take the other one as the new CFA register; this seems to
1305   work pretty well.  If it's wrong for some target, it's simple
1306   enough not to set RTX_FRAME_RELATED_P on the insn in question.
1307
1308   Changes in the register we use for saving registers to the stack:
1309   This is usually SP, but not always.  Again, we deduce that if you
1310   copy SP into another register (and SP is not the CFA register),
1311   then the new register is the one we will be using for register
1312   saves.  This also seems to work.
1313
1314   Register saves: There's not much guesswork about this one; if
1315   RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
1316   register save, and the register used to calculate the destination
1317   had better be the one we think we're using for this purpose.
1318   It's also assumed that a copy from a call-saved register to another
1319   register is saving that register if RTX_FRAME_RELATED_P is set on
1320   that instruction.  If the copy is from a call-saved register to
1321   the *same* register, that means that the register is now the same
1322   value as in the caller.
1323
1324   Except: If the register being saved is the CFA register, and the
1325   offset is nonzero, we are saving the CFA, so we assume we have to
1326   use DW_CFA_def_cfa_expression.  If the offset is 0, we assume that
1327   the intent is to save the value of SP from the previous frame.
1328
1329   In addition, if a register has previously been saved to a different
1330   register,
1331
1332   Invariants / Summaries of Rules
1333
1334   cfa          current rule for calculating the CFA.  It usually
1335                consists of a register and an offset.
1336   cfa_store    register used by prologue code to save things to the stack
1337                cfa_store.offset is the offset from the value of
1338                cfa_store.reg to the actual CFA
1339   cfa_temp     register holding an integral value.  cfa_temp.offset
1340                stores the value, which will be used to adjust the
1341                stack pointer.  cfa_temp is also used like cfa_store,
1342                to track stores to the stack via fp or a temp reg.
1343
1344   Rules  1- 4: Setting a register's value to cfa.reg or an expression
1345                with cfa.reg as the first operand changes the cfa.reg and its
1346                cfa.offset.  Rule 1 and 4 also set cfa_temp.reg and
1347                cfa_temp.offset.
1348
1349   Rules  6- 9: Set a non-cfa.reg register value to a constant or an
1350                expression yielding a constant.  This sets cfa_temp.reg
1351                and cfa_temp.offset.
1352
1353   Rule 5:      Create a new register cfa_store used to save items to the
1354                stack.
1355
1356   Rules 10-14: Save a register to the stack.  Define offset as the
1357                difference of the original location and cfa_store's
1358                location (or cfa_temp's location if cfa_temp is used).
1359
1360   The Rules
1361
1362   "{a,b}" indicates a choice of a xor b.
1363   "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.
1364
1365   Rule 1:
1366   (set <reg1> <reg2>:cfa.reg)
1367   effects: cfa.reg = <reg1>
1368            cfa.offset unchanged
1369            cfa_temp.reg = <reg1>
1370            cfa_temp.offset = cfa.offset
1371
1372   Rule 2:
1373   (set sp ({minus,plus,losum} {sp,fp}:cfa.reg
1374                               {<const_int>,<reg>:cfa_temp.reg}))
1375   effects: cfa.reg = sp if fp used
1376            cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
1377            cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
1378              if cfa_store.reg==sp
1379
1380   Rule 3:
1381   (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
1382   effects: cfa.reg = fp
1383            cfa_offset += +/- <const_int>
1384
1385   Rule 4:
1386   (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
1387   constraints: <reg1> != fp
1388                <reg1> != sp
1389   effects: cfa.reg = <reg1>
1390            cfa_temp.reg = <reg1>
1391            cfa_temp.offset = cfa.offset
1392
1393   Rule 5:
1394   (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
1395   constraints: <reg1> != fp
1396                <reg1> != sp
1397   effects: cfa_store.reg = <reg1>
1398            cfa_store.offset = cfa.offset - cfa_temp.offset
1399
1400   Rule 6:
1401   (set <reg> <const_int>)
1402   effects: cfa_temp.reg = <reg>
1403            cfa_temp.offset = <const_int>
1404
1405   Rule 7:
1406   (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
1407   effects: cfa_temp.reg = <reg1>
1408            cfa_temp.offset |= <const_int>
1409
1410   Rule 8:
1411   (set <reg> (high <exp>))
1412   effects: none
1413
1414   Rule 9:
1415   (set <reg> (lo_sum <exp> <const_int>))
1416   effects: cfa_temp.reg = <reg>
1417            cfa_temp.offset = <const_int>
1418
1419   Rule 10:
1420   (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
1421   effects: cfa_store.offset -= <const_int>
1422            cfa.offset = cfa_store.offset if cfa.reg == sp
1423            cfa.reg = sp
1424            cfa.base_offset = -cfa_store.offset
1425
1426   Rule 11:
1427   (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>)
1428   effects: cfa_store.offset += -/+ mode_size(mem)
1429            cfa.offset = cfa_store.offset if cfa.reg == sp
1430            cfa.reg = sp
1431            cfa.base_offset = -cfa_store.offset
1432
1433   Rule 12:
1434   (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))
1435
1436        <reg2>)
1437   effects: cfa.reg = <reg1>
1438            cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
1439
1440   Rule 13:
1441   (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
1442   effects: cfa.reg = <reg1>
1443            cfa.base_offset = -{cfa_store,cfa_temp}.offset
1444
1445   Rule 14:
1446   (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>)
1447   effects: cfa.reg = <reg1>
1448            cfa.base_offset = -cfa_temp.offset
1449            cfa_temp.offset -= mode_size(mem)
1450
1451   Rule 15:
1452   (set <reg> {unspec, unspec_volatile})
1453   effects: target-dependent  */
1454
1455 static void
1456 dwarf2out_frame_debug_expr (rtx expr, const char *label)
1457 {
1458   rtx src, dest;
1459   HOST_WIDE_INT offset;
1460
1461   /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
1462      the PARALLEL independently. The first element is always processed if
1463      it is a SET. This is for backward compatibility.   Other elements
1464      are processed only if they are SETs and the RTX_FRAME_RELATED_P
1465      flag is set in them.  */
1466   if (GET_CODE (expr) == PARALLEL || GET_CODE (expr) == SEQUENCE)
1467     {
1468       int par_index;
1469       int limit = XVECLEN (expr, 0);
1470
1471       for (par_index = 0; par_index < limit; par_index++)
1472         if (GET_CODE (XVECEXP (expr, 0, par_index)) == SET
1473             && (RTX_FRAME_RELATED_P (XVECEXP (expr, 0, par_index))
1474                 || par_index == 0))
1475           dwarf2out_frame_debug_expr (XVECEXP (expr, 0, par_index), label);
1476
1477       return;
1478     }
1479
1480   gcc_assert (GET_CODE (expr) == SET);
1481
1482   src = SET_SRC (expr);
1483   dest = SET_DEST (expr);
1484
1485   if (GET_CODE (src) == REG)
1486     {
1487       rtx rsi = reg_saved_in (src);
1488       if (rsi)
1489         src = rsi;
1490     }
1491
1492   switch (GET_CODE (dest))
1493     {
1494     case REG:
1495       switch (GET_CODE (src))
1496         {
1497           /* Setting FP from SP.  */
1498         case REG:
1499           if (cfa.reg == (unsigned) REGNO (src))
1500             {
1501               /* Rule 1 */
1502               /* Update the CFA rule wrt SP or FP.  Make sure src is
1503                  relative to the current CFA register.
1504
1505                  We used to require that dest be either SP or FP, but the
1506                  ARM copies SP to a temporary register, and from there to
1507                  FP.  So we just rely on the backends to only set
1508                  RTX_FRAME_RELATED_P on appropriate insns.  */
1509               cfa.reg = REGNO (dest);
1510               cfa_temp.reg = cfa.reg;
1511               cfa_temp.offset = cfa.offset;
1512             }
1513           else
1514             {
1515               /* Saving a register in a register.  */
1516               gcc_assert (call_used_regs [REGNO (dest)]
1517                           && (!fixed_regs [REGNO (dest)]
1518                               /* For the SPARC and its register window.  */
1519                               || DWARF_FRAME_REGNUM (REGNO (src))
1520                                    == DWARF_FRAME_RETURN_COLUMN));
1521               queue_reg_save (label, src, dest, 0);
1522             }
1523           break;
1524
1525         case PLUS:
1526         case MINUS:
1527         case LO_SUM:
1528           if (dest == stack_pointer_rtx)
1529             {
1530               /* Rule 2 */
1531               /* Adjusting SP.  */
1532               switch (GET_CODE (XEXP (src, 1)))
1533                 {
1534                 case CONST_INT:
1535                   offset = INTVAL (XEXP (src, 1));
1536                   break;
1537                 case REG:
1538                   gcc_assert ((unsigned) REGNO (XEXP (src, 1))
1539                               == cfa_temp.reg);
1540                   offset = cfa_temp.offset;
1541                   break;
1542                 default:
1543                   gcc_unreachable ();
1544                 }
1545
1546               if (XEXP (src, 0) == hard_frame_pointer_rtx)
1547                 {
1548                   /* Restoring SP from FP in the epilogue.  */
1549                   gcc_assert (cfa.reg == (unsigned) HARD_FRAME_POINTER_REGNUM);
1550                   cfa.reg = STACK_POINTER_REGNUM;
1551                 }
1552               else if (GET_CODE (src) == LO_SUM)
1553                 /* Assume we've set the source reg of the LO_SUM from sp.  */
1554                 ;
1555               else
1556                 gcc_assert (XEXP (src, 0) == stack_pointer_rtx);
1557
1558               if (GET_CODE (src) != MINUS)
1559                 offset = -offset;
1560               if (cfa.reg == STACK_POINTER_REGNUM)
1561                 cfa.offset += offset;
1562               if (cfa_store.reg == STACK_POINTER_REGNUM)
1563                 cfa_store.offset += offset;
1564             }
1565           else if (dest == hard_frame_pointer_rtx)
1566             {
1567               /* Rule 3 */
1568               /* Either setting the FP from an offset of the SP,
1569                  or adjusting the FP */
1570               gcc_assert (frame_pointer_needed);
1571
1572               gcc_assert (REG_P (XEXP (src, 0))
1573                           && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg
1574                           && GET_CODE (XEXP (src, 1)) == CONST_INT);
1575               offset = INTVAL (XEXP (src, 1));
1576               if (GET_CODE (src) != MINUS)
1577                 offset = -offset;
1578               cfa.offset += offset;
1579               cfa.reg = HARD_FRAME_POINTER_REGNUM;
1580             }
1581           else
1582             {
1583               gcc_assert (GET_CODE (src) != MINUS);
1584
1585               /* Rule 4 */
1586               if (REG_P (XEXP (src, 0))
1587                   && REGNO (XEXP (src, 0)) == cfa.reg
1588                   && GET_CODE (XEXP (src, 1)) == CONST_INT)
1589                 {
1590                   /* Setting a temporary CFA register that will be copied
1591                      into the FP later on.  */
1592                   offset = - INTVAL (XEXP (src, 1));
1593                   cfa.offset += offset;
1594                   cfa.reg = REGNO (dest);
1595                   /* Or used to save regs to the stack.  */
1596                   cfa_temp.reg = cfa.reg;
1597                   cfa_temp.offset = cfa.offset;
1598                 }
1599
1600               /* Rule 5 */
1601               else if (REG_P (XEXP (src, 0))
1602                        && REGNO (XEXP (src, 0)) == cfa_temp.reg
1603                        && XEXP (src, 1) == stack_pointer_rtx)
1604                 {
1605                   /* Setting a scratch register that we will use instead
1606                      of SP for saving registers to the stack.  */
1607                   gcc_assert (cfa.reg == STACK_POINTER_REGNUM);
1608                   cfa_store.reg = REGNO (dest);
1609                   cfa_store.offset = cfa.offset - cfa_temp.offset;
1610                 }
1611
1612               /* Rule 9 */
1613               else if (GET_CODE (src) == LO_SUM
1614                        && GET_CODE (XEXP (src, 1)) == CONST_INT)
1615                 {
1616                   cfa_temp.reg = REGNO (dest);
1617                   cfa_temp.offset = INTVAL (XEXP (src, 1));
1618                 }
1619               else
1620                 gcc_unreachable ();
1621             }
1622           break;
1623
1624           /* Rule 6 */
1625         case CONST_INT:
1626           cfa_temp.reg = REGNO (dest);
1627           cfa_temp.offset = INTVAL (src);
1628           break;
1629
1630           /* Rule 7 */
1631         case IOR:
1632           gcc_assert (REG_P (XEXP (src, 0))
1633                       && (unsigned) REGNO (XEXP (src, 0)) == cfa_temp.reg
1634                       && GET_CODE (XEXP (src, 1)) == CONST_INT);
1635
1636           if ((unsigned) REGNO (dest) != cfa_temp.reg)
1637             cfa_temp.reg = REGNO (dest);
1638           cfa_temp.offset |= INTVAL (XEXP (src, 1));
1639           break;
1640
1641           /* Skip over HIGH, assuming it will be followed by a LO_SUM,
1642              which will fill in all of the bits.  */
1643           /* Rule 8 */
1644         case HIGH:
1645           break;
1646
1647           /* Rule 15 */
1648         case UNSPEC:
1649         case UNSPEC_VOLATILE:
1650           gcc_assert (targetm.dwarf_handle_frame_unspec);
1651           targetm.dwarf_handle_frame_unspec (label, expr, XINT (src, 1));
1652           break;
1653
1654         default:
1655           gcc_unreachable ();
1656         }
1657
1658       def_cfa_1 (label, &cfa);
1659       break;
1660
1661     case MEM:
1662       gcc_assert (REG_P (src));
1663
1664       /* Saving a register to the stack.  Make sure dest is relative to the
1665          CFA register.  */
1666       switch (GET_CODE (XEXP (dest, 0)))
1667         {
1668           /* Rule 10 */
1669           /* With a push.  */
1670         case PRE_MODIFY:
1671           /* We can't handle variable size modifications.  */
1672           gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1))
1673                       == CONST_INT);
1674           offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1));
1675
1676           gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
1677                       && cfa_store.reg == STACK_POINTER_REGNUM);
1678
1679           cfa_store.offset += offset;
1680           if (cfa.reg == STACK_POINTER_REGNUM)
1681             cfa.offset = cfa_store.offset;
1682
1683           offset = -cfa_store.offset;
1684           break;
1685
1686           /* Rule 11 */
1687         case PRE_INC:
1688         case PRE_DEC:
1689           offset = GET_MODE_SIZE (GET_MODE (dest));
1690           if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
1691             offset = -offset;
1692
1693           gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
1694                       && cfa_store.reg == STACK_POINTER_REGNUM);
1695
1696           cfa_store.offset += offset;
1697           if (cfa.reg == STACK_POINTER_REGNUM)
1698             cfa.offset = cfa_store.offset;
1699
1700           offset = -cfa_store.offset;
1701           break;
1702
1703           /* Rule 12 */
1704           /* With an offset.  */
1705         case PLUS:
1706         case MINUS:
1707         case LO_SUM:
1708           {
1709             int regno;
1710
1711             gcc_assert (GET_CODE (XEXP (XEXP (dest, 0), 1)) == CONST_INT);
1712             offset = INTVAL (XEXP (XEXP (dest, 0), 1));
1713             if (GET_CODE (XEXP (dest, 0)) == MINUS)
1714               offset = -offset;
1715
1716             regno = REGNO (XEXP (XEXP (dest, 0), 0));
1717
1718             if (cfa_store.reg == (unsigned) regno)
1719               offset -= cfa_store.offset;
1720             else
1721               {
1722                 gcc_assert (cfa_temp.reg == (unsigned) regno);
1723                 offset -= cfa_temp.offset;
1724               }
1725           }
1726           break;
1727
1728           /* Rule 13 */
1729           /* Without an offset.  */
1730         case REG:
1731           {
1732             int regno = REGNO (XEXP (dest, 0));
1733
1734             if (cfa_store.reg == (unsigned) regno)
1735               offset = -cfa_store.offset;
1736             else
1737               {
1738                 gcc_assert (cfa_temp.reg == (unsigned) regno);
1739                 offset = -cfa_temp.offset;
1740               }
1741           }
1742           break;
1743
1744           /* Rule 14 */
1745         case POST_INC:
1746           gcc_assert (cfa_temp.reg
1747                       == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)));
1748           offset = -cfa_temp.offset;
1749           cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest));
1750           break;
1751
1752         default:
1753           gcc_unreachable ();
1754         }
1755
1756       if (REGNO (src) != STACK_POINTER_REGNUM
1757           && REGNO (src) != HARD_FRAME_POINTER_REGNUM
1758           && (unsigned) REGNO (src) == cfa.reg)
1759         {
1760           /* We're storing the current CFA reg into the stack.  */
1761
1762           if (cfa.offset == 0)
1763             {
1764               /* If the source register is exactly the CFA, assume
1765                  we're saving SP like any other register; this happens
1766                  on the ARM.  */
1767               def_cfa_1 (label, &cfa);
1768               queue_reg_save (label, stack_pointer_rtx, NULL_RTX, offset);
1769               break;
1770             }
1771           else
1772             {
1773               /* Otherwise, we'll need to look in the stack to
1774                  calculate the CFA.  */
1775               rtx x = XEXP (dest, 0);
1776
1777               if (!REG_P (x))
1778                 x = XEXP (x, 0);
1779               gcc_assert (REG_P (x));
1780
1781               cfa.reg = REGNO (x);
1782               cfa.base_offset = offset;
1783               cfa.indirect = 1;
1784               def_cfa_1 (label, &cfa);
1785               break;
1786             }
1787         }
1788
1789       def_cfa_1 (label, &cfa);
1790       queue_reg_save (label, src, NULL_RTX, offset);
1791       break;
1792
1793     default:
1794       gcc_unreachable ();
1795     }
1796 }
1797
1798 /* Record call frame debugging information for INSN, which either
1799    sets SP or FP (adjusting how we calculate the frame address) or saves a
1800    register to the stack.  If INSN is NULL_RTX, initialize our state.
1801
1802    If AFTER_P is false, we're being called before the insn is emitted,
1803    otherwise after.  Call instructions get invoked twice.  */
1804
1805 void
1806 dwarf2out_frame_debug (rtx insn, bool after_p)
1807 {
1808   const char *label;
1809   rtx src;
1810
1811   if (insn == NULL_RTX)
1812     {
1813       size_t i;
1814
1815       /* Flush any queued register saves.  */
1816       flush_queued_reg_saves ();
1817
1818       /* Set up state for generating call frame debug info.  */
1819       lookup_cfa (&cfa);
1820       gcc_assert (cfa.reg
1821                   == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
1822
1823       cfa.reg = STACK_POINTER_REGNUM;
1824       cfa_store = cfa;
1825       cfa_temp.reg = -1;
1826       cfa_temp.offset = 0;
1827
1828       for (i = 0; i < num_regs_saved_in_regs; i++)
1829         {
1830           regs_saved_in_regs[i].orig_reg = NULL_RTX;
1831           regs_saved_in_regs[i].saved_in_reg = NULL_RTX;
1832         }
1833       num_regs_saved_in_regs = 0;
1834       return;
1835     }
1836
1837   if (!NONJUMP_INSN_P (insn) || clobbers_queued_reg_save (insn))
1838     flush_queued_reg_saves ();
1839
1840   if (! RTX_FRAME_RELATED_P (insn))
1841     {
1842       if (!ACCUMULATE_OUTGOING_ARGS)
1843         dwarf2out_stack_adjust (insn, after_p);
1844       return;
1845     }
1846
1847   label = dwarf2out_cfi_label ();
1848   src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1849   if (src)
1850     insn = XEXP (src, 0);
1851   else
1852     insn = PATTERN (insn);
1853
1854   dwarf2out_frame_debug_expr (insn, label);
1855 }
1856
1857 #endif
1858
1859 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used.  */
1860 static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
1861  (enum dwarf_call_frame_info cfi);
1862
1863 static enum dw_cfi_oprnd_type
1864 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
1865 {
1866   switch (cfi)
1867     {
1868     case DW_CFA_nop:
1869     case DW_CFA_GNU_window_save:
1870       return dw_cfi_oprnd_unused;
1871
1872     case DW_CFA_set_loc:
1873     case DW_CFA_advance_loc1:
1874     case DW_CFA_advance_loc2:
1875     case DW_CFA_advance_loc4:
1876     case DW_CFA_MIPS_advance_loc8:
1877       return dw_cfi_oprnd_addr;
1878
1879     case DW_CFA_offset:
1880     case DW_CFA_offset_extended:
1881     case DW_CFA_def_cfa:
1882     case DW_CFA_offset_extended_sf:
1883     case DW_CFA_def_cfa_sf:
1884     case DW_CFA_restore_extended:
1885     case DW_CFA_undefined:
1886     case DW_CFA_same_value:
1887     case DW_CFA_def_cfa_register:
1888     case DW_CFA_register:
1889       return dw_cfi_oprnd_reg_num;
1890
1891     case DW_CFA_def_cfa_offset:
1892     case DW_CFA_GNU_args_size:
1893     case DW_CFA_def_cfa_offset_sf:
1894       return dw_cfi_oprnd_offset;
1895
1896     case DW_CFA_def_cfa_expression:
1897     case DW_CFA_expression:
1898       return dw_cfi_oprnd_loc;
1899
1900     default:
1901       gcc_unreachable ();
1902     }
1903 }
1904
1905 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used.  */
1906 static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
1907  (enum dwarf_call_frame_info cfi);
1908
1909 static enum dw_cfi_oprnd_type
1910 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
1911 {
1912   switch (cfi)
1913     {
1914     case DW_CFA_def_cfa:
1915     case DW_CFA_def_cfa_sf:
1916     case DW_CFA_offset:
1917     case DW_CFA_offset_extended_sf:
1918     case DW_CFA_offset_extended:
1919       return dw_cfi_oprnd_offset;
1920
1921     case DW_CFA_register:
1922       return dw_cfi_oprnd_reg_num;
1923
1924     default:
1925       return dw_cfi_oprnd_unused;
1926     }
1927 }
1928
1929 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1930
1931 /* Map register numbers held in the call frame info that gcc has
1932    collected using DWARF_FRAME_REGNUM to those that should be output in
1933    .debug_frame and .eh_frame.  */
1934 #ifndef DWARF2_FRAME_REG_OUT
1935 #define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO)
1936 #endif
1937
1938 /* Output a Call Frame Information opcode and its operand(s).  */
1939
1940 static void
1941 output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int for_eh)
1942 {
1943   unsigned long r;
1944   if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
1945     dw2_asm_output_data (1, (cfi->dw_cfi_opc
1946                              | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)),
1947                          "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX,
1948                          cfi->dw_cfi_oprnd1.dw_cfi_offset);
1949   else if (cfi->dw_cfi_opc == DW_CFA_offset)
1950     {
1951       r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
1952       dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
1953                            "DW_CFA_offset, column 0x%lx", r);
1954       dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
1955     }
1956   else if (cfi->dw_cfi_opc == DW_CFA_restore)
1957     {
1958       r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
1959       dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
1960                            "DW_CFA_restore, column 0x%lx", r);
1961     }
1962   else
1963     {
1964       dw2_asm_output_data (1, cfi->dw_cfi_opc,
1965                            "%s", dwarf_cfi_name (cfi->dw_cfi_opc));
1966
1967       switch (cfi->dw_cfi_opc)
1968         {
1969         case DW_CFA_set_loc:
1970           if (for_eh)
1971             dw2_asm_output_encoded_addr_rtx (
1972                 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0),
1973                 gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr),
1974                 NULL);
1975           else
1976             dw2_asm_output_addr (DWARF2_ADDR_SIZE,
1977                                  cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL);
1978           break;
1979
1980         case DW_CFA_advance_loc1:
1981           dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr,
1982                                 fde->dw_fde_current_label, NULL);
1983           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1984           break;
1985
1986         case DW_CFA_advance_loc2:
1987           dw2_asm_output_delta (2, cfi->dw_cfi_oprnd1.dw_cfi_addr,
1988                                 fde->dw_fde_current_label, NULL);
1989           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1990           break;
1991
1992         case DW_CFA_advance_loc4:
1993           dw2_asm_output_delta (4, cfi->dw_cfi_oprnd1.dw_cfi_addr,
1994                                 fde->dw_fde_current_label, NULL);
1995           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1996           break;
1997
1998         case DW_CFA_MIPS_advance_loc8:
1999           dw2_asm_output_delta (8, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2000                                 fde->dw_fde_current_label, NULL);
2001           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2002           break;
2003
2004         case DW_CFA_offset_extended:
2005         case DW_CFA_def_cfa:
2006           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2007           dw2_asm_output_data_uleb128 (r, NULL);
2008           dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
2009           break;
2010
2011         case DW_CFA_offset_extended_sf:
2012         case DW_CFA_def_cfa_sf:
2013           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2014           dw2_asm_output_data_uleb128 (r, NULL);
2015           dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
2016           break;
2017
2018         case DW_CFA_restore_extended:
2019         case DW_CFA_undefined:
2020         case DW_CFA_same_value:
2021         case DW_CFA_def_cfa_register:
2022           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2023           dw2_asm_output_data_uleb128 (r, NULL);
2024           break;
2025
2026         case DW_CFA_register:
2027           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2028           dw2_asm_output_data_uleb128 (r, NULL);
2029           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, for_eh);
2030           dw2_asm_output_data_uleb128 (r, NULL);
2031           break;
2032
2033         case DW_CFA_def_cfa_offset:
2034         case DW_CFA_GNU_args_size:
2035           dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
2036           break;
2037
2038         case DW_CFA_def_cfa_offset_sf:
2039           dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
2040           break;
2041
2042         case DW_CFA_GNU_window_save:
2043           break;
2044
2045         case DW_CFA_def_cfa_expression:
2046         case DW_CFA_expression:
2047           output_cfa_loc (cfi);
2048           break;
2049
2050         case DW_CFA_GNU_negative_offset_extended:
2051           /* Obsoleted by DW_CFA_offset_extended_sf.  */
2052           gcc_unreachable ();
2053
2054         default:
2055           break;
2056         }
2057     }
2058 }
2059
2060 /* Output the call frame information used to record information
2061    that relates to calculating the frame pointer, and records the
2062    location of saved registers.  */
2063
2064 static void
2065 output_call_frame_info (int for_eh)
2066 {
2067   unsigned int i;
2068   dw_fde_ref fde;
2069   dw_cfi_ref cfi;
2070   char l1[20], l2[20], section_start_label[20];
2071   bool any_lsda_needed = false;
2072   char augmentation[6];
2073   int augmentation_size;
2074   int fde_encoding = DW_EH_PE_absptr;
2075   int per_encoding = DW_EH_PE_absptr;
2076   int lsda_encoding = DW_EH_PE_absptr;
2077
2078   /* Don't emit a CIE if there won't be any FDEs.  */
2079   if (fde_table_in_use == 0)
2080     return;
2081
2082   /* If we make FDEs linkonce, we may have to emit an empty label for
2083      an FDE that wouldn't otherwise be emitted.  We want to avoid
2084      having an FDE kept around when the function it refers to is
2085      discarded.  Example where this matters: a primary function
2086      template in C++ requires EH information, but an explicit
2087      specialization doesn't.  */
2088   if (TARGET_USES_WEAK_UNWIND_INFO
2089       && ! flag_asynchronous_unwind_tables
2090       && for_eh)
2091     for (i = 0; i < fde_table_in_use; i++)
2092       if ((fde_table[i].nothrow || fde_table[i].all_throwers_are_sibcalls)
2093           && !fde_table[i].uses_eh_lsda
2094           && ! DECL_WEAK (fde_table[i].decl))
2095         targetm.asm_out.unwind_label (asm_out_file, fde_table[i].decl,
2096                                       for_eh, /* empty */ 1);
2097
2098   /* If we don't have any functions we'll want to unwind out of, don't
2099      emit any EH unwind information.  Note that if exceptions aren't
2100      enabled, we won't have collected nothrow information, and if we
2101      asked for asynchronous tables, we always want this info.  */
2102   if (for_eh)
2103     {
2104       bool any_eh_needed = !flag_exceptions || flag_asynchronous_unwind_tables;
2105
2106       for (i = 0; i < fde_table_in_use; i++)
2107         if (fde_table[i].uses_eh_lsda)
2108           any_eh_needed = any_lsda_needed = true;
2109         else if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
2110           any_eh_needed = true;
2111         else if (! fde_table[i].nothrow
2112                  && ! fde_table[i].all_throwers_are_sibcalls)
2113           any_eh_needed = true;
2114
2115       if (! any_eh_needed)
2116         return;
2117     }
2118
2119   /* We're going to be generating comments, so turn on app.  */
2120   if (flag_debug_asm)
2121     app_enable ();
2122
2123   if (for_eh)
2124     targetm.asm_out.eh_frame_section ();
2125   else
2126     named_section_flags (DEBUG_FRAME_SECTION, SECTION_DEBUG);
2127
2128   ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
2129   ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
2130
2131   /* Output the CIE.  */
2132   ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
2133   ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
2134   dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
2135                         "Length of Common Information Entry");
2136   ASM_OUTPUT_LABEL (asm_out_file, l1);
2137
2138   /* Now that the CIE pointer is PC-relative for EH,
2139      use 0 to identify the CIE.  */
2140   dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
2141                        (for_eh ? 0 : DW_CIE_ID),
2142                        "CIE Identifier Tag");
2143
2144   dw2_asm_output_data (1, DW_CIE_VERSION, "CIE Version");
2145
2146   augmentation[0] = 0;
2147   augmentation_size = 0;
2148   if (for_eh)
2149     {
2150       char *p;
2151
2152       /* Augmentation:
2153          z      Indicates that a uleb128 is present to size the
2154                 augmentation section.
2155          L      Indicates the encoding (and thus presence) of
2156                 an LSDA pointer in the FDE augmentation.
2157          R      Indicates a non-default pointer encoding for
2158                 FDE code pointers.
2159          P      Indicates the presence of an encoding + language
2160                 personality routine in the CIE augmentation.  */
2161
2162       fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
2163       per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
2164       lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
2165
2166       p = augmentation + 1;
2167       if (eh_personality_libfunc)
2168         {
2169           *p++ = 'P';
2170           augmentation_size += 1 + size_of_encoded_value (per_encoding);
2171         }
2172       if (any_lsda_needed)
2173         {
2174           *p++ = 'L';
2175           augmentation_size += 1;
2176         }
2177       if (fde_encoding != DW_EH_PE_absptr)
2178         {
2179           *p++ = 'R';
2180           augmentation_size += 1;
2181         }
2182       if (p > augmentation + 1)
2183         {
2184           augmentation[0] = 'z';
2185           *p = '\0';
2186         }
2187
2188       /* Ug.  Some platforms can't do unaligned dynamic relocations at all.  */
2189       if (eh_personality_libfunc && per_encoding == DW_EH_PE_aligned)
2190         {
2191           int offset = (  4             /* Length */
2192                         + 4             /* CIE Id */
2193                         + 1             /* CIE version */
2194                         + strlen (augmentation) + 1     /* Augmentation */
2195                         + size_of_uleb128 (1)           /* Code alignment */
2196                         + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
2197                         + 1             /* RA column */
2198                         + 1             /* Augmentation size */
2199                         + 1             /* Personality encoding */ );
2200           int pad = -offset & (PTR_SIZE - 1);
2201
2202           augmentation_size += pad;
2203
2204           /* Augmentations should be small, so there's scarce need to
2205              iterate for a solution.  Die if we exceed one uleb128 byte.  */
2206           gcc_assert (size_of_uleb128 (augmentation_size) == 1);
2207         }
2208     }
2209
2210   dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
2211   dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
2212   dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
2213                                "CIE Data Alignment Factor");
2214
2215   if (DW_CIE_VERSION == 1)
2216     dw2_asm_output_data (1, DWARF_FRAME_RETURN_COLUMN, "CIE RA Column");
2217   else
2218     dw2_asm_output_data_uleb128 (DWARF_FRAME_RETURN_COLUMN, "CIE RA Column");
2219
2220   if (augmentation[0])
2221     {
2222       dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
2223       if (eh_personality_libfunc)
2224         {
2225           dw2_asm_output_data (1, per_encoding, "Personality (%s)",
2226                                eh_data_format_name (per_encoding));
2227           dw2_asm_output_encoded_addr_rtx (per_encoding,
2228                                            eh_personality_libfunc, NULL);
2229         }
2230
2231       if (any_lsda_needed)
2232         dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
2233                              eh_data_format_name (lsda_encoding));
2234
2235       if (fde_encoding != DW_EH_PE_absptr)
2236         dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
2237                              eh_data_format_name (fde_encoding));
2238     }
2239
2240   for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
2241     output_cfi (cfi, NULL, for_eh);
2242
2243   /* Pad the CIE out to an address sized boundary.  */
2244   ASM_OUTPUT_ALIGN (asm_out_file,
2245                     floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
2246   ASM_OUTPUT_LABEL (asm_out_file, l2);
2247
2248   /* Loop through all of the FDE's.  */
2249   for (i = 0; i < fde_table_in_use; i++)
2250     {
2251       fde = &fde_table[i];
2252
2253       /* Don't emit EH unwind info for leaf functions that don't need it.  */
2254       if (for_eh && !flag_asynchronous_unwind_tables && flag_exceptions
2255           && (fde->nothrow || fde->all_throwers_are_sibcalls)
2256           && ! (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
2257           && !fde->uses_eh_lsda)
2258         continue;
2259
2260       targetm.asm_out.unwind_label (asm_out_file, fde->decl, for_eh, /* empty */ 0);
2261       targetm.asm_out.internal_label (asm_out_file, FDE_LABEL, for_eh + i * 2);
2262       ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i * 2);
2263       ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i * 2);
2264       dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
2265                             "FDE Length");
2266       ASM_OUTPUT_LABEL (asm_out_file, l1);
2267
2268       if (for_eh)
2269         dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
2270       else
2271         dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
2272                                "FDE CIE offset");
2273
2274       if (for_eh)
2275         {
2276           rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, fde->dw_fde_begin);
2277           SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;
2278           dw2_asm_output_encoded_addr_rtx (fde_encoding,
2279                                            sym_ref,
2280                                            "FDE initial location");
2281           if (fde->dw_fde_switched_sections)
2282             {
2283               rtx sym_ref2 = gen_rtx_SYMBOL_REF (Pmode,
2284                                       fde->dw_fde_unlikely_section_label);
2285               rtx sym_ref3= gen_rtx_SYMBOL_REF (Pmode,
2286                                       fde->dw_fde_hot_section_label);
2287               SYMBOL_REF_FLAGS (sym_ref2) |= SYMBOL_FLAG_LOCAL;
2288               SYMBOL_REF_FLAGS (sym_ref3) |= SYMBOL_FLAG_LOCAL;
2289               dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref3,
2290                                                "FDE initial location");
2291               dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2292                                     fde->dw_fde_hot_section_end_label,
2293                                     fde->dw_fde_hot_section_label,
2294                                     "FDE address range");
2295               dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref2,
2296                                                "FDE initial location");
2297               dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2298                                     fde->dw_fde_unlikely_section_end_label,
2299                                     fde->dw_fde_unlikely_section_label,
2300                                     "FDE address range");
2301             }
2302           else
2303             dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2304                                   fde->dw_fde_end, fde->dw_fde_begin,
2305                                   "FDE address range");
2306         }
2307       else
2308         {
2309           dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin,
2310                                "FDE initial location");
2311           if (fde->dw_fde_switched_sections)
2312             {
2313               dw2_asm_output_addr (DWARF2_ADDR_SIZE,
2314                                    fde->dw_fde_hot_section_label,
2315                                    "FDE initial location");
2316               dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2317                                     fde->dw_fde_hot_section_end_label,
2318                                     fde->dw_fde_hot_section_label,
2319                                     "FDE address range");
2320               dw2_asm_output_addr (DWARF2_ADDR_SIZE,
2321                                    fde->dw_fde_unlikely_section_label,
2322                                    "FDE initial location");
2323               dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2324                                     fde->dw_fde_unlikely_section_end_label,
2325                                     fde->dw_fde_unlikely_section_label,
2326                                     "FDE address range");
2327             }
2328           else
2329             dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2330                                   fde->dw_fde_end, fde->dw_fde_begin,
2331                                   "FDE address range");
2332         }
2333
2334       if (augmentation[0])
2335         {
2336           if (any_lsda_needed)
2337             {
2338               int size = size_of_encoded_value (lsda_encoding);
2339
2340               if (lsda_encoding == DW_EH_PE_aligned)
2341                 {
2342                   int offset = (  4             /* Length */
2343                                 + 4             /* CIE offset */
2344                                 + 2 * size_of_encoded_value (fde_encoding)
2345                                 + 1             /* Augmentation size */ );
2346                   int pad = -offset & (PTR_SIZE - 1);
2347
2348                   size += pad;
2349                   gcc_assert (size_of_uleb128 (size) == 1);
2350                 }
2351
2352               dw2_asm_output_data_uleb128 (size, "Augmentation size");
2353
2354               if (fde->uses_eh_lsda)
2355                 {
2356                   ASM_GENERATE_INTERNAL_LABEL (l1, "LLSDA",
2357                                                fde->funcdef_number);
2358                   dw2_asm_output_encoded_addr_rtx (
2359                         lsda_encoding, gen_rtx_SYMBOL_REF (Pmode, l1),
2360                         "Language Specific Data Area");
2361                 }
2362               else
2363                 {
2364                   if (lsda_encoding == DW_EH_PE_aligned)
2365                     ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
2366                   dw2_asm_output_data
2367                     (size_of_encoded_value (lsda_encoding), 0,
2368                      "Language Specific Data Area (none)");
2369                 }
2370             }
2371           else
2372             dw2_asm_output_data_uleb128 (0, "Augmentation size");
2373         }
2374
2375       /* Loop through the Call Frame Instructions associated with
2376          this FDE.  */
2377       fde->dw_fde_current_label = fde->dw_fde_begin;
2378       for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
2379         output_cfi (cfi, fde, for_eh);
2380
2381       /* Pad the FDE out to an address sized boundary.  */
2382       ASM_OUTPUT_ALIGN (asm_out_file,
2383                         floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
2384       ASM_OUTPUT_LABEL (asm_out_file, l2);
2385     }
2386
2387   if (for_eh && targetm.terminate_dw2_eh_frame_info)
2388     dw2_asm_output_data (4, 0, "End of Table");
2389 #ifdef MIPS_DEBUGGING_INFO
2390   /* Work around Irix 6 assembler bug whereby labels at the end of a section
2391      get a value of 0.  Putting .align 0 after the label fixes it.  */
2392   ASM_OUTPUT_ALIGN (asm_out_file, 0);
2393 #endif
2394
2395   /* Turn off app to make assembly quicker.  */
2396   if (flag_debug_asm)
2397     app_disable ();
2398 }
2399
2400 /* Output a marker (i.e. a label) for the beginning of a function, before
2401    the prologue.  */
2402
2403 void
2404 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
2405                           const char *file ATTRIBUTE_UNUSED)
2406 {
2407   char label[MAX_ARTIFICIAL_LABEL_BYTES];
2408   char * dup_label;
2409   dw_fde_ref fde;
2410
2411   current_function_func_begin_label = NULL;
2412
2413 #ifdef TARGET_UNWIND_INFO
2414   /* ??? current_function_func_begin_label is also used by except.c
2415      for call-site information.  We must emit this label if it might
2416      be used.  */
2417   if ((! flag_exceptions || USING_SJLJ_EXCEPTIONS)
2418       && ! dwarf2out_do_frame ())
2419     return;
2420 #else
2421   if (! dwarf2out_do_frame ())
2422     return;
2423 #endif
2424
2425   function_section (current_function_decl);
2426   ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
2427                                current_function_funcdef_no);
2428   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
2429                           current_function_funcdef_no);
2430   dup_label = xstrdup (label);
2431   current_function_func_begin_label = dup_label;
2432
2433 #ifdef TARGET_UNWIND_INFO
2434   /* We can elide the fde allocation if we're not emitting debug info.  */
2435   if (! dwarf2out_do_frame ())
2436     return;
2437 #endif
2438
2439   /* Expand the fde table if necessary.  */
2440   if (fde_table_in_use == fde_table_allocated)
2441     {
2442       fde_table_allocated += FDE_TABLE_INCREMENT;
2443       fde_table = ggc_realloc (fde_table,
2444                                fde_table_allocated * sizeof (dw_fde_node));
2445       memset (fde_table + fde_table_in_use, 0,
2446               FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
2447     }
2448
2449   /* Record the FDE associated with this function.  */
2450   current_funcdef_fde = fde_table_in_use;
2451
2452   /* Add the new FDE at the end of the fde_table.  */
2453   fde = &fde_table[fde_table_in_use++];
2454   fde->decl = current_function_decl;
2455   fde->dw_fde_begin = dup_label;
2456   fde->dw_fde_current_label = NULL;
2457   fde->dw_fde_hot_section_label = NULL;
2458   fde->dw_fde_hot_section_end_label = NULL;
2459   fde->dw_fde_unlikely_section_label = NULL;
2460   fde->dw_fde_unlikely_section_end_label = NULL;
2461   fde->dw_fde_switched_sections = false;
2462   fde->dw_fde_end = NULL;
2463   fde->dw_fde_cfi = NULL;
2464   fde->funcdef_number = current_function_funcdef_no;
2465   fde->nothrow = TREE_NOTHROW (current_function_decl);
2466   fde->uses_eh_lsda = cfun->uses_eh_lsda;
2467   fde->all_throwers_are_sibcalls = cfun->all_throwers_are_sibcalls;
2468
2469   args_size = old_args_size = 0;
2470
2471   /* We only want to output line number information for the genuine dwarf2
2472      prologue case, not the eh frame case.  */
2473 #ifdef DWARF2_DEBUGGING_INFO
2474   if (file)
2475     dwarf2out_source_line (line, file);
2476 #endif
2477 }
2478
2479 /* Output a marker (i.e. a label) for the absolute end of the generated code
2480    for a function definition.  This gets called *after* the epilogue code has
2481    been generated.  */
2482
2483 void
2484 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
2485                         const char *file ATTRIBUTE_UNUSED)
2486 {
2487   dw_fde_ref fde;
2488   char label[MAX_ARTIFICIAL_LABEL_BYTES];
2489
2490   /* Output a label to mark the endpoint of the code generated for this
2491      function.  */
2492   ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
2493                                current_function_funcdef_no);
2494   ASM_OUTPUT_LABEL (asm_out_file, label);
2495   fde = &fde_table[fde_table_in_use - 1];
2496   fde->dw_fde_end = xstrdup (label);
2497 }
2498
2499 void
2500 dwarf2out_frame_init (void)
2501 {
2502   /* Allocate the initial hunk of the fde_table.  */
2503   fde_table = ggc_alloc_cleared (FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
2504   fde_table_allocated = FDE_TABLE_INCREMENT;
2505   fde_table_in_use = 0;
2506
2507   /* Generate the CFA instructions common to all FDE's.  Do it now for the
2508      sake of lookup_cfa.  */
2509
2510 #ifdef DWARF2_UNWIND_INFO
2511   /* On entry, the Canonical Frame Address is at SP.  */
2512   dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
2513   initial_return_save (INCOMING_RETURN_ADDR_RTX);
2514 #endif
2515 }
2516
2517 void
2518 dwarf2out_frame_finish (void)
2519 {
2520   /* Output call frame information.  */
2521   if (write_symbols == DWARF2_DEBUG
2522       || write_symbols == VMS_AND_DWARF2_DEBUG
2523 #ifdef DWARF2_FRAME_INFO
2524       || DWARF2_FRAME_INFO
2525 #endif
2526       )
2527     output_call_frame_info (0);
2528
2529 #ifndef TARGET_UNWIND_INFO
2530   /* Output another copy for the unwinder.  */
2531   if (! USING_SJLJ_EXCEPTIONS && (flag_unwind_tables || flag_exceptions))
2532     output_call_frame_info (1);
2533 #endif
2534 }
2535 #endif
2536 \f
2537 /* And now, the subset of the debugging information support code necessary
2538    for emitting location expressions.  */
2539
2540 /* We need some way to distinguish DW_OP_addr with a direct symbol
2541    relocation from DW_OP_addr with a dtp-relative symbol relocation.  */
2542 #define INTERNAL_DW_OP_tls_addr         (0x100 + DW_OP_addr)
2543
2544
2545 typedef struct dw_val_struct *dw_val_ref;
2546 typedef struct die_struct *dw_die_ref;
2547 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
2548 typedef struct dw_loc_list_struct *dw_loc_list_ref;
2549
2550 /* Each DIE may have a series of attribute/value pairs.  Values
2551    can take on several forms.  The forms that are used in this
2552    implementation are listed below.  */
2553
2554 enum dw_val_class
2555 {
2556   dw_val_class_addr,
2557   dw_val_class_offset,
2558   dw_val_class_loc,
2559   dw_val_class_loc_list,
2560   dw_val_class_range_list,
2561   dw_val_class_const,
2562   dw_val_class_unsigned_const,
2563   dw_val_class_long_long,
2564   dw_val_class_vec,
2565   dw_val_class_flag,
2566   dw_val_class_die_ref,
2567   dw_val_class_fde_ref,
2568   dw_val_class_lbl_id,
2569   dw_val_class_lbl_offset,
2570   dw_val_class_str
2571 };
2572
2573 /* Describe a double word constant value.  */
2574 /* ??? Every instance of long_long in the code really means CONST_DOUBLE.  */
2575
2576 typedef struct dw_long_long_struct GTY(())
2577 {
2578   unsigned long hi;
2579   unsigned long low;
2580 }
2581 dw_long_long_const;
2582
2583 /* Describe a floating point constant value, or a vector constant value.  */
2584
2585 typedef struct dw_vec_struct GTY(())
2586 {
2587   unsigned char * GTY((length ("%h.length"))) array;
2588   unsigned length;
2589   unsigned elt_size;
2590 }
2591 dw_vec_const;
2592
2593 /* The dw_val_node describes an attribute's value, as it is
2594    represented internally.  */
2595
2596 typedef struct dw_val_struct GTY(())
2597 {
2598   enum dw_val_class val_class;
2599   union dw_val_struct_union
2600     {
2601       rtx GTY ((tag ("dw_val_class_addr"))) val_addr;
2602       unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset;
2603       dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list;
2604       dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc;
2605       HOST_WIDE_INT GTY ((default)) val_int;
2606       unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned;
2607       dw_long_long_const GTY ((tag ("dw_val_class_long_long"))) val_long_long;
2608       dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec;
2609       struct dw_val_die_union
2610         {
2611           dw_die_ref die;
2612           int external;
2613         } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref;
2614       unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index;
2615       struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str;
2616       char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id;
2617       unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag;
2618     }
2619   GTY ((desc ("%1.val_class"))) v;
2620 }
2621 dw_val_node;
2622
2623 /* Locations in memory are described using a sequence of stack machine
2624    operations.  */
2625
2626 typedef struct dw_loc_descr_struct GTY(())
2627 {
2628   dw_loc_descr_ref dw_loc_next;
2629   enum dwarf_location_atom dw_loc_opc;
2630   dw_val_node dw_loc_oprnd1;
2631   dw_val_node dw_loc_oprnd2;
2632   int dw_loc_addr;
2633 }
2634 dw_loc_descr_node;
2635
2636 /* Location lists are ranges + location descriptions for that range,
2637    so you can track variables that are in different places over
2638    their entire life.  */
2639 typedef struct dw_loc_list_struct GTY(())
2640 {
2641   dw_loc_list_ref dw_loc_next;
2642   const char *begin; /* Label for begin address of range */
2643   const char *end;  /* Label for end address of range */
2644   char *ll_symbol; /* Label for beginning of location list.
2645                       Only on head of list */
2646   const char *section; /* Section this loclist is relative to */
2647   dw_loc_descr_ref expr;
2648 } dw_loc_list_node;
2649
2650 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
2651
2652 static const char *dwarf_stack_op_name (unsigned);
2653 static dw_loc_descr_ref new_loc_descr (enum dwarf_location_atom,
2654                                        unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT);
2655 static void add_loc_descr (dw_loc_descr_ref *, dw_loc_descr_ref);
2656 static unsigned long size_of_loc_descr (dw_loc_descr_ref);
2657 static unsigned long size_of_locs (dw_loc_descr_ref);
2658 static void output_loc_operands (dw_loc_descr_ref);
2659 static void output_loc_sequence (dw_loc_descr_ref);
2660
2661 /* Convert a DWARF stack opcode into its string name.  */
2662
2663 static const char *
2664 dwarf_stack_op_name (unsigned int op)
2665 {
2666   switch (op)
2667     {
2668     case DW_OP_addr:
2669     case INTERNAL_DW_OP_tls_addr:
2670       return "DW_OP_addr";
2671     case DW_OP_deref:
2672       return "DW_OP_deref";
2673     case DW_OP_const1u:
2674       return "DW_OP_const1u";
2675     case DW_OP_const1s:
2676       return "DW_OP_const1s";
2677     case DW_OP_const2u:
2678       return "DW_OP_const2u";
2679     case DW_OP_const2s:
2680       return "DW_OP_const2s";
2681     case DW_OP_const4u:
2682       return "DW_OP_const4u";
2683     case DW_OP_const4s:
2684       return "DW_OP_const4s";
2685     case DW_OP_const8u:
2686       return "DW_OP_const8u";
2687     case DW_OP_const8s:
2688       return "DW_OP_const8s";
2689     case DW_OP_constu:
2690       return "DW_OP_constu";
2691     case DW_OP_consts:
2692       return "DW_OP_consts";
2693     case DW_OP_dup:
2694       return "DW_OP_dup";
2695     case DW_OP_drop:
2696       return "DW_OP_drop";
2697     case DW_OP_over:
2698       return "DW_OP_over";
2699     case DW_OP_pick:
2700       return "DW_OP_pick";
2701     case DW_OP_swap:
2702       return "DW_OP_swap";
2703     case DW_OP_rot:
2704       return "DW_OP_rot";
2705     case DW_OP_xderef:
2706       return "DW_OP_xderef";
2707     case DW_OP_abs:
2708       return "DW_OP_abs";
2709     case DW_OP_and:
2710       return "DW_OP_and";
2711     case DW_OP_div:
2712       return "DW_OP_div";
2713     case DW_OP_minus:
2714       return "DW_OP_minus";
2715     case DW_OP_mod:
2716       return "DW_OP_mod";
2717     case DW_OP_mul:
2718       return "DW_OP_mul";
2719     case DW_OP_neg:
2720       return "DW_OP_neg";
2721     case DW_OP_not:
2722       return "DW_OP_not";
2723     case DW_OP_or:
2724       return "DW_OP_or";
2725     case DW_OP_plus:
2726       return "DW_OP_plus";
2727     case DW_OP_plus_uconst:
2728       return "DW_OP_plus_uconst";
2729     case DW_OP_shl:
2730       return "DW_OP_shl";
2731     case DW_OP_shr:
2732       return "DW_OP_shr";
2733     case DW_OP_shra:
2734       return "DW_OP_shra";
2735     case DW_OP_xor:
2736       return "DW_OP_xor";
2737     case DW_OP_bra:
2738       return "DW_OP_bra";
2739     case DW_OP_eq:
2740       return "DW_OP_eq";
2741     case DW_OP_ge:
2742       return "DW_OP_ge";
2743     case DW_OP_gt:
2744       return "DW_OP_gt";
2745     case DW_OP_le:
2746       return "DW_OP_le";
2747     case DW_OP_lt:
2748       return "DW_OP_lt";
2749     case DW_OP_ne:
2750       return "DW_OP_ne";
2751     case DW_OP_skip:
2752       return "DW_OP_skip";
2753     case DW_OP_lit0:
2754       return "DW_OP_lit0";
2755     case DW_OP_lit1:
2756       return "DW_OP_lit1";
2757     case DW_OP_lit2:
2758       return "DW_OP_lit2";
2759     case DW_OP_lit3:
2760       return "DW_OP_lit3";
2761     case DW_OP_lit4:
2762       return "DW_OP_lit4";
2763     case DW_OP_lit5:
2764       return "DW_OP_lit5";
2765     case DW_OP_lit6:
2766       return "DW_OP_lit6";
2767     case DW_OP_lit7:
2768       return "DW_OP_lit7";
2769     case DW_OP_lit8:
2770       return "DW_OP_lit8";
2771     case DW_OP_lit9:
2772       return "DW_OP_lit9";
2773     case DW_OP_lit10:
2774       return "DW_OP_lit10";
2775     case DW_OP_lit11:
2776       return "DW_OP_lit11";
2777     case DW_OP_lit12:
2778       return "DW_OP_lit12";
2779     case DW_OP_lit13:
2780       return "DW_OP_lit13";
2781     case DW_OP_lit14:
2782       return "DW_OP_lit14";
2783     case DW_OP_lit15:
2784       return "DW_OP_lit15";
2785     case DW_OP_lit16:
2786       return "DW_OP_lit16";
2787     case DW_OP_lit17:
2788       return "DW_OP_lit17";
2789     case DW_OP_lit18:
2790       return "DW_OP_lit18";
2791     case DW_OP_lit19:
2792       return "DW_OP_lit19";
2793     case DW_OP_lit20:
2794       return "DW_OP_lit20";
2795     case DW_OP_lit21:
2796       return "DW_OP_lit21";
2797     case DW_OP_lit22:
2798       return "DW_OP_lit22";
2799     case DW_OP_lit23:
2800       return "DW_OP_lit23";
2801     case DW_OP_lit24:
2802       return "DW_OP_lit24";
2803     case DW_OP_lit25:
2804       return "DW_OP_lit25";
2805     case DW_OP_lit26:
2806       return "DW_OP_lit26";
2807     case DW_OP_lit27:
2808       return "DW_OP_lit27";
2809     case DW_OP_lit28:
2810       return "DW_OP_lit28";
2811     case DW_OP_lit29:
2812       return "DW_OP_lit29";
2813     case DW_OP_lit30:
2814       return "DW_OP_lit30";
2815     case DW_OP_lit31:
2816       return "DW_OP_lit31";
2817     case DW_OP_reg0:
2818       return "DW_OP_reg0";
2819     case DW_OP_reg1:
2820       return "DW_OP_reg1";
2821     case DW_OP_reg2:
2822       return "DW_OP_reg2";
2823     case DW_OP_reg3:
2824       return "DW_OP_reg3";
2825     case DW_OP_reg4:
2826       return "DW_OP_reg4";
2827     case DW_OP_reg5:
2828       return "DW_OP_reg5";
2829     case DW_OP_reg6:
2830       return "DW_OP_reg6";
2831     case DW_OP_reg7:
2832       return "DW_OP_reg7";
2833     case DW_OP_reg8:
2834       return "DW_OP_reg8";
2835     case DW_OP_reg9:
2836       return "DW_OP_reg9";
2837     case DW_OP_reg10:
2838       return "DW_OP_reg10";
2839     case DW_OP_reg11:
2840       return "DW_OP_reg11";
2841     case DW_OP_reg12:
2842       return "DW_OP_reg12";
2843     case DW_OP_reg13:
2844       return "DW_OP_reg13";
2845     case DW_OP_reg14:
2846       return "DW_OP_reg14";
2847     case DW_OP_reg15:
2848       return "DW_OP_reg15";
2849     case DW_OP_reg16:
2850       return "DW_OP_reg16";
2851     case DW_OP_reg17:
2852       return "DW_OP_reg17";
2853     case DW_OP_reg18:
2854       return "DW_OP_reg18";
2855     case DW_OP_reg19:
2856       return "DW_OP_reg19";
2857     case DW_OP_reg20:
2858       return "DW_OP_reg20";
2859     case DW_OP_reg21:
2860       return "DW_OP_reg21";
2861     case DW_OP_reg22:
2862       return "DW_OP_reg22";
2863     case DW_OP_reg23:
2864       return "DW_OP_reg23";
2865     case DW_OP_reg24:
2866       return "DW_OP_reg24";
2867     case DW_OP_reg25:
2868       return "DW_OP_reg25";
2869     case DW_OP_reg26:
2870       return "DW_OP_reg26";
2871     case DW_OP_reg27:
2872       return "DW_OP_reg27";
2873     case DW_OP_reg28:
2874       return "DW_OP_reg28";
2875     case DW_OP_reg29:
2876       return "DW_OP_reg29";
2877     case DW_OP_reg30:
2878       return "DW_OP_reg30";
2879     case DW_OP_reg31:
2880       return "DW_OP_reg31";
2881     case DW_OP_breg0:
2882       return "DW_OP_breg0";
2883     case DW_OP_breg1:
2884       return "DW_OP_breg1";
2885     case DW_OP_breg2:
2886       return "DW_OP_breg2";
2887     case DW_OP_breg3:
2888       return "DW_OP_breg3";
2889     case DW_OP_breg4:
2890       return "DW_OP_breg4";
2891     case DW_OP_breg5:
2892       return "DW_OP_breg5";
2893     case DW_OP_breg6:
2894       return "DW_OP_breg6";
2895     case DW_OP_breg7:
2896       return "DW_OP_breg7";
2897     case DW_OP_breg8:
2898       return "DW_OP_breg8";
2899     case DW_OP_breg9:
2900       return "DW_OP_breg9";
2901     case DW_OP_breg10:
2902       return "DW_OP_breg10";
2903     case DW_OP_breg11:
2904       return "DW_OP_breg11";
2905     case DW_OP_breg12:
2906       return "DW_OP_breg12";
2907     case DW_OP_breg13:
2908       return "DW_OP_breg13";
2909     case DW_OP_breg14:
2910       return "DW_OP_breg14";
2911     case DW_OP_breg15:
2912       return "DW_OP_breg15";
2913     case DW_OP_breg16:
2914       return "DW_OP_breg16";
2915     case DW_OP_breg17:
2916       return "DW_OP_breg17";
2917     case DW_OP_breg18:
2918       return "DW_OP_breg18";
2919     case DW_OP_breg19:
2920       return "DW_OP_breg19";
2921     case DW_OP_breg20:
2922       return "DW_OP_breg20";
2923     case DW_OP_breg21:
2924       return "DW_OP_breg21";
2925     case DW_OP_breg22:
2926       return "DW_OP_breg22";
2927     case DW_OP_breg23:
2928       return "DW_OP_breg23";
2929     case DW_OP_breg24:
2930       return "DW_OP_breg24";
2931     case DW_OP_breg25:
2932       return "DW_OP_breg25";
2933     case DW_OP_breg26:
2934       return "DW_OP_breg26";
2935     case DW_OP_breg27:
2936       return "DW_OP_breg27";
2937     case DW_OP_breg28:
2938       return "DW_OP_breg28";
2939     case DW_OP_breg29:
2940       return "DW_OP_breg29";
2941     case DW_OP_breg30:
2942       return "DW_OP_breg30";
2943     case DW_OP_breg31:
2944       return "DW_OP_breg31";
2945     case DW_OP_regx:
2946       return "DW_OP_regx";
2947     case DW_OP_fbreg:
2948       return "DW_OP_fbreg";
2949     case DW_OP_bregx:
2950       return "DW_OP_bregx";
2951     case DW_OP_piece:
2952       return "DW_OP_piece";
2953     case DW_OP_deref_size:
2954       return "DW_OP_deref_size";
2955     case DW_OP_xderef_size:
2956       return "DW_OP_xderef_size";
2957     case DW_OP_nop:
2958       return "DW_OP_nop";
2959     case DW_OP_push_object_address:
2960       return "DW_OP_push_object_address";
2961     case DW_OP_call2:
2962       return "DW_OP_call2";
2963     case DW_OP_call4:
2964       return "DW_OP_call4";
2965     case DW_OP_call_ref:
2966       return "DW_OP_call_ref";
2967     case DW_OP_GNU_push_tls_address:
2968       return "DW_OP_GNU_push_tls_address";
2969     default:
2970       return "OP_<unknown>";
2971     }
2972 }
2973
2974 /* Return a pointer to a newly allocated location description.  Location
2975    descriptions are simple expression terms that can be strung
2976    together to form more complicated location (address) descriptions.  */
2977
2978 static inline dw_loc_descr_ref
2979 new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
2980                unsigned HOST_WIDE_INT oprnd2)
2981 {
2982   dw_loc_descr_ref descr = ggc_alloc_cleared (sizeof (dw_loc_descr_node));
2983
2984   descr->dw_loc_opc = op;
2985   descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
2986   descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
2987   descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
2988   descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
2989
2990   return descr;
2991 }
2992
2993
2994 /* Add a location description term to a location description expression.  */
2995
2996 static inline void
2997 add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
2998 {
2999   dw_loc_descr_ref *d;
3000
3001   /* Find the end of the chain.  */
3002   for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
3003     ;
3004
3005   *d = descr;
3006 }
3007
3008 /* Return the size of a location descriptor.  */
3009
3010 static unsigned long
3011 size_of_loc_descr (dw_loc_descr_ref loc)
3012 {
3013   unsigned long size = 1;
3014
3015   switch (loc->dw_loc_opc)
3016     {
3017     case DW_OP_addr:
3018     case INTERNAL_DW_OP_tls_addr:
3019       size += DWARF2_ADDR_SIZE;
3020       break;
3021     case DW_OP_const1u:
3022     case DW_OP_const1s:
3023       size += 1;
3024       break;
3025     case DW_OP_const2u:
3026     case DW_OP_const2s:
3027       size += 2;
3028       break;
3029     case DW_OP_const4u:
3030     case DW_OP_const4s:
3031       size += 4;
3032       break;
3033     case DW_OP_const8u:
3034     case DW_OP_const8s:
3035       size += 8;
3036       break;
3037     case DW_OP_constu:
3038       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3039       break;
3040     case DW_OP_consts:
3041       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3042       break;
3043     case DW_OP_pick:
3044       size += 1;
3045       break;
3046     case DW_OP_plus_uconst:
3047       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3048       break;
3049     case DW_OP_skip:
3050     case DW_OP_bra:
3051       size += 2;
3052       break;
3053     case DW_OP_breg0:
3054     case DW_OP_breg1:
3055     case DW_OP_breg2:
3056     case DW_OP_breg3:
3057     case DW_OP_breg4:
3058     case DW_OP_breg5:
3059     case DW_OP_breg6:
3060     case DW_OP_breg7:
3061     case DW_OP_breg8:
3062     case DW_OP_breg9:
3063     case DW_OP_breg10:
3064     case DW_OP_breg11:
3065     case DW_OP_breg12:
3066     case DW_OP_breg13:
3067     case DW_OP_breg14:
3068     case DW_OP_breg15:
3069     case DW_OP_breg16:
3070     case DW_OP_breg17:
3071     case DW_OP_breg18:
3072     case DW_OP_breg19:
3073     case DW_OP_breg20:
3074     case DW_OP_breg21:
3075     case DW_OP_breg22:
3076     case DW_OP_breg23:
3077     case DW_OP_breg24:
3078     case DW_OP_breg25:
3079     case DW_OP_breg26:
3080     case DW_OP_breg27:
3081     case DW_OP_breg28:
3082     case DW_OP_breg29:
3083     case DW_OP_breg30:
3084     case DW_OP_breg31:
3085       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3086       break;
3087     case DW_OP_regx:
3088       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3089       break;
3090     case DW_OP_fbreg:
3091       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3092       break;
3093     case DW_OP_bregx:
3094       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3095       size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
3096       break;
3097     case DW_OP_piece:
3098       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3099       break;
3100     case DW_OP_deref_size:
3101     case DW_OP_xderef_size:
3102       size += 1;
3103       break;
3104     case DW_OP_call2:
3105       size += 2;
3106       break;
3107     case DW_OP_call4:
3108       size += 4;
3109       break;
3110     case DW_OP_call_ref:
3111       size += DWARF2_ADDR_SIZE;
3112       break;
3113     default:
3114       break;
3115     }
3116
3117   return size;
3118 }
3119
3120 /* Return the size of a series of location descriptors.  */
3121
3122 static unsigned long
3123 size_of_locs (dw_loc_descr_ref loc)
3124 {
3125   unsigned long size;
3126
3127   for (size = 0; loc != NULL; loc = loc->dw_loc_next)
3128     {
3129       loc->dw_loc_addr = size;
3130       size += size_of_loc_descr (loc);
3131     }
3132
3133   return size;
3134 }
3135
3136 /* Output location description stack opcode's operands (if any).  */
3137
3138 static void
3139 output_loc_operands (dw_loc_descr_ref loc)
3140 {
3141   dw_val_ref val1 = &loc->dw_loc_oprnd1;
3142   dw_val_ref val2 = &loc->dw_loc_oprnd2;
3143
3144   switch (loc->dw_loc_opc)
3145     {
3146 #ifdef DWARF2_DEBUGGING_INFO
3147     case DW_OP_addr:
3148       dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
3149       break;
3150     case DW_OP_const2u:
3151     case DW_OP_const2s:
3152       dw2_asm_output_data (2, val1->v.val_int, NULL);
3153       break;
3154     case DW_OP_const4u:
3155     case DW_OP_const4s:
3156       dw2_asm_output_data (4, val1->v.val_int, NULL);
3157       break;
3158     case DW_OP_const8u:
3159     case DW_OP_const8s:
3160       gcc_assert (HOST_BITS_PER_LONG >= 64);
3161       dw2_asm_output_data (8, val1->v.val_int, NULL);
3162       break;
3163     case DW_OP_skip:
3164     case DW_OP_bra:
3165       {
3166         int offset;
3167
3168         gcc_assert (val1->val_class == dw_val_class_loc);
3169         offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
3170
3171         dw2_asm_output_data (2, offset, NULL);
3172       }
3173       break;
3174 #else
3175     case DW_OP_addr:
3176     case DW_OP_const2u:
3177     case DW_OP_const2s:
3178     case DW_OP_const4u:
3179     case DW_OP_const4s:
3180     case DW_OP_const8u:
3181     case DW_OP_const8s:
3182     case DW_OP_skip:
3183     case DW_OP_bra:
3184       /* We currently don't make any attempt to make sure these are
3185          aligned properly like we do for the main unwind info, so
3186          don't support emitting things larger than a byte if we're
3187          only doing unwinding.  */
3188       gcc_unreachable ();
3189 #endif
3190     case DW_OP_const1u:
3191     case DW_OP_const1s:
3192       dw2_asm_output_data (1, val1->v.val_int, NULL);
3193       break;
3194     case DW_OP_constu:
3195       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3196       break;
3197     case DW_OP_consts:
3198       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3199       break;
3200     case DW_OP_pick:
3201       dw2_asm_output_data (1, val1->v.val_int, NULL);
3202       break;
3203     case DW_OP_plus_uconst:
3204       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3205       break;
3206     case DW_OP_breg0:
3207     case DW_OP_breg1:
3208     case DW_OP_breg2:
3209     case DW_OP_breg3:
3210     case DW_OP_breg4:
3211     case DW_OP_breg5:
3212     case DW_OP_breg6:
3213     case DW_OP_breg7:
3214     case DW_OP_breg8:
3215     case DW_OP_breg9:
3216     case DW_OP_breg10:
3217     case DW_OP_breg11:
3218     case DW_OP_breg12:
3219     case DW_OP_breg13:
3220     case DW_OP_breg14:
3221     case DW_OP_breg15:
3222     case DW_OP_breg16:
3223     case DW_OP_breg17:
3224     case DW_OP_breg18:
3225     case DW_OP_breg19:
3226     case DW_OP_breg20:
3227     case DW_OP_breg21:
3228     case DW_OP_breg22:
3229     case DW_OP_breg23:
3230     case DW_OP_breg24:
3231     case DW_OP_breg25:
3232     case DW_OP_breg26:
3233     case DW_OP_breg27:
3234     case DW_OP_breg28:
3235     case DW_OP_breg29:
3236     case DW_OP_breg30:
3237     case DW_OP_breg31:
3238       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3239       break;
3240     case DW_OP_regx:
3241       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3242       break;
3243     case DW_OP_fbreg:
3244       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3245       break;
3246     case DW_OP_bregx:
3247       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3248       dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
3249       break;
3250     case DW_OP_piece:
3251       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3252       break;
3253     case DW_OP_deref_size:
3254     case DW_OP_xderef_size:
3255       dw2_asm_output_data (1, val1->v.val_int, NULL);
3256       break;
3257
3258     case INTERNAL_DW_OP_tls_addr:
3259 #ifdef ASM_OUTPUT_DWARF_DTPREL
3260       ASM_OUTPUT_DWARF_DTPREL (asm_out_file, DWARF2_ADDR_SIZE,
3261                                val1->v.val_addr);
3262       fputc ('\n', asm_out_file);
3263 #else
3264       gcc_unreachable ();
3265 #endif
3266       break;
3267
3268     default:
3269       /* Other codes have no operands.  */
3270       break;
3271     }
3272 }
3273
3274 /* Output a sequence of location operations.  */
3275
3276 static void
3277 output_loc_sequence (dw_loc_descr_ref loc)
3278 {
3279   for (; loc != NULL; loc = loc->dw_loc_next)
3280     {
3281       /* Output the opcode.  */
3282       dw2_asm_output_data (1, loc->dw_loc_opc,
3283                            "%s", dwarf_stack_op_name (loc->dw_loc_opc));
3284
3285       /* Output the operand(s) (if any).  */
3286       output_loc_operands (loc);
3287     }
3288 }
3289
3290 /* This routine will generate the correct assembly data for a location
3291    description based on a cfi entry with a complex address.  */
3292
3293 static void
3294 output_cfa_loc (dw_cfi_ref cfi)
3295 {
3296   dw_loc_descr_ref loc;
3297   unsigned long size;
3298
3299   /* Output the size of the block.  */
3300   loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
3301   size = size_of_locs (loc);
3302   dw2_asm_output_data_uleb128 (size, NULL);
3303
3304   /* Now output the operations themselves.  */
3305   output_loc_sequence (loc);
3306 }
3307
3308 /* This function builds a dwarf location descriptor sequence from
3309    a dw_cfa_location.  */
3310
3311 static struct dw_loc_descr_struct *
3312 build_cfa_loc (dw_cfa_location *cfa)
3313 {
3314   struct dw_loc_descr_struct *head, *tmp;
3315
3316   gcc_assert (cfa->indirect);
3317
3318   if (cfa->base_offset)
3319     {
3320       if (cfa->reg <= 31)
3321         head = new_loc_descr (DW_OP_breg0 + cfa->reg, cfa->base_offset, 0);
3322       else
3323         head = new_loc_descr (DW_OP_bregx, cfa->reg, cfa->base_offset);
3324     }
3325   else if (cfa->reg <= 31)
3326     head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0);
3327   else
3328     head = new_loc_descr (DW_OP_regx, cfa->reg, 0);
3329
3330   head->dw_loc_oprnd1.val_class = dw_val_class_const;
3331   tmp = new_loc_descr (DW_OP_deref, 0, 0);
3332   add_loc_descr (&head, tmp);
3333   if (cfa->offset != 0)
3334     {
3335       tmp = new_loc_descr (DW_OP_plus_uconst, cfa->offset, 0);
3336       add_loc_descr (&head, tmp);
3337     }
3338
3339   return head;
3340 }
3341
3342 /* This function fills in aa dw_cfa_location structure from a dwarf location
3343    descriptor sequence.  */
3344
3345 static void
3346 get_cfa_from_loc_descr (dw_cfa_location *cfa, struct dw_loc_descr_struct *loc)
3347 {
3348   struct dw_loc_descr_struct *ptr;
3349   cfa->offset = 0;
3350   cfa->base_offset = 0;
3351   cfa->indirect = 0;
3352   cfa->reg = -1;
3353
3354   for (ptr = loc; ptr != NULL; ptr = ptr->dw_loc_next)
3355     {
3356       enum dwarf_location_atom op = ptr->dw_loc_opc;
3357
3358       switch (op)
3359         {
3360         case DW_OP_reg0:
3361         case DW_OP_reg1:
3362         case DW_OP_reg2:
3363         case DW_OP_reg3:
3364         case DW_OP_reg4:
3365         case DW_OP_reg5:
3366         case DW_OP_reg6:
3367         case DW_OP_reg7:
3368         case DW_OP_reg8:
3369         case DW_OP_reg9:
3370         case DW_OP_reg10:
3371         case DW_OP_reg11:
3372         case DW_OP_reg12:
3373         case DW_OP_reg13:
3374         case DW_OP_reg14:
3375         case DW_OP_reg15:
3376         case DW_OP_reg16:
3377         case DW_OP_reg17:
3378         case DW_OP_reg18:
3379         case DW_OP_reg19:
3380         case DW_OP_reg20:
3381         case DW_OP_reg21:
3382         case DW_OP_reg22:
3383         case DW_OP_reg23:
3384         case DW_OP_reg24:
3385         case DW_OP_reg25:
3386         case DW_OP_reg26:
3387         case DW_OP_reg27:
3388         case DW_OP_reg28:
3389         case DW_OP_reg29:
3390         case DW_OP_reg30:
3391         case DW_OP_reg31:
3392           cfa->reg = op - DW_OP_reg0;
3393           break;
3394         case DW_OP_regx:
3395           cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
3396           break;
3397         case DW_OP_breg0:
3398         case DW_OP_breg1:
3399         case DW_OP_breg2:
3400         case DW_OP_breg3:
3401         case DW_OP_breg4:
3402         case DW_OP_breg5:
3403         case DW_OP_breg6:
3404         case DW_OP_breg7:
3405         case DW_OP_breg8:
3406         case DW_OP_breg9:
3407         case DW_OP_breg10:
3408         case DW_OP_breg11:
3409         case DW_OP_breg12:
3410         case DW_OP_breg13:
3411         case DW_OP_breg14:
3412         case DW_OP_breg15:
3413         case DW_OP_breg16:
3414         case DW_OP_breg17:
3415         case DW_OP_breg18:
3416         case DW_OP_breg19:
3417         case DW_OP_breg20:
3418         case DW_OP_breg21:
3419         case DW_OP_breg22:
3420         case DW_OP_breg23:
3421         case DW_OP_breg24:
3422         case DW_OP_breg25:
3423         case DW_OP_breg26:
3424         case DW_OP_breg27:
3425         case DW_OP_breg28:
3426         case DW_OP_breg29:
3427         case DW_OP_breg30:
3428         case DW_OP_breg31:
3429           cfa->reg = op - DW_OP_breg0;
3430           cfa->base_offset = ptr->dw_loc_oprnd1.v.val_int;
3431           break;
3432         case DW_OP_bregx:
3433           cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
3434           cfa->base_offset = ptr->dw_loc_oprnd2.v.val_int;
3435           break;
3436         case DW_OP_deref:
3437           cfa->indirect = 1;
3438           break;
3439         case DW_OP_plus_uconst:
3440           cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned;
3441           break;
3442         default:
3443           internal_error ("DW_LOC_OP %s not implemented\n",
3444                           dwarf_stack_op_name (ptr->dw_loc_opc));
3445         }
3446     }
3447 }
3448 #endif /* .debug_frame support */
3449 \f
3450 /* And now, the support for symbolic debugging information.  */
3451 #ifdef DWARF2_DEBUGGING_INFO
3452
3453 /* .debug_str support.  */
3454 static int output_indirect_string (void **, void *);
3455
3456 static void dwarf2out_init (const char *);
3457 static void dwarf2out_finish (const char *);
3458 static void dwarf2out_define (unsigned int, const char *);
3459 static void dwarf2out_undef (unsigned int, const char *);
3460 static void dwarf2out_start_source_file (unsigned, const char *);
3461 static void dwarf2out_end_source_file (unsigned);
3462 static void dwarf2out_begin_block (unsigned, unsigned);
3463 static void dwarf2out_end_block (unsigned, unsigned);
3464 static bool dwarf2out_ignore_block (tree);
3465 static void dwarf2out_global_decl (tree);
3466 static void dwarf2out_type_decl (tree, int);
3467 static void dwarf2out_imported_module_or_decl (tree, tree);
3468 static void dwarf2out_abstract_function (tree);
3469 static void dwarf2out_var_location (rtx);
3470 static void dwarf2out_begin_function (tree);
3471 static void dwarf2out_switch_text_section (void);
3472
3473 /* The debug hooks structure.  */
3474
3475 const struct gcc_debug_hooks dwarf2_debug_hooks =
3476 {
3477   dwarf2out_init,
3478   dwarf2out_finish,
3479   dwarf2out_define,
3480   dwarf2out_undef,
3481   dwarf2out_start_source_file,
3482   dwarf2out_end_source_file,
3483   dwarf2out_begin_block,
3484   dwarf2out_end_block,
3485   dwarf2out_ignore_block,
3486   dwarf2out_source_line,
3487   dwarf2out_begin_prologue,
3488   debug_nothing_int_charstar,   /* end_prologue */
3489   dwarf2out_end_epilogue,
3490   dwarf2out_begin_function,
3491   debug_nothing_int,            /* end_function */
3492   dwarf2out_decl,               /* function_decl */
3493   dwarf2out_global_decl,
3494   dwarf2out_type_decl,          /* type_decl */
3495   dwarf2out_imported_module_or_decl,
3496   debug_nothing_tree,           /* deferred_inline_function */
3497   /* The DWARF 2 backend tries to reduce debugging bloat by not
3498      emitting the abstract description of inline functions until
3499      something tries to reference them.  */
3500   dwarf2out_abstract_function,  /* outlining_inline_function */
3501   debug_nothing_rtx,            /* label */
3502   debug_nothing_int,            /* handle_pch */
3503   dwarf2out_var_location,
3504   dwarf2out_switch_text_section,
3505   1                             /* start_end_main_source_file */
3506 };
3507 #endif
3508 \f
3509 /* NOTE: In the comments in this file, many references are made to
3510    "Debugging Information Entries".  This term is abbreviated as `DIE'
3511    throughout the remainder of this file.  */
3512
3513 /* An internal representation of the DWARF output is built, and then
3514    walked to generate the DWARF debugging info.  The walk of the internal
3515    representation is done after the entire program has been compiled.
3516    The types below are used to describe the internal representation.  */
3517
3518 /* Various DIE's use offsets relative to the beginning of the
3519    .debug_info section to refer to each other.  */
3520
3521 typedef long int dw_offset;
3522
3523 /* Define typedefs here to avoid circular dependencies.  */
3524
3525 typedef struct dw_attr_struct *dw_attr_ref;
3526 typedef struct dw_line_info_struct *dw_line_info_ref;
3527 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
3528 typedef struct pubname_struct *pubname_ref;
3529 typedef struct dw_ranges_struct *dw_ranges_ref;
3530
3531 /* Each entry in the line_info_table maintains the file and
3532    line number associated with the label generated for that
3533    entry.  The label gives the PC value associated with
3534    the line number entry.  */
3535
3536 typedef struct dw_line_info_struct GTY(())
3537 {
3538   unsigned long dw_file_num;
3539   unsigned long dw_line_num;
3540 }
3541 dw_line_info_entry;
3542
3543 /* Line information for functions in separate sections; each one gets its
3544    own sequence.  */
3545 typedef struct dw_separate_line_info_struct GTY(())
3546 {
3547   unsigned long dw_file_num;
3548   unsigned long dw_line_num;
3549   unsigned long function;
3550 }
3551 dw_separate_line_info_entry;
3552
3553 /* Each DIE attribute has a field specifying the attribute kind,
3554    a link to the next attribute in the chain, and an attribute value.
3555    Attributes are typically linked below the DIE they modify.  */
3556
3557 typedef struct dw_attr_struct GTY(())
3558 {
3559   enum dwarf_attribute dw_attr;
3560   dw_attr_ref dw_attr_next;
3561   dw_val_node dw_attr_val;
3562 }
3563 dw_attr_node;
3564
3565 /* The Debugging Information Entry (DIE) structure */
3566
3567 typedef struct die_struct GTY(())
3568 {
3569   enum dwarf_tag die_tag;
3570   char *die_symbol;
3571   dw_attr_ref die_attr;
3572   dw_die_ref die_parent;
3573   dw_die_ref die_child;
3574   dw_die_ref die_sib;
3575   dw_die_ref die_definition; /* ref from a specification to its definition */
3576   dw_offset die_offset;
3577   unsigned long die_abbrev;
3578   int die_mark;
3579   unsigned int decl_id;
3580 }
3581 die_node;
3582
3583 /* The pubname structure */
3584
3585 typedef struct pubname_struct GTY(())
3586 {
3587   dw_die_ref die;
3588   char *name;
3589 }
3590 pubname_entry;
3591
3592 struct dw_ranges_struct GTY(())
3593 {
3594   int block_num;
3595 };
3596
3597 /* The limbo die list structure.  */
3598 typedef struct limbo_die_struct GTY(())
3599 {
3600   dw_die_ref die;
3601   tree created_for;
3602   struct limbo_die_struct *next;
3603 }
3604 limbo_die_node;
3605
3606 /* How to start an assembler comment.  */
3607 #ifndef ASM_COMMENT_START
3608 #define ASM_COMMENT_START ";#"
3609 #endif
3610
3611 /* Define a macro which returns nonzero for a TYPE_DECL which was
3612    implicitly generated for a tagged type.
3613
3614    Note that unlike the gcc front end (which generates a NULL named
3615    TYPE_DECL node for each complete tagged type, each array type, and
3616    each function type node created) the g++ front end generates a
3617    _named_ TYPE_DECL node for each tagged type node created.
3618    These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
3619    generate a DW_TAG_typedef DIE for them.  */
3620
3621 #define TYPE_DECL_IS_STUB(decl)                         \
3622   (DECL_NAME (decl) == NULL_TREE                        \
3623    || (DECL_ARTIFICIAL (decl)                           \
3624        && is_tagged_type (TREE_TYPE (decl))             \
3625        && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl)))  \
3626            /* This is necessary for stub decls that     \
3627               appear in nested inline functions.  */    \
3628            || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
3629                && (decl_ultimate_origin (decl)          \
3630                    == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
3631
3632 /* Information concerning the compilation unit's programming
3633    language, and compiler version.  */
3634
3635 /* Fixed size portion of the DWARF compilation unit header.  */
3636 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
3637   (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
3638
3639 /* Fixed size portion of public names info.  */
3640 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
3641
3642 /* Fixed size portion of the address range info.  */
3643 #define DWARF_ARANGES_HEADER_SIZE                                       \
3644   (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4,      \
3645                 DWARF2_ADDR_SIZE * 2)                                   \
3646    - DWARF_INITIAL_LENGTH_SIZE)
3647
3648 /* Size of padding portion in the address range info.  It must be
3649    aligned to twice the pointer size.  */
3650 #define DWARF_ARANGES_PAD_SIZE \
3651   (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3652                 DWARF2_ADDR_SIZE * 2) \
3653    - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
3654
3655 /* Use assembler line directives if available.  */
3656 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
3657 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
3658 #define DWARF2_ASM_LINE_DEBUG_INFO 1
3659 #else
3660 #define DWARF2_ASM_LINE_DEBUG_INFO 0
3661 #endif
3662 #endif
3663
3664 /* Minimum line offset in a special line info. opcode.
3665    This value was chosen to give a reasonable range of values.  */
3666 #define DWARF_LINE_BASE  -10
3667
3668 /* First special line opcode - leave room for the standard opcodes.  */
3669 #define DWARF_LINE_OPCODE_BASE  10
3670
3671 /* Range of line offsets in a special line info. opcode.  */
3672 #define DWARF_LINE_RANGE  (254-DWARF_LINE_OPCODE_BASE+1)
3673
3674 /* Flag that indicates the initial value of the is_stmt_start flag.
3675    In the present implementation, we do not mark any lines as
3676    the beginning of a source statement, because that information
3677    is not made available by the GCC front-end.  */
3678 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
3679
3680 #ifdef DWARF2_DEBUGGING_INFO
3681 /* This location is used by calc_die_sizes() to keep track
3682    the offset of each DIE within the .debug_info section.  */
3683 static unsigned long next_die_offset;
3684 #endif
3685
3686 /* Record the root of the DIE's built for the current compilation unit.  */
3687 static GTY(()) dw_die_ref comp_unit_die;
3688
3689 /* A list of DIEs with a NULL parent waiting to be relocated.  */
3690 static GTY(()) limbo_die_node *limbo_die_list;
3691
3692 /* Filenames referenced by this compilation unit.  */
3693 static GTY(()) varray_type file_table;
3694 static GTY(()) varray_type file_table_emitted;
3695 static GTY(()) size_t file_table_last_lookup_index;
3696
3697 /* A hash table of references to DIE's that describe declarations.
3698    The key is a DECL_UID() which is a unique number identifying each decl.  */
3699 static GTY ((param_is (struct die_struct))) htab_t decl_die_table;
3700
3701 /* Node of the variable location list.  */
3702 struct var_loc_node GTY ((chain_next ("%h.next")))
3703 {
3704   rtx GTY (()) var_loc_note;
3705   const char * GTY (()) label;
3706   const char * GTY (()) section_label;
3707   struct var_loc_node * GTY (()) next;
3708 };
3709
3710 /* Variable location list.  */
3711 struct var_loc_list_def GTY (())
3712 {
3713   struct var_loc_node * GTY (()) first;
3714
3715   /* Do not mark the last element of the chained list because
3716      it is marked through the chain.  */
3717   struct var_loc_node * GTY ((skip ("%h"))) last;
3718
3719   /* DECL_UID of the variable decl.  */
3720   unsigned int decl_id;
3721 };
3722 typedef struct var_loc_list_def var_loc_list;
3723
3724
3725 /* Table of decl location linked lists.  */
3726 static GTY ((param_is (var_loc_list))) htab_t decl_loc_table;
3727
3728 /* A pointer to the base of a list of references to DIE's that
3729    are uniquely identified by their tag, presence/absence of
3730    children DIE's, and list of attribute/value pairs.  */
3731 static GTY((length ("abbrev_die_table_allocated")))
3732   dw_die_ref *abbrev_die_table;
3733
3734 /* Number of elements currently allocated for abbrev_die_table.  */
3735 static GTY(()) unsigned abbrev_die_table_allocated;
3736
3737 /* Number of elements in type_die_table currently in use.  */
3738 static GTY(()) unsigned abbrev_die_table_in_use;
3739
3740 /* Size (in elements) of increments by which we may expand the
3741    abbrev_die_table.  */
3742 #define ABBREV_DIE_TABLE_INCREMENT 256
3743
3744 /* A pointer to the base of a table that contains line information
3745    for each source code line in .text in the compilation unit.  */
3746 static GTY((length ("line_info_table_allocated")))
3747      dw_line_info_ref line_info_table;
3748
3749 /* Number of elements currently allocated for line_info_table.  */
3750 static GTY(()) unsigned line_info_table_allocated;
3751
3752 /* Number of elements in line_info_table currently in use.  */
3753 static GTY(()) unsigned line_info_table_in_use;
3754
3755 /* A pointer to the base of a table that contains line information
3756    for each source code line outside of .text in the compilation unit.  */
3757 static GTY ((length ("separate_line_info_table_allocated")))
3758      dw_separate_line_info_ref separate_line_info_table;
3759
3760 /* Number of elements currently allocated for separate_line_info_table.  */
3761 static GTY(()) unsigned separate_line_info_table_allocated;
3762
3763 /* Number of elements in separate_line_info_table currently in use.  */
3764 static GTY(()) unsigned separate_line_info_table_in_use;
3765
3766 /* Size (in elements) of increments by which we may expand the
3767    line_info_table.  */
3768 #define LINE_INFO_TABLE_INCREMENT 1024
3769
3770 /* A pointer to the base of a table that contains a list of publicly
3771    accessible names.  */
3772 static GTY ((length ("pubname_table_allocated"))) pubname_ref pubname_table;
3773
3774 /* Number of elements currently allocated for pubname_table.  */
3775 static GTY(()) unsigned pubname_table_allocated;
3776
3777 /* Number of elements in pubname_table currently in use.  */
3778 static GTY(()) unsigned pubname_table_in_use;
3779
3780 /* Size (in elements) of increments by which we may expand the
3781    pubname_table.  */
3782 #define PUBNAME_TABLE_INCREMENT 64
3783
3784 /* Array of dies for which we should generate .debug_arange info.  */
3785 static GTY((length ("arange_table_allocated"))) dw_die_ref *arange_table;
3786
3787 /* Number of elements currently allocated for arange_table.  */
3788 static GTY(()) unsigned arange_table_allocated;
3789
3790 /* Number of elements in arange_table currently in use.  */
3791 static GTY(()) unsigned arange_table_in_use;
3792
3793 /* Size (in elements) of increments by which we may expand the
3794    arange_table.  */
3795 #define ARANGE_TABLE_INCREMENT 64
3796
3797 /* Array of dies for which we should generate .debug_ranges info.  */
3798 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;
3799
3800 /* Number of elements currently allocated for ranges_table.  */
3801 static GTY(()) unsigned ranges_table_allocated;
3802
3803 /* Number of elements in ranges_table currently in use.  */
3804 static GTY(()) unsigned ranges_table_in_use;
3805
3806 /* Size (in elements) of increments by which we may expand the
3807    ranges_table.  */
3808 #define RANGES_TABLE_INCREMENT 64
3809
3810 /* Whether we have location lists that need outputting */
3811 static GTY(()) unsigned have_location_lists;
3812
3813 /* Unique label counter.  */
3814 static GTY(()) unsigned int loclabel_num;
3815
3816 #ifdef DWARF2_DEBUGGING_INFO
3817 /* Record whether the function being analyzed contains inlined functions.  */
3818 static int current_function_has_inlines;
3819 #endif
3820 #if 0 && defined (MIPS_DEBUGGING_INFO)
3821 static int comp_unit_has_inlines;
3822 #endif
3823
3824 /* Number of file tables emitted in maybe_emit_file().  */
3825 static GTY(()) int emitcount = 0;
3826
3827 /* Number of internal labels generated by gen_internal_sym().  */
3828 static GTY(()) int label_num;
3829
3830 #ifdef DWARF2_DEBUGGING_INFO
3831
3832 /* Forward declarations for functions defined in this file.  */
3833
3834 static int is_pseudo_reg (rtx);
3835 static tree type_main_variant (tree);
3836 static int is_tagged_type (tree);
3837 static const char *dwarf_tag_name (unsigned);
3838 static const char *dwarf_attr_name (unsigned);
3839 static const char *dwarf_form_name (unsigned);
3840 static tree decl_ultimate_origin (tree);
3841 static tree block_ultimate_origin (tree);
3842 static tree decl_class_context (tree);
3843 static void add_dwarf_attr (dw_die_ref, dw_attr_ref);
3844 static inline enum dw_val_class AT_class (dw_attr_ref);
3845 static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
3846 static inline unsigned AT_flag (dw_attr_ref);
3847 static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
3848 static inline HOST_WIDE_INT AT_int (dw_attr_ref);
3849 static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
3850 static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref);
3851 static void add_AT_long_long (dw_die_ref, enum dwarf_attribute, unsigned long,
3852                               unsigned long);
3853 static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int,
3854                                unsigned int, unsigned char *);
3855 static hashval_t debug_str_do_hash (const void *);
3856 static int debug_str_eq (const void *, const void *);
3857 static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
3858 static inline const char *AT_string (dw_attr_ref);
3859 static int AT_string_form (dw_attr_ref);
3860 static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
3861 static void add_AT_specification (dw_die_ref, dw_die_ref);
3862 static inline dw_die_ref AT_ref (dw_attr_ref);
3863 static inline int AT_ref_external (dw_attr_ref);
3864 static inline void set_AT_ref_external (dw_attr_ref, int);
3865 static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned);
3866 static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
3867 static inline dw_loc_descr_ref AT_loc (dw_attr_ref);
3868 static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
3869                              dw_loc_list_ref);
3870 static inline dw_loc_list_ref AT_loc_list (dw_attr_ref);
3871 static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx);
3872 static inline rtx AT_addr (dw_attr_ref);
3873 static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
3874 static void add_AT_lbl_offset (dw_die_ref, enum dwarf_attribute, const char *);
3875 static void add_AT_offset (dw_die_ref, enum dwarf_attribute,
3876                            unsigned HOST_WIDE_INT);
3877 static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
3878                                unsigned long);
3879 static inline const char *AT_lbl (dw_attr_ref);
3880 static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
3881 static const char *get_AT_low_pc (dw_die_ref);
3882 static const char *get_AT_hi_pc (dw_die_ref);
3883 static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
3884 static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
3885 static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
3886 static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
3887 static bool is_c_family (void);
3888 static bool is_cxx (void);
3889 static bool is_java (void);
3890 static bool is_fortran (void);
3891 static bool is_ada (void);
3892 static void remove_AT (dw_die_ref, enum dwarf_attribute);
3893 static void remove_child_TAG (dw_die_ref, enum dwarf_tag);
3894 static inline void free_die (dw_die_ref);
3895 static void remove_children (dw_die_ref);
3896 static void add_child_die (dw_die_ref, dw_die_ref);
3897 static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
3898 static dw_die_ref lookup_type_die (tree);
3899 static void equate_type_number_to_die (tree, dw_die_ref);
3900 static hashval_t decl_die_table_hash (const void *);
3901 static int decl_die_table_eq (const void *, const void *);
3902 static dw_die_ref lookup_decl_die (tree);
3903 static hashval_t decl_loc_table_hash (const void *);
3904 static int decl_loc_table_eq (const void *, const void *);
3905 static var_loc_list *lookup_decl_loc (tree);
3906 static void equate_decl_number_to_die (tree, dw_die_ref);
3907 static void add_var_loc_to_decl (tree, struct var_loc_node *);
3908 static void print_spaces (FILE *);
3909 static void print_die (dw_die_ref, FILE *);
3910 static void print_dwarf_line_table (FILE *);
3911 static void reverse_die_lists (dw_die_ref);
3912 static void reverse_all_dies (dw_die_ref);
3913 static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
3914 static dw_die_ref pop_compile_unit (dw_die_ref);
3915 static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
3916 static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *);
3917 static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
3918 static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
3919 static int same_dw_val_p (dw_val_node *, dw_val_node *, int *);
3920 static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
3921 static int same_die_p (dw_die_ref, dw_die_ref, int *);
3922 static int same_die_p_wrap (dw_die_ref, dw_die_ref);
3923 static void compute_section_prefix (dw_die_ref);
3924 static int is_type_die (dw_die_ref);
3925 static int is_comdat_die (dw_die_ref);
3926 static int is_symbol_die (dw_die_ref);
3927 static void assign_symbol_names (dw_die_ref);
3928 static void break_out_includes (dw_die_ref);
3929 static hashval_t htab_cu_hash (const void *);
3930 static int htab_cu_eq (const void *, const void *);
3931 static void htab_cu_del (void *);
3932 static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *);
3933 static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned);
3934 static void add_sibling_attributes (dw_die_ref);
3935 static void build_abbrev_table (dw_die_ref);
3936 static void output_location_lists (dw_die_ref);
3937 static int constant_size (long unsigned);
3938 static unsigned long size_of_die (dw_die_ref);
3939 static void calc_die_sizes (dw_die_ref);
3940 static void mark_dies (dw_die_ref);
3941 static void unmark_dies (dw_die_ref);
3942 static void unmark_all_dies (dw_die_ref);
3943 static unsigned long size_of_pubnames (void);
3944 static unsigned long size_of_aranges (void);
3945 static enum dwarf_form value_format (dw_attr_ref);
3946 static void output_value_format (dw_attr_ref);
3947 static void output_abbrev_section (void);
3948 static void output_die_symbol (dw_die_ref);
3949 static void output_die (dw_die_ref);
3950 static void output_compilation_unit_header (void);
3951 static void output_comp_unit (dw_die_ref, int);
3952 static const char *dwarf2_name (tree, int);
3953 static void add_pubname (tree, dw_die_ref);
3954 static void output_pubnames (void);
3955 static void add_arange (tree, dw_die_ref);
3956 static void output_aranges (void);
3957 static unsigned int add_ranges (tree);
3958 static void output_ranges (void);
3959 static void output_line_info (void);
3960 static void output_file_names (void);
3961 static dw_die_ref base_type_die (tree);
3962 static tree root_type (tree);
3963 static int is_base_type (tree);
3964 static bool is_subrange_type (tree);
3965 static dw_die_ref subrange_type_die (tree, dw_die_ref);
3966 static dw_die_ref modified_type_die (tree, int, int, dw_die_ref);
3967 static int type_is_enum (tree);
3968 static unsigned int dbx_reg_number (rtx);
3969 static dw_loc_descr_ref reg_loc_descriptor (rtx);
3970 static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int);
3971 static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx);
3972 static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
3973 static dw_loc_descr_ref based_loc_descr (unsigned, HOST_WIDE_INT, bool);
3974 static int is_based_loc (rtx);
3975 static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode, bool);
3976 static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx);
3977 static dw_loc_descr_ref loc_descriptor (rtx, bool);
3978 static dw_loc_descr_ref loc_descriptor_from_tree_1 (tree, int);
3979 static dw_loc_descr_ref loc_descriptor_from_tree (tree);
3980 static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
3981 static tree field_type (tree);
3982 static unsigned int simple_type_align_in_bits (tree);
3983 static unsigned int simple_decl_align_in_bits (tree);
3984 static unsigned HOST_WIDE_INT simple_type_size_in_bits (tree);
3985 static HOST_WIDE_INT field_byte_offset (tree);
3986 static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
3987                                          dw_loc_descr_ref);
3988 static void add_data_member_location_attribute (dw_die_ref, tree);
3989 static void add_const_value_attribute (dw_die_ref, rtx);
3990 static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
3991 static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
3992 static void insert_float (rtx, unsigned char *);
3993 static rtx rtl_for_decl_location (tree);
3994 static void add_location_or_const_value_attribute (dw_die_ref, tree,
3995                                                    enum dwarf_attribute);
3996 static void tree_add_const_value_attribute (dw_die_ref, tree);
3997 static void add_name_attribute (dw_die_ref, const char *);
3998 static void add_comp_dir_attribute (dw_die_ref);
3999 static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree);
4000 static void add_subscript_info (dw_die_ref, tree);
4001 static void add_byte_size_attribute (dw_die_ref, tree);
4002 static void add_bit_offset_attribute (dw_die_ref, tree);
4003 static void add_bit_size_attribute (dw_die_ref, tree);
4004 static void add_prototyped_attribute (dw_die_ref, tree);
4005 static void add_abstract_origin_attribute (dw_die_ref, tree);
4006 static void add_pure_or_virtual_attribute (dw_die_ref, tree);
4007 static void add_src_coords_attributes (dw_die_ref, tree);
4008 static void add_name_and_src_coords_attributes (dw_die_ref, tree);
4009 static void push_decl_scope (tree);
4010 static void pop_decl_scope (void);
4011 static dw_die_ref scope_die_for (tree, dw_die_ref);
4012 static inline int local_scope_p (dw_die_ref);
4013 static inline int class_or_namespace_scope_p (dw_die_ref);
4014 static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref);
4015 static void add_calling_convention_attribute (dw_die_ref, tree);
4016 static const char *type_tag (tree);
4017 static tree member_declared_type (tree);
4018 #if 0
4019 static const char *decl_start_label (tree);
4020 #endif
4021 static void gen_array_type_die (tree, dw_die_ref);
4022 #if 0
4023 static void gen_entry_point_die (tree, dw_die_ref);
4024 #endif
4025 static void gen_inlined_enumeration_type_die (tree, dw_die_ref);
4026 static void gen_inlined_structure_type_die (tree, dw_die_ref);
4027 static void gen_inlined_union_type_die (tree, dw_die_ref);
4028 static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
4029 static dw_die_ref gen_formal_parameter_die (tree, dw_die_ref);
4030 static void gen_unspecified_parameters_die (tree, dw_die_ref);
4031 static void gen_formal_types_die (tree, dw_die_ref);
4032 static void gen_subprogram_die (tree, dw_die_ref);
4033 static void gen_variable_die (tree, dw_die_ref);
4034 static void gen_label_die (tree, dw_die_ref);
4035 static void gen_lexical_block_die (tree, dw_die_ref, int);
4036 static void gen_inlined_subroutine_die (tree, dw_die_ref, int);
4037 static void gen_field_die (tree, dw_die_ref);
4038 static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
4039 static dw_die_ref gen_compile_unit_die (const char *);
4040 static void gen_string_type_die (tree, dw_die_ref);
4041 static void gen_inheritance_die (tree, tree, dw_die_ref);
4042 static void gen_member_die (tree, dw_die_ref);
4043 static void gen_struct_or_union_type_die (tree, dw_die_ref);
4044 static void gen_subroutine_type_die (tree, dw_die_ref);
4045 static void gen_typedef_die (tree, dw_die_ref);
4046 static void gen_type_die (tree, dw_die_ref);
4047 static void gen_tagged_type_instantiation_die (tree, dw_die_ref);
4048 static void gen_block_die (tree, dw_die_ref, int);
4049 static void decls_for_scope (tree, dw_die_ref, int);
4050 static int is_redundant_typedef (tree);
4051 static void gen_namespace_die (tree);
4052 static void gen_decl_die (tree, dw_die_ref);
4053 static dw_die_ref force_decl_die (tree);
4054 static dw_die_ref force_type_die (tree);
4055 static dw_die_ref setup_namespace_context (tree, dw_die_ref);
4056 static void declare_in_namespace (tree, dw_die_ref);
4057 static unsigned lookup_filename (const char *);
4058 static void init_file_table (void);
4059 static void retry_incomplete_types (void);
4060 static void gen_type_die_for_member (tree, tree, dw_die_ref);
4061 static void splice_child_die (dw_die_ref, dw_die_ref);
4062 static int file_info_cmp (const void *, const void *);
4063 static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
4064                                      const char *, const char *, unsigned);
4065 static void add_loc_descr_to_loc_list (dw_loc_list_ref *, dw_loc_descr_ref,
4066                                        const char *, const char *,
4067                                        const char *);
4068 static void output_loc_list (dw_loc_list_ref);
4069 static char *gen_internal_sym (const char *);
4070
4071 static void prune_unmark_dies (dw_die_ref);
4072 static void prune_unused_types_mark (dw_die_ref, int);
4073 static void prune_unused_types_walk (dw_die_ref);
4074 static void prune_unused_types_walk_attribs (dw_die_ref);
4075 static void prune_unused_types_prune (dw_die_ref);
4076 static void prune_unused_types (void);
4077 static int maybe_emit_file (int);
4078
4079 /* Section names used to hold DWARF debugging information.  */
4080 #ifndef DEBUG_INFO_SECTION
4081 #define DEBUG_INFO_SECTION      ".debug_info"
4082 #endif
4083 #ifndef DEBUG_ABBREV_SECTION
4084 #define DEBUG_ABBREV_SECTION    ".debug_abbrev"
4085 #endif
4086 #ifndef DEBUG_ARANGES_SECTION
4087 #define DEBUG_ARANGES_SECTION   ".debug_aranges"
4088 #endif
4089 #ifndef DEBUG_MACINFO_SECTION
4090 #define DEBUG_MACINFO_SECTION   ".debug_macinfo"
4091 #endif
4092 #ifndef DEBUG_LINE_SECTION
4093 #define DEBUG_LINE_SECTION      ".debug_line"
4094 #endif
4095 #ifndef DEBUG_LOC_SECTION
4096 #define DEBUG_LOC_SECTION       ".debug_loc"
4097 #endif
4098 #ifndef DEBUG_PUBNAMES_SECTION
4099 #define DEBUG_PUBNAMES_SECTION  ".debug_pubnames"
4100 #endif
4101 #ifndef DEBUG_STR_SECTION
4102 #define DEBUG_STR_SECTION       ".debug_str"
4103 #endif
4104 #ifndef DEBUG_RANGES_SECTION
4105 #define DEBUG_RANGES_SECTION    ".debug_ranges"
4106 #endif
4107
4108 /* Standard ELF section names for compiled code and data.  */
4109 #ifndef TEXT_SECTION_NAME
4110 #define TEXT_SECTION_NAME       ".text"
4111 #endif
4112
4113 /* Section flags for .debug_str section.  */
4114 #define DEBUG_STR_SECTION_FLAGS \
4115   (HAVE_GAS_SHF_MERGE && flag_merge_constants                   \
4116    ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1        \
4117    : SECTION_DEBUG)
4118
4119 /* Labels we insert at beginning sections we can reference instead of
4120    the section names themselves.  */
4121
4122 #ifndef TEXT_SECTION_LABEL
4123 #define TEXT_SECTION_LABEL              "Ltext"
4124 #endif
4125 #ifndef COLD_TEXT_SECTION_LABEL
4126 #define COLD_TEXT_SECTION_LABEL         "Ltext_cold"
4127 #endif
4128 #ifndef DEBUG_LINE_SECTION_LABEL
4129 #define DEBUG_LINE_SECTION_LABEL        "Ldebug_line"
4130 #endif
4131 #ifndef DEBUG_INFO_SECTION_LABEL
4132 #define DEBUG_INFO_SECTION_LABEL        "Ldebug_info"
4133 #endif
4134 #ifndef DEBUG_ABBREV_SECTION_LABEL
4135 #define DEBUG_ABBREV_SECTION_LABEL      "Ldebug_abbrev"
4136 #endif
4137 #ifndef DEBUG_LOC_SECTION_LABEL
4138 #define DEBUG_LOC_SECTION_LABEL         "Ldebug_loc"
4139 #endif
4140 #ifndef DEBUG_RANGES_SECTION_LABEL
4141 #define DEBUG_RANGES_SECTION_LABEL      "Ldebug_ranges"
4142 #endif
4143 #ifndef DEBUG_MACINFO_SECTION_LABEL
4144 #define DEBUG_MACINFO_SECTION_LABEL     "Ldebug_macinfo"
4145 #endif
4146
4147 /* Definitions of defaults for formats and names of various special
4148    (artificial) labels which may be generated within this file (when the -g
4149    options is used and DWARF2_DEBUGGING_INFO is in effect.
4150    If necessary, these may be overridden from within the tm.h file, but
4151    typically, overriding these defaults is unnecessary.  */
4152
4153 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
4154 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4155 static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4156 static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
4157 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4158 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4159 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4160 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4161 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4162 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
4163
4164 #ifndef TEXT_END_LABEL
4165 #define TEXT_END_LABEL          "Letext"
4166 #endif
4167 #ifndef COLD_END_LABEL
4168 #define COLD_END_LABEL          "Letext_cold"
4169 #endif
4170 #ifndef BLOCK_BEGIN_LABEL
4171 #define BLOCK_BEGIN_LABEL       "LBB"
4172 #endif
4173 #ifndef BLOCK_END_LABEL
4174 #define BLOCK_END_LABEL         "LBE"
4175 #endif
4176 #ifndef LINE_CODE_LABEL
4177 #define LINE_CODE_LABEL         "LM"
4178 #endif
4179 #ifndef SEPARATE_LINE_CODE_LABEL
4180 #define SEPARATE_LINE_CODE_LABEL        "LSM"
4181 #endif
4182 \f
4183 /* We allow a language front-end to designate a function that is to be
4184    called to "demangle" any name before it is put into a DIE.  */
4185
4186 static const char *(*demangle_name_func) (const char *);
4187
4188 void
4189 dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
4190 {
4191   demangle_name_func = func;
4192 }
4193
4194 /* Test if rtl node points to a pseudo register.  */
4195
4196 static inline int
4197 is_pseudo_reg (rtx rtl)
4198 {
4199   return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
4200           || (GET_CODE (rtl) == SUBREG
4201               && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
4202 }
4203
4204 /* Return a reference to a type, with its const and volatile qualifiers
4205    removed.  */
4206
4207 static inline tree
4208 type_main_variant (tree type)
4209 {
4210   type = TYPE_MAIN_VARIANT (type);
4211
4212   /* ??? There really should be only one main variant among any group of
4213      variants of a given type (and all of the MAIN_VARIANT values for all
4214      members of the group should point to that one type) but sometimes the C
4215      front-end messes this up for array types, so we work around that bug
4216      here.  */
4217   if (TREE_CODE (type) == ARRAY_TYPE)
4218     while (type != TYPE_MAIN_VARIANT (type))
4219       type = TYPE_MAIN_VARIANT (type);
4220
4221   return type;
4222 }
4223
4224 /* Return nonzero if the given type node represents a tagged type.  */
4225
4226 static inline int
4227 is_tagged_type (tree type)
4228 {
4229   enum tree_code code = TREE_CODE (type);
4230
4231   return (code == RECORD_TYPE || code == UNION_TYPE
4232           || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
4233 }
4234
4235 /* Convert a DIE tag into its string name.  */
4236
4237 static const char *
4238 dwarf_tag_name (unsigned int tag)
4239 {
4240   switch (tag)
4241     {
4242     case DW_TAG_padding:
4243       return "DW_TAG_padding";
4244     case DW_TAG_array_type:
4245       return "DW_TAG_array_type";
4246     case DW_TAG_class_type:
4247       return "DW_TAG_class_type";
4248     case DW_TAG_entry_point:
4249       return "DW_TAG_entry_point";
4250     case DW_TAG_enumeration_type:
4251       return "DW_TAG_enumeration_type";
4252     case DW_TAG_formal_parameter:
4253       return "DW_TAG_formal_parameter";
4254     case DW_TAG_imported_declaration:
4255       return "DW_TAG_imported_declaration";
4256     case DW_TAG_label:
4257       return "DW_TAG_label";
4258     case DW_TAG_lexical_block:
4259       return "DW_TAG_lexical_block";
4260     case DW_TAG_member:
4261       return "DW_TAG_member";
4262     case DW_TAG_pointer_type:
4263       return "DW_TAG_pointer_type";
4264     case DW_TAG_reference_type:
4265       return "DW_TAG_reference_type";
4266     case DW_TAG_compile_unit:
4267       return "DW_TAG_compile_unit";
4268     case DW_TAG_string_type:
4269       return "DW_TAG_string_type";
4270     case DW_TAG_structure_type:
4271       return "DW_TAG_structure_type";
4272     case DW_TAG_subroutine_type:
4273       return "DW_TAG_subroutine_type";
4274     case DW_TAG_typedef:
4275       return "DW_TAG_typedef";
4276     case DW_TAG_union_type:
4277       return "DW_TAG_union_type";
4278     case DW_TAG_unspecified_parameters:
4279       return "DW_TAG_unspecified_parameters";
4280     case DW_TAG_variant:
4281       return "DW_TAG_variant";
4282     case DW_TAG_common_block:
4283       return "DW_TAG_common_block";
4284     case DW_TAG_common_inclusion:
4285       return "DW_TAG_common_inclusion";
4286     case DW_TAG_inheritance:
4287       return "DW_TAG_inheritance";
4288     case DW_TAG_inlined_subroutine:
4289       return "DW_TAG_inlined_subroutine";
4290     case DW_TAG_module:
4291       return "DW_TAG_module";
4292     case DW_TAG_ptr_to_member_type:
4293       return "DW_TAG_ptr_to_member_type";
4294     case DW_TAG_set_type:
4295       return "DW_TAG_set_type";
4296     case DW_TAG_subrange_type:
4297       return "DW_TAG_subrange_type";
4298     case DW_TAG_with_stmt:
4299       return "DW_TAG_with_stmt";
4300     case DW_TAG_access_declaration:
4301       return "DW_TAG_access_declaration";
4302     case DW_TAG_base_type:
4303       return "DW_TAG_base_type";
4304     case DW_TAG_catch_block:
4305       return "DW_TAG_catch_block";
4306     case DW_TAG_const_type:
4307       return "DW_TAG_const_type";
4308     case DW_TAG_constant:
4309       return "DW_TAG_constant";
4310     case DW_TAG_enumerator:
4311       return "DW_TAG_enumerator";
4312     case DW_TAG_file_type:
4313       return "DW_TAG_file_type";
4314     case DW_TAG_friend:
4315       return "DW_TAG_friend";
4316     case DW_TAG_namelist:
4317       return "DW_TAG_namelist";
4318     case DW_TAG_namelist_item:
4319       return "DW_TAG_namelist_item";
4320     case DW_TAG_namespace:
4321       return "DW_TAG_namespace";
4322     case DW_TAG_packed_type:
4323       return "DW_TAG_packed_type";
4324     case DW_TAG_subprogram:
4325       return "DW_TAG_subprogram";
4326     case DW_TAG_template_type_param:
4327       return "DW_TAG_template_type_param";
4328     case DW_TAG_template_value_param:
4329       return "DW_TAG_template_value_param";
4330     case DW_TAG_thrown_type:
4331       return "DW_TAG_thrown_type";
4332     case DW_TAG_try_block:
4333       return "DW_TAG_try_block";
4334     case DW_TAG_variant_part:
4335       return "DW_TAG_variant_part";
4336     case DW_TAG_variable:
4337       return "DW_TAG_variable";
4338     case DW_TAG_volatile_type:
4339       return "DW_TAG_volatile_type";
4340     case DW_TAG_imported_module:
4341       return "DW_TAG_imported_module";
4342     case DW_TAG_MIPS_loop:
4343       return "DW_TAG_MIPS_loop";
4344     case DW_TAG_format_label:
4345       return "DW_TAG_format_label";
4346     case DW_TAG_function_template:
4347       return "DW_TAG_function_template";
4348     case DW_TAG_class_template:
4349       return "DW_TAG_class_template";
4350     case DW_TAG_GNU_BINCL:
4351       return "DW_TAG_GNU_BINCL";
4352     case DW_TAG_GNU_EINCL:
4353       return "DW_TAG_GNU_EINCL";
4354     default:
4355       return "DW_TAG_<unknown>";
4356     }
4357 }
4358
4359 /* Convert a DWARF attribute code into its string name.  */
4360
4361 static const char *
4362 dwarf_attr_name (unsigned int attr)
4363 {
4364   switch (attr)
4365     {
4366     case DW_AT_sibling:
4367       return "DW_AT_sibling";
4368     case DW_AT_location:
4369       return "DW_AT_location";
4370     case DW_AT_name:
4371       return "DW_AT_name";
4372     case DW_AT_ordering:
4373       return "DW_AT_ordering";
4374     case DW_AT_subscr_data:
4375       return "DW_AT_subscr_data";
4376     case DW_AT_byte_size:
4377       return "DW_AT_byte_size";
4378     case DW_AT_bit_offset:
4379       return "DW_AT_bit_offset";
4380     case DW_AT_bit_size:
4381       return "DW_AT_bit_size";
4382     case DW_AT_element_list:
4383       return "DW_AT_element_list";
4384     case DW_AT_stmt_list:
4385       return "DW_AT_stmt_list";
4386     case DW_AT_low_pc:
4387       return "DW_AT_low_pc";
4388     case DW_AT_high_pc:
4389       return "DW_AT_high_pc";
4390     case DW_AT_language:
4391       return "DW_AT_language";
4392     case DW_AT_member:
4393       return "DW_AT_member";
4394     case DW_AT_discr:
4395       return "DW_AT_discr";
4396     case DW_AT_discr_value:
4397       return "DW_AT_discr_value";
4398     case DW_AT_visibility:
4399       return "DW_AT_visibility";
4400     case DW_AT_import:
4401       return "DW_AT_import";
4402     case DW_AT_string_length:
4403       return "DW_AT_string_length";
4404     case DW_AT_common_reference:
4405       return "DW_AT_common_reference";
4406     case DW_AT_comp_dir:
4407       return "DW_AT_comp_dir";
4408     case DW_AT_const_value:
4409       return "DW_AT_const_value";
4410     case DW_AT_containing_type:
4411       return "DW_AT_containing_type";
4412     case DW_AT_default_value:
4413       return "DW_AT_default_value";
4414     case DW_AT_inline:
4415       return "DW_AT_inline";
4416     case DW_AT_is_optional:
4417       return "DW_AT_is_optional";
4418     case DW_AT_lower_bound:
4419       return "DW_AT_lower_bound";
4420     case DW_AT_producer:
4421       return "DW_AT_producer";
4422     case DW_AT_prototyped:
4423       return "DW_AT_prototyped";
4424     case DW_AT_return_addr:
4425       return "DW_AT_return_addr";
4426     case DW_AT_start_scope:
4427       return "DW_AT_start_scope";
4428     case DW_AT_stride_size:
4429       return "DW_AT_stride_size";
4430     case DW_AT_upper_bound:
4431       return "DW_AT_upper_bound";
4432     case DW_AT_abstract_origin:
4433       return "DW_AT_abstract_origin";
4434     case DW_AT_accessibility:
4435       return "DW_AT_accessibility";
4436     case DW_AT_address_class:
4437       return "DW_AT_address_class";
4438     case DW_AT_artificial:
4439       return "DW_AT_artificial";
4440     case DW_AT_base_types:
4441       return "DW_AT_base_types";
4442     case DW_AT_calling_convention:
4443       return "DW_AT_calling_convention";
4444     case DW_AT_count:
4445       return "DW_AT_count";
4446     case DW_AT_data_member_location:
4447       return "DW_AT_data_member_location";
4448     case DW_AT_decl_column:
4449       return "DW_AT_decl_column";
4450     case DW_AT_decl_file:
4451       return "DW_AT_decl_file";
4452     case DW_AT_decl_line:
4453       return "DW_AT_decl_line";
4454     case DW_AT_declaration:
4455       return "DW_AT_declaration";
4456     case DW_AT_discr_list:
4457       return "DW_AT_discr_list";
4458     case DW_AT_encoding:
4459       return "DW_AT_encoding";
4460     case DW_AT_external:
4461       return "DW_AT_external";
4462     case DW_AT_frame_base:
4463       return "DW_AT_frame_base";
4464     case DW_AT_friend:
4465       return "DW_AT_friend";
4466     case DW_AT_identifier_case:
4467       return "DW_AT_identifier_case";
4468     case DW_AT_macro_info:
4469       return "DW_AT_macro_info";
4470     case DW_AT_namelist_items:
4471       return "DW_AT_namelist_items";
4472     case DW_AT_priority:
4473       return "DW_AT_priority";
4474     case DW_AT_segment:
4475       return "DW_AT_segment";
4476     case DW_AT_specification:
4477       return "DW_AT_specification";
4478     case DW_AT_static_link:
4479       return "DW_AT_static_link";
4480     case DW_AT_type:
4481       return "DW_AT_type";
4482     case DW_AT_use_location:
4483       return "DW_AT_use_location";
4484     case DW_AT_variable_parameter:
4485       return "DW_AT_variable_parameter";
4486     case DW_AT_virtuality:
4487       return "DW_AT_virtuality";
4488     case DW_AT_vtable_elem_location:
4489       return "DW_AT_vtable_elem_location";
4490
4491     case DW_AT_allocated:
4492       return "DW_AT_allocated";
4493     case DW_AT_associated:
4494       return "DW_AT_associated";
4495     case DW_AT_data_location:
4496       return "DW_AT_data_location";
4497     case DW_AT_stride:
4498       return "DW_AT_stride";
4499     case DW_AT_entry_pc:
4500       return "DW_AT_entry_pc";
4501     case DW_AT_use_UTF8:
4502       return "DW_AT_use_UTF8";
4503     case DW_AT_extension:
4504       return "DW_AT_extension";
4505     case DW_AT_ranges:
4506       return "DW_AT_ranges";
4507     case DW_AT_trampoline:
4508       return "DW_AT_trampoline";
4509     case DW_AT_call_column:
4510       return "DW_AT_call_column";
4511     case DW_AT_call_file:
4512       return "DW_AT_call_file";
4513     case DW_AT_call_line:
4514       return "DW_AT_call_line";
4515
4516     case DW_AT_MIPS_fde:
4517       return "DW_AT_MIPS_fde";
4518     case DW_AT_MIPS_loop_begin:
4519       return "DW_AT_MIPS_loop_begin";
4520     case DW_AT_MIPS_tail_loop_begin:
4521       return "DW_AT_MIPS_tail_loop_begin";
4522     case DW_AT_MIPS_epilog_begin:
4523       return "DW_AT_MIPS_epilog_begin";
4524     case DW_AT_MIPS_loop_unroll_factor:
4525       return "DW_AT_MIPS_loop_unroll_factor";
4526     case DW_AT_MIPS_software_pipeline_depth:
4527       return "DW_AT_MIPS_software_pipeline_depth";
4528     case DW_AT_MIPS_linkage_name:
4529       return "DW_AT_MIPS_linkage_name";
4530     case DW_AT_MIPS_stride:
4531       return "DW_AT_MIPS_stride";
4532     case DW_AT_MIPS_abstract_name:
4533       return "DW_AT_MIPS_abstract_name";
4534     case DW_AT_MIPS_clone_origin:
4535       return "DW_AT_MIPS_clone_origin";
4536     case DW_AT_MIPS_has_inlines:
4537       return "DW_AT_MIPS_has_inlines";
4538
4539     case DW_AT_sf_names:
4540       return "DW_AT_sf_names";
4541     case DW_AT_src_info:
4542       return "DW_AT_src_info";
4543     case DW_AT_mac_info:
4544       return "DW_AT_mac_info";
4545     case DW_AT_src_coords:
4546       return "DW_AT_src_coords";
4547     case DW_AT_body_begin:
4548       return "DW_AT_body_begin";
4549     case DW_AT_body_end:
4550       return "DW_AT_body_end";
4551     case DW_AT_GNU_vector:
4552       return "DW_AT_GNU_vector";
4553
4554     case DW_AT_VMS_rtnbeg_pd_address:
4555       return "DW_AT_VMS_rtnbeg_pd_address";
4556
4557     default:
4558       return "DW_AT_<unknown>";
4559     }
4560 }
4561
4562 /* Convert a DWARF value form code into its string name.  */
4563
4564 static const char *
4565 dwarf_form_name (unsigned int form)
4566 {
4567   switch (form)
4568     {
4569     case DW_FORM_addr:
4570       return "DW_FORM_addr";
4571     case DW_FORM_block2:
4572       return "DW_FORM_block2";
4573     case DW_FORM_block4:
4574       return "DW_FORM_block4";
4575     case DW_FORM_data2:
4576       return "DW_FORM_data2";
4577     case DW_FORM_data4:
4578       return "DW_FORM_data4";
4579     case DW_FORM_data8:
4580       return "DW_FORM_data8";
4581     case DW_FORM_string:
4582       return "DW_FORM_string";
4583     case DW_FORM_block:
4584       return "DW_FORM_block";
4585     case DW_FORM_block1:
4586       return "DW_FORM_block1";
4587     case DW_FORM_data1:
4588       return "DW_FORM_data1";
4589     case DW_FORM_flag:
4590       return "DW_FORM_flag";
4591     case DW_FORM_sdata:
4592       return "DW_FORM_sdata";
4593     case DW_FORM_strp:
4594       return "DW_FORM_strp";
4595     case DW_FORM_udata:
4596       return "DW_FORM_udata";
4597     case DW_FORM_ref_addr:
4598       return "DW_FORM_ref_addr";
4599     case DW_FORM_ref1:
4600       return "DW_FORM_ref1";
4601     case DW_FORM_ref2:
4602       return "DW_FORM_ref2";
4603     case DW_FORM_ref4:
4604       return "DW_FORM_ref4";
4605     case DW_FORM_ref8:
4606       return "DW_FORM_ref8";
4607     case DW_FORM_ref_udata:
4608       return "DW_FORM_ref_udata";
4609     case DW_FORM_indirect:
4610       return "DW_FORM_indirect";
4611     default:
4612       return "DW_FORM_<unknown>";
4613     }
4614 }
4615 \f
4616 /* Determine the "ultimate origin" of a decl.  The decl may be an inlined
4617    instance of an inlined instance of a decl which is local to an inline
4618    function, so we have to trace all of the way back through the origin chain
4619    to find out what sort of node actually served as the original seed for the
4620    given block.  */
4621
4622 static tree
4623 decl_ultimate_origin (tree decl)
4624 {
4625   /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
4626      nodes in the function to point to themselves; ignore that if
4627      we're trying to output the abstract instance of this function.  */
4628   if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
4629     return NULL_TREE;
4630
4631   /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
4632      most distant ancestor, this should never happen.  */
4633   gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));
4634
4635   return DECL_ABSTRACT_ORIGIN (decl);
4636 }
4637
4638 /* Determine the "ultimate origin" of a block.  The block may be an inlined
4639    instance of an inlined instance of a block which is local to an inline
4640    function, so we have to trace all of the way back through the origin chain
4641    to find out what sort of node actually served as the original seed for the
4642    given block.  */
4643
4644 static tree
4645 block_ultimate_origin (tree block)
4646 {
4647   tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
4648
4649   /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
4650      nodes in the function to point to themselves; ignore that if
4651      we're trying to output the abstract instance of this function.  */
4652   if (BLOCK_ABSTRACT (block) && immediate_origin == block)
4653     return NULL_TREE;
4654
4655   if (immediate_origin == NULL_TREE)
4656     return NULL_TREE;
4657   else
4658     {
4659       tree ret_val;
4660       tree lookahead = immediate_origin;
4661
4662       do
4663         {
4664           ret_val = lookahead;
4665           lookahead = (TREE_CODE (ret_val) == BLOCK
4666                        ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
4667         }
4668       while (lookahead != NULL && lookahead != ret_val);
4669
4670       /* The block's abstract origin chain may not be the *ultimate* origin of
4671          the block. It could lead to a DECL that has an abstract origin set.
4672          If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
4673          will give us if it has one).  Note that DECL's abstract origins are
4674          supposed to be the most distant ancestor (or so decl_ultimate_origin
4675          claims), so we don't need to loop following the DECL origins.  */
4676       if (DECL_P (ret_val))
4677         return DECL_ORIGIN (ret_val);
4678
4679       return ret_val;
4680     }
4681 }
4682
4683 /* Get the class to which DECL belongs, if any.  In g++, the DECL_CONTEXT
4684    of a virtual function may refer to a base class, so we check the 'this'
4685    parameter.  */
4686
4687 static tree
4688 decl_class_context (tree decl)
4689 {
4690   tree context = NULL_TREE;
4691
4692   if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
4693     context = DECL_CONTEXT (decl);
4694   else
4695     context = TYPE_MAIN_VARIANT
4696       (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
4697
4698   if (context && !TYPE_P (context))
4699     context = NULL_TREE;
4700
4701   return context;
4702 }
4703 \f
4704 /* Add an attribute/value pair to a DIE.  We build the lists up in reverse
4705    addition order, and correct that in reverse_all_dies.  */
4706
4707 static inline void
4708 add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
4709 {
4710   if (die != NULL && attr != NULL)
4711     {
4712       attr->dw_attr_next = die->die_attr;
4713       die->die_attr = attr;
4714     }
4715 }
4716
4717 static inline enum dw_val_class
4718 AT_class (dw_attr_ref a)
4719 {
4720   return a->dw_attr_val.val_class;
4721 }
4722
4723 /* Add a flag value attribute to a DIE.  */
4724
4725 static inline void
4726 add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
4727 {
4728   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4729
4730   attr->dw_attr_next = NULL;
4731   attr->dw_attr = attr_kind;
4732   attr->dw_attr_val.val_class = dw_val_class_flag;
4733   attr->dw_attr_val.v.val_flag = flag;
4734   add_dwarf_attr (die, attr);
4735 }
4736
4737 static inline unsigned
4738 AT_flag (dw_attr_ref a)
4739 {
4740   gcc_assert (a && AT_class (a) == dw_val_class_flag);
4741   return a->dw_attr_val.v.val_flag;
4742 }
4743
4744 /* Add a signed integer attribute value to a DIE.  */
4745
4746 static inline void
4747 add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val)
4748 {
4749   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4750
4751   attr->dw_attr_next = NULL;
4752   attr->dw_attr = attr_kind;
4753   attr->dw_attr_val.val_class = dw_val_class_const;
4754   attr->dw_attr_val.v.val_int = int_val;
4755   add_dwarf_attr (die, attr);
4756 }
4757
4758 static inline HOST_WIDE_INT
4759 AT_int (dw_attr_ref a)
4760 {
4761   gcc_assert (a && AT_class (a) == dw_val_class_const);
4762   return a->dw_attr_val.v.val_int;
4763 }
4764
4765 /* Add an unsigned integer attribute value to a DIE.  */
4766
4767 static inline void
4768 add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
4769                  unsigned HOST_WIDE_INT unsigned_val)
4770 {
4771   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4772
4773   attr->dw_attr_next = NULL;
4774   attr->dw_attr = attr_kind;
4775   attr->dw_attr_val.val_class = dw_val_class_unsigned_const;
4776   attr->dw_attr_val.v.val_unsigned = unsigned_val;
4777   add_dwarf_attr (die, attr);
4778 }
4779
4780 static inline unsigned HOST_WIDE_INT
4781 AT_unsigned (dw_attr_ref a)
4782 {
4783   gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const);
4784   return a->dw_attr_val.v.val_unsigned;
4785 }
4786
4787 /* Add an unsigned double integer attribute value to a DIE.  */
4788
4789 static inline void
4790 add_AT_long_long (dw_die_ref die, enum dwarf_attribute attr_kind,
4791                   long unsigned int val_hi, long unsigned int val_low)
4792 {
4793   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4794
4795   attr->dw_attr_next = NULL;
4796   attr->dw_attr = attr_kind;
4797   attr->dw_attr_val.val_class = dw_val_class_long_long;
4798   attr->dw_attr_val.v.val_long_long.hi = val_hi;
4799   attr->dw_attr_val.v.val_long_long.low = val_low;
4800   add_dwarf_attr (die, attr);
4801 }
4802
4803 /* Add a floating point attribute value to a DIE and return it.  */
4804
4805 static inline void
4806 add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind,
4807             unsigned int length, unsigned int elt_size, unsigned char *array)
4808 {
4809   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4810
4811   attr->dw_attr_next = NULL;
4812   attr->dw_attr = attr_kind;
4813   attr->dw_attr_val.val_class = dw_val_class_vec;
4814   attr->dw_attr_val.v.val_vec.length = length;
4815   attr->dw_attr_val.v.val_vec.elt_size = elt_size;
4816   attr->dw_attr_val.v.val_vec.array = array;
4817   add_dwarf_attr (die, attr);
4818 }
4819
4820 /* Hash and equality functions for debug_str_hash.  */
4821
4822 static hashval_t
4823 debug_str_do_hash (const void *x)
4824 {
4825   return htab_hash_string (((const struct indirect_string_node *)x)->str);
4826 }
4827
4828 static int
4829 debug_str_eq (const void *x1, const void *x2)
4830 {
4831   return strcmp ((((const struct indirect_string_node *)x1)->str),
4832                  (const char *)x2) == 0;
4833 }
4834
4835 /* Add a string attribute value to a DIE.  */
4836
4837 static inline void
4838 add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
4839 {
4840   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4841   struct indirect_string_node *node;
4842   void **slot;
4843
4844   if (! debug_str_hash)
4845     debug_str_hash = htab_create_ggc (10, debug_str_do_hash,
4846                                       debug_str_eq, NULL);
4847
4848   slot = htab_find_slot_with_hash (debug_str_hash, str,
4849                                    htab_hash_string (str), INSERT);
4850   if (*slot == NULL)
4851     *slot = ggc_alloc_cleared (sizeof (struct indirect_string_node));
4852   node = (struct indirect_string_node *) *slot;
4853   node->str = ggc_strdup (str);
4854   node->refcount++;
4855
4856   attr->dw_attr_next = NULL;
4857   attr->dw_attr = attr_kind;
4858   attr->dw_attr_val.val_class = dw_val_class_str;
4859   attr->dw_attr_val.v.val_str = node;
4860   add_dwarf_attr (die, attr);
4861 }
4862
4863 static inline const char *
4864 AT_string (dw_attr_ref a)
4865 {
4866   gcc_assert (a && AT_class (a) == dw_val_class_str);
4867   return a->dw_attr_val.v.val_str->str;
4868 }
4869
4870 /* Find out whether a string should be output inline in DIE
4871    or out-of-line in .debug_str section.  */
4872
4873 static int
4874 AT_string_form (dw_attr_ref a)
4875 {
4876   struct indirect_string_node *node;
4877   unsigned int len;
4878   char label[32];
4879
4880   gcc_assert (a && AT_class (a) == dw_val_class_str);
4881
4882   node = a->dw_attr_val.v.val_str;
4883   if (node->form)
4884     return node->form;
4885
4886   len = strlen (node->str) + 1;
4887
4888   /* If the string is shorter or equal to the size of the reference, it is
4889      always better to put it inline.  */
4890   if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
4891     return node->form = DW_FORM_string;
4892
4893   /* If we cannot expect the linker to merge strings in .debug_str
4894      section, only put it into .debug_str if it is worth even in this
4895      single module.  */
4896   if ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) == 0
4897       && (len - DWARF_OFFSET_SIZE) * node->refcount <= len)
4898     return node->form = DW_FORM_string;
4899
4900   ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
4901   ++dw2_string_counter;
4902   node->label = xstrdup (label);
4903
4904   return node->form = DW_FORM_strp;
4905 }
4906
4907 /* Add a DIE reference attribute value to a DIE.  */
4908
4909 static inline void
4910 add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
4911 {
4912   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4913
4914   attr->dw_attr_next = NULL;
4915   attr->dw_attr = attr_kind;
4916   attr->dw_attr_val.val_class = dw_val_class_die_ref;
4917   attr->dw_attr_val.v.val_die_ref.die = targ_die;
4918   attr->dw_attr_val.v.val_die_ref.external = 0;
4919   add_dwarf_attr (die, attr);
4920 }
4921
4922 /* Add an AT_specification attribute to a DIE, and also make the back
4923    pointer from the specification to the definition.  */
4924
4925 static inline void
4926 add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
4927 {
4928   add_AT_die_ref (die, DW_AT_specification, targ_die);
4929   gcc_assert (!targ_die->die_definition);
4930   targ_die->die_definition = die;
4931 }
4932
4933 static inline dw_die_ref
4934 AT_ref (dw_attr_ref a)
4935 {
4936   gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
4937   return a->dw_attr_val.v.val_die_ref.die;
4938 }
4939
4940 static inline int
4941 AT_ref_external (dw_attr_ref a)
4942 {
4943   if (a && AT_class (a) == dw_val_class_die_ref)
4944     return a->dw_attr_val.v.val_die_ref.external;
4945
4946   return 0;
4947 }
4948
4949 static inline void
4950 set_AT_ref_external (dw_attr_ref a, int i)
4951 {
4952   gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
4953   a->dw_attr_val.v.val_die_ref.external = i;
4954 }
4955
4956 /* Add an FDE reference attribute value to a DIE.  */
4957
4958 static inline void
4959 add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde)
4960 {
4961   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4962
4963   attr->dw_attr_next = NULL;
4964   attr->dw_attr = attr_kind;
4965   attr->dw_attr_val.val_class = dw_val_class_fde_ref;
4966   attr->dw_attr_val.v.val_fde_index = targ_fde;
4967   add_dwarf_attr (die, attr);
4968 }
4969
4970 /* Add a location description attribute value to a DIE.  */
4971
4972 static inline void
4973 add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
4974 {
4975   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4976
4977   attr->dw_attr_next = NULL;
4978   attr->dw_attr = attr_kind;
4979   attr->dw_attr_val.val_class = dw_val_class_loc;
4980   attr->dw_attr_val.v.val_loc = loc;
4981   add_dwarf_attr (die, attr);
4982 }
4983
4984 static inline dw_loc_descr_ref
4985 AT_loc (dw_attr_ref a)
4986 {
4987   gcc_assert (a && AT_class (a) == dw_val_class_loc);
4988   return a->dw_attr_val.v.val_loc;
4989 }
4990
4991 static inline void
4992 add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
4993 {
4994   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4995
4996   attr->dw_attr_next = NULL;
4997   attr->dw_attr = attr_kind;
4998   attr->dw_attr_val.val_class = dw_val_class_loc_list;
4999   attr->dw_attr_val.v.val_loc_list = loc_list;
5000   add_dwarf_attr (die, attr);
5001   have_location_lists = 1;
5002 }
5003
5004 static inline dw_loc_list_ref
5005 AT_loc_list (dw_attr_ref a)
5006 {
5007   gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
5008   return a->dw_attr_val.v.val_loc_list;
5009 }
5010
5011 /* Add an address constant attribute value to a DIE.  */
5012
5013 static inline void
5014 add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr)
5015 {
5016   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5017
5018   attr->dw_attr_next = NULL;
5019   attr->dw_attr = attr_kind;
5020   attr->dw_attr_val.val_class = dw_val_class_addr;
5021   attr->dw_attr_val.v.val_addr = addr;
5022   add_dwarf_attr (die, attr);
5023 }
5024
5025 static inline rtx
5026 AT_addr (dw_attr_ref a)
5027 {
5028   gcc_assert (a && AT_class (a) == dw_val_class_addr);
5029   return a->dw_attr_val.v.val_addr;
5030 }
5031
5032 /* Add a label identifier attribute value to a DIE.  */
5033
5034 static inline void
5035 add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id)
5036 {
5037   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5038
5039   attr->dw_attr_next = NULL;
5040   attr->dw_attr = attr_kind;
5041   attr->dw_attr_val.val_class = dw_val_class_lbl_id;
5042   attr->dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
5043   add_dwarf_attr (die, attr);
5044 }
5045
5046 /* Add a section offset attribute value to a DIE.  */
5047
5048 static inline void
5049 add_AT_lbl_offset (dw_die_ref die, enum dwarf_attribute attr_kind, const char *label)
5050 {
5051   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5052
5053   attr->dw_attr_next = NULL;
5054   attr->dw_attr = attr_kind;
5055   attr->dw_attr_val.val_class = dw_val_class_lbl_offset;
5056   attr->dw_attr_val.v.val_lbl_id = xstrdup (label);
5057   add_dwarf_attr (die, attr);
5058 }
5059
5060 /* Add an offset attribute value to a DIE.  */
5061
5062 static inline void
5063 add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind,
5064                unsigned HOST_WIDE_INT offset)
5065 {
5066   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5067
5068   attr->dw_attr_next = NULL;
5069   attr->dw_attr = attr_kind;
5070   attr->dw_attr_val.val_class = dw_val_class_offset;
5071   attr->dw_attr_val.v.val_offset = offset;
5072   add_dwarf_attr (die, attr);
5073 }
5074
5075 /* Add an range_list attribute value to a DIE.  */
5076
5077 static void
5078 add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
5079                    long unsigned int offset)
5080 {
5081   dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5082
5083   attr->dw_attr_next = NULL;
5084   attr->dw_attr = attr_kind;
5085   attr->dw_attr_val.val_class = dw_val_class_range_list;
5086   attr->dw_attr_val.v.val_offset = offset;
5087   add_dwarf_attr (die, attr);
5088 }
5089
5090 static inline const char *
5091 AT_lbl (dw_attr_ref a)
5092 {
5093   gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
5094                     || AT_class (a) == dw_val_class_lbl_offset));
5095   return a->dw_attr_val.v.val_lbl_id;
5096 }
5097
5098 /* Get the attribute of type attr_kind.  */
5099
5100 static dw_attr_ref
5101 get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
5102 {
5103   dw_attr_ref a;
5104   dw_die_ref spec = NULL;
5105
5106   if (die != NULL)
5107     {
5108       for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
5109         if (a->dw_attr == attr_kind)
5110           return a;
5111         else if (a->dw_attr == DW_AT_specification
5112                  || a->dw_attr == DW_AT_abstract_origin)
5113           spec = AT_ref (a);
5114
5115       if (spec)
5116         return get_AT (spec, attr_kind);
5117     }
5118
5119   return NULL;
5120 }
5121
5122 /* Return the "low pc" attribute value, typically associated with a subprogram
5123    DIE.  Return null if the "low pc" attribute is either not present, or if it
5124    cannot be represented as an assembler label identifier.  */
5125
5126 static inline const char *
5127 get_AT_low_pc (dw_die_ref die)
5128 {
5129   dw_attr_ref a = get_AT (die, DW_AT_low_pc);
5130
5131   return a ? AT_lbl (a) : NULL;
5132 }
5133
5134 /* Return the "high pc" attribute value, typically associated with a subprogram
5135    DIE.  Return null if the "high pc" attribute is either not present, or if it
5136    cannot be represented as an assembler label identifier.  */
5137
5138 static inline const char *
5139 get_AT_hi_pc (dw_die_ref die)
5140 {
5141   dw_attr_ref a = get_AT (die, DW_AT_high_pc);
5142
5143   return a ? AT_lbl (a) : NULL;
5144 }
5145
5146 /* Return the value of the string attribute designated by ATTR_KIND, or
5147    NULL if it is not present.  */
5148
5149 static inline const char *
5150 get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
5151 {
5152   dw_attr_ref a = get_AT (die, attr_kind);
5153
5154   return a ? AT_string (a) : NULL;
5155 }
5156
5157 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
5158    if it is not present.  */
5159
5160 static inline int
5161 get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
5162 {
5163   dw_attr_ref a = get_AT (die, attr_kind);
5164
5165   return a ? AT_flag (a) : 0;
5166 }
5167
5168 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
5169    if it is not present.  */
5170
5171 static inline unsigned
5172 get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
5173 {
5174   dw_attr_ref a = get_AT (die, attr_kind);
5175
5176   return a ? AT_unsigned (a) : 0;
5177 }
5178
5179 static inline dw_die_ref
5180 get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
5181 {
5182   dw_attr_ref a = get_AT (die, attr_kind);
5183
5184   return a ? AT_ref (a) : NULL;
5185 }
5186
5187 /* Return TRUE if the language is C or C++.  */
5188
5189 static inline bool
5190 is_c_family (void)
5191 {
5192   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5193
5194   return (lang == DW_LANG_C || lang == DW_LANG_C89
5195           || lang == DW_LANG_C_plus_plus);
5196 }
5197
5198 /* Return TRUE if the language is C++.  */
5199
5200 static inline bool
5201 is_cxx (void)
5202 {
5203   return (get_AT_unsigned (comp_unit_die, DW_AT_language)
5204           == DW_LANG_C_plus_plus);
5205 }
5206
5207 /* Return TRUE if the language is Fortran.  */
5208
5209 static inline bool
5210 is_fortran (void)
5211 {
5212   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5213
5214   return (lang == DW_LANG_Fortran77
5215           || lang == DW_LANG_Fortran90
5216           || lang == DW_LANG_Fortran95);
5217 }
5218
5219 /* Return TRUE if the language is Java.  */
5220
5221 static inline bool
5222 is_java (void)
5223 {
5224   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5225
5226   return lang == DW_LANG_Java;
5227 }
5228
5229 /* Return TRUE if the language is Ada.  */
5230
5231 static inline bool
5232 is_ada (void)
5233 {
5234   unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5235
5236   return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
5237 }
5238
5239 /* Free up the memory used by A.  */
5240
5241 static inline void free_AT (dw_attr_ref);
5242 static inline void
5243 free_AT (dw_attr_ref a)
5244 {
5245   if (AT_class (a) == dw_val_class_str)
5246     if (a->dw_attr_val.v.val_str->refcount)
5247       a->dw_attr_val.v.val_str->refcount--;
5248 }
5249
5250 /* Remove the specified attribute if present.  */
5251
5252 static void
5253 remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
5254 {
5255   dw_attr_ref *p;
5256   dw_attr_ref removed = NULL;
5257
5258   if (die != NULL)
5259     {
5260       for (p = &(die->die_attr); *p; p = &((*p)->dw_attr_next))
5261         if ((*p)->dw_attr == attr_kind)
5262           {
5263             removed = *p;
5264             *p = (*p)->dw_attr_next;
5265             break;
5266           }
5267
5268       if (removed != 0)
5269         free_AT (removed);
5270     }
5271 }
5272
5273 /* Remove child die whose die_tag is specified tag.  */
5274
5275 static void
5276 remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
5277 {
5278   dw_die_ref current, prev, next;
5279   current = die->die_child;
5280   prev = NULL;
5281   while (current != NULL)
5282     {
5283       if (current->die_tag == tag)
5284         {
5285           next = current->die_sib;
5286           if (prev == NULL)
5287             die->die_child = next;
5288           else
5289             prev->die_sib = next;
5290           free_die (current);
5291           current = next;
5292         }
5293       else
5294         {
5295           prev = current;
5296           current = current->die_sib;
5297         }
5298     }
5299 }
5300
5301 /* Free up the memory used by DIE.  */
5302
5303 static inline void
5304 free_die (dw_die_ref die)
5305 {
5306   remove_children (die);
5307 }
5308
5309 /* Discard the children of this DIE.  */
5310
5311 static void
5312 remove_children (dw_die_ref die)
5313 {
5314   dw_die_ref child_die = die->die_child;
5315
5316   die->die_child = NULL;
5317
5318   while (child_die != NULL)
5319     {
5320       dw_die_ref tmp_die = child_die;
5321       dw_attr_ref a;
5322
5323       child_die = child_die->die_sib;
5324
5325       for (a = tmp_die->die_attr; a != NULL;)
5326         {
5327           dw_attr_ref tmp_a = a;
5328
5329           a = a->dw_attr_next;
5330           free_AT (tmp_a);
5331         }
5332
5333       free_die (tmp_die);
5334     }
5335 }
5336
5337 /* Add a child DIE below its parent.  We build the lists up in reverse
5338    addition order, and correct that in reverse_all_dies.  */
5339
5340 static inline void
5341 add_child_die (dw_die_ref die, dw_die_ref child_die)
5342 {
5343   if (die != NULL && child_die != NULL)
5344     {
5345       gcc_assert (die != child_die);
5346
5347       child_die->die_parent = die;
5348       child_die->die_sib = die->die_child;
5349       die->die_child = child_die;
5350     }
5351 }
5352
5353 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
5354    is the specification, to the front of PARENT's list of children.  */
5355
5356 static void
5357 splice_child_die (dw_die_ref parent, dw_die_ref child)
5358 {
5359   dw_die_ref *p;
5360
5361   /* We want the declaration DIE from inside the class, not the
5362      specification DIE at toplevel.  */
5363   if (child->die_parent != parent)
5364     {
5365       dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
5366
5367       if (tmp)
5368         child = tmp;
5369     }
5370
5371   gcc_assert (child->die_parent == parent
5372               || (child->die_parent
5373                   == get_AT_ref (parent, DW_AT_specification)));
5374
5375   for (p = &(child->die_parent->die_child); *p; p = &((*p)->die_sib))
5376     if (*p == child)
5377       {
5378         *p = child->die_sib;
5379         break;
5380       }
5381
5382   child->die_parent = parent;
5383   child->die_sib = parent->die_child;
5384   parent->die_child = child;
5385 }
5386
5387 /* Return a pointer to a newly created DIE node.  */
5388
5389 static inline dw_die_ref
5390 new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
5391 {
5392   dw_die_ref die = ggc_alloc_cleared (sizeof (die_node));
5393
5394   die->die_tag = tag_value;
5395
5396   if (parent_die != NULL)
5397     add_child_die (parent_die, die);
5398   else
5399     {
5400       limbo_die_node *limbo_node;
5401
5402       limbo_node = ggc_alloc_cleared (sizeof (limbo_die_node));
5403       limbo_node->die = die;
5404       limbo_node->created_for = t;
5405       limbo_node->next = limbo_die_list;
5406       limbo_die_list = limbo_node;
5407     }
5408
5409   return die;
5410 }
5411
5412 /* Return the DIE associated with the given type specifier.  */
5413
5414 static inline dw_die_ref
5415 lookup_type_die (tree type)
5416 {
5417   return TYPE_SYMTAB_DIE (type);
5418 }
5419
5420 /* Equate a DIE to a given type specifier.  */
5421
5422 static inline void
5423 equate_type_number_to_die (tree type, dw_die_ref type_die)
5424 {
5425   TYPE_SYMTAB_DIE (type) = type_die;
5426 }
5427
5428 /* Returns a hash value for X (which really is a die_struct).  */
5429
5430 static hashval_t
5431 decl_die_table_hash (const void *x)
5432 {
5433   return (hashval_t) ((const dw_die_ref) x)->decl_id;
5434 }
5435
5436 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y.  */
5437
5438 static int
5439 decl_die_table_eq (const void *x, const void *y)
5440 {
5441   return (((const dw_die_ref) x)->decl_id == DECL_UID ((const tree) y));
5442 }
5443
5444 /* Return the DIE associated with a given declaration.  */
5445
5446 static inline dw_die_ref
5447 lookup_decl_die (tree decl)
5448 {
5449   return htab_find_with_hash (decl_die_table, decl, DECL_UID (decl));
5450 }
5451
5452 /* Returns a hash value for X (which really is a var_loc_list).  */
5453
5454 static hashval_t
5455 decl_loc_table_hash (const void *x)
5456 {
5457   return (hashval_t) ((const var_loc_list *) x)->decl_id;
5458 }
5459
5460 /* Return nonzero if decl_id of var_loc_list X is the same as
5461    UID of decl *Y.  */
5462
5463 static int
5464 decl_loc_table_eq (const void *x, const void *y)
5465 {
5466   return (((const var_loc_list *) x)->decl_id == DECL_UID ((const tree) y));
5467 }
5468
5469 /* Return the var_loc list associated with a given declaration.  */
5470
5471 static inline var_loc_list *
5472 lookup_decl_loc (tree decl)
5473 {
5474   return htab_find_with_hash (decl_loc_table, decl, DECL_UID (decl));
5475 }
5476
5477 /* Equate a DIE to a particular declaration.  */
5478
5479 static void
5480 equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
5481 {
5482   unsigned int decl_id = DECL_UID (decl);
5483   void **slot;
5484
5485   slot = htab_find_slot_with_hash (decl_die_table, decl, decl_id, INSERT);
5486   *slot = decl_die;
5487   decl_die->decl_id = decl_id;
5488 }
5489
5490 /* Add a variable location node to the linked list for DECL.  */
5491
5492 static void
5493 add_var_loc_to_decl (tree decl, struct var_loc_node *loc)
5494 {
5495   unsigned int decl_id = DECL_UID (decl);
5496   var_loc_list *temp;
5497   void **slot;
5498
5499   slot = htab_find_slot_with_hash (decl_loc_table, decl, decl_id, INSERT);
5500   if (*slot == NULL)
5501     {
5502       temp = ggc_alloc_cleared (sizeof (var_loc_list));
5503       temp->decl_id = decl_id;
5504       *slot = temp;
5505     }
5506   else
5507     temp = *slot;
5508
5509   if (temp->last)
5510     {
5511       /* If the current location is the same as the end of the list,
5512          we have nothing to do.  */
5513       if (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->last->var_loc_note),
5514                         NOTE_VAR_LOCATION_LOC (loc->var_loc_note)))
5515         {
5516           /* Add LOC to the end of list and update LAST.  */
5517           temp->last->next = loc;
5518           temp->last = loc;
5519         }
5520     }
5521   /* Do not add empty location to the beginning of the list.  */
5522   else if (NOTE_VAR_LOCATION_LOC (loc->var_loc_note) != NULL_RTX)
5523     {
5524       temp->first = loc;
5525       temp->last = loc;
5526     }
5527 }
5528 \f
5529 /* Keep track of the number of spaces used to indent the
5530    output of the debugging routines that print the structure of
5531    the DIE internal representation.  */
5532 static int print_indent;
5533
5534 /* Indent the line the number of spaces given by print_indent.  */
5535
5536 static inline void
5537 print_spaces (FILE *outfile)
5538 {
5539   fprintf (outfile, "%*s", print_indent, "");
5540 }
5541
5542 /* Print the information associated with a given DIE, and its children.
5543    This routine is a debugging aid only.  */
5544
5545 static void
5546 print_die (dw_die_ref die, FILE *outfile)
5547 {
5548   dw_attr_ref a;
5549   dw_die_ref c;
5550
5551   print_spaces (outfile);
5552   fprintf (outfile, "DIE %4lu: %s\n",
5553            die->die_offset, dwarf_tag_name (die->die_tag));
5554   print_spaces (outfile);
5555   fprintf (outfile, "  abbrev id: %lu", die->die_abbrev);
5556   fprintf (outfile, " offset: %lu\n", die->die_offset);
5557
5558   for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
5559     {
5560       print_spaces (outfile);
5561       fprintf (outfile, "  %s: ", dwarf_attr_name (a->dw_attr));
5562
5563       switch (AT_class (a))
5564         {
5565         case dw_val_class_addr:
5566           fprintf (outfile, "address");
5567           break;
5568         case dw_val_class_offset:
5569           fprintf (outfile, "offset");
5570           break;
5571         case dw_val_class_loc:
5572           fprintf (outfile, "location descriptor");
5573           break;
5574         case dw_val_class_loc_list:
5575           fprintf (outfile, "location list -> label:%s",
5576                    AT_loc_list (a)->ll_symbol);
5577           break;
5578         case dw_val_class_range_list:
5579           fprintf (outfile, "range list");
5580           break;
5581         case dw_val_class_const:
5582           fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, AT_int (a));
5583           break;
5584         case dw_val_class_unsigned_const:
5585           fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, AT_unsigned (a));
5586           break;
5587         case dw_val_class_long_long:
5588           fprintf (outfile, "constant (%lu,%lu)",
5589                    a->dw_attr_val.v.val_long_long.hi,
5590                    a->dw_attr_val.v.val_long_long.low);
5591           break;
5592         case dw_val_class_vec:
5593           fprintf (outfile, "floating-point or vector constant");
5594           break;
5595         case dw_val_class_flag:
5596           fprintf (outfile, "%u", AT_flag (a));
5597           break;
5598         case dw_val_class_die_ref:
5599           if (AT_ref (a) != NULL)
5600             {
5601               if (AT_ref (a)->die_symbol)
5602                 fprintf (outfile, "die -> label: %s", AT_ref (a)->die_symbol);
5603               else
5604                 fprintf (outfile, "die -> %lu", AT_ref (a)->die_offset);
5605             }
5606           else
5607             fprintf (outfile, "die -> <null>");
5608           break;
5609         case dw_val_class_lbl_id:
5610         case dw_val_class_lbl_offset:
5611           fprintf (outfile, "label: %s", AT_lbl (a));
5612           break;
5613         case dw_val_class_str:
5614           if (AT_string (a) != NULL)
5615             fprintf (outfile, "\"%s\"", AT_string (a));
5616           else
5617             fprintf (outfile, "<null>");
5618           break;
5619         default:
5620           break;
5621         }
5622
5623       fprintf (outfile, "\n");
5624     }
5625
5626   if (die->die_child != NULL)
5627     {
5628       print_indent += 4;
5629       for (c = die->die_child; c != NULL; c = c->die_sib)
5630         print_die (c, outfile);
5631
5632       print_indent -= 4;
5633     }
5634   if (print_indent == 0)
5635     fprintf (outfile, "\n");
5636 }
5637
5638 /* Print the contents of the source code line number correspondence table.
5639    This routine is a debugging aid only.  */
5640
5641 static void
5642 print_dwarf_line_table (FILE *outfile)
5643 {
5644   unsigned i;
5645   dw_line_info_ref line_info;
5646
5647   fprintf (outfile, "\n\nDWARF source line information\n");
5648   for (i = 1; i < line_info_table_in_use; i++)
5649     {
5650       line_info = &line_info_table[i];
5651       fprintf (outfile, "%5d: ", i);
5652       fprintf (outfile, "%-20s",
5653                VARRAY_CHAR_PTR (file_table, line_info->dw_file_num));
5654       fprintf (outfile, "%6ld", line_info->dw_line_num);
5655       fprintf (outfile, "\n");
5656     }
5657
5658   fprintf (outfile, "\n\n");
5659 }
5660
5661 /* Print the information collected for a given DIE.  */
5662
5663 void
5664 debug_dwarf_die (dw_die_ref die)
5665 {
5666   print_die (die, stderr);
5667 }
5668
5669 /* Print all DWARF information collected for the compilation unit.
5670    This routine is a debugging aid only.  */
5671
5672 void
5673 debug_dwarf (void)
5674 {
5675   print_indent = 0;
5676   print_die (comp_unit_die, stderr);
5677   if (! DWARF2_ASM_LINE_DEBUG_INFO)
5678     print_dwarf_line_table (stderr);
5679 }
5680 \f
5681 /* We build up the lists of children and attributes by pushing new ones
5682    onto the beginning of the list.  Reverse the lists for DIE so that
5683    they are in order of addition.  */
5684
5685 static void
5686 reverse_die_lists (dw_die_ref die)
5687 {
5688   dw_die_ref c, cp, cn;
5689   dw_attr_ref a, ap, an;
5690
5691   for (a = die->die_attr, ap = 0; a; a = an)
5692     {
5693       an = a->dw_attr_next;
5694       a->dw_attr_next = ap;
5695       ap = a;
5696     }
5697
5698   die->die_attr = ap;
5699
5700   for (c = die->die_child, cp = 0; c; c = cn)
5701     {
5702       cn = c->die_sib;
5703       c->die_sib = cp;
5704       cp = c;
5705     }
5706
5707   die->die_child = cp;
5708 }
5709
5710 /* reverse_die_lists only reverses the single die you pass it. Since we used to
5711    reverse all dies in add_sibling_attributes, which runs through all the dies,
5712    it would reverse all the dies.  Now, however, since we don't call
5713    reverse_die_lists in add_sibling_attributes, we need a routine to
5714    recursively reverse all the dies. This is that routine.  */
5715
5716 static void
5717 reverse_all_dies (dw_die_ref die)
5718 {
5719   dw_die_ref c;
5720
5721   reverse_die_lists (die);
5722
5723   for (c = die->die_child; c; c = c->die_sib)
5724     reverse_all_dies (c);
5725 }
5726
5727 /* Start a new compilation unit DIE for an include file.  OLD_UNIT is the CU
5728    for the enclosing include file, if any.  BINCL_DIE is the DW_TAG_GNU_BINCL
5729    DIE that marks the start of the DIEs for this include file.  */
5730
5731 static dw_die_ref
5732 push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die)
5733 {
5734   const char *filename = get_AT_string (bincl_die, DW_AT_name);
5735   dw_die_ref new_unit = gen_compile_unit_die (filename);
5736
5737   new_unit->die_sib = old_unit;
5738   return new_unit;
5739 }
5740
5741 /* Close an include-file CU and reopen the enclosing one.  */
5742
5743 static dw_die_ref
5744 pop_compile_unit (dw_die_ref old_unit)
5745 {
5746   dw_die_ref new_unit = old_unit->die_sib;
5747
5748   old_unit->die_sib = NULL;
5749   return new_unit;
5750 }
5751
5752 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5753 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
5754
5755 /* Calculate the checksum of a location expression.  */
5756
5757 static inline void
5758 loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
5759 {
5760   CHECKSUM (loc->dw_loc_opc);
5761   CHECKSUM (loc->dw_loc_oprnd1);
5762   CHECKSUM (loc->dw_loc_oprnd2);
5763 }
5764
5765 /* Calculate the checksum of an attribute.  */
5766
5767 static void
5768 attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark)
5769 {
5770   dw_loc_descr_ref loc;
5771   rtx r;
5772
5773   CHECKSUM (at->dw_attr);
5774
5775   /* We don't care about differences in file numbering.  */
5776   if (at->dw_attr == DW_AT_decl_file
5777       /* Or that this was compiled with a different compiler snapshot; if
5778          the output is the same, that's what matters.  */
5779       || at->dw_attr == DW_AT_producer)
5780     return;
5781
5782   switch (AT_class (at))
5783     {
5784     case dw_val_class_const:
5785       CHECKSUM (at->dw_attr_val.v.val_int);
5786       break;
5787     case dw_val_class_unsigned_const:
5788       CHECKSUM (at->dw_attr_val.v.val_unsigned);
5789       break;
5790     case dw_val_class_long_long:
5791       CHECKSUM (at->dw_attr_val.v.val_long_long);
5792       break;
5793     case dw_val_class_vec:
5794       CHECKSUM (at->dw_attr_val.v.val_vec);
5795       break;
5796     case dw_val_class_flag:
5797       CHECKSUM (at->dw_attr_val.v.val_flag);
5798       break;
5799     case dw_val_class_str:
5800       CHECKSUM_STRING (AT_string (at));
5801       break;
5802
5803     case dw_val_class_addr:
5804       r = AT_addr (at);
5805       gcc_assert (GET_CODE (r) == SYMBOL_REF);
5806       CHECKSUM_STRING (XSTR (r, 0));
5807       break;
5808
5809     case dw_val_class_offset:
5810       CHECKSUM (at->dw_attr_val.v.val_offset);
5811       break;
5812
5813     case dw_val_class_loc:
5814       for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
5815         loc_checksum (loc, ctx);
5816       break;
5817
5818     case dw_val_class_die_ref:
5819       die_checksum (AT_ref (at), ctx, mark);
5820       break;
5821
5822     case dw_val_class_fde_ref:
5823     case dw_val_class_lbl_id:
5824     case dw_val_class_lbl_offset:
5825       break;
5826
5827     default:
5828       break;
5829     }
5830 }
5831
5832 /* Calculate the checksum of a DIE.  */
5833
5834 static void
5835 die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
5836 {
5837   dw_die_ref c;
5838   dw_attr_ref a;
5839
5840   /* To avoid infinite recursion.  */
5841   if (die->die_mark)
5842     {
5843       CHECKSUM (die->die_mark);
5844       return;
5845     }
5846   die->die_mark = ++(*mark);
5847
5848   CHECKSUM (die->die_tag);
5849
5850   for (a = die->die_attr; a; a = a->dw_attr_next)
5851     attr_checksum (a, ctx, mark);
5852
5853   for (c = die->die_child; c; c = c->die_sib)
5854     die_checksum (c, ctx, mark);
5855 }
5856
5857 #undef CHECKSUM
5858 #undef CHECKSUM_STRING
5859
5860 /* Do the location expressions look same?  */
5861 static inline int
5862 same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
5863 {
5864   return loc1->dw_loc_opc == loc2->dw_loc_opc
5865          && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
5866          && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
5867 }
5868
5869 /* Do the values look the same?  */
5870 static int
5871 same_dw_val_p (dw_val_node *v1, dw_val_node *v2, int *mark)
5872 {
5873   dw_loc_descr_ref loc1, loc2;
5874   rtx r1, r2;
5875
5876   if (v1->val_class != v2->val_class)
5877     return 0;
5878
5879   switch (v1->val_class)
5880     {
5881     case dw_val_class_const:
5882       return v1->v.val_int == v2->v.val_int;
5883     case dw_val_class_unsigned_const:
5884       return v1->v.val_unsigned == v2->v.val_unsigned;
5885     case dw_val_class_long_long:
5886       return v1->v.val_long_long.hi == v2->v.val_long_long.hi
5887              && v1->v.val_long_long.low == v2->v.val_long_long.low;
5888     case dw_val_class_vec:
5889       if (v1->v.val_vec.length != v2->v.val_vec.length
5890           || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size)
5891         return 0;
5892       if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array,
5893                   v1->v.val_vec.length * v1->v.val_vec.elt_size))
5894         return 0;
5895       return 1;
5896     case dw_val_class_flag:
5897       return v1->v.val_flag == v2->v.val_flag;
5898     case dw_val_class_str:
5899       return !strcmp(v1->v.val_str->str, v2->v.val_str->str);
5900
5901     case dw_val_class_addr:
5902       r1 = v1->v.val_addr;
5903       r2 = v2->v.val_addr;
5904       if (GET_CODE (r1) != GET_CODE (r2))
5905         return 0;
5906       gcc_assert (GET_CODE (r1) == SYMBOL_REF);
5907       return !strcmp (XSTR (r1, 0), XSTR (r2, 0));
5908
5909     case dw_val_class_offset:
5910       return v1->v.val_offset == v2->v.val_offset;
5911
5912     case dw_val_class_loc:
5913       for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
5914            loc1 && loc2;
5915            loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
5916         if (!same_loc_p (loc1, loc2, mark))
5917           return 0;
5918       return !loc1 && !loc2;
5919
5920     case dw_val_class_die_ref:
5921       return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
5922
5923     case dw_val_class_fde_ref:
5924     case dw_val_class_lbl_id:
5925     case dw_val_class_lbl_offset:
5926       return 1;
5927
5928     default:
5929       return 1;
5930     }
5931 }
5932
5933 /* Do the attributes look the same?  */
5934
5935 static int
5936 same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark)
5937 {
5938   if (at1->dw_attr != at2->dw_attr)
5939     return 0;
5940
5941   /* We don't care about differences in file numbering.  */
5942   if (at1->dw_attr == DW_AT_decl_file
5943       /* Or that this was compiled with a different compiler snapshot; if
5944          the output is the same, that's what matters.  */
5945       || at1->dw_attr == DW_AT_producer)
5946     return 1;
5947
5948   return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
5949 }
5950
5951 /* Do the dies look the same?  */
5952
5953 static int
5954 same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
5955 {
5956   dw_die_ref c1, c2;
5957   dw_attr_ref a1, a2;
5958
5959   /* To avoid infinite recursion.  */
5960   if (die1->die_mark)
5961     return die1->die_mark == die2->die_mark;
5962   die1->die_mark = die2->die_mark = ++(*mark);
5963
5964   if (die1->die_tag != die2->die_tag)
5965     return 0;
5966
5967   for (a1 = die1->die_attr, a2 = die2->die_attr;
5968        a1 && a2;
5969        a1 = a1->dw_attr_next, a2 = a2->dw_attr_next)
5970     if (!same_attr_p (a1, a2, mark))
5971       return 0;
5972   if (a1 || a2)
5973     return 0;
5974
5975   for (c1 = die1->die_child, c2 = die2->die_child;
5976        c1 && c2;
5977        c1 = c1->die_sib, c2 = c2->die_sib)
5978     if (!same_die_p (c1, c2, mark))
5979       return 0;
5980   if (c1 || c2)
5981     return 0;
5982
5983   return 1;
5984 }
5985
5986 /* Do the dies look the same?  Wrapper around same_die_p.  */
5987
5988 static int
5989 same_die_p_wrap (dw_die_ref die1, dw_die_ref die2)
5990 {
5991   int mark = 0;
5992   int ret = same_die_p (die1, die2, &mark);
5993
5994   unmark_all_dies (die1);
5995   unmark_all_dies (die2);
5996
5997   return ret;
5998 }
5999
6000 /* The prefix to attach to symbols on DIEs in the current comdat debug
6001    info section.  */
6002 static char *comdat_symbol_id;
6003
6004 /* The index of the current symbol within the current comdat CU.  */
6005 static unsigned int comdat_symbol_number;
6006
6007 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
6008    children, and set comdat_symbol_id accordingly.  */
6009
6010 static void
6011 compute_section_prefix (dw_die_ref unit_die)
6012 {
6013   const char *die_name = get_AT_string (unit_die, DW_AT_name);
6014   const char *base = die_name ? lbasename (die_name) : "anonymous";
6015   char *name = alloca (strlen (base) + 64);
6016   char *p;
6017   int i, mark;
6018   unsigned char checksum[16];
6019   struct md5_ctx ctx;
6020
6021   /* Compute the checksum of the DIE, then append part of it as hex digits to
6022      the name filename of the unit.  */
6023
6024   md5_init_ctx (&ctx);
6025   mark = 0;
6026   die_checksum (unit_die, &ctx, &mark);
6027   unmark_all_dies (unit_die);
6028   md5_finish_ctx (&ctx, checksum);
6029
6030   sprintf (name, "%s.", base);
6031   clean_symbol_name (name);
6032
6033   p = name + strlen (name);
6034   for (i = 0; i < 4; i++)
6035     {
6036       sprintf (p, "%.2x", checksum[i]);
6037       p += 2;
6038     }
6039
6040   comdat_symbol_id = unit_die->die_symbol = xstrdup (name);
6041   comdat_symbol_number = 0;
6042 }
6043
6044 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P.  */
6045
6046 static int
6047 is_type_die (dw_die_ref die)
6048 {
6049   switch (die->die_tag)
6050     {
6051     case DW_TAG_array_type:
6052     case DW_TAG_class_type:
6053     case DW_TAG_enumeration_type:
6054     case DW_TAG_pointer_type:
6055     case DW_TAG_reference_type:
6056     case DW_TAG_string_type:
6057     case DW_TAG_structure_type:
6058     case DW_TAG_subroutine_type:
6059     case DW_TAG_union_type:
6060     case DW_TAG_ptr_to_member_type:
6061     case DW_TAG_set_type:
6062     case DW_TAG_subrange_type:
6063     case DW_TAG_base_type:
6064     case DW_TAG_const_type:
6065     case DW_TAG_file_type:
6066     case DW_TAG_packed_type:
6067     case DW_TAG_volatile_type:
6068     case DW_TAG_typedef:
6069       return 1;
6070     default:
6071       return 0;
6072     }
6073 }
6074
6075 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
6076    Basically, we want to choose the bits that are likely to be shared between
6077    compilations (types) and leave out the bits that are specific to individual
6078    compilations (functions).  */
6079
6080 static int
6081 is_comdat_die (dw_die_ref c)
6082 {
6083   /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
6084      we do for stabs.  The advantage is a greater likelihood of sharing between
6085      objects that don't include headers in the same order (and therefore would
6086      put the base types in a different comdat).  jason 8/28/00 */
6087
6088   if (c->die_tag == DW_TAG_base_type)
6089     return 0;
6090
6091   if (c->die_tag == DW_TAG_pointer_type
6092       || c->die_tag == DW_TAG_reference_type
6093       || c->die_tag == DW_TAG_const_type
6094       || c->die_tag == DW_TAG_volatile_type)
6095     {
6096       dw_die_ref t = get_AT_ref (c, DW_AT_type);
6097
6098       return t ? is_comdat_die (t) : 0;
6099     }
6100
6101   return is_type_die (c);
6102 }
6103
6104 /* Returns 1 iff C is the sort of DIE that might be referred to from another
6105    compilation unit.  */
6106
6107 static int
6108 is_symbol_die (dw_die_ref c)
6109 {
6110   return (is_type_die (c)
6111           || (get_AT (c, DW_AT_declaration)
6112               && !get_AT (c, DW_AT_specification)));
6113 }
6114
6115 static char *
6116 gen_internal_sym (const char *prefix)
6117 {
6118   char buf[256];
6119
6120   ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
6121   return xstrdup (buf);
6122 }
6123
6124 /* Assign symbols to all worthy DIEs under DIE.  */
6125
6126 static void
6127 assign_symbol_names (dw_die_ref die)
6128 {
6129   dw_die_ref c;
6130
6131   if (is_symbol_die (die))
6132     {
6133       if (comdat_symbol_id)
6134         {
6135           char *p = alloca (strlen (comdat_symbol_id) + 64);
6136
6137           sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
6138                    comdat_symbol_id, comdat_symbol_number++);
6139           die->die_symbol = xstrdup (p);
6140         }
6141       else
6142         die->die_symbol = gen_internal_sym ("LDIE");
6143     }
6144
6145   for (c = die->die_child; c != NULL; c = c->die_sib)
6146     assign_symbol_names (c);
6147 }
6148
6149 struct cu_hash_table_entry
6150 {
6151   dw_die_ref cu;
6152   unsigned min_comdat_num, max_comdat_num;
6153   struct cu_hash_table_entry *next;
6154 };
6155
6156 /* Routines to manipulate hash table of CUs.  */
6157 static hashval_t
6158 htab_cu_hash (const void *of)
6159 {
6160   const struct cu_hash_table_entry *entry = of;
6161
6162   return htab_hash_string (entry->cu->die_symbol);
6163 }
6164
6165 static int
6166 htab_cu_eq (const void *of1, const void *of2)
6167 {
6168   const struct cu_hash_table_entry *entry1 = of1;
6169   const struct die_struct *entry2 = of2;
6170
6171   return !strcmp (entry1->cu->die_symbol, entry2->die_symbol);
6172 }
6173
6174 static void
6175 htab_cu_del (void *what)
6176 {
6177   struct cu_hash_table_entry *next, *entry = what;
6178
6179   while (entry)
6180     {
6181       next = entry->next;
6182       free (entry);
6183       entry = next;
6184     }
6185 }
6186
6187 /* Check whether we have already seen this CU and set up SYM_NUM
6188    accordingly.  */
6189 static int
6190 check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num)
6191 {
6192   struct cu_hash_table_entry dummy;
6193   struct cu_hash_table_entry **slot, *entry, *last = &dummy;
6194
6195   dummy.max_comdat_num = 0;
6196
6197   slot = (struct cu_hash_table_entry **)
6198     htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
6199         INSERT);
6200   entry = *slot;
6201
6202   for (; entry; last = entry, entry = entry->next)
6203     {
6204       if (same_die_p_wrap (cu, entry->cu))
6205         break;
6206     }
6207
6208   if (entry)
6209     {
6210       *sym_num = entry->min_comdat_num;
6211       return 1;
6212     }
6213
6214   entry = xcalloc (1, sizeof (struct cu_hash_table_entry));
6215   entry->cu = cu;
6216   entry->min_comdat_num = *sym_num = last->max_comdat_num;
6217   entry->next = *slot;
6218   *slot = entry;
6219
6220   return 0;
6221 }
6222
6223 /* Record SYM_NUM to record of CU in HTABLE.  */
6224 static void
6225 record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num)
6226 {
6227   struct cu_hash_table_entry **slot, *entry;
6228
6229   slot = (struct cu_hash_table_entry **)
6230     htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
6231         NO_INSERT);
6232   entry = *slot;
6233
6234   entry->max_comdat_num = sym_num;
6235 }
6236
6237 /* Traverse the DIE (which is always comp_unit_die), and set up
6238    additional compilation units for each of the include files we see
6239    bracketed by BINCL/EINCL.  */
6240
6241 static void
6242 break_out_includes (dw_die_ref die)
6243 {
6244   dw_die_ref *ptr;
6245   dw_die_ref unit = NULL;
6246   limbo_die_node *node, **pnode;
6247   htab_t cu_hash_table;
6248
6249   for (ptr = &(die->die_child); *ptr;)
6250     {
6251       dw_die_ref c = *ptr;
6252
6253       if (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL
6254           || (unit && is_comdat_die (c)))
6255         {
6256           /* This DIE is for a secondary CU; remove it from the main one.  */
6257           *ptr = c->die_sib;
6258
6259           if (c->die_tag == DW_TAG_GNU_BINCL)
6260             {
6261               unit = push_new_compile_unit (unit, c);
6262               free_die (c);
6263             }
6264           else if (c->die_tag == DW_TAG_GNU_EINCL)
6265             {
6266               unit = pop_compile_unit (unit);
6267               free_die (c);
6268             }
6269           else
6270             add_child_die (unit, c);
6271         }
6272       else
6273         {
6274           /* Leave this DIE in the main CU.  */
6275           ptr = &(c->die_sib);
6276           continue;
6277         }
6278     }
6279
6280 #if 0
6281   /* We can only use this in debugging, since the frontend doesn't check
6282      to make sure that we leave every include file we enter.  */
6283   gcc_assert (!unit);
6284 #endif
6285
6286   assign_symbol_names (die);
6287   cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del);
6288   for (node = limbo_die_list, pnode = &limbo_die_list;
6289        node;
6290        node = node->next)
6291     {
6292       int is_dupl;
6293
6294       compute_section_prefix (node->die);
6295       is_dupl = check_duplicate_cu (node->die, cu_hash_table,
6296                         &comdat_symbol_number);
6297       assign_symbol_names (node->die);
6298       if (is_dupl)
6299         *pnode = node->next;
6300       else
6301         {
6302           pnode = &node->next;
6303           record_comdat_symbol_number (node->die, cu_hash_table,
6304                 comdat_symbol_number);
6305         }
6306     }
6307   htab_delete (cu_hash_table);
6308 }
6309
6310 /* Traverse the DIE and add a sibling attribute if it may have the
6311    effect of speeding up access to siblings.  To save some space,
6312    avoid generating sibling attributes for DIE's without children.  */
6313
6314 static void
6315 add_sibling_attributes (dw_die_ref die)
6316 {
6317   dw_die_ref c;
6318
6319   if (die->die_tag != DW_TAG_compile_unit
6320       && die->die_sib && die->die_child != NULL)
6321     /* Add the sibling link to the front of the attribute list.  */
6322     add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
6323
6324   for (c = die->die_child; c != NULL; c = c->die_sib)
6325     add_sibling_attributes (c);
6326 }
6327
6328 /* Output all location lists for the DIE and its children.  */
6329
6330 static void
6331 output_location_lists (dw_die_ref die)
6332 {
6333   dw_die_ref c;
6334   dw_attr_ref d_attr;
6335
6336   for (d_attr = die->die_attr; d_attr; d_attr = d_attr->dw_attr_next)
6337     if (AT_class (d_attr) == dw_val_class_loc_list)
6338       output_loc_list (AT_loc_list (d_attr));
6339
6340   for (c = die->die_child; c != NULL; c = c->die_sib)
6341     output_location_lists (c);
6342
6343 }
6344
6345 /* The format of each DIE (and its attribute value pairs) is encoded in an
6346    abbreviation table.  This routine builds the abbreviation table and assigns
6347    a unique abbreviation id for each abbreviation entry.  The children of each
6348    die are visited recursively.  */
6349
6350 static void
6351 build_abbrev_table (dw_die_ref die)
6352 {
6353   unsigned long abbrev_id;
6354   unsigned int n_alloc;
6355   dw_die_ref c;
6356   dw_attr_ref d_attr, a_attr;
6357
6358   /* Scan the DIE references, and mark as external any that refer to
6359      DIEs from other CUs (i.e. those which are not marked).  */
6360   for (d_attr = die->die_attr; d_attr; d_attr = d_attr->dw_attr_next)
6361     if (AT_class (d_attr) == dw_val_class_die_ref
6362         && AT_ref (d_attr)->die_mark == 0)
6363       {
6364         gcc_assert (AT_ref (d_attr)->die_symbol);
6365
6366         set_AT_ref_external (d_attr, 1);
6367       }
6368
6369   for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
6370     {
6371       dw_die_ref abbrev = abbrev_die_table[abbrev_id];
6372
6373       if (abbrev->die_tag == die->die_tag)
6374         {
6375           if ((abbrev->die_child != NULL) == (die->die_child != NULL))
6376             {
6377               a_attr = abbrev->die_attr;
6378               d_attr = die->die_attr;
6379
6380               while (a_attr != NULL && d_attr != NULL)
6381                 {
6382                   if ((a_attr->dw_attr != d_attr->dw_attr)
6383                       || (value_format (a_attr) != value_format (d_attr)))
6384                     break;
6385
6386                   a_attr = a_attr->dw_attr_next;
6387                   d_attr = d_attr->dw_attr_next;
6388                 }
6389
6390               if (a_attr == NULL && d_attr == NULL)
6391                 break;
6392             }
6393         }
6394     }
6395
6396   if (abbrev_id >= abbrev_die_table_in_use)
6397     {
6398       if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
6399         {
6400           n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
6401           abbrev_die_table = ggc_realloc (abbrev_die_table,
6402                                           sizeof (dw_die_ref) * n_alloc);
6403
6404           memset (&abbrev_die_table[abbrev_die_table_allocated], 0,
6405                  (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
6406           abbrev_die_table_allocated = n_alloc;
6407         }
6408
6409       ++abbrev_die_table_in_use;
6410       abbrev_die_table[abbrev_id] = die;
6411     }
6412
6413   die->die_abbrev = abbrev_id;
6414   for (c = die->die_child; c != NULL; c = c->die_sib)
6415     build_abbrev_table (c);
6416 }
6417 \f
6418 /* Return the power-of-two number of bytes necessary to represent VALUE.  */
6419
6420 static int
6421 constant_size (long unsigned int value)
6422 {
6423   int log;
6424
6425   if (value == 0)
6426     log = 0;
6427   else
6428     log = floor_log2 (value);
6429
6430   log = log / 8;
6431   log = 1 << (floor_log2 (log) + 1);
6432
6433   return log;
6434 }
6435
6436 /* Return the size of a DIE as it is represented in the
6437    .debug_info section.  */
6438
6439 static unsigned long
6440 size_of_die (dw_die_ref die)
6441 {
6442   unsigned long size = 0;
6443   dw_attr_ref a;
6444
6445   size += size_of_uleb128 (die->die_abbrev);
6446   for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
6447     {
6448       switch (AT_class (a))
6449         {
6450         case dw_val_class_addr:
6451           size += DWARF2_ADDR_SIZE;
6452           break;
6453         case dw_val_class_offset:
6454           size += DWARF_OFFSET_SIZE;
6455           break;
6456         case dw_val_class_loc:
6457           {
6458             unsigned long lsize = size_of_locs (AT_loc (a));
6459
6460             /* Block length.  */
6461             size += constant_size (lsize);
6462             size += lsize;
6463           }
6464           break;
6465         case dw_val_class_loc_list:
6466           size += DWARF_OFFSET_SIZE;
6467           break;
6468         case dw_val_class_range_list:
6469           size += DWARF_OFFSET_SIZE;
6470           break;
6471         case dw_val_class_const:
6472           size += size_of_sleb128 (AT_int (a));
6473           break;
6474         case dw_val_class_unsigned_const:
6475           size += constant_size (AT_unsigned (a));
6476           break;
6477         case dw_val_class_long_long:
6478           size += 1 + 2*HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR; /* block */
6479           break;
6480         case dw_val_class_vec:
6481           size += 1 + (a->dw_attr_val.v.val_vec.length
6482                        * a->dw_attr_val.v.val_vec.elt_size); /* block */
6483           break;
6484         case dw_val_class_flag:
6485           size += 1;
6486           break;
6487         case dw_val_class_die_ref:
6488           if (AT_ref_external (a))
6489             size += DWARF2_ADDR_SIZE;
6490           else
6491             size += DWARF_OFFSET_SIZE;
6492           break;
6493         case dw_val_class_fde_ref:
6494           size += DWARF_OFFSET_SIZE;
6495           break;
6496         case dw_val_class_lbl_id:
6497           size += DWARF2_ADDR_SIZE;
6498           break;
6499         case dw_val_class_lbl_offset:
6500           size += DWARF_OFFSET_SIZE;
6501           break;
6502         case dw_val_class_str:
6503           if (AT_string_form (a) == DW_FORM_strp)
6504             size += DWARF_OFFSET_SIZE;
6505           else
6506             size += strlen (a->dw_attr_val.v.val_str->str) + 1;
6507           break;
6508         default:
6509           gcc_unreachable ();
6510         }
6511     }
6512
6513   return size;
6514 }
6515
6516 /* Size the debugging information associated with a given DIE.  Visits the
6517    DIE's children recursively.  Updates the global variable next_die_offset, on
6518    each time through.  Uses the current value of next_die_offset to update the
6519    die_offset field in each DIE.  */
6520
6521 static void
6522 calc_die_sizes (dw_die_ref die)
6523 {
6524   dw_die_ref c;
6525
6526   die->die_offset = next_die_offset;
6527   next_die_offset += size_of_die (die);
6528
6529   for (c = die->die_child; c != NULL; c = c->die_sib)
6530     calc_die_sizes (c);
6531
6532   if (die->die_child != NULL)
6533     /* Count the null byte used to terminate sibling lists.  */
6534     next_die_offset += 1;
6535 }
6536
6537 /* Set the marks for a die and its children.  We do this so
6538    that we know whether or not a reference needs to use FORM_ref_addr; only
6539    DIEs in the same CU will be marked.  We used to clear out the offset
6540    and use that as the flag, but ran into ordering problems.  */
6541
6542 static void
6543 mark_dies (dw_die_ref die)
6544 {
6545   dw_die_ref c;
6546
6547   gcc_assert (!die->die_mark);
6548
6549   die->die_mark = 1;
6550   for (c = die->die_child; c; c = c->die_sib)
6551     mark_dies (c);
6552 }
6553
6554 /* Clear the marks for a die and its children.  */
6555
6556 static void
6557 unmark_dies (dw_die_ref die)
6558 {
6559   dw_die_ref c;
6560
6561   gcc_assert (die->die_mark);
6562
6563   die->die_mark = 0;
6564   for (c = die->die_child; c; c = c->die_sib)
6565     unmark_dies (c);
6566 }
6567
6568 /* Clear the marks for a die, its children and referred dies.  */
6569
6570 static void
6571 unmark_all_dies (dw_die_ref die)
6572 {
6573   dw_die_ref c;
6574   dw_attr_ref a;
6575
6576   if (!die->die_mark)
6577     return;
6578   die->die_mark = 0;
6579
6580   for (c = die->die_child; c; c = c->die_sib)
6581     unmark_all_dies (c);
6582
6583   for (a = die->die_attr; a; a = a->dw_attr_next)
6584     if (AT_class (a) == dw_val_class_die_ref)
6585       unmark_all_dies (AT_ref (a));
6586 }
6587
6588 /* Return the size of the .debug_pubnames table  generated for the
6589    compilation unit.  */
6590
6591 static unsigned long
6592 size_of_pubnames (void)
6593 {
6594   unsigned long size;
6595   unsigned i;
6596
6597   size = DWARF_PUBNAMES_HEADER_SIZE;
6598   for (i = 0; i < pubname_table_in_use; i++)
6599     {
6600       pubname_ref p = &pubname_table[i];
6601       size += DWARF_OFFSET_SIZE + strlen (p->name) + 1;
6602     }
6603
6604   size += DWARF_OFFSET_SIZE;
6605   return size;
6606 }
6607
6608 /* Return the size of the information in the .debug_aranges section.  */
6609
6610 static unsigned long
6611 size_of_aranges (void)
6612 {
6613   unsigned long size;
6614
6615   size = DWARF_ARANGES_HEADER_SIZE;
6616
6617   /* Count the address/length pair for this compilation unit.  */
6618   size += 2 * DWARF2_ADDR_SIZE;
6619   size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use;
6620
6621   /* Count the two zero words used to terminated the address range table.  */
6622   size += 2 * DWARF2_ADDR_SIZE;
6623   return size;
6624 }
6625 \f
6626 /* Select the encoding of an attribute value.  */
6627
6628 static enum dwarf_form
6629 value_format (dw_attr_ref a)
6630 {
6631   switch (a->dw_attr_val.val_class)
6632     {
6633     case dw_val_class_addr:
6634       return DW_FORM_addr;
6635     case dw_val_class_range_list:
6636     case dw_val_class_offset:
6637       switch (DWARF_OFFSET_SIZE)
6638         {
6639         case 4:
6640           return DW_FORM_data4;
6641         case 8:
6642           return DW_FORM_data8;
6643         default:
6644           gcc_unreachable ();
6645         }
6646     case dw_val_class_loc_list:
6647       /* FIXME: Could be DW_FORM_data8, with a > 32 bit size
6648          .debug_loc section */
6649       return DW_FORM_data4;
6650     case dw_val_class_loc:
6651       switch (constant_size (size_of_locs (AT_loc (a))))
6652         {
6653         case 1:
6654           return DW_FORM_block1;
6655         case 2:
6656           return DW_FORM_block2;
6657         default:
6658           gcc_unreachable ();
6659         }
6660     case dw_val_class_const:
6661       return DW_FORM_sdata;
6662     case dw_val_class_unsigned_const:
6663       switch (constant_size (AT_unsigned (a)))
6664         {
6665         case 1:
6666           return DW_FORM_data1;
6667         case 2:
6668           return DW_FORM_data2;
6669         case 4:
6670           return DW_FORM_data4;
6671         case 8:
6672           return DW_FORM_data8;
6673         default:
6674           gcc_unreachable ();
6675         }
6676     case dw_val_class_long_long:
6677       return DW_FORM_block1;
6678     case dw_val_class_vec:
6679       return DW_FORM_block1;
6680     case dw_val_class_flag:
6681       return DW_FORM_flag;
6682     case dw_val_class_die_ref:
6683       if (AT_ref_external (a))
6684         return DW_FORM_ref_addr;
6685       else
6686         return DW_FORM_ref;
6687     case dw_val_class_fde_ref:
6688       return DW_FORM_data;
6689     case dw_val_class_lbl_id:
6690       return DW_FORM_addr;
6691     case dw_val_class_lbl_offset:
6692       return DW_FORM_data;
6693     case dw_val_class_str:
6694       return AT_string_form (a);
6695
6696     default:
6697       gcc_unreachable ();
6698     }
6699 }
6700
6701 /* Output the encoding of an attribute value.  */
6702
6703 static void
6704 output_value_format (dw_attr_ref a)
6705 {
6706   enum dwarf_form form = value_format (a);
6707
6708   dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
6709 }
6710
6711 /* Output the .debug_abbrev section which defines the DIE abbreviation
6712    table.  */
6713
6714 static void
6715 output_abbrev_section (void)
6716 {
6717   unsigned long abbrev_id;
6718
6719   dw_attr_ref a_attr;
6720
6721   for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
6722     {
6723       dw_die_ref abbrev = abbrev_die_table[abbrev_id];
6724
6725       dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
6726       dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
6727                                    dwarf_tag_name (abbrev->die_tag));
6728
6729       if (abbrev->die_child != NULL)
6730         dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
6731       else
6732         dw2_asm_output_data (1, DW_children_no, "DW_children_no");
6733
6734       for (a_attr = abbrev->die_attr; a_attr != NULL;
6735            a_attr = a_attr->dw_attr_next)
6736         {
6737           dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
6738                                        dwarf_attr_name (a_attr->dw_attr));
6739           output_value_format (a_attr);
6740         }
6741
6742       dw2_asm_output_data (1, 0, NULL);
6743       dw2_asm_output_data (1, 0, NULL);
6744     }
6745
6746   /* Terminate the table.  */
6747   dw2_asm_output_data (1, 0, NULL);
6748 }
6749
6750 /* Output a symbol we can use to refer to this DIE from another CU.  */
6751
6752 static inline void
6753 output_die_symbol (dw_die_ref die)
6754 {
6755   char *sym = die->die_symbol;
6756
6757   if (sym == 0)
6758     return;
6759
6760   if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
6761     /* We make these global, not weak; if the target doesn't support
6762        .linkonce, it doesn't support combining the sections, so debugging
6763        will break.  */
6764     targetm.asm_out.globalize_label (asm_out_file, sym);
6765
6766   ASM_OUTPUT_LABEL (asm_out_file, sym);
6767 }
6768
6769 /* Return a new location list, given the begin and end range, and the
6770    expression. gensym tells us whether to generate a new internal symbol for
6771    this location list node, which is done for the head of the list only.  */
6772
6773 static inline dw_loc_list_ref
6774 new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end,
6775               const char *section, unsigned int gensym)
6776 {
6777   dw_loc_list_ref retlist = ggc_alloc_cleared (sizeof (dw_loc_list_node));
6778
6779   retlist->begin = begin;
6780   retlist->end = end;
6781   retlist->expr = expr;
6782   retlist->section = section;
6783   if (gensym)
6784     retlist->ll_symbol = gen_internal_sym ("LLST");
6785
6786   return retlist;
6787 }
6788
6789 /* Add a location description expression to a location list.  */
6790
6791 static inline void
6792 add_loc_descr_to_loc_list (dw_loc_list_ref *list_head, dw_loc_descr_ref descr,
6793                            const char *begin, const char *end,
6794                            const char *section)
6795 {
6796   dw_loc_list_ref *d;
6797
6798   /* Find the end of the chain.  */
6799   for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
6800     ;
6801
6802   /* Add a new location list node to the list.  */
6803   *d = new_loc_list (descr, begin, end, section, 0);
6804 }
6805
6806 static void
6807 dwarf2out_switch_text_section (void)
6808 {
6809   dw_fde_ref fde;
6810   struct function *cfun = DECL_STRUCT_FUNCTION (current_function_decl);
6811
6812   fde = &fde_table[fde_table_in_use - 1];
6813   fde->dw_fde_switched_sections = true;
6814   fde->dw_fde_hot_section_label = cfun->hot_section_label;
6815   fde->dw_fde_hot_section_end_label = cfun->hot_section_end_label;
6816   fde->dw_fde_unlikely_section_label = cfun->cold_section_label;
6817   fde->dw_fde_unlikely_section_end_label = cfun->cold_section_end_label;
6818   separate_line_info_table_in_use++;
6819 }
6820
6821 /* Output the location list given to us.  */
6822
6823 static void
6824 output_loc_list (dw_loc_list_ref list_head)
6825 {
6826   dw_loc_list_ref curr = list_head;
6827
6828   ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
6829
6830   /* Walk the location list, and output each range + expression.  */
6831   for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
6832     {
6833       unsigned long size;
6834       if (separate_line_info_table_in_use == 0)
6835         {
6836           dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
6837                                 "Location list begin address (%s)",
6838                                 list_head->ll_symbol);
6839           dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
6840                                 "Location list end address (%s)",
6841                                 list_head->ll_symbol);
6842         }
6843       else
6844         {
6845           dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
6846                                "Location list begin address (%s)",
6847                                list_head->ll_symbol);
6848           dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end,
6849                                "Location list end address (%s)",
6850                                list_head->ll_symbol);
6851         }
6852       size = size_of_locs (curr->expr);
6853
6854       /* Output the block length for this list of location operations.  */
6855       gcc_assert (size <= 0xffff);
6856       dw2_asm_output_data (2, size, "%s", "Location expression size");
6857
6858       output_loc_sequence (curr->expr);
6859     }
6860
6861   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
6862                        "Location list terminator begin (%s)",
6863                        list_head->ll_symbol);
6864   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
6865                        "Location list terminator end (%s)",
6866                        list_head->ll_symbol);
6867 }
6868
6869 /* Output the DIE and its attributes.  Called recursively to generate
6870    the definitions of each child DIE.  */
6871
6872 static void
6873 output_die (dw_die_ref die)
6874 {
6875   dw_attr_ref a;
6876   dw_die_ref c;
6877   unsigned long size;
6878
6879   /* If someone in another CU might refer to us, set up a symbol for
6880      them to point to.  */
6881   if (die->die_symbol)
6882     output_die_symbol (die);
6883
6884   dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (0x%lx) %s)",
6885                                die->die_offset, dwarf_tag_name (die->die_tag));
6886
6887   for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
6888     {
6889       const char *name = dwarf_attr_name (a->dw_attr);
6890
6891       switch (AT_class (a))
6892         {
6893         case dw_val_class_addr:
6894           dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
6895           break;
6896
6897         case dw_val_class_offset:
6898           dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
6899                                "%s", name);
6900           break;
6901
6902         case dw_val_class_range_list:
6903           {
6904             char *p = strchr (ranges_section_label, '\0');
6905
6906             sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX,
6907                      a->dw_attr_val.v.val_offset);
6908             dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
6909                                    "%s", name);
6910             *p = '\0';
6911           }
6912           break;
6913
6914         case dw_val_class_loc:
6915           size = size_of_locs (AT_loc (a));
6916
6917           /* Output the block length for this list of location operations.  */
6918           dw2_asm_output_data (constant_size (size), size, "%s", name);
6919
6920           output_loc_sequence (AT_loc (a));
6921           break;
6922
6923         case dw_val_class_const:
6924           /* ??? It would be slightly more efficient to use a scheme like is
6925              used for unsigned constants below, but gdb 4.x does not sign
6926              extend.  Gdb 5.x does sign extend.  */
6927           dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
6928           break;
6929
6930         case dw_val_class_unsigned_const:
6931           dw2_asm_output_data (constant_size (AT_unsigned (a)),
6932                                AT_unsigned (a), "%s", name);
6933           break;
6934
6935         case dw_val_class_long_long:
6936           {
6937             unsigned HOST_WIDE_INT first, second;
6938
6939             dw2_asm_output_data (1,
6940                                  2 * HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
6941                                  "%s", name);
6942
6943             if (WORDS_BIG_ENDIAN)
6944               {
6945                 first = a->dw_attr_val.v.val_long_long.hi;
6946                 second = a->dw_attr_val.v.val_long_long.low;
6947               }
6948             else
6949               {
6950                 first = a->dw_attr_val.v.val_long_long.low;
6951                 second = a->dw_attr_val.v.val_long_long.hi;
6952               }
6953
6954             dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
6955                                  first, "long long constant");
6956             dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
6957                                  second, NULL);
6958           }
6959           break;
6960
6961         case dw_val_class_vec:
6962           {
6963             unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size;
6964             unsigned int len = a->dw_attr_val.v.val_vec.length;
6965             unsigned int i;
6966             unsigned char *p;
6967
6968             dw2_asm_output_data (1, len * elt_size, "%s", name);
6969             if (elt_size > sizeof (HOST_WIDE_INT))
6970               {
6971                 elt_size /= 2;
6972                 len *= 2;
6973               }
6974             for (i = 0, p = a->dw_attr_val.v.val_vec.array;
6975                  i < len;
6976                  i++, p += elt_size)
6977               dw2_asm_output_data (elt_size, extract_int (p, elt_size),
6978                                    "fp or vector constant word %u", i);
6979             break;
6980           }
6981
6982         case dw_val_class_flag:
6983           dw2_asm_output_data (1, AT_flag (a), "%s", name);
6984           break;
6985
6986         case dw_val_class_loc_list:
6987           {
6988             char *sym = AT_loc_list (a)->ll_symbol;
6989
6990             gcc_assert (sym);
6991             dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, "%s", name);
6992           }
6993           break;
6994
6995         case dw_val_class_die_ref:
6996           if (AT_ref_external (a))
6997             {
6998               char *sym = AT_ref (a)->die_symbol;
6999
7000               gcc_assert (sym);
7001               dw2_asm_output_offset (DWARF2_ADDR_SIZE, sym, "%s", name);
7002             }
7003           else
7004             {
7005               gcc_assert (AT_ref (a)->die_offset);
7006               dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
7007                                    "%s", name);
7008             }
7009           break;
7010
7011         case dw_val_class_fde_ref:
7012           {
7013             char l1[20];
7014
7015             ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
7016                                          a->dw_attr_val.v.val_fde_index * 2);
7017             dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, "%s", name);
7018           }
7019           break;
7020
7021         case dw_val_class_lbl_id:
7022           dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
7023           break;
7024
7025         case dw_val_class_lbl_offset:
7026           dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a), "%s", name);
7027           break;
7028
7029         case dw_val_class_str:
7030           if (AT_string_form (a) == DW_FORM_strp)
7031             dw2_asm_output_offset (DWARF_OFFSET_SIZE,
7032                                    a->dw_attr_val.v.val_str->label,
7033                                    "%s: \"%s\"", name, AT_string (a));
7034           else
7035             dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
7036           break;
7037
7038         default:
7039           gcc_unreachable ();
7040         }
7041     }
7042
7043   for (c = die->die_child; c != NULL; c = c->die_sib)
7044     output_die (c);
7045
7046   /* Add null byte to terminate sibling list.  */
7047   if (die->die_child != NULL)
7048     dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx",
7049                          die->die_offset);
7050 }
7051
7052 /* Output the compilation unit that appears at the beginning of the
7053    .debug_info section, and precedes the DIE descriptions.  */
7054
7055 static void
7056 output_compilation_unit_header (void)
7057 {
7058   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7059     dw2_asm_output_data (4, 0xffffffff,
7060       "Initial length escape value indicating 64-bit DWARF extension");
7061   dw2_asm_output_data (DWARF_OFFSET_SIZE,
7062                        next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
7063                        "Length of Compilation Unit Info");
7064   dw2_asm_output_data (2, DWARF_VERSION, "DWARF version number");
7065   dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
7066                          "Offset Into Abbrev. Section");
7067   dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
7068 }
7069
7070 /* Output the compilation unit DIE and its children.  */
7071
7072 static void
7073 output_comp_unit (dw_die_ref die, int output_if_empty)
7074 {
7075   const char *secname;
7076   char *oldsym, *tmp;
7077
7078   /* Unless we are outputting main CU, we may throw away empty ones.  */
7079   if (!output_if_empty && die->die_child == NULL)
7080     return;
7081
7082   /* Even if there are no children of this DIE, we must output the information
7083      about the compilation unit.  Otherwise, on an empty translation unit, we
7084      will generate a present, but empty, .debug_info section.  IRIX 6.5 `nm'
7085      will then complain when examining the file.  First mark all the DIEs in
7086      this CU so we know which get local refs.  */
7087   mark_dies (die);
7088
7089   build_abbrev_table (die);
7090
7091   /* Initialize the beginning DIE offset - and calculate sizes/offsets.  */
7092   next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
7093   calc_die_sizes (die);
7094
7095   oldsym = die->die_symbol;
7096   if (oldsym)
7097     {
7098       tmp = alloca (strlen (oldsym) + 24);
7099
7100       sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
7101       secname = tmp;
7102       die->die_symbol = NULL;
7103     }
7104   else
7105     secname = (const char *) DEBUG_INFO_SECTION;
7106
7107   /* Output debugging information.  */
7108   named_section_flags (secname, SECTION_DEBUG);
7109   output_compilation_unit_header ();
7110   output_die (die);
7111
7112   /* Leave the marks on the main CU, so we can check them in
7113      output_pubnames.  */
7114   if (oldsym)
7115     {
7116       unmark_dies (die);
7117       die->die_symbol = oldsym;
7118     }
7119 }
7120
7121 /* The DWARF2 pubname for a nested thingy looks like "A::f".  The
7122    output of lang_hooks.decl_printable_name for C++ looks like
7123    "A::f(int)".  Let's drop the argument list, and maybe the scope.  */
7124
7125 static const char *
7126 dwarf2_name (tree decl, int scope)
7127 {
7128   return lang_hooks.decl_printable_name (decl, scope ? 1 : 0);
7129 }
7130
7131 /* Add a new entry to .debug_pubnames if appropriate.  */
7132
7133 static void
7134 add_pubname (tree decl, dw_die_ref die)
7135 {
7136   pubname_ref p;
7137
7138   if (! TREE_PUBLIC (decl))
7139     return;
7140
7141   if (pubname_table_in_use == pubname_table_allocated)
7142     {
7143       pubname_table_allocated += PUBNAME_TABLE_INCREMENT;
7144       pubname_table
7145         = ggc_realloc (pubname_table,
7146                        (pubname_table_allocated * sizeof (pubname_entry)));
7147       memset (pubname_table + pubname_table_in_use, 0,
7148               PUBNAME_TABLE_INCREMENT * sizeof (pubname_entry));
7149     }
7150
7151   p = &pubname_table[pubname_table_in_use++];
7152   p->die = die;
7153   p->name = xstrdup (dwarf2_name (decl, 1));
7154 }
7155
7156 /* Output the public names table used to speed up access to externally
7157    visible names.  For now, only generate entries for externally
7158    visible procedures.  */
7159
7160 static void
7161 output_pubnames (void)
7162 {
7163   unsigned i;
7164   unsigned long pubnames_length = size_of_pubnames ();
7165
7166   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7167     dw2_asm_output_data (4, 0xffffffff,
7168       "Initial length escape value indicating 64-bit DWARF extension");
7169   dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
7170                        "Length of Public Names Info");
7171   dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7172   dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
7173                          "Offset of Compilation Unit Info");
7174   dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
7175                        "Compilation Unit Length");
7176
7177   for (i = 0; i < pubname_table_in_use; i++)
7178     {
7179       pubname_ref pub = &pubname_table[i];
7180
7181       /* We shouldn't see pubnames for DIEs outside of the main CU.  */
7182       gcc_assert (pub->die->die_mark);
7183
7184       dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset,
7185                            "DIE offset");
7186
7187       dw2_asm_output_nstring (pub->name, -1, "external name");
7188     }
7189
7190   dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
7191 }
7192
7193 /* Add a new entry to .debug_aranges if appropriate.  */
7194
7195 static void
7196 add_arange (tree decl, dw_die_ref die)
7197 {
7198   if (! DECL_SECTION_NAME (decl))
7199     return;
7200
7201   if (arange_table_in_use == arange_table_allocated)
7202     {
7203       arange_table_allocated += ARANGE_TABLE_INCREMENT;
7204       arange_table = ggc_realloc (arange_table,
7205                                   (arange_table_allocated
7206                                    * sizeof (dw_die_ref)));
7207       memset (arange_table + arange_table_in_use, 0,
7208               ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref));
7209     }
7210
7211   arange_table[arange_table_in_use++] = die;
7212 }
7213
7214 /* Output the information that goes into the .debug_aranges table.
7215    Namely, define the beginning and ending address range of the
7216    text section generated for this compilation unit.  */
7217
7218 static void
7219 output_aranges (void)
7220 {
7221   unsigned i;
7222   unsigned long aranges_length = size_of_aranges ();
7223
7224   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7225     dw2_asm_output_data (4, 0xffffffff,
7226       "Initial length escape value indicating 64-bit DWARF extension");
7227   dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
7228                        "Length of Address Ranges Info");
7229   dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7230   dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
7231                          "Offset of Compilation Unit Info");
7232   dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
7233   dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
7234
7235   /* We need to align to twice the pointer size here.  */
7236   if (DWARF_ARANGES_PAD_SIZE)
7237     {
7238       /* Pad using a 2 byte words so that padding is correct for any
7239          pointer size.  */
7240       dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
7241                            2 * DWARF2_ADDR_SIZE);
7242       for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
7243         dw2_asm_output_data (2, 0, NULL);
7244     }
7245
7246   dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
7247   dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
7248                         text_section_label, "Length");
7249   if (flag_reorder_blocks_and_partition)
7250     {
7251       dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
7252                            "Address");
7253       dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label,
7254                             cold_text_section_label, "Length");
7255     }
7256
7257   for (i = 0; i < arange_table_in_use; i++)
7258     {
7259       dw_die_ref die = arange_table[i];
7260
7261       /* We shouldn't see aranges for DIEs outside of the main CU.  */
7262       gcc_assert (die->die_mark);
7263
7264       if (die->die_tag == DW_TAG_subprogram)
7265         {
7266           dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die),
7267                                "Address");
7268           dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die),
7269                                 get_AT_low_pc (die), "Length");
7270         }
7271       else
7272         {
7273           /* A static variable; extract the symbol from DW_AT_location.
7274              Note that this code isn't currently hit, as we only emit
7275              aranges for functions (jason 9/23/99).  */
7276           dw_attr_ref a = get_AT (die, DW_AT_location);
7277           dw_loc_descr_ref loc;
7278
7279           gcc_assert (a && AT_class (a) == dw_val_class_loc);
7280
7281           loc = AT_loc (a);
7282           gcc_assert (loc->dw_loc_opc == DW_OP_addr);
7283
7284           dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE,
7285                                    loc->dw_loc_oprnd1.v.val_addr, "Address");
7286           dw2_asm_output_data (DWARF2_ADDR_SIZE,
7287                                get_AT_unsigned (die, DW_AT_byte_size),
7288                                "Length");
7289         }
7290     }
7291
7292   /* Output the terminator words.  */
7293   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7294   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7295 }
7296
7297 /* Add a new entry to .debug_ranges.  Return the offset at which it
7298    was placed.  */
7299
7300 static unsigned int
7301 add_ranges (tree block)
7302 {
7303   unsigned int in_use = ranges_table_in_use;
7304
7305   if (in_use == ranges_table_allocated)
7306     {
7307       ranges_table_allocated += RANGES_TABLE_INCREMENT;
7308       ranges_table
7309         = ggc_realloc (ranges_table, (ranges_table_allocated
7310                                       * sizeof (struct dw_ranges_struct)));
7311       memset (ranges_table + ranges_table_in_use, 0,
7312               RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
7313     }
7314
7315   ranges_table[in_use].block_num = (block ? BLOCK_NUMBER (block) : 0);
7316   ranges_table_in_use = in_use + 1;
7317
7318   return in_use * 2 * DWARF2_ADDR_SIZE;
7319 }
7320
7321 static void
7322 output_ranges (void)
7323 {
7324   unsigned i;
7325   static const char *const start_fmt = "Offset 0x%x";
7326   const char *fmt = start_fmt;
7327
7328   for (i = 0; i < ranges_table_in_use; i++)
7329     {
7330       int block_num = ranges_table[i].block_num;
7331
7332       if (block_num)
7333         {
7334           char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
7335           char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
7336
7337           ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
7338           ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
7339
7340           /* If all code is in the text section, then the compilation
7341              unit base address defaults to DW_AT_low_pc, which is the
7342              base of the text section.  */
7343           if (separate_line_info_table_in_use == 0)
7344             {
7345               dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
7346                                     text_section_label,
7347                                     fmt, i * 2 * DWARF2_ADDR_SIZE);
7348               dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
7349                                     text_section_label, NULL);
7350             }
7351
7352           /* Otherwise, we add a DW_AT_entry_pc attribute to force the
7353              compilation unit base address to zero, which allows us to
7354              use absolute addresses, and not worry about whether the
7355              target supports cross-section arithmetic.  */
7356           else
7357             {
7358               dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
7359                                    fmt, i * 2 * DWARF2_ADDR_SIZE);
7360               dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
7361             }
7362
7363           fmt = NULL;
7364         }
7365       else
7366         {
7367           dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7368           dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7369           fmt = start_fmt;
7370         }
7371     }
7372 }
7373
7374 /* Data structure containing information about input files.  */
7375 struct file_info
7376 {
7377   char *path;           /* Complete file name.  */
7378   char *fname;          /* File name part.  */
7379   int length;           /* Length of entire string.  */
7380   int file_idx;         /* Index in input file table.  */
7381   int dir_idx;          /* Index in directory table.  */
7382 };
7383
7384 /* Data structure containing information about directories with source
7385    files.  */
7386 struct dir_info
7387 {
7388   char *path;           /* Path including directory name.  */
7389   int length;           /* Path length.  */
7390   int prefix;           /* Index of directory entry which is a prefix.  */
7391   int count;            /* Number of files in this directory.  */
7392   int dir_idx;          /* Index of directory used as base.  */
7393   int used;             /* Used in the end?  */
7394 };
7395
7396 /* Callback function for file_info comparison.  We sort by looking at
7397    the directories in the path.  */
7398
7399 static int
7400 file_info_cmp (const void *p1, const void *p2)
7401 {
7402   const struct file_info *s1 = p1;
7403   const struct file_info *s2 = p2;
7404   unsigned char *cp1;
7405   unsigned char *cp2;
7406
7407   /* Take care of file names without directories.  We need to make sure that
7408      we return consistent values to qsort since some will get confused if
7409      we return the same value when identical operands are passed in opposite
7410      orders.  So if neither has a directory, return 0 and otherwise return
7411      1 or -1 depending on which one has the directory.  */
7412   if ((s1->path == s1->fname || s2->path == s2->fname))
7413     return (s2->path == s2->fname) - (s1->path == s1->fname);
7414
7415   cp1 = (unsigned char *) s1->path;
7416   cp2 = (unsigned char *) s2->path;
7417
7418   while (1)
7419     {
7420       ++cp1;
7421       ++cp2;
7422       /* Reached the end of the first path?  If so, handle like above.  */
7423       if ((cp1 == (unsigned char *) s1->fname)
7424           || (cp2 == (unsigned char *) s2->fname))
7425         return ((cp2 == (unsigned char *) s2->fname)
7426                 - (cp1 == (unsigned char *) s1->fname));
7427
7428       /* Character of current path component the same?  */
7429       else if (*cp1 != *cp2)
7430         return *cp1 - *cp2;
7431     }
7432 }
7433
7434 /* Output the directory table and the file name table.  We try to minimize
7435    the total amount of memory needed.  A heuristic is used to avoid large
7436    slowdowns with many input files.  */
7437
7438 static void
7439 output_file_names (void)
7440 {
7441   struct file_info *files;
7442   struct dir_info *dirs;
7443   int *saved;
7444   int *savehere;
7445   int *backmap;
7446   size_t ndirs;
7447   int idx_offset;
7448   size_t i;
7449   int idx;
7450
7451   /* Handle the case where file_table is empty.  */
7452   if (VARRAY_ACTIVE_SIZE (file_table) <= 1)
7453     {
7454       dw2_asm_output_data (1, 0, "End directory table");
7455       dw2_asm_output_data (1, 0, "End file name table");
7456       return;
7457     }
7458
7459   /* Allocate the various arrays we need.  */
7460   files = alloca (VARRAY_ACTIVE_SIZE (file_table) * sizeof (struct file_info));
7461   dirs = alloca (VARRAY_ACTIVE_SIZE (file_table) * sizeof (struct dir_info));
7462
7463   /* Sort the file names.  */
7464   for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7465     {
7466       char *f;
7467
7468       /* Skip all leading "./".  */
7469       f = VARRAY_CHAR_PTR (file_table, i);
7470       while (f[0] == '.' && f[1] == '/')
7471         f += 2;
7472
7473       /* Create a new array entry.  */
7474       files[i].path = f;
7475       files[i].length = strlen (f);
7476       files[i].file_idx = i;
7477
7478       /* Search for the file name part.  */
7479       f = strrchr (f, '/');
7480       files[i].fname = f == NULL ? files[i].path : f + 1;
7481     }
7482
7483   qsort (files + 1, VARRAY_ACTIVE_SIZE (file_table) - 1,
7484          sizeof (files[0]), file_info_cmp);
7485
7486   /* Find all the different directories used.  */
7487   dirs[0].path = files[1].path;
7488   dirs[0].length = files[1].fname - files[1].path;
7489   dirs[0].prefix = -1;
7490   dirs[0].count = 1;
7491   dirs[0].dir_idx = 0;
7492   dirs[0].used = 0;
7493   files[1].dir_idx = 0;
7494   ndirs = 1;
7495
7496   for (i = 2; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7497     if (files[i].fname - files[i].path == dirs[ndirs - 1].length
7498         && memcmp (dirs[ndirs - 1].path, files[i].path,
7499                    dirs[ndirs - 1].length) == 0)
7500       {
7501         /* Same directory as last entry.  */
7502         files[i].dir_idx = ndirs - 1;
7503         ++dirs[ndirs - 1].count;
7504       }
7505     else
7506       {
7507         size_t j;
7508
7509         /* This is a new directory.  */
7510         dirs[ndirs].path = files[i].path;
7511         dirs[ndirs].length = files[i].fname - files[i].path;
7512         dirs[ndirs].count = 1;
7513         dirs[ndirs].dir_idx = ndirs;
7514         dirs[ndirs].used = 0;
7515         files[i].dir_idx = ndirs;
7516
7517         /* Search for a prefix.  */
7518         dirs[ndirs].prefix = -1;
7519         for (j = 0; j < ndirs; j++)
7520           if (dirs[j].length < dirs[ndirs].length
7521               && dirs[j].length > 1
7522               && (dirs[ndirs].prefix == -1
7523                   || dirs[j].length > dirs[dirs[ndirs].prefix].length)
7524               && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
7525             dirs[ndirs].prefix = j;
7526
7527         ++ndirs;
7528       }
7529
7530   /* Now to the actual work.  We have to find a subset of the directories which
7531      allow expressing the file name using references to the directory table
7532      with the least amount of characters.  We do not do an exhaustive search
7533      where we would have to check out every combination of every single
7534      possible prefix.  Instead we use a heuristic which provides nearly optimal
7535      results in most cases and never is much off.  */
7536   saved = alloca (ndirs * sizeof (int));
7537   savehere = alloca (ndirs * sizeof (int));
7538
7539   memset (saved, '\0', ndirs * sizeof (saved[0]));
7540   for (i = 0; i < ndirs; i++)
7541     {
7542       size_t j;
7543       int total;
7544
7545       /* We can always save some space for the current directory.  But this
7546          does not mean it will be enough to justify adding the directory.  */
7547       savehere[i] = dirs[i].length;
7548       total = (savehere[i] - saved[i]) * dirs[i].count;
7549
7550       for (j = i + 1; j < ndirs; j++)
7551         {
7552           savehere[j] = 0;
7553           if (saved[j] < dirs[i].length)
7554             {
7555               /* Determine whether the dirs[i] path is a prefix of the
7556                  dirs[j] path.  */
7557               int k;
7558
7559               k = dirs[j].prefix;
7560               while (k != -1 && k != (int) i)
7561                 k = dirs[k].prefix;
7562
7563               if (k == (int) i)
7564                 {
7565                   /* Yes it is.  We can possibly safe some memory but
7566                      writing the filenames in dirs[j] relative to
7567                      dirs[i].  */
7568                   savehere[j] = dirs[i].length;
7569                   total += (savehere[j] - saved[j]) * dirs[j].count;
7570                 }
7571             }
7572         }
7573
7574       /* Check whether we can safe enough to justify adding the dirs[i]
7575          directory.  */
7576       if (total > dirs[i].length + 1)
7577         {
7578           /* It's worthwhile adding.  */
7579           for (j = i; j < ndirs; j++)
7580             if (savehere[j] > 0)
7581               {
7582                 /* Remember how much we saved for this directory so far.  */
7583                 saved[j] = savehere[j];
7584
7585                 /* Remember the prefix directory.  */
7586                 dirs[j].dir_idx = i;
7587               }
7588         }
7589     }
7590
7591   /* We have to emit them in the order they appear in the file_table array
7592      since the index is used in the debug info generation.  To do this
7593      efficiently we generate a back-mapping of the indices first.  */
7594   backmap = alloca (VARRAY_ACTIVE_SIZE (file_table) * sizeof (int));
7595   for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7596     {
7597       backmap[files[i].file_idx] = i;
7598
7599       /* Mark this directory as used.  */
7600       dirs[dirs[files[i].dir_idx].dir_idx].used = 1;
7601     }
7602
7603   /* That was it.  We are ready to emit the information.  First emit the
7604      directory name table.  We have to make sure the first actually emitted
7605      directory name has index one; zero is reserved for the current working
7606      directory.  Make sure we do not confuse these indices with the one for the
7607      constructed table (even though most of the time they are identical).  */
7608   idx = 1;
7609   idx_offset = dirs[0].length > 0 ? 1 : 0;
7610   for (i = 1 - idx_offset; i < ndirs; i++)
7611     if (dirs[i].used != 0)
7612       {
7613         dirs[i].used = idx++;
7614         dw2_asm_output_nstring (dirs[i].path, dirs[i].length - 1,
7615                                 "Directory Entry: 0x%x", dirs[i].used);
7616       }
7617
7618   dw2_asm_output_data (1, 0, "End directory table");
7619
7620   /* Correct the index for the current working directory entry if it
7621      exists.  */
7622   if (idx_offset == 0)
7623     dirs[0].used = 0;
7624
7625   /* Now write all the file names.  */
7626   for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7627     {
7628       int file_idx = backmap[i];
7629       int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
7630
7631       dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
7632                               "File Entry: 0x%lx", (unsigned long) i);
7633
7634       /* Include directory index.  */
7635       dw2_asm_output_data_uleb128 (dirs[dir_idx].used, NULL);
7636
7637       /* Modification time.  */
7638       dw2_asm_output_data_uleb128 (0, NULL);
7639
7640       /* File length in bytes.  */
7641       dw2_asm_output_data_uleb128 (0, NULL);
7642     }
7643
7644   dw2_asm_output_data (1, 0, "End file name table");
7645 }
7646
7647
7648 /* Output the source line number correspondence information.  This
7649    information goes into the .debug_line section.  */
7650
7651 static void
7652 output_line_info (void)
7653 {
7654   char l1[20], l2[20], p1[20], p2[20];
7655   char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
7656   char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
7657   unsigned opc;
7658   unsigned n_op_args;
7659   unsigned long lt_index;
7660   unsigned long current_line;
7661   long line_offset;
7662   long line_delta;
7663   unsigned long current_file;
7664   unsigned long function;
7665   struct function *cfun = DECL_STRUCT_FUNCTION (current_function_decl);
7666
7667   ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
7668   ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
7669   ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
7670   ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);
7671
7672   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7673     dw2_asm_output_data (4, 0xffffffff,
7674       "Initial length escape value indicating 64-bit DWARF extension");
7675   dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
7676                         "Length of Source Line Info");
7677   ASM_OUTPUT_LABEL (asm_out_file, l1);
7678
7679   dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7680   dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
7681   ASM_OUTPUT_LABEL (asm_out_file, p1);
7682
7683   /* Define the architecture-dependent minimum instruction length (in
7684    bytes).  In this implementation of DWARF, this field is used for
7685    information purposes only.  Since GCC generates assembly language,
7686    we have no a priori knowledge of how many instruction bytes are
7687    generated for each source line, and therefore can use only the
7688    DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
7689    commands.  Accordingly, we fix this as `1', which is "correct
7690    enough" for all architectures, and don't let the target override.  */
7691   dw2_asm_output_data (1, 1,
7692                        "Minimum Instruction Length");
7693
7694   dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
7695                        "Default is_stmt_start flag");
7696   dw2_asm_output_data (1, DWARF_LINE_BASE,
7697                        "Line Base Value (Special Opcodes)");
7698   dw2_asm_output_data (1, DWARF_LINE_RANGE,
7699                        "Line Range Value (Special Opcodes)");
7700   dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
7701                        "Special Opcode Base");
7702
7703   for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
7704     {
7705       switch (opc)
7706         {
7707         case DW_LNS_advance_pc:
7708         case DW_LNS_advance_line:
7709         case DW_LNS_set_file:
7710         case DW_LNS_set_column:
7711         case DW_LNS_fixed_advance_pc:
7712           n_op_args = 1;
7713           break;
7714         default:
7715           n_op_args = 0;
7716           break;
7717         }
7718
7719       dw2_asm_output_data (1, n_op_args, "opcode: 0x%x has %d args",
7720                            opc, n_op_args);
7721     }
7722
7723   /* Write out the information about the files we use.  */
7724   output_file_names ();
7725   ASM_OUTPUT_LABEL (asm_out_file, p2);
7726
7727   /* We used to set the address register to the first location in the text
7728      section here, but that didn't accomplish anything since we already
7729      have a line note for the opening brace of the first function.  */
7730
7731   /* Generate the line number to PC correspondence table, encoded as
7732      a series of state machine operations.  */
7733   current_file = 1;
7734   current_line = 1;
7735   if (last_text_section == in_unlikely_executed_text
7736       || (last_text_section == in_named
7737           && last_text_section_name == cfun->unlikely_text_section_name))
7738     strcpy (prev_line_label, cfun->cold_section_label);
7739   else
7740     strcpy (prev_line_label, text_section_label);
7741   for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
7742     {
7743       dw_line_info_ref line_info = &line_info_table[lt_index];
7744
7745 #if 0
7746       /* Disable this optimization for now; GDB wants to see two line notes
7747          at the beginning of a function so it can find the end of the
7748          prologue.  */
7749
7750       /* Don't emit anything for redundant notes.  Just updating the
7751          address doesn't accomplish anything, because we already assume
7752          that anything after the last address is this line.  */
7753       if (line_info->dw_line_num == current_line
7754           && line_info->dw_file_num == current_file)
7755         continue;
7756 #endif
7757
7758       /* Emit debug info for the address of the current line.
7759
7760          Unfortunately, we have little choice here currently, and must always
7761          use the most general form.  GCC does not know the address delta
7762          itself, so we can't use DW_LNS_advance_pc.  Many ports do have length
7763          attributes which will give an upper bound on the address range.  We
7764          could perhaps use length attributes to determine when it is safe to
7765          use DW_LNS_fixed_advance_pc.  */
7766
7767       ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
7768       if (0)
7769         {
7770           /* This can handle deltas up to 0xffff.  This takes 3 bytes.  */
7771           dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
7772                                "DW_LNS_fixed_advance_pc");
7773           dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
7774         }
7775       else
7776         {
7777           /* This can handle any delta.  This takes
7778              4+DWARF2_ADDR_SIZE bytes.  */
7779           dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7780           dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7781           dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7782           dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
7783         }
7784
7785       strcpy (prev_line_label, line_label);
7786
7787       /* Emit debug info for the source file of the current line, if
7788          different from the previous line.  */
7789       if (line_info->dw_file_num != current_file)
7790         {
7791           current_file = line_info->dw_file_num;
7792           dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
7793           dw2_asm_output_data_uleb128 (current_file, "(\"%s\")",
7794                                        VARRAY_CHAR_PTR (file_table,
7795                                                         current_file));
7796         }
7797
7798       /* Emit debug info for the current line number, choosing the encoding
7799          that uses the least amount of space.  */
7800       if (line_info->dw_line_num != current_line)
7801         {
7802           line_offset = line_info->dw_line_num - current_line;
7803           line_delta = line_offset - DWARF_LINE_BASE;
7804           current_line = line_info->dw_line_num;
7805           if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
7806             /* This can handle deltas from -10 to 234, using the current
7807                definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.  This
7808                takes 1 byte.  */
7809             dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
7810                                  "line %lu", current_line);
7811           else
7812             {
7813               /* This can handle any delta.  This takes at least 4 bytes,
7814                  depending on the value being encoded.  */
7815               dw2_asm_output_data (1, DW_LNS_advance_line,
7816                                    "advance to line %lu", current_line);
7817               dw2_asm_output_data_sleb128 (line_offset, NULL);
7818               dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
7819             }
7820         }
7821       else
7822         /* We still need to start a new row, so output a copy insn.  */
7823         dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
7824     }
7825
7826   /* Emit debug info for the address of the end of the function.  */
7827   if (0)
7828     {
7829       dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
7830                            "DW_LNS_fixed_advance_pc");
7831       dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL);
7832     }
7833   else
7834     {
7835       dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7836       dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7837       dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7838       dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL);
7839     }
7840
7841   dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
7842   dw2_asm_output_data_uleb128 (1, NULL);
7843   dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
7844
7845   function = 0;
7846   current_file = 1;
7847   current_line = 1;
7848   for (lt_index = 0; lt_index < separate_line_info_table_in_use;)
7849     {
7850       dw_separate_line_info_ref line_info
7851         = &separate_line_info_table[lt_index];
7852
7853 #if 0
7854       /* Don't emit anything for redundant notes.  */
7855       if (line_info->dw_line_num == current_line
7856           && line_info->dw_file_num == current_file
7857           && line_info->function == function)
7858         goto cont;
7859 #endif
7860
7861       /* Emit debug info for the address of the current line.  If this is
7862          a new function, or the first line of a function, then we need
7863          to handle it differently.  */
7864       ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
7865                                    lt_index);
7866       if (function != line_info->function)
7867         {
7868           function = line_info->function;
7869
7870           /* Set the address register to the first line in the function.  */
7871           dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7872           dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7873           dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7874           dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
7875         }
7876       else
7877         {
7878           /* ??? See the DW_LNS_advance_pc comment above.  */
7879           if (0)
7880             {
7881               dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
7882                                    "DW_LNS_fixed_advance_pc");
7883               dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
7884             }
7885           else
7886             {
7887               dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7888               dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7889               dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7890               dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
7891             }
7892         }
7893
7894       strcpy (prev_line_label, line_label);
7895
7896       /* Emit debug info for the source file of the current line, if
7897          different from the previous line.  */
7898       if (line_info->dw_file_num != current_file)
7899         {
7900           current_file = line_info->dw_file_num;
7901           dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
7902           dw2_asm_output_data_uleb128 (current_file, "(\"%s\")",
7903                                        VARRAY_CHAR_PTR (file_table,
7904                                                         current_file));
7905         }
7906
7907       /* Emit debug info for the current line number, choosing the encoding
7908          that uses the least amount of space.  */
7909       if (line_info->dw_line_num != current_line)
7910         {
7911           line_offset = line_info->dw_line_num - current_line;
7912           line_delta = line_offset - DWARF_LINE_BASE;
7913           current_line = line_info->dw_line_num;
7914           if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
7915             dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
7916                                  "line %lu", current_line);
7917           else
7918             {
7919               dw2_asm_output_data (1, DW_LNS_advance_line,
7920                                    "advance to line %lu", current_line);
7921               dw2_asm_output_data_sleb128 (line_offset, NULL);
7922               dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
7923             }
7924         }
7925       else
7926         dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
7927
7928 #if 0
7929     cont:
7930 #endif
7931
7932       lt_index++;
7933
7934       /* If we're done with a function, end its sequence.  */
7935       if (lt_index == separate_line_info_table_in_use
7936           || separate_line_info_table[lt_index].function != function)
7937         {
7938           current_file = 1;
7939           current_line = 1;
7940
7941           /* Emit debug info for the address of the end of the function.  */
7942           ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
7943           if (0)
7944             {
7945               dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
7946                                    "DW_LNS_fixed_advance_pc");
7947               dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
7948             }
7949           else
7950             {
7951               dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7952               dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7953               dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7954               dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
7955             }
7956
7957           /* Output the marker for the end of this sequence.  */
7958           dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
7959           dw2_asm_output_data_uleb128 (1, NULL);
7960           dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
7961         }
7962     }
7963
7964   /* Output the marker for the end of the line number info.  */
7965   ASM_OUTPUT_LABEL (asm_out_file, l2);
7966 }
7967 \f
7968 /* Given a pointer to a tree node for some base type, return a pointer to
7969    a DIE that describes the given type.
7970
7971    This routine must only be called for GCC type nodes that correspond to
7972    Dwarf base (fundamental) types.  */
7973
7974 static dw_die_ref
7975 base_type_die (tree type)
7976 {
7977   dw_die_ref base_type_result;
7978   const char *type_name;
7979   enum dwarf_type encoding;
7980   tree name = TYPE_NAME (type);
7981
7982   if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE)
7983     return 0;
7984
7985   if (name)
7986     {
7987       if (TREE_CODE (name) == TYPE_DECL)
7988         name = DECL_NAME (name);
7989
7990       type_name = IDENTIFIER_POINTER (name);
7991     }
7992   else
7993     type_name = "__unknown__";
7994
7995   switch (TREE_CODE (type))
7996     {
7997     case INTEGER_TYPE:
7998       /* Carefully distinguish the C character types, without messing
7999          up if the language is not C. Note that we check only for the names
8000          that contain spaces; other names might occur by coincidence in other
8001          languages.  */
8002       if (! (TYPE_PRECISION (type) == CHAR_TYPE_SIZE
8003              && (type == char_type_node
8004                  || ! strcmp (type_name, "signed char")
8005                  || ! strcmp (type_name, "unsigned char"))))
8006         {
8007           if (TYPE_UNSIGNED (type))
8008             encoding = DW_ATE_unsigned;
8009           else
8010             encoding = DW_ATE_signed;
8011           break;
8012         }
8013       /* else fall through.  */
8014
8015     case CHAR_TYPE:
8016       /* GNU Pascal/Ada CHAR type.  Not used in C.  */
8017       if (TYPE_UNSIGNED (type))
8018         encoding = DW_ATE_unsigned_char;
8019       else
8020         encoding = DW_ATE_signed_char;
8021       break;
8022
8023     case REAL_TYPE:
8024       encoding = DW_ATE_float;
8025       break;
8026
8027       /* Dwarf2 doesn't know anything about complex ints, so use
8028          a user defined type for it.  */
8029     case COMPLEX_TYPE:
8030       if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
8031         encoding = DW_ATE_complex_float;
8032       else
8033         encoding = DW_ATE_lo_user;
8034       break;
8035
8036     case BOOLEAN_TYPE:
8037       /* GNU FORTRAN/Ada/C++ BOOLEAN type.  */
8038       encoding = DW_ATE_boolean;
8039       break;
8040
8041     default:
8042       /* No other TREE_CODEs are Dwarf fundamental types.  */
8043       gcc_unreachable ();
8044     }
8045
8046   base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type);
8047   if (demangle_name_func)
8048     type_name = (*demangle_name_func) (type_name);
8049
8050   add_AT_string (base_type_result, DW_AT_name, type_name);
8051   add_AT_unsigned (base_type_result, DW_AT_byte_size,
8052                    int_size_in_bytes (type));
8053   add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
8054
8055   return base_type_result;
8056 }
8057
8058 /* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
8059    the Dwarf "root" type for the given input type.  The Dwarf "root" type of
8060    a given type is generally the same as the given type, except that if the
8061    given type is a pointer or reference type, then the root type of the given
8062    type is the root type of the "basis" type for the pointer or reference
8063    type.  (This definition of the "root" type is recursive.) Also, the root
8064    type of a `const' qualified type or a `volatile' qualified type is the
8065    root type of the given type without the qualifiers.  */
8066
8067 static tree
8068 root_type (tree type)
8069 {
8070   if (TREE_CODE (type) == ERROR_MARK)
8071     return error_mark_node;
8072
8073   switch (TREE_CODE (type))
8074     {
8075     case ERROR_MARK:
8076       return error_mark_node;
8077
8078     case POINTER_TYPE:
8079     case REFERENCE_TYPE:
8080       return type_main_variant (root_type (TREE_TYPE (type)));
8081
8082     default:
8083       return type_main_variant (type);
8084     }
8085 }
8086
8087 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
8088    given input type is a Dwarf "fundamental" type.  Otherwise return null.  */
8089
8090 static inline int
8091 is_base_type (tree type)
8092 {
8093   switch (TREE_CODE (type))
8094     {
8095     case ERROR_MARK:
8096     case VOID_TYPE:
8097     case INTEGER_TYPE:
8098     case REAL_TYPE:
8099     case COMPLEX_TYPE:
8100     case BOOLEAN_TYPE:
8101     case CHAR_TYPE:
8102       return 1;
8103
8104     case ARRAY_TYPE:
8105     case RECORD_TYPE:
8106     case UNION_TYPE:
8107     case QUAL_UNION_TYPE:
8108     case ENUMERAL_TYPE:
8109     case FUNCTION_TYPE:
8110     case METHOD_TYPE:
8111     case POINTER_TYPE:
8112     case REFERENCE_TYPE:
8113     case OFFSET_TYPE:
8114     case LANG_TYPE:
8115     case VECTOR_TYPE:
8116       return 0;
8117
8118     default:
8119       gcc_unreachable ();
8120     }
8121
8122   return 0;
8123 }
8124
8125 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
8126    node, return the size in bits for the type if it is a constant, or else
8127    return the alignment for the type if the type's size is not constant, or
8128    else return BITS_PER_WORD if the type actually turns out to be an
8129    ERROR_MARK node.  */
8130
8131 static inline unsigned HOST_WIDE_INT
8132 simple_type_size_in_bits (tree type)
8133 {
8134   if (TREE_CODE (type) == ERROR_MARK)
8135     return BITS_PER_WORD;
8136   else if (TYPE_SIZE (type) == NULL_TREE)
8137     return 0;
8138   else if (host_integerp (TYPE_SIZE (type), 1))
8139     return tree_low_cst (TYPE_SIZE (type), 1);
8140   else
8141     return TYPE_ALIGN (type);
8142 }
8143
8144 /* Return true if the debug information for the given type should be
8145    emitted as a subrange type.  */
8146
8147 static inline bool
8148 is_subrange_type (tree type)
8149 {
8150   tree subtype = TREE_TYPE (type);
8151
8152   /* Subrange types are identified by the fact that they are integer
8153      types, and that they have a subtype which is either an integer type
8154      or an enumeral type.  */
8155
8156   if (TREE_CODE (type) != INTEGER_TYPE
8157       || subtype == NULL_TREE)
8158     return false;
8159
8160   if (TREE_CODE (subtype) != INTEGER_TYPE
8161       && TREE_CODE (subtype) != ENUMERAL_TYPE)
8162     return false;
8163
8164   if (TREE_CODE (type) == TREE_CODE (subtype)
8165       && int_size_in_bytes (type) == int_size_in_bytes (subtype)
8166       && TYPE_MIN_VALUE (type) != NULL
8167       && TYPE_MIN_VALUE (subtype) != NULL
8168       && tree_int_cst_equal (TYPE_MIN_VALUE (type), TYPE_MIN_VALUE (subtype))
8169       && TYPE_MAX_VALUE (type) != NULL
8170       && TYPE_MAX_VALUE (subtype) != NULL
8171       && tree_int_cst_equal (TYPE_MAX_VALUE (type), TYPE_MAX_VALUE (subtype)))
8172     {
8173       /* The type and its subtype have the same representation.  If in
8174          addition the two types also have the same name, then the given
8175          type is not a subrange type, but rather a plain base type.  */
8176       /* FIXME: brobecker/2004-03-22:
8177          Sizetype INTEGER_CSTs nodes are canonicalized.  It should
8178          therefore be sufficient to check the TYPE_SIZE node pointers
8179          rather than checking the actual size.  Unfortunately, we have
8180          found some cases, such as in the Ada "integer" type, where
8181          this is not the case.  Until this problem is solved, we need to
8182          keep checking the actual size.  */
8183       tree type_name = TYPE_NAME (type);
8184       tree subtype_name = TYPE_NAME (subtype);
8185
8186       if (type_name != NULL && TREE_CODE (type_name) == TYPE_DECL)
8187         type_name = DECL_NAME (type_name);
8188
8189       if (subtype_name != NULL && TREE_CODE (subtype_name) == TYPE_DECL)
8190         subtype_name = DECL_NAME (subtype_name);
8191
8192       if (type_name == subtype_name)
8193         return false;
8194     }
8195
8196   return true;
8197 }
8198
8199 /*  Given a pointer to a tree node for a subrange type, return a pointer
8200     to a DIE that describes the given type.  */
8201
8202 static dw_die_ref
8203 subrange_type_die (tree type, dw_die_ref context_die)
8204 {
8205   dw_die_ref subtype_die;
8206   dw_die_ref subrange_die;
8207   tree name = TYPE_NAME (type);
8208   const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type);
8209   tree subtype = TREE_TYPE (type);
8210
8211   if (context_die == NULL)
8212     context_die = comp_unit_die;
8213
8214   if (TREE_CODE (subtype) == ENUMERAL_TYPE)
8215     subtype_die = gen_enumeration_type_die (subtype, context_die);
8216   else
8217     subtype_die = base_type_die (subtype);
8218
8219   subrange_die = new_die (DW_TAG_subrange_type, context_die, type);
8220
8221   if (name != NULL)
8222     {
8223       if (TREE_CODE (name) == TYPE_DECL)
8224         name = DECL_NAME (name);
8225       add_name_attribute (subrange_die, IDENTIFIER_POINTER (name));
8226     }
8227
8228   if (int_size_in_bytes (subtype) != size_in_bytes)
8229     {
8230       /* The size of the subrange type and its base type do not match,
8231          so we need to generate a size attribute for the subrange type.  */
8232       add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
8233     }
8234
8235   if (TYPE_MIN_VALUE (type) != NULL)
8236     add_bound_info (subrange_die, DW_AT_lower_bound,
8237                     TYPE_MIN_VALUE (type));
8238   if (TYPE_MAX_VALUE (type) != NULL)
8239     add_bound_info (subrange_die, DW_AT_upper_bound,
8240                     TYPE_MAX_VALUE (type));
8241   add_AT_die_ref (subrange_die, DW_AT_type, subtype_die);
8242
8243   return subrange_die;
8244 }
8245
8246 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
8247    entry that chains various modifiers in front of the given type.  */
8248
8249 static dw_die_ref
8250 modified_type_die (tree type, int is_const_type, int is_volatile_type,
8251                    dw_die_ref context_die)
8252 {
8253   enum tree_code code = TREE_CODE (type);
8254   dw_die_ref mod_type_die = NULL;
8255   dw_die_ref sub_die = NULL;
8256   tree item_type = NULL;
8257
8258   if (code != ERROR_MARK)
8259     {
8260       tree qualified_type;
8261
8262       /* See if we already have the appropriately qualified variant of
8263          this type.  */
8264       qualified_type
8265         = get_qualified_type (type,
8266                               ((is_const_type ? TYPE_QUAL_CONST : 0)
8267                                | (is_volatile_type
8268                                   ? TYPE_QUAL_VOLATILE : 0)));
8269
8270       /* If we do, then we can just use its DIE, if it exists.  */
8271       if (qualified_type)
8272         {
8273           mod_type_die = lookup_type_die (qualified_type);
8274           if (mod_type_die)
8275             return mod_type_die;
8276         }
8277
8278       /* Handle C typedef types.  */
8279       if (qualified_type && TYPE_NAME (qualified_type)
8280           && TREE_CODE (TYPE_NAME (qualified_type)) == TYPE_DECL
8281           && DECL_ORIGINAL_TYPE (TYPE_NAME (qualified_type)))
8282         {
8283           tree type_name = TYPE_NAME (qualified_type);
8284           tree dtype = TREE_TYPE (type_name);
8285
8286           if (qualified_type == dtype)
8287             {
8288               /* For a named type, use the typedef.  */
8289               gen_type_die (qualified_type, context_die);
8290               mod_type_die = lookup_type_die (qualified_type);
8291             }
8292           else if (is_const_type < TYPE_READONLY (dtype)
8293                    || is_volatile_type < TYPE_VOLATILE (dtype))
8294             /* cv-unqualified version of named type.  Just use the unnamed
8295                type to which it refers.  */
8296             mod_type_die
8297               = modified_type_die (DECL_ORIGINAL_TYPE (type_name),
8298                                    is_const_type, is_volatile_type,
8299                                    context_die);
8300
8301           /* Else cv-qualified version of named type; fall through.  */
8302         }
8303
8304       if (mod_type_die)
8305         /* OK.  */
8306         ;
8307       else if (is_const_type)
8308         {
8309           mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type);
8310           sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
8311         }
8312       else if (is_volatile_type)
8313         {
8314           mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type);
8315           sub_die = modified_type_die (type, 0, 0, context_die);
8316         }
8317       else if (code == POINTER_TYPE)
8318         {
8319           mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type);
8320           add_AT_unsigned (mod_type_die, DW_AT_byte_size,
8321                            simple_type_size_in_bits (type) / BITS_PER_UNIT);
8322 #if 0
8323           add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
8324 #endif
8325           item_type = TREE_TYPE (type);
8326         }
8327       else if (code == REFERENCE_TYPE)
8328         {
8329           mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type);
8330           add_AT_unsigned (mod_type_die, DW_AT_byte_size,
8331                            simple_type_size_in_bits (type) / BITS_PER_UNIT);
8332 #if 0
8333           add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
8334 #endif
8335           item_type = TREE_TYPE (type);
8336         }
8337       else if (is_subrange_type (type))
8338         mod_type_die = subrange_type_die (type, context_die);
8339       else if (is_base_type (type))
8340         mod_type_die = base_type_die (type);
8341       else
8342         {
8343           gen_type_die (type, context_die);
8344
8345           /* We have to get the type_main_variant here (and pass that to the
8346              `lookup_type_die' routine) because the ..._TYPE node we have
8347              might simply be a *copy* of some original type node (where the
8348              copy was created to help us keep track of typedef names) and
8349              that copy might have a different TYPE_UID from the original
8350              ..._TYPE node.  */
8351           if (TREE_CODE (type) != VECTOR_TYPE)
8352             mod_type_die = lookup_type_die (type_main_variant (type));
8353           else
8354             /* Vectors have the debugging information in the type,
8355                not the main variant.  */
8356             mod_type_die = lookup_type_die (type);
8357           gcc_assert (mod_type_die);
8358         }
8359
8360       /* We want to equate the qualified type to the die below.  */
8361       type = qualified_type;
8362     }
8363
8364   if (type)
8365     equate_type_number_to_die (type, mod_type_die);
8366   if (item_type)
8367     /* We must do this after the equate_type_number_to_die call, in case
8368        this is a recursive type.  This ensures that the modified_type_die
8369        recursion will terminate even if the type is recursive.  Recursive
8370        types are possible in Ada.  */
8371     sub_die = modified_type_die (item_type,
8372                                  TYPE_READONLY (item_type),
8373                                  TYPE_VOLATILE (item_type),
8374                                  context_die);
8375
8376   if (sub_die != NULL)
8377     add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
8378
8379   return mod_type_die;
8380 }
8381
8382 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
8383    an enumerated type.  */
8384
8385 static inline int
8386 type_is_enum (tree type)
8387 {
8388   return TREE_CODE (type) == ENUMERAL_TYPE;
8389 }
8390
8391 /* Return the DBX register number described by a given RTL node.  */
8392
8393 static unsigned int
8394 dbx_reg_number (rtx rtl)
8395 {
8396   unsigned regno = REGNO (rtl);
8397
8398   gcc_assert (regno < FIRST_PSEUDO_REGISTER);
8399
8400   return DBX_REGISTER_NUMBER (regno);
8401 }
8402
8403 /* Return a location descriptor that designates a machine register or
8404    zero if there is none.  */
8405
8406 static dw_loc_descr_ref
8407 reg_loc_descriptor (rtx rtl)
8408 {
8409   unsigned reg;
8410   rtx regs;
8411
8412   if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
8413     return 0;
8414
8415   reg = dbx_reg_number (rtl);
8416   regs = targetm.dwarf_register_span (rtl);
8417
8418   if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1
8419       || regs)
8420     return multiple_reg_loc_descriptor (rtl, regs);
8421   else
8422     return one_reg_loc_descriptor (reg);
8423 }
8424
8425 /* Return a location descriptor that designates a machine register for
8426    a given hard register number.  */
8427
8428 static dw_loc_descr_ref
8429 one_reg_loc_descriptor (unsigned int regno)
8430 {
8431   if (regno <= 31)
8432     return new_loc_descr (DW_OP_reg0 + regno, 0, 0);
8433   else
8434     return new_loc_descr (DW_OP_regx, regno, 0);
8435 }
8436
8437 /* Given an RTL of a register, return a location descriptor that
8438    designates a value that spans more than one register.  */
8439
8440 static dw_loc_descr_ref
8441 multiple_reg_loc_descriptor (rtx rtl, rtx regs)
8442 {
8443   int nregs, size, i;
8444   unsigned reg;
8445   dw_loc_descr_ref loc_result = NULL;
8446
8447   reg = dbx_reg_number (rtl);
8448   nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)];
8449
8450   /* Simple, contiguous registers.  */
8451   if (regs == NULL_RTX)
8452     {
8453       size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;
8454
8455       loc_result = NULL;
8456       while (nregs--)
8457         {
8458           dw_loc_descr_ref t;
8459
8460           t = one_reg_loc_descriptor (reg);
8461           add_loc_descr (&loc_result, t);
8462           add_loc_descr (&loc_result, new_loc_descr (DW_OP_piece, size, 0));
8463           ++reg;
8464         }
8465       return loc_result;
8466     }
8467
8468   /* Now onto stupid register sets in non contiguous locations.  */
8469
8470   gcc_assert (GET_CODE (regs) == PARALLEL);
8471
8472   size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
8473   loc_result = NULL;
8474
8475   for (i = 0; i < XVECLEN (regs, 0); ++i)
8476     {
8477       dw_loc_descr_ref t;
8478
8479       t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i)));
8480       add_loc_descr (&loc_result, t);
8481       size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
8482       add_loc_descr (&loc_result, new_loc_descr (DW_OP_piece, size, 0));
8483     }
8484   return loc_result;
8485 }
8486
8487 /* Return a location descriptor that designates a constant.  */
8488
8489 static dw_loc_descr_ref
8490 int_loc_descriptor (HOST_WIDE_INT i)
8491 {
8492   enum dwarf_location_atom op;
8493
8494   /* Pick the smallest representation of a constant, rather than just
8495      defaulting to the LEB encoding.  */
8496   if (i >= 0)
8497     {
8498       if (i <= 31)
8499         op = DW_OP_lit0 + i;
8500       else if (i <= 0xff)
8501         op = DW_OP_const1u;
8502       else if (i <= 0xffff)
8503         op = DW_OP_const2u;
8504       else if (HOST_BITS_PER_WIDE_INT == 32
8505                || i <= 0xffffffff)
8506         op = DW_OP_const4u;
8507       else
8508         op = DW_OP_constu;
8509     }
8510   else
8511     {
8512       if (i >= -0x80)
8513         op = DW_OP_const1s;
8514       else if (i >= -0x8000)
8515         op = DW_OP_const2s;
8516       else if (HOST_BITS_PER_WIDE_INT == 32
8517                || i >= -0x80000000)
8518         op = DW_OP_const4s;
8519       else
8520         op = DW_OP_consts;
8521     }
8522
8523   return new_loc_descr (op, i, 0);
8524 }
8525
8526 /* Return a location descriptor that designates a base+offset location.  */
8527
8528 static dw_loc_descr_ref
8529 based_loc_descr (unsigned int reg, HOST_WIDE_INT offset, bool can_use_fbreg)
8530 {
8531   dw_loc_descr_ref loc_result;
8532   /* For the "frame base", we use the frame pointer or stack pointer
8533      registers, since the RTL for local variables is relative to one of
8534      them.  */
8535   unsigned fp_reg = DBX_REGISTER_NUMBER (frame_pointer_needed
8536                                          ? HARD_FRAME_POINTER_REGNUM
8537                                          : STACK_POINTER_REGNUM);
8538
8539   if (reg == fp_reg && can_use_fbreg)
8540     loc_result = new_loc_descr (DW_OP_fbreg, offset, 0);
8541   else if (reg <= 31)
8542     loc_result = new_loc_descr (DW_OP_breg0 + reg, offset, 0);
8543   else
8544     loc_result = new_loc_descr (DW_OP_bregx, reg, offset);
8545
8546   return loc_result;
8547 }
8548
8549 /* Return true if this RTL expression describes a base+offset calculation.  */
8550
8551 static inline int
8552 is_based_loc (rtx rtl)
8553 {
8554   return (GET_CODE (rtl) == PLUS
8555           && ((REG_P (XEXP (rtl, 0))
8556                && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
8557                && GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
8558 }
8559
8560 /* The following routine converts the RTL for a variable or parameter
8561    (resident in memory) into an equivalent Dwarf representation of a
8562    mechanism for getting the address of that same variable onto the top of a
8563    hypothetical "address evaluation" stack.
8564
8565    When creating memory location descriptors, we are effectively transforming
8566    the RTL for a memory-resident object into its Dwarf postfix expression
8567    equivalent.  This routine recursively descends an RTL tree, turning
8568    it into Dwarf postfix code as it goes.
8569
8570    MODE is the mode of the memory reference, needed to handle some
8571    autoincrement addressing modes.
8572
8573    CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the location
8574    list for RTL. We can't use it when we are emitting location list for
8575    virtual variable frame_base_decl (i.e. a location list for DW_AT_frame_base)
8576    which describes how frame base changes when !frame_pointer_needed.
8577
8578    Return 0 if we can't represent the location.  */
8579
8580 static dw_loc_descr_ref
8581 mem_loc_descriptor (rtx rtl, enum machine_mode mode, bool can_use_fbreg)
8582 {
8583   dw_loc_descr_ref mem_loc_result = NULL;
8584   enum dwarf_location_atom op;
8585
8586   /* Note that for a dynamically sized array, the location we will generate a
8587      description of here will be the lowest numbered location which is
8588      actually within the array.  That's *not* necessarily the same as the
8589      zeroth element of the array.  */
8590
8591   rtl = targetm.delegitimize_address (rtl);
8592
8593   switch (GET_CODE (rtl))
8594     {
8595     case POST_INC:
8596     case POST_DEC:
8597     case POST_MODIFY:
8598       /* POST_INC and POST_DEC can be handled just like a SUBREG.  So we
8599          just fall into the SUBREG code.  */
8600
8601       /* ... fall through ...  */
8602
8603     case SUBREG:
8604       /* The case of a subreg may arise when we have a local (register)
8605          variable or a formal (register) parameter which doesn't quite fill
8606          up an entire register.  For now, just assume that it is
8607          legitimate to make the Dwarf info refer to the whole register which
8608          contains the given subreg.  */
8609       rtl = SUBREG_REG (rtl);
8610
8611       /* ... fall through ...  */
8612
8613     case REG:
8614       /* Whenever a register number forms a part of the description of the
8615          method for calculating the (dynamic) address of a memory resident
8616          object, DWARF rules require the register number be referred to as
8617          a "base register".  This distinction is not based in any way upon
8618          what category of register the hardware believes the given register
8619          belongs to.  This is strictly DWARF terminology we're dealing with
8620          here. Note that in cases where the location of a memory-resident
8621          data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
8622          OP_CONST (0)) the actual DWARF location descriptor that we generate
8623          may just be OP_BASEREG (basereg).  This may look deceptively like
8624          the object in question was allocated to a register (rather than in
8625          memory) so DWARF consumers need to be aware of the subtle
8626          distinction between OP_REG and OP_BASEREG.  */
8627       if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
8628         mem_loc_result = based_loc_descr (dbx_reg_number (rtl), 0,
8629                                           can_use_fbreg);
8630       break;
8631
8632     case MEM:
8633       mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl),
8634                                            can_use_fbreg);
8635       if (mem_loc_result != 0)
8636         add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
8637       break;
8638
8639     case LO_SUM:
8640          rtl = XEXP (rtl, 1);
8641
8642       /* ... fall through ...  */
8643
8644     case LABEL_REF:
8645       /* Some ports can transform a symbol ref into a label ref, because
8646          the symbol ref is too far away and has to be dumped into a constant
8647          pool.  */
8648     case CONST:
8649     case SYMBOL_REF:
8650       /* Alternatively, the symbol in the constant pool might be referenced
8651          by a different symbol.  */
8652       if (GET_CODE (rtl) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (rtl))
8653         {
8654           bool marked;
8655           rtx tmp = get_pool_constant_mark (rtl, &marked);
8656
8657           if (GET_CODE (tmp) == SYMBOL_REF)
8658             {
8659               rtl = tmp;
8660               if (CONSTANT_POOL_ADDRESS_P (tmp))
8661                 get_pool_constant_mark (tmp, &marked);
8662               else
8663                 marked = true;
8664             }
8665
8666           /* If all references to this pool constant were optimized away,
8667              it was not output and thus we can't represent it.
8668              FIXME: might try to use DW_OP_const_value here, though
8669              DW_OP_piece complicates it.  */
8670           if (!marked)
8671             return 0;
8672         }
8673
8674       mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
8675       mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
8676       mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl;
8677       VARRAY_PUSH_RTX (used_rtx_varray, rtl);
8678       break;
8679
8680     case PRE_MODIFY:
8681       /* Extract the PLUS expression nested inside and fall into
8682          PLUS code below.  */
8683       rtl = XEXP (rtl, 1);
8684       goto plus;
8685
8686     case PRE_INC:
8687     case PRE_DEC:
8688       /* Turn these into a PLUS expression and fall into the PLUS code
8689          below.  */
8690       rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
8691                           GEN_INT (GET_CODE (rtl) == PRE_INC
8692                                    ? GET_MODE_UNIT_SIZE (mode)
8693                                    : -GET_MODE_UNIT_SIZE (mode)));
8694
8695       /* ... fall through ...  */
8696
8697     case PLUS:
8698     plus:
8699       if (is_based_loc (rtl))
8700         mem_loc_result = based_loc_descr (dbx_reg_number (XEXP (rtl, 0)),
8701                                           INTVAL (XEXP (rtl, 1)),
8702                                           can_use_fbreg);
8703       else
8704         {
8705           mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode,
8706                                                can_use_fbreg);
8707           if (mem_loc_result == 0)
8708             break;
8709
8710           if (GET_CODE (XEXP (rtl, 1)) == CONST_INT
8711               && INTVAL (XEXP (rtl, 1)) >= 0)
8712             add_loc_descr (&mem_loc_result,
8713                            new_loc_descr (DW_OP_plus_uconst,
8714                                           INTVAL (XEXP (rtl, 1)), 0));
8715           else
8716             {
8717               add_loc_descr (&mem_loc_result,
8718                              mem_loc_descriptor (XEXP (rtl, 1), mode,
8719                                                  can_use_fbreg));
8720               add_loc_descr (&mem_loc_result,
8721                              new_loc_descr (DW_OP_plus, 0, 0));
8722             }
8723         }
8724       break;
8725
8726     /* If a pseudo-reg is optimized away, it is possible for it to
8727        be replaced with a MEM containing a multiply or shift.  */
8728     case MULT:
8729       op = DW_OP_mul;
8730       goto do_binop;
8731
8732     case ASHIFT:
8733       op = DW_OP_shl;
8734       goto do_binop;
8735
8736     case ASHIFTRT:
8737       op = DW_OP_shra;
8738       goto do_binop;
8739
8740     case LSHIFTRT:
8741       op = DW_OP_shr;
8742       goto do_binop;
8743
8744     do_binop:
8745       {
8746         dw_loc_descr_ref op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
8747                                                    can_use_fbreg);
8748         dw_loc_descr_ref op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
8749                                                    can_use_fbreg);
8750
8751         if (op0 == 0 || op1 == 0)
8752           break;
8753
8754         mem_loc_result = op0;
8755         add_loc_descr (&mem_loc_result, op1);
8756         add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
8757         break;
8758       }
8759
8760     case CONST_INT:
8761       mem_loc_result = int_loc_descriptor (INTVAL (rtl));
8762       break;
8763
8764     default:
8765       gcc_unreachable ();
8766     }
8767
8768   return mem_loc_result;
8769 }
8770
8771 /* Return a descriptor that describes the concatenation of two locations.
8772    This is typically a complex variable.  */
8773
8774 static dw_loc_descr_ref
8775 concat_loc_descriptor (rtx x0, rtx x1)
8776 {
8777   dw_loc_descr_ref cc_loc_result = NULL;
8778   dw_loc_descr_ref x0_ref = loc_descriptor (x0, false);
8779   dw_loc_descr_ref x1_ref = loc_descriptor (x1, false);
8780
8781   if (x0_ref == 0 || x1_ref == 0)
8782     return 0;
8783
8784   cc_loc_result = x0_ref;
8785   add_loc_descr (&cc_loc_result,
8786                  new_loc_descr (DW_OP_piece,
8787                                 GET_MODE_SIZE (GET_MODE (x0)), 0));
8788
8789   add_loc_descr (&cc_loc_result, x1_ref);
8790   add_loc_descr (&cc_loc_result,
8791                  new_loc_descr (DW_OP_piece,
8792                                 GET_MODE_SIZE (GET_MODE (x1)), 0));
8793
8794   return cc_loc_result;
8795 }
8796
8797 /* Output a proper Dwarf location descriptor for a variable or parameter
8798    which is either allocated in a register or in a memory location.  For a
8799    register, we just generate an OP_REG and the register number.  For a
8800    memory location we provide a Dwarf postfix expression describing how to
8801    generate the (dynamic) address of the object onto the address stack.
8802
8803    If we don't know how to describe it, return 0.  */
8804
8805 static dw_loc_descr_ref
8806 loc_descriptor (rtx rtl, bool can_use_fbreg)
8807 {
8808   dw_loc_descr_ref loc_result = NULL;
8809
8810   switch (GET_CODE (rtl))
8811     {
8812     case SUBREG:
8813       /* The case of a subreg may arise when we have a local (register)
8814          variable or a formal (register) parameter which doesn't quite fill
8815          up an entire register.  For now, just assume that it is
8816          legitimate to make the Dwarf info refer to the whole register which
8817          contains the given subreg.  */
8818       rtl = SUBREG_REG (rtl);
8819
8820       /* ... fall through ...  */
8821
8822     case REG:
8823       loc_result = reg_loc_descriptor (rtl);
8824       break;
8825
8826     case MEM:
8827       loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl),
8828                                        can_use_fbreg);
8829       break;
8830
8831     case CONCAT:
8832       loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1));
8833       break;
8834
8835     case VAR_LOCATION:
8836       /* Single part.  */
8837       if (GET_CODE (XEXP (rtl, 1)) != PARALLEL)
8838         {
8839           loc_result = loc_descriptor (XEXP (XEXP (rtl, 1), 0), can_use_fbreg);
8840           break;
8841         }
8842
8843       rtl = XEXP (rtl, 1);
8844       /* FALLTHRU */
8845
8846     case PARALLEL:
8847       {
8848         rtvec par_elems = XVEC (rtl, 0);
8849         int num_elem = GET_NUM_ELEM (par_elems);
8850         enum machine_mode mode;
8851         int i;
8852
8853         /* Create the first one, so we have something to add to.  */
8854         loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0),
8855                                      can_use_fbreg);
8856         mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0));
8857         add_loc_descr (&loc_result,
8858                        new_loc_descr (DW_OP_piece, GET_MODE_SIZE (mode), 0));
8859         for (i = 1; i < num_elem; i++)
8860           {
8861             dw_loc_descr_ref temp;
8862
8863             temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0),
8864                                    can_use_fbreg);
8865             add_loc_descr (&loc_result, temp);
8866             mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0));
8867             add_loc_descr (&loc_result,
8868                            new_loc_descr (DW_OP_piece,
8869                                           GET_MODE_SIZE (mode), 0));
8870           }
8871       }
8872       break;
8873
8874     default:
8875       gcc_unreachable ();
8876     }
8877
8878   return loc_result;
8879 }
8880
8881 /* Similar, but generate the descriptor from trees instead of rtl.  This comes
8882    up particularly with variable length arrays.  WANT_ADDRESS is 2 if this is
8883    a top-level invocation of loc_descriptor_from_tree; is 1 if this is not a
8884    top-level invocation, and we require the address of LOC; is 0 if we require
8885    the value of LOC.  */
8886
8887 static dw_loc_descr_ref
8888 loc_descriptor_from_tree_1 (tree loc, int want_address)
8889 {
8890   dw_loc_descr_ref ret, ret1;
8891   int have_address = 0;
8892   int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
8893   enum dwarf_location_atom op;
8894
8895   /* ??? Most of the time we do not take proper care for sign/zero
8896      extending the values properly.  Hopefully this won't be a real
8897      problem...  */
8898
8899   switch (TREE_CODE (loc))
8900     {
8901     case ERROR_MARK:
8902       return 0;
8903
8904     case PLACEHOLDER_EXPR:
8905       /* This case involves extracting fields from an object to determine the
8906          position of other fields.  We don't try to encode this here.  The
8907          only user of this is Ada, which encodes the needed information using
8908          the names of types.  */
8909       return 0;
8910
8911     case CALL_EXPR:
8912       return 0;
8913
8914     case PREINCREMENT_EXPR:
8915     case PREDECREMENT_EXPR:
8916     case POSTINCREMENT_EXPR:
8917     case POSTDECREMENT_EXPR:
8918       /* There are no opcodes for these operations.  */
8919       return 0;
8920
8921     case ADDR_EXPR:
8922       /* If we already want an address, there's nothing we can do.  */
8923       if (want_address)
8924         return 0;
8925
8926       /* Otherwise, process the argument and look for the address.  */
8927       return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 1);
8928
8929     case VAR_DECL:
8930       if (DECL_THREAD_LOCAL (loc))
8931         {
8932           rtx rtl;
8933
8934 #ifndef ASM_OUTPUT_DWARF_DTPREL
8935           /* If this is not defined, we have no way to emit the data.  */
8936           return 0;
8937 #endif
8938
8939           /* The way DW_OP_GNU_push_tls_address is specified, we can only
8940              look up addresses of objects in the current module.  */
8941           if (DECL_EXTERNAL (loc))
8942             return 0;
8943
8944           rtl = rtl_for_decl_location (loc);
8945           if (rtl == NULL_RTX)
8946             return 0;
8947
8948           if (!MEM_P (rtl))
8949             return 0;
8950           rtl = XEXP (rtl, 0);
8951           if (! CONSTANT_P (rtl))
8952             return 0;
8953
8954           ret = new_loc_descr (INTERNAL_DW_OP_tls_addr, 0, 0);
8955           ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
8956           ret->dw_loc_oprnd1.v.val_addr = rtl;
8957
8958           ret1 = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0);
8959           add_loc_descr (&ret, ret1);
8960
8961           have_address = 1;
8962           break;
8963         }
8964       /* FALLTHRU */
8965
8966     case PARM_DECL:
8967       if (DECL_VALUE_EXPR (loc))
8968         return loc_descriptor_from_tree_1 (DECL_VALUE_EXPR (loc), want_address);
8969       /* FALLTHRU */
8970
8971     case RESULT_DECL:
8972       {
8973         rtx rtl = rtl_for_decl_location (loc);
8974
8975         if (rtl == NULL_RTX)
8976           return 0;
8977         else if (GET_CODE (rtl) == CONST_INT)
8978           {
8979             HOST_WIDE_INT val = INTVAL (rtl);
8980             if (TYPE_UNSIGNED (TREE_TYPE (loc)))
8981               val &= GET_MODE_MASK (DECL_MODE (loc));
8982             ret = int_loc_descriptor (val);
8983           }
8984         else if (GET_CODE (rtl) == CONST_STRING)
8985           return 0;
8986         else if (CONSTANT_P (rtl))
8987           {
8988             ret = new_loc_descr (DW_OP_addr, 0, 0);
8989             ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
8990             ret->dw_loc_oprnd1.v.val_addr = rtl;
8991           }
8992         else
8993           {
8994             enum machine_mode mode;
8995
8996             /* Certain constructs can only be represented at top-level.  */
8997             if (want_address == 2)
8998               return loc_descriptor (rtl, false);
8999
9000             mode = GET_MODE (rtl);
9001             if (MEM_P (rtl))
9002               {
9003                 rtl = XEXP (rtl, 0);
9004                 have_address = 1;
9005               }
9006             ret = mem_loc_descriptor (rtl, mode, false);
9007           }
9008       }
9009       break;
9010
9011     case INDIRECT_REF:
9012       ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9013       have_address = 1;
9014       break;
9015
9016     case COMPOUND_EXPR:
9017       return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), want_address);
9018
9019     case NOP_EXPR:
9020     case CONVERT_EXPR:
9021     case NON_LVALUE_EXPR:
9022     case VIEW_CONVERT_EXPR:
9023     case SAVE_EXPR:
9024     case MODIFY_EXPR:
9025       return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), want_address);
9026
9027     case COMPONENT_REF:
9028     case BIT_FIELD_REF:
9029     case ARRAY_REF:
9030     case ARRAY_RANGE_REF:
9031       {
9032         tree obj, offset;
9033         HOST_WIDE_INT bitsize, bitpos, bytepos;
9034         enum machine_mode mode;
9035         int volatilep;
9036
9037         obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
9038                                    &unsignedp, &volatilep, false);
9039
9040         if (obj == loc)
9041           return 0;
9042
9043         ret = loc_descriptor_from_tree_1 (obj, 1);
9044         if (ret == 0
9045             || bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
9046           return 0;
9047
9048         if (offset != NULL_TREE)
9049           {
9050             /* Variable offset.  */
9051             add_loc_descr (&ret, loc_descriptor_from_tree_1 (offset, 0));
9052             add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
9053           }
9054
9055         bytepos = bitpos / BITS_PER_UNIT;
9056         if (bytepos > 0)
9057           add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0));
9058         else if (bytepos < 0)
9059           {
9060             add_loc_descr (&ret, int_loc_descriptor (bytepos));
9061             add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
9062           }
9063
9064         have_address = 1;
9065         break;
9066       }
9067
9068     case INTEGER_CST:
9069       if (host_integerp (loc, 0))
9070         ret = int_loc_descriptor (tree_low_cst (loc, 0));
9071       else
9072         return 0;
9073       break;
9074
9075     case CONSTRUCTOR:
9076       {
9077         /* Get an RTL for this, if something has been emitted.  */
9078         rtx rtl = lookup_constant_def (loc);
9079         enum machine_mode mode;
9080
9081         if (!rtl || !MEM_P (rtl))
9082           return 0;
9083         mode = GET_MODE (rtl);
9084         rtl = XEXP (rtl, 0);
9085         ret = mem_loc_descriptor (rtl, mode, false);
9086         have_address = 1;
9087         break;
9088       }
9089
9090     case TRUTH_AND_EXPR:
9091     case TRUTH_ANDIF_EXPR:
9092     case BIT_AND_EXPR:
9093       op = DW_OP_and;
9094       goto do_binop;
9095
9096     case TRUTH_XOR_EXPR:
9097     case BIT_XOR_EXPR:
9098       op = DW_OP_xor;
9099       goto do_binop;
9100
9101     case TRUTH_OR_EXPR:
9102     case TRUTH_ORIF_EXPR:
9103     case BIT_IOR_EXPR:
9104       op = DW_OP_or;
9105       goto do_binop;
9106
9107     case FLOOR_DIV_EXPR:
9108     case CEIL_DIV_EXPR:
9109     case ROUND_DIV_EXPR:
9110     case TRUNC_DIV_EXPR:
9111       op = DW_OP_div;
9112       goto do_binop;
9113
9114     case MINUS_EXPR:
9115       op = DW_OP_minus;
9116       goto do_binop;
9117
9118     case FLOOR_MOD_EXPR:
9119     case CEIL_MOD_EXPR:
9120     case ROUND_MOD_EXPR:
9121     case TRUNC_MOD_EXPR:
9122       op = DW_OP_mod;
9123       goto do_binop;
9124
9125     case MULT_EXPR:
9126       op = DW_OP_mul;
9127       goto do_binop;
9128
9129     case LSHIFT_EXPR:
9130       op = DW_OP_shl;
9131       goto do_binop;
9132
9133     case RSHIFT_EXPR:
9134       op = (unsignedp ? DW_OP_shr : DW_OP_shra);
9135       goto do_binop;
9136
9137     case PLUS_EXPR:
9138       if (TREE_CODE (TREE_OPERAND (loc, 1)) == INTEGER_CST
9139           && host_integerp (TREE_OPERAND (loc, 1), 0))
9140         {
9141           ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9142           if (ret == 0)
9143             return 0;
9144
9145           add_loc_descr (&ret,
9146                          new_loc_descr (DW_OP_plus_uconst,
9147                                         tree_low_cst (TREE_OPERAND (loc, 1),
9148                                                       0),
9149                                         0));
9150           break;
9151         }
9152
9153       op = DW_OP_plus;
9154       goto do_binop;
9155
9156     case LE_EXPR:
9157       if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9158         return 0;
9159
9160       op = DW_OP_le;
9161       goto do_binop;
9162
9163     case GE_EXPR:
9164       if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9165         return 0;
9166
9167       op = DW_OP_ge;
9168       goto do_binop;
9169
9170     case LT_EXPR:
9171       if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9172         return 0;
9173
9174       op = DW_OP_lt;
9175       goto do_binop;
9176
9177     case GT_EXPR:
9178       if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9179         return 0;
9180
9181       op = DW_OP_gt;
9182       goto do_binop;
9183
9184     case EQ_EXPR:
9185       op = DW_OP_eq;
9186       goto do_binop;
9187
9188     case NE_EXPR:
9189       op = DW_OP_ne;
9190       goto do_binop;
9191
9192     do_binop:
9193       ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9194       ret1 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
9195       if (ret == 0 || ret1 == 0)
9196         return 0;
9197
9198       add_loc_descr (&ret, ret1);
9199       add_loc_descr (&ret, new_loc_descr (op, 0, 0));
9200       break;
9201
9202     case TRUTH_NOT_EXPR:
9203     case BIT_NOT_EXPR:
9204       op = DW_OP_not;
9205       goto do_unop;
9206
9207     case ABS_EXPR:
9208       op = DW_OP_abs;
9209       goto do_unop;
9210
9211     case NEGATE_EXPR:
9212       op = DW_OP_neg;
9213       goto do_unop;
9214
9215     do_unop:
9216       ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9217       if (ret == 0)
9218         return 0;
9219
9220       add_loc_descr (&ret, new_loc_descr (op, 0, 0));
9221       break;
9222
9223     case MIN_EXPR:
9224     case MAX_EXPR:
9225       {
9226         const enum tree_code code =
9227           TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
9228
9229         loc = build3 (COND_EXPR, TREE_TYPE (loc),
9230                       build2 (code, integer_type_node,
9231                               TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
9232                       TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
9233       }
9234
9235       /* ... fall through ...  */
9236
9237     case COND_EXPR:
9238       {
9239         dw_loc_descr_ref lhs
9240           = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
9241         dw_loc_descr_ref rhs
9242           = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 2), 0);
9243         dw_loc_descr_ref bra_node, jump_node, tmp;
9244
9245         ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9246         if (ret == 0 || lhs == 0 || rhs == 0)
9247           return 0;
9248
9249         bra_node = new_loc_descr (DW_OP_bra, 0, 0);
9250         add_loc_descr (&ret, bra_node);
9251
9252         add_loc_descr (&ret, rhs);
9253         jump_node = new_loc_descr (DW_OP_skip, 0, 0);
9254         add_loc_descr (&ret, jump_node);
9255
9256         add_loc_descr (&ret, lhs);
9257         bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
9258         bra_node->dw_loc_oprnd1.v.val_loc = lhs;
9259
9260         /* ??? Need a node to point the skip at.  Use a nop.  */
9261         tmp = new_loc_descr (DW_OP_nop, 0, 0);
9262         add_loc_descr (&ret, tmp);
9263         jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
9264         jump_node->dw_loc_oprnd1.v.val_loc = tmp;
9265       }
9266       break;
9267
9268     case FIX_TRUNC_EXPR:
9269     case FIX_CEIL_EXPR:
9270     case FIX_FLOOR_EXPR:
9271     case FIX_ROUND_EXPR:
9272       return 0;
9273
9274     default:
9275       /* Leave front-end specific codes as simply unknown.  This comes
9276          up, for instance, with the C STMT_EXPR.  */
9277       if ((unsigned int) TREE_CODE (loc)
9278           >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
9279         return 0;
9280
9281 #ifdef ENABLE_CHECKING
9282       /* Otherwise this is a generic code; we should just lists all of
9283          these explicitly.  Aborting means we forgot one.  */
9284       gcc_unreachable ();
9285 #else
9286       /* In a release build, we want to degrade gracefully: better to
9287          generate incomplete debugging information than to crash.  */
9288       return NULL;
9289 #endif
9290     }
9291
9292   /* Show if we can't fill the request for an address.  */
9293   if (want_address && !have_address)
9294     return 0;
9295
9296   /* If we've got an address and don't want one, dereference.  */
9297   if (!want_address && have_address)
9298     {
9299       HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
9300
9301       if (size > DWARF2_ADDR_SIZE || size == -1)
9302         return 0;
9303       else if (size == DWARF2_ADDR_SIZE)
9304         op = DW_OP_deref;
9305       else
9306         op = DW_OP_deref_size;
9307
9308       add_loc_descr (&ret, new_loc_descr (op, size, 0));
9309     }
9310
9311   return ret;
9312 }
9313
9314 static inline dw_loc_descr_ref
9315 loc_descriptor_from_tree (tree loc)
9316 {
9317   return loc_descriptor_from_tree_1 (loc, 2);
9318 }
9319
9320 /* Given a value, round it up to the lowest multiple of `boundary'
9321    which is not less than the value itself.  */
9322
9323 static inline HOST_WIDE_INT
9324 ceiling (HOST_WIDE_INT value, unsigned int boundary)
9325 {
9326   return (((value + boundary - 1) / boundary) * boundary);
9327 }
9328
9329 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
9330    pointer to the declared type for the relevant field variable, or return
9331    `integer_type_node' if the given node turns out to be an
9332    ERROR_MARK node.  */
9333
9334 static inline tree
9335 field_type (tree decl)
9336 {
9337   tree type;
9338
9339   if (TREE_CODE (decl) == ERROR_MARK)
9340     return integer_type_node;
9341
9342   type = DECL_BIT_FIELD_TYPE (decl);
9343   if (type == NULL_TREE)
9344     type = TREE_TYPE (decl);
9345
9346   return type;
9347 }
9348
9349 /* Given a pointer to a tree node, return the alignment in bits for
9350    it, or else return BITS_PER_WORD if the node actually turns out to
9351    be an ERROR_MARK node.  */
9352
9353 static inline unsigned
9354 simple_type_align_in_bits (tree type)
9355 {
9356   return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
9357 }
9358
9359 static inline unsigned
9360 simple_decl_align_in_bits (tree decl)
9361 {
9362   return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
9363 }
9364
9365 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
9366    lowest addressed byte of the "containing object" for the given FIELD_DECL,
9367    or return 0 if we are unable to determine what that offset is, either
9368    because the argument turns out to be a pointer to an ERROR_MARK node, or
9369    because the offset is actually variable.  (We can't handle the latter case
9370    just yet).  */
9371
9372 static HOST_WIDE_INT
9373 field_byte_offset (tree decl)
9374 {
9375   unsigned int type_align_in_bits;
9376   unsigned int decl_align_in_bits;
9377   unsigned HOST_WIDE_INT type_size_in_bits;
9378   HOST_WIDE_INT object_offset_in_bits;
9379   tree type;
9380   tree field_size_tree;
9381   HOST_WIDE_INT bitpos_int;
9382   HOST_WIDE_INT deepest_bitpos;
9383   unsigned HOST_WIDE_INT field_size_in_bits;
9384
9385   if (TREE_CODE (decl) == ERROR_MARK)
9386     return 0;
9387
9388   gcc_assert (TREE_CODE (decl) == FIELD_DECL);
9389
9390   type = field_type (decl);
9391   field_size_tree = DECL_SIZE (decl);
9392
9393   /* The size could be unspecified if there was an error, or for
9394      a flexible array member.  */
9395   if (! field_size_tree)
9396     field_size_tree = bitsize_zero_node;
9397
9398   /* We cannot yet cope with fields whose positions are variable, so
9399      for now, when we see such things, we simply return 0.  Someday, we may
9400      be able to handle such cases, but it will be damn difficult.  */
9401   if (! host_integerp (bit_position (decl), 0))
9402     return 0;
9403
9404   bitpos_int = int_bit_position (decl);
9405
9406   /* If we don't know the size of the field, pretend it's a full word.  */
9407   if (host_integerp (field_size_tree, 1))
9408     field_size_in_bits = tree_low_cst (field_size_tree, 1);
9409   else
9410     field_size_in_bits = BITS_PER_WORD;
9411
9412   type_size_in_bits = simple_type_size_in_bits (type);
9413   type_align_in_bits = simple_type_align_in_bits (type);
9414   decl_align_in_bits = simple_decl_align_in_bits (decl);
9415
9416   /* The GCC front-end doesn't make any attempt to keep track of the starting
9417      bit offset (relative to the start of the containing structure type) of the
9418      hypothetical "containing object" for a bit-field.  Thus, when computing
9419      the byte offset value for the start of the "containing object" of a
9420      bit-field, we must deduce this information on our own. This can be rather
9421      tricky to do in some cases.  For example, handling the following structure
9422      type definition when compiling for an i386/i486 target (which only aligns
9423      long long's to 32-bit boundaries) can be very tricky:
9424
9425          struct S { int field1; long long field2:31; };
9426
9427      Fortunately, there is a simple rule-of-thumb which can be used in such
9428      cases.  When compiling for an i386/i486, GCC will allocate 8 bytes for the
9429      structure shown above.  It decides to do this based upon one simple rule
9430      for bit-field allocation.  GCC allocates each "containing object" for each
9431      bit-field at the first (i.e. lowest addressed) legitimate alignment
9432      boundary (based upon the required minimum alignment for the declared type
9433      of the field) which it can possibly use, subject to the condition that
9434      there is still enough available space remaining in the containing object
9435      (when allocated at the selected point) to fully accommodate all of the
9436      bits of the bit-field itself.
9437
9438      This simple rule makes it obvious why GCC allocates 8 bytes for each
9439      object of the structure type shown above.  When looking for a place to
9440      allocate the "containing object" for `field2', the compiler simply tries
9441      to allocate a 64-bit "containing object" at each successive 32-bit
9442      boundary (starting at zero) until it finds a place to allocate that 64-
9443      bit field such that at least 31 contiguous (and previously unallocated)
9444      bits remain within that selected 64 bit field.  (As it turns out, for the
9445      example above, the compiler finds it is OK to allocate the "containing
9446      object" 64-bit field at bit-offset zero within the structure type.)
9447
9448      Here we attempt to work backwards from the limited set of facts we're
9449      given, and we try to deduce from those facts, where GCC must have believed
9450      that the containing object started (within the structure type). The value
9451      we deduce is then used (by the callers of this routine) to generate
9452      DW_AT_location and DW_AT_bit_offset attributes for fields (both bit-fields
9453      and, in the case of DW_AT_location, regular fields as well).  */
9454
9455   /* Figure out the bit-distance from the start of the structure to the
9456      "deepest" bit of the bit-field.  */
9457   deepest_bitpos = bitpos_int + field_size_in_bits;
9458
9459   /* This is the tricky part.  Use some fancy footwork to deduce where the
9460      lowest addressed bit of the containing object must be.  */
9461   object_offset_in_bits = deepest_bitpos - type_size_in_bits;
9462
9463   /* Round up to type_align by default.  This works best for bitfields.  */
9464   object_offset_in_bits += type_align_in_bits - 1;
9465   object_offset_in_bits /= type_align_in_bits;
9466   object_offset_in_bits *= type_align_in_bits;
9467
9468   if (object_offset_in_bits > bitpos_int)
9469     {
9470       /* Sigh, the decl must be packed.  */
9471       object_offset_in_bits = deepest_bitpos - type_size_in_bits;
9472
9473       /* Round up to decl_align instead.  */
9474       object_offset_in_bits += decl_align_in_bits - 1;
9475       object_offset_in_bits /= decl_align_in_bits;
9476       object_offset_in_bits *= decl_align_in_bits;
9477     }
9478
9479   return object_offset_in_bits / BITS_PER_UNIT;
9480 }
9481 \f
9482 /* The following routines define various Dwarf attributes and any data
9483    associated with them.  */
9484
9485 /* Add a location description attribute value to a DIE.
9486
9487    This emits location attributes suitable for whole variables and
9488    whole parameters.  Note that the location attributes for struct fields are
9489    generated by the routine `data_member_location_attribute' below.  */
9490
9491 static inline void
9492 add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
9493                              dw_loc_descr_ref descr)
9494 {
9495   if (descr != 0)
9496     add_AT_loc (die, attr_kind, descr);
9497 }
9498
9499 /* Attach the specialized form of location attribute used for data members of
9500    struct and union types.  In the special case of a FIELD_DECL node which
9501    represents a bit-field, the "offset" part of this special location
9502    descriptor must indicate the distance in bytes from the lowest-addressed
9503    byte of the containing struct or union type to the lowest-addressed byte of
9504    the "containing object" for the bit-field.  (See the `field_byte_offset'
9505    function above).
9506
9507    For any given bit-field, the "containing object" is a hypothetical object
9508    (of some integral or enum type) within which the given bit-field lives.  The
9509    type of this hypothetical "containing object" is always the same as the
9510    declared type of the individual bit-field itself (for GCC anyway... the
9511    DWARF spec doesn't actually mandate this).  Note that it is the size (in
9512    bytes) of the hypothetical "containing object" which will be given in the
9513    DW_AT_byte_size attribute for this bit-field.  (See the
9514    `byte_size_attribute' function below.)  It is also used when calculating the
9515    value of the DW_AT_bit_offset attribute.  (See the `bit_offset_attribute'
9516    function below.)  */
9517
9518 static void
9519 add_data_member_location_attribute (dw_die_ref die, tree decl)
9520 {
9521   HOST_WIDE_INT offset;
9522   dw_loc_descr_ref loc_descr = 0;
9523
9524   if (TREE_CODE (decl) == TREE_BINFO)
9525     {
9526       /* We're working on the TAG_inheritance for a base class.  */
9527       if (BINFO_VIRTUAL_P (decl) && is_cxx ())
9528         {
9529           /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
9530              aren't at a fixed offset from all (sub)objects of the same
9531              type.  We need to extract the appropriate offset from our
9532              vtable.  The following dwarf expression means
9533
9534                BaseAddr = ObAddr + *((*ObAddr) - Offset)
9535
9536              This is specific to the V3 ABI, of course.  */
9537
9538           dw_loc_descr_ref tmp;
9539
9540           /* Make a copy of the object address.  */
9541           tmp = new_loc_descr (DW_OP_dup, 0, 0);
9542           add_loc_descr (&loc_descr, tmp);
9543
9544           /* Extract the vtable address.  */
9545           tmp = new_loc_descr (DW_OP_deref, 0, 0);
9546           add_loc_descr (&loc_descr, tmp);
9547
9548           /* Calculate the address of the offset.  */
9549           offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
9550           gcc_assert (offset < 0);
9551
9552           tmp = int_loc_descriptor (-offset);
9553           add_loc_descr (&loc_descr, tmp);
9554           tmp = new_loc_descr (DW_OP_minus, 0, 0);
9555           add_loc_descr (&loc_descr, tmp);
9556
9557           /* Extract the offset.  */
9558           tmp = new_loc_descr (DW_OP_deref, 0, 0);
9559           add_loc_descr (&loc_descr, tmp);
9560
9561           /* Add it to the object address.  */
9562           tmp = new_loc_descr (DW_OP_plus, 0, 0);
9563           add_loc_descr (&loc_descr, tmp);
9564         }
9565       else
9566         offset = tree_low_cst (BINFO_OFFSET (decl), 0);
9567     }
9568   else
9569     offset = field_byte_offset (decl);
9570
9571   if (! loc_descr)
9572     {
9573       enum dwarf_location_atom op;
9574
9575       /* The DWARF2 standard says that we should assume that the structure
9576          address is already on the stack, so we can specify a structure field
9577          address by using DW_OP_plus_uconst.  */
9578
9579 #ifdef MIPS_DEBUGGING_INFO
9580       /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
9581          operator correctly.  It works only if we leave the offset on the
9582          stack.  */
9583       op = DW_OP_constu;
9584 #else
9585       op = DW_OP_plus_uconst;
9586 #endif
9587
9588       loc_descr = new_loc_descr (op, offset, 0);
9589     }
9590
9591   add_AT_loc (die, DW_AT_data_member_location, loc_descr);
9592 }
9593
9594 /* Writes integer values to dw_vec_const array.  */
9595
9596 static void
9597 insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest)
9598 {
9599   while (size != 0)
9600     {
9601       *dest++ = val & 0xff;
9602       val >>= 8;
9603       --size;
9604     }
9605 }
9606
9607 /* Reads integers from dw_vec_const array.  Inverse of insert_int.  */
9608
9609 static HOST_WIDE_INT
9610 extract_int (const unsigned char *src, unsigned int size)
9611 {
9612   HOST_WIDE_INT val = 0;
9613
9614   src += size;
9615   while (size != 0)
9616     {
9617       val <<= 8;
9618       val |= *--src & 0xff;
9619       --size;
9620     }
9621   return val;
9622 }
9623
9624 /* Writes floating point values to dw_vec_const array.  */
9625
9626 static void
9627 insert_float (rtx rtl, unsigned char *array)
9628 {
9629   REAL_VALUE_TYPE rv;
9630   long val[4];
9631   int i;
9632
9633   REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
9634   real_to_target (val, &rv, GET_MODE (rtl));
9635
9636   /* real_to_target puts 32-bit pieces in each long.  Pack them.  */
9637   for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++)
9638     {
9639       insert_int (val[i], 4, array);
9640       array += 4;
9641     }
9642 }
9643
9644 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
9645    does not have a "location" either in memory or in a register.  These
9646    things can arise in GNU C when a constant is passed as an actual parameter
9647    to an inlined function.  They can also arise in C++ where declared
9648    constants do not necessarily get memory "homes".  */
9649
9650 static void
9651 add_const_value_attribute (dw_die_ref die, rtx rtl)
9652 {
9653   switch (GET_CODE (rtl))
9654     {
9655     case CONST_INT:
9656       {
9657         HOST_WIDE_INT val = INTVAL (rtl);
9658
9659         if (val < 0)
9660           add_AT_int (die, DW_AT_const_value, val);
9661         else
9662           add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val);
9663       }
9664       break;
9665
9666     case CONST_DOUBLE:
9667       /* Note that a CONST_DOUBLE rtx could represent either an integer or a
9668          floating-point constant.  A CONST_DOUBLE is used whenever the
9669          constant requires more than one word in order to be adequately
9670          represented.  We output CONST_DOUBLEs as blocks.  */
9671       {
9672         enum machine_mode mode = GET_MODE (rtl);
9673
9674         if (GET_MODE_CLASS (mode) == MODE_FLOAT)
9675           {
9676             unsigned int length = GET_MODE_SIZE (mode);
9677             unsigned char *array = ggc_alloc (length);
9678
9679             insert_float (rtl, array);
9680             add_AT_vec (die, DW_AT_const_value, length / 4, 4, array);
9681           }
9682         else
9683           {
9684             /* ??? We really should be using HOST_WIDE_INT throughout.  */
9685             gcc_assert (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT);
9686
9687             add_AT_long_long (die, DW_AT_const_value,
9688                               CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
9689           }
9690       }
9691       break;
9692
9693     case CONST_VECTOR:
9694       {
9695         enum machine_mode mode = GET_MODE (rtl);
9696         unsigned int elt_size = GET_MODE_UNIT_SIZE (mode);
9697         unsigned int length = CONST_VECTOR_NUNITS (rtl);
9698         unsigned char *array = ggc_alloc (length * elt_size);
9699         unsigned int i;
9700         unsigned char *p;
9701
9702         switch (GET_MODE_CLASS (mode))
9703           {
9704           case MODE_VECTOR_INT:
9705             for (i = 0, p = array; i < length; i++, p += elt_size)
9706               {
9707                 rtx elt = CONST_VECTOR_ELT (rtl, i);
9708                 HOST_WIDE_INT lo, hi;
9709
9710                 switch (GET_CODE (elt))
9711                   {
9712                   case CONST_INT:
9713                     lo = INTVAL (elt);
9714                     hi = -(lo < 0);
9715                     break;
9716
9717                   case CONST_DOUBLE:
9718                     lo = CONST_DOUBLE_LOW (elt);
9719                     hi = CONST_DOUBLE_HIGH (elt);
9720                     break;
9721
9722                   default:
9723                     gcc_unreachable ();
9724                   }
9725
9726                 if (elt_size <= sizeof (HOST_WIDE_INT))
9727                   insert_int (lo, elt_size, p);
9728                 else
9729                   {
9730                     unsigned char *p0 = p;
9731                     unsigned char *p1 = p + sizeof (HOST_WIDE_INT);
9732
9733                     gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
9734                     if (WORDS_BIG_ENDIAN)
9735                       {
9736                         p0 = p1;
9737                         p1 = p;
9738                       }
9739                     insert_int (lo, sizeof (HOST_WIDE_INT), p0);
9740                     insert_int (hi, sizeof (HOST_WIDE_INT), p1);
9741                   }
9742               }
9743             break;
9744
9745           case MODE_VECTOR_FLOAT:
9746             for (i = 0, p = array; i < length; i++, p += elt_size)
9747               {
9748                 rtx elt = CONST_VECTOR_ELT (rtl, i);
9749                 insert_float (elt, p);
9750               }
9751             break;
9752
9753           default:
9754             gcc_unreachable ();
9755           }
9756
9757         add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
9758       }
9759       break;
9760
9761     case CONST_STRING:
9762       add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
9763       break;
9764
9765     case SYMBOL_REF:
9766     case LABEL_REF:
9767     case CONST:
9768       add_AT_addr (die, DW_AT_const_value, rtl);
9769       VARRAY_PUSH_RTX (used_rtx_varray, rtl);
9770       break;
9771
9772     case PLUS:
9773       /* In cases where an inlined instance of an inline function is passed
9774          the address of an `auto' variable (which is local to the caller) we
9775          can get a situation where the DECL_RTL of the artificial local
9776          variable (for the inlining) which acts as a stand-in for the
9777          corresponding formal parameter (of the inline function) will look
9778          like (plus:SI (reg:SI FRAME_PTR) (const_int ...)).  This is not
9779          exactly a compile-time constant expression, but it isn't the address
9780          of the (artificial) local variable either.  Rather, it represents the
9781          *value* which the artificial local variable always has during its
9782          lifetime.  We currently have no way to represent such quasi-constant
9783          values in Dwarf, so for now we just punt and generate nothing.  */
9784       break;
9785
9786     default:
9787       /* No other kinds of rtx should be possible here.  */
9788       gcc_unreachable ();
9789     }
9790
9791 }
9792
9793 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
9794    for use in a later add_const_value_attribute call.  */
9795
9796 static rtx
9797 rtl_for_decl_init (tree init, tree type)
9798 {
9799   rtx rtl = NULL_RTX;
9800
9801   /* If a variable is initialized with a string constant without embedded
9802      zeros, build CONST_STRING.  */
9803   if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE)
9804     {
9805       tree enttype = TREE_TYPE (type);
9806       tree domain = TYPE_DOMAIN (type);
9807       enum machine_mode mode = TYPE_MODE (enttype);
9808
9809       if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
9810           && domain
9811           && integer_zerop (TYPE_MIN_VALUE (domain))
9812           && compare_tree_int (TYPE_MAX_VALUE (domain),
9813                                TREE_STRING_LENGTH (init) - 1) == 0
9814           && ((size_t) TREE_STRING_LENGTH (init)
9815               == strlen (TREE_STRING_POINTER (init)) + 1))
9816         rtl = gen_rtx_CONST_STRING (VOIDmode,
9817                                     ggc_strdup (TREE_STRING_POINTER (init)));
9818     }
9819   /* If the initializer is something that we know will expand into an
9820      immediate RTL constant, expand it now.  Expanding anything else
9821      tends to produce unresolved symbols; see debug/5770 and c++/6381.  */
9822   /* Aggregate, vector, and complex types may contain constructors that may
9823      result in code being generated when expand_expr is called, so we can't
9824      handle them here.  Integer and float are useful and safe types to handle
9825      here.  */
9826   else if ((INTEGRAL_TYPE_P (type) || SCALAR_FLOAT_TYPE_P (type))
9827            && initializer_constant_valid_p (init, type) == null_pointer_node)
9828     {
9829       rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
9830
9831       /* If expand_expr returns a MEM, it wasn't immediate.  */
9832       gcc_assert (!rtl || !MEM_P (rtl));
9833     }
9834
9835   return rtl;
9836 }
9837
9838 /* Generate RTL for the variable DECL to represent its location.  */
9839
9840 static rtx
9841 rtl_for_decl_location (tree decl)
9842 {
9843   rtx rtl;
9844
9845   /* Here we have to decide where we are going to say the parameter "lives"
9846      (as far as the debugger is concerned).  We only have a couple of
9847      choices.  GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
9848
9849      DECL_RTL normally indicates where the parameter lives during most of the
9850      activation of the function.  If optimization is enabled however, this
9851      could be either NULL or else a pseudo-reg.  Both of those cases indicate
9852      that the parameter doesn't really live anywhere (as far as the code
9853      generation parts of GCC are concerned) during most of the function's
9854      activation.  That will happen (for example) if the parameter is never
9855      referenced within the function.
9856
9857      We could just generate a location descriptor here for all non-NULL
9858      non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
9859      a little nicer than that if we also consider DECL_INCOMING_RTL in cases
9860      where DECL_RTL is NULL or is a pseudo-reg.
9861
9862      Note however that we can only get away with using DECL_INCOMING_RTL as
9863      a backup substitute for DECL_RTL in certain limited cases.  In cases
9864      where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
9865      we can be sure that the parameter was passed using the same type as it is
9866      declared to have within the function, and that its DECL_INCOMING_RTL
9867      points us to a place where a value of that type is passed.
9868
9869      In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
9870      we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
9871      because in these cases DECL_INCOMING_RTL points us to a value of some
9872      type which is *different* from the type of the parameter itself.  Thus,
9873      if we tried to use DECL_INCOMING_RTL to generate a location attribute in
9874      such cases, the debugger would end up (for example) trying to fetch a
9875      `float' from a place which actually contains the first part of a
9876      `double'.  That would lead to really incorrect and confusing
9877      output at debug-time.
9878
9879      So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
9880      in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl).  There
9881      are a couple of exceptions however.  On little-endian machines we can
9882      get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
9883      not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
9884      an integral type that is smaller than TREE_TYPE (decl). These cases arise
9885      when (on a little-endian machine) a non-prototyped function has a
9886      parameter declared to be of type `short' or `char'.  In such cases,
9887      TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
9888      be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
9889      passed `int' value.  If the debugger then uses that address to fetch
9890      a `short' or a `char' (on a little-endian machine) the result will be
9891      the correct data, so we allow for such exceptional cases below.
9892
9893      Note that our goal here is to describe the place where the given formal
9894      parameter lives during most of the function's activation (i.e. between the
9895      end of the prologue and the start of the epilogue).  We'll do that as best
9896      as we can. Note however that if the given formal parameter is modified
9897      sometime during the execution of the function, then a stack backtrace (at
9898      debug-time) will show the function as having been called with the *new*
9899      value rather than the value which was originally passed in.  This happens
9900      rarely enough that it is not a major problem, but it *is* a problem, and
9901      I'd like to fix it.
9902
9903      A future version of dwarf2out.c may generate two additional attributes for
9904      any given DW_TAG_formal_parameter DIE which will describe the "passed
9905      type" and the "passed location" for the given formal parameter in addition
9906      to the attributes we now generate to indicate the "declared type" and the
9907      "active location" for each parameter.  This additional set of attributes
9908      could be used by debuggers for stack backtraces. Separately, note that
9909      sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
9910      This happens (for example) for inlined-instances of inline function formal
9911      parameters which are never referenced.  This really shouldn't be
9912      happening.  All PARM_DECL nodes should get valid non-NULL
9913      DECL_INCOMING_RTL values.  FIXME.  */
9914
9915   /* Use DECL_RTL as the "location" unless we find something better.  */
9916   rtl = DECL_RTL_IF_SET (decl);
9917
9918   /* When generating abstract instances, ignore everything except
9919      constants, symbols living in memory, and symbols living in
9920      fixed registers.  */
9921   if (! reload_completed)
9922     {
9923       if (rtl
9924           && (CONSTANT_P (rtl)
9925               || (MEM_P (rtl)
9926                   && CONSTANT_P (XEXP (rtl, 0)))
9927               || (REG_P (rtl)
9928                   && TREE_CODE (decl) == VAR_DECL
9929                   && TREE_STATIC (decl))))
9930         {
9931           rtl = targetm.delegitimize_address (rtl);
9932           return rtl;
9933         }
9934       rtl = NULL_RTX;
9935     }
9936   else if (TREE_CODE (decl) == PARM_DECL)
9937     {
9938       if (rtl == NULL_RTX || is_pseudo_reg (rtl))
9939         {
9940           tree declared_type = TREE_TYPE (decl);
9941           tree passed_type = DECL_ARG_TYPE (decl);
9942           enum machine_mode dmode = TYPE_MODE (declared_type);
9943           enum machine_mode pmode = TYPE_MODE (passed_type);
9944
9945           /* This decl represents a formal parameter which was optimized out.
9946              Note that DECL_INCOMING_RTL may be NULL in here, but we handle
9947              all cases where (rtl == NULL_RTX) just below.  */
9948           if (dmode == pmode)
9949             rtl = DECL_INCOMING_RTL (decl);
9950           else if (SCALAR_INT_MODE_P (dmode)
9951                    && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode)
9952                    && DECL_INCOMING_RTL (decl))
9953             {
9954               rtx inc = DECL_INCOMING_RTL (decl);
9955               if (REG_P (inc))
9956                 rtl = inc;
9957               else if (MEM_P (inc))
9958                 {
9959                   if (BYTES_BIG_ENDIAN)
9960                     rtl = adjust_address_nv (inc, dmode,
9961                                              GET_MODE_SIZE (pmode)
9962                                              - GET_MODE_SIZE (dmode));
9963                   else
9964                     rtl = inc;
9965                 }
9966             }
9967         }
9968
9969       /* If the parm was passed in registers, but lives on the stack, then
9970          make a big endian correction if the mode of the type of the
9971          parameter is not the same as the mode of the rtl.  */
9972       /* ??? This is the same series of checks that are made in dbxout.c before
9973          we reach the big endian correction code there.  It isn't clear if all
9974          of these checks are necessary here, but keeping them all is the safe
9975          thing to do.  */
9976       else if (MEM_P (rtl)
9977                && XEXP (rtl, 0) != const0_rtx
9978                && ! CONSTANT_P (XEXP (rtl, 0))
9979                /* Not passed in memory.  */
9980                && !MEM_P (DECL_INCOMING_RTL (decl))
9981                /* Not passed by invisible reference.  */
9982                && (!REG_P (XEXP (rtl, 0))
9983                    || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
9984                    || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
9985 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
9986                    || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
9987 #endif
9988                      )
9989                /* Big endian correction check.  */
9990                && BYTES_BIG_ENDIAN
9991                && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
9992                && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
9993                    < UNITS_PER_WORD))
9994         {
9995           int offset = (UNITS_PER_WORD
9996                         - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
9997
9998           rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
9999                              plus_constant (XEXP (rtl, 0), offset));
10000         }
10001     }
10002   else if (TREE_CODE (decl) == VAR_DECL
10003            && rtl
10004            && MEM_P (rtl)
10005            && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl))
10006            && BYTES_BIG_ENDIAN)
10007     {
10008       int rsize = GET_MODE_SIZE (GET_MODE (rtl));
10009       int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)));
10010
10011       /* If a variable is declared "register" yet is smaller than
10012          a register, then if we store the variable to memory, it
10013          looks like we're storing a register-sized value, when in
10014          fact we are not.  We need to adjust the offset of the
10015          storage location to reflect the actual value's bytes,
10016          else gdb will not be able to display it.  */
10017       if (rsize > dsize)
10018         rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
10019                            plus_constant (XEXP (rtl, 0), rsize-dsize));
10020     }
10021
10022   if (rtl != NULL_RTX)
10023     {
10024       rtl = eliminate_regs (rtl, 0, NULL_RTX);
10025 #ifdef LEAF_REG_REMAP
10026       if (current_function_uses_only_leaf_regs)
10027         leaf_renumber_regs_insn (rtl);
10028 #endif
10029     }
10030
10031   /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
10032      and will have been substituted directly into all expressions that use it.
10033      C does not have such a concept, but C++ and other languages do.  */
10034   else if (TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
10035     rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl));
10036
10037   if (rtl)
10038     rtl = targetm.delegitimize_address (rtl);
10039
10040   /* If we don't look past the constant pool, we risk emitting a
10041      reference to a constant pool entry that isn't referenced from
10042      code, and thus is not emitted.  */
10043   if (rtl)
10044     rtl = avoid_constant_pool_reference (rtl);
10045
10046   return rtl;
10047 }
10048
10049 /* Return true if DECL's containing function has a frame base attribute.
10050    Return false otherwise.  */
10051
10052 static bool
10053 containing_function_has_frame_base (tree decl)
10054 {
10055   tree declcontext = decl_function_context (decl);
10056   dw_die_ref context;
10057   dw_attr_ref attr;
10058
10059   if (!declcontext)
10060     return false;
10061
10062   context = lookup_decl_die (declcontext);
10063   if (!context)
10064     return false;
10065
10066   for (attr = context->die_attr; attr; attr = attr->dw_attr_next)
10067     if (attr->dw_attr == DW_AT_frame_base)
10068       return true;
10069   return false;
10070 }
10071
10072 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
10073    data attribute for a variable or a parameter.  We generate the
10074    DW_AT_const_value attribute only in those cases where the given variable
10075    or parameter does not have a true "location" either in memory or in a
10076    register.  This can happen (for example) when a constant is passed as an
10077    actual argument in a call to an inline function.  (It's possible that
10078    these things can crop up in other ways also.)  Note that one type of
10079    constant value which can be passed into an inlined function is a constant
10080    pointer.  This can happen for example if an actual argument in an inlined
10081    function call evaluates to a compile-time constant address.  */
10082
10083 static void
10084 add_location_or_const_value_attribute (dw_die_ref die, tree decl,
10085                                        enum dwarf_attribute attr)
10086 {
10087   rtx rtl;
10088   dw_loc_descr_ref descr;
10089   var_loc_list *loc_list;
10090   bool can_use_fb;
10091   struct var_loc_node *node;
10092   if (TREE_CODE (decl) == ERROR_MARK)
10093     return;
10094
10095   gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
10096               || TREE_CODE (decl) == RESULT_DECL);
10097
10098   can_use_fb = containing_function_has_frame_base (decl);
10099
10100   /* See if we possibly have multiple locations for this variable.  */
10101   loc_list = lookup_decl_loc (decl);
10102
10103   /* If it truly has multiple locations, the first and last node will
10104      differ.  */
10105   if (loc_list && loc_list->first != loc_list->last)
10106     {
10107       const char *secname;
10108       const char *endname;
10109       dw_loc_list_ref list;
10110       rtx varloc;
10111       struct function *cfun = DECL_STRUCT_FUNCTION (current_function_decl);
10112
10113
10114       /* We need to figure out what section we should use as the base
10115          for the address ranges where a given location is valid.
10116          1. If this particular DECL has a section associated with it,
10117          use that.
10118          2. If this function has a section associated with it, use
10119          that.
10120          3. Otherwise, use the text section.
10121          XXX: If you split a variable across multiple sections, this
10122          won't notice.  */
10123
10124       if (DECL_SECTION_NAME (decl))
10125         {
10126           tree sectree = DECL_SECTION_NAME (decl);
10127           secname = TREE_STRING_POINTER (sectree);
10128         }
10129       else if (current_function_decl
10130                && DECL_SECTION_NAME (current_function_decl))
10131         {
10132           tree sectree = DECL_SECTION_NAME (current_function_decl);
10133           secname = TREE_STRING_POINTER (sectree);
10134         }
10135       else if (last_text_section == in_unlikely_executed_text
10136                || (last_text_section == in_named
10137                    && last_text_section_name == cfun->unlikely_text_section_name))
10138         secname = cfun->cold_section_label;
10139       else
10140         secname = text_section_label;
10141
10142       /* Now that we know what section we are using for a base,
10143          actually construct the list of locations.
10144          The first location information is what is passed to the
10145          function that creates the location list, and the remaining
10146          locations just get added on to that list.
10147          Note that we only know the start address for a location
10148          (IE location changes), so to build the range, we use
10149          the range [current location start, next location start].
10150          This means we have to special case the last node, and generate
10151          a range of [last location start, end of function label].  */
10152
10153       node = loc_list->first;
10154       varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10155       list = new_loc_list (loc_descriptor (varloc, can_use_fb),
10156                            node->label, node->next->label, secname, 1);
10157       node = node->next;
10158
10159       for (; node->next; node = node->next)
10160         if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
10161           {
10162             /* The variable has a location between NODE->LABEL and
10163                NODE->NEXT->LABEL.  */
10164             varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10165             add_loc_descr_to_loc_list (&list,
10166                                        loc_descriptor (varloc,
10167                                                        can_use_fb),
10168                                        node->label, node->next->label, secname);
10169           }
10170
10171       /* If the variable has a location at the last label
10172          it keeps its location until the end of function.  */
10173       if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
10174         {
10175           char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
10176
10177           varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10178           if (!current_function_decl)
10179             endname = text_end_label;
10180           else
10181             {
10182               ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
10183                                            current_function_funcdef_no);
10184               endname = ggc_strdup (label_id);
10185             }
10186           add_loc_descr_to_loc_list (&list,
10187                                      loc_descriptor (varloc,
10188                                                      can_use_fb),
10189                                      node->label, endname, secname);
10190         }
10191
10192       /* Finally, add the location list to the DIE, and we are done.  */
10193       add_AT_loc_list (die, attr, list);
10194       return;
10195     }
10196
10197   /* Try to get some constant RTL for this decl, and use that as the value of
10198      the location.  */
10199
10200   rtl = rtl_for_decl_location (decl);
10201   if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING))
10202     {
10203       add_const_value_attribute (die, rtl);
10204       return;
10205     }
10206
10207   /* We couldn't get any rtl, and we had no >1 element location list, so try
10208      directly generating the location description from the tree.  */
10209   descr = loc_descriptor_from_tree (decl);
10210   if (descr)
10211     {
10212       add_AT_location_description (die, attr, descr);
10213       return;
10214     }
10215
10216   /* Lastly, if we have tried to generate the location otherwise, and it
10217      didn't work out (we wouldn't be here if we did), and we have a one entry
10218      location list, try generating a location from that.  */
10219   if (loc_list && loc_list->first)
10220     {
10221       node = loc_list->first;
10222       descr = loc_descriptor (NOTE_VAR_LOCATION (node->var_loc_note),
10223                               can_use_fb);
10224       if (descr)
10225         add_AT_location_description (die, attr, descr);
10226     }
10227 }
10228
10229 /* If we don't have a copy of this variable in memory for some reason (such
10230    as a C++ member constant that doesn't have an out-of-line definition),
10231    we should tell the debugger about the constant value.  */
10232
10233 static void
10234 tree_add_const_value_attribute (dw_die_ref var_die, tree decl)
10235 {
10236   tree init = DECL_INITIAL (decl);
10237   tree type = TREE_TYPE (decl);
10238   rtx rtl;
10239
10240   if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl) && init)
10241     /* OK */;
10242   else
10243     return;
10244
10245   rtl = rtl_for_decl_init (init, type);
10246   if (rtl)
10247     add_const_value_attribute (var_die, rtl);
10248 }
10249
10250 /* Generate a DW_AT_name attribute given some string value to be included as
10251    the value of the attribute.  */
10252
10253 static void
10254 add_name_attribute (dw_die_ref die, const char *name_string)
10255 {
10256   if (name_string != NULL && *name_string != 0)
10257     {
10258       if (demangle_name_func)
10259         name_string = (*demangle_name_func) (name_string);
10260
10261       add_AT_string (die, DW_AT_name, name_string);
10262     }
10263 }
10264
10265 /* Generate a DW_AT_comp_dir attribute for DIE.  */
10266
10267 static void
10268 add_comp_dir_attribute (dw_die_ref die)
10269 {
10270   const char *wd = get_src_pwd ();
10271   if (wd != NULL)
10272     add_AT_string (die, DW_AT_comp_dir, wd);
10273 }
10274
10275 /* Given a tree node describing an array bound (either lower or upper) output
10276    a representation for that bound.  */
10277
10278 static void
10279 add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound)
10280 {
10281   switch (TREE_CODE (bound))
10282     {
10283     case ERROR_MARK:
10284       return;
10285
10286     /* All fixed-bounds are represented by INTEGER_CST nodes.  */
10287     case INTEGER_CST:
10288       if (! host_integerp (bound, 0)
10289           || (bound_attr == DW_AT_lower_bound
10290               && (((is_c_family () || is_java ()) &&  integer_zerop (bound))
10291                   || (is_fortran () && integer_onep (bound)))))
10292         /* Use the default.  */
10293         ;
10294       else
10295         add_AT_unsigned (subrange_die, bound_attr, tree_low_cst (bound, 0));
10296       break;
10297
10298     case CONVERT_EXPR:
10299     case NOP_EXPR:
10300     case NON_LVALUE_EXPR:
10301     case VIEW_CONVERT_EXPR:
10302       add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
10303       break;
10304
10305     case SAVE_EXPR:
10306       break;
10307
10308     case VAR_DECL:
10309     case PARM_DECL:
10310     case RESULT_DECL:
10311       {
10312         dw_die_ref decl_die = lookup_decl_die (bound);
10313
10314         /* ??? Can this happen, or should the variable have been bound
10315            first?  Probably it can, since I imagine that we try to create
10316            the types of parameters in the order in which they exist in
10317            the list, and won't have created a forward reference to a
10318            later parameter.  */
10319         if (decl_die != NULL)
10320           add_AT_die_ref (subrange_die, bound_attr, decl_die);
10321         break;
10322       }
10323
10324     default:
10325       {
10326         /* Otherwise try to create a stack operation procedure to
10327            evaluate the value of the array bound.  */
10328
10329         dw_die_ref ctx, decl_die;
10330         dw_loc_descr_ref loc;
10331
10332         loc = loc_descriptor_from_tree (bound);
10333         if (loc == NULL)
10334           break;
10335
10336         if (current_function_decl == 0)
10337           ctx = comp_unit_die;
10338         else
10339           ctx = lookup_decl_die (current_function_decl);
10340
10341         decl_die = new_die (DW_TAG_variable, ctx, bound);
10342         add_AT_flag (decl_die, DW_AT_artificial, 1);
10343         add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
10344         add_AT_loc (decl_die, DW_AT_location, loc);
10345
10346         add_AT_die_ref (subrange_die, bound_attr, decl_die);
10347         break;
10348       }
10349     }
10350 }
10351
10352 /* Note that the block of subscript information for an array type also
10353    includes information about the element type of type given array type.  */
10354
10355 static void
10356 add_subscript_info (dw_die_ref type_die, tree type)
10357 {
10358 #ifndef MIPS_DEBUGGING_INFO
10359   unsigned dimension_number;
10360 #endif
10361   tree lower, upper;
10362   dw_die_ref subrange_die;
10363
10364   /* The GNU compilers represent multidimensional array types as sequences of
10365      one dimensional array types whose element types are themselves array
10366      types.  Here we squish that down, so that each multidimensional array
10367      type gets only one array_type DIE in the Dwarf debugging info. The draft
10368      Dwarf specification say that we are allowed to do this kind of
10369      compression in C (because there is no difference between an array or
10370      arrays and a multidimensional array in C) but for other source languages
10371      (e.g. Ada) we probably shouldn't do this.  */
10372
10373   /* ??? The SGI dwarf reader fails for multidimensional arrays with a
10374      const enum type.  E.g. const enum machine_mode insn_operand_mode[2][10].
10375      We work around this by disabling this feature.  See also
10376      gen_array_type_die.  */
10377 #ifndef MIPS_DEBUGGING_INFO
10378   for (dimension_number = 0;
10379        TREE_CODE (type) == ARRAY_TYPE;
10380        type = TREE_TYPE (type), dimension_number++)
10381 #endif
10382     {
10383       tree domain = TYPE_DOMAIN (type);
10384
10385       /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
10386          and (in GNU C only) variable bounds.  Handle all three forms
10387          here.  */
10388       subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
10389       if (domain)
10390         {
10391           /* We have an array type with specified bounds.  */
10392           lower = TYPE_MIN_VALUE (domain);
10393           upper = TYPE_MAX_VALUE (domain);
10394
10395           /* Define the index type.  */
10396           if (TREE_TYPE (domain))
10397             {
10398               /* ??? This is probably an Ada unnamed subrange type.  Ignore the
10399                  TREE_TYPE field.  We can't emit debug info for this
10400                  because it is an unnamed integral type.  */
10401               if (TREE_CODE (domain) == INTEGER_TYPE
10402                   && TYPE_NAME (domain) == NULL_TREE
10403                   && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
10404                   && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
10405                 ;
10406               else
10407                 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
10408                                     type_die);
10409             }
10410
10411           /* ??? If upper is NULL, the array has unspecified length,
10412              but it does have a lower bound.  This happens with Fortran
10413                dimension arr(N:*)
10414              Since the debugger is definitely going to need to know N
10415              to produce useful results, go ahead and output the lower
10416              bound solo, and hope the debugger can cope.  */
10417
10418           add_bound_info (subrange_die, DW_AT_lower_bound, lower);
10419           if (upper)
10420             add_bound_info (subrange_die, DW_AT_upper_bound, upper);
10421         }
10422
10423       /* Otherwise we have an array type with an unspecified length.  The
10424          DWARF-2 spec does not say how to handle this; let's just leave out the
10425          bounds.  */
10426     }
10427 }
10428
10429 static void
10430 add_byte_size_attribute (dw_die_ref die, tree tree_node)
10431 {
10432   unsigned size;
10433
10434   switch (TREE_CODE (tree_node))
10435     {
10436     case ERROR_MARK:
10437       size = 0;
10438       break;
10439     case ENUMERAL_TYPE:
10440     case RECORD_TYPE:
10441     case UNION_TYPE:
10442     case QUAL_UNION_TYPE:
10443       size = int_size_in_bytes (tree_node);
10444       break;
10445     case FIELD_DECL:
10446       /* For a data member of a struct or union, the DW_AT_byte_size is
10447          generally given as the number of bytes normally allocated for an
10448          object of the *declared* type of the member itself.  This is true
10449          even for bit-fields.  */
10450       size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
10451       break;
10452     default:
10453       gcc_unreachable ();
10454     }
10455
10456   /* Note that `size' might be -1 when we get to this point.  If it is, that
10457      indicates that the byte size of the entity in question is variable.  We
10458      have no good way of expressing this fact in Dwarf at the present time,
10459      so just let the -1 pass on through.  */
10460   add_AT_unsigned (die, DW_AT_byte_size, size);
10461 }
10462
10463 /* For a FIELD_DECL node which represents a bit-field, output an attribute
10464    which specifies the distance in bits from the highest order bit of the
10465    "containing object" for the bit-field to the highest order bit of the
10466    bit-field itself.
10467
10468    For any given bit-field, the "containing object" is a hypothetical object
10469    (of some integral or enum type) within which the given bit-field lives.  The
10470    type of this hypothetical "containing object" is always the same as the
10471    declared type of the individual bit-field itself.  The determination of the
10472    exact location of the "containing object" for a bit-field is rather
10473    complicated.  It's handled by the `field_byte_offset' function (above).
10474
10475    Note that it is the size (in bytes) of the hypothetical "containing object"
10476    which will be given in the DW_AT_byte_size attribute for this bit-field.
10477    (See `byte_size_attribute' above).  */
10478
10479 static inline void
10480 add_bit_offset_attribute (dw_die_ref die, tree decl)
10481 {
10482   HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
10483   tree type = DECL_BIT_FIELD_TYPE (decl);
10484   HOST_WIDE_INT bitpos_int;
10485   HOST_WIDE_INT highest_order_object_bit_offset;
10486   HOST_WIDE_INT highest_order_field_bit_offset;
10487   HOST_WIDE_INT unsigned bit_offset;
10488
10489   /* Must be a field and a bit field.  */
10490   gcc_assert (type && TREE_CODE (decl) == FIELD_DECL);
10491
10492   /* We can't yet handle bit-fields whose offsets are variable, so if we
10493      encounter such things, just return without generating any attribute
10494      whatsoever.  Likewise for variable or too large size.  */
10495   if (! host_integerp (bit_position (decl), 0)
10496       || ! host_integerp (DECL_SIZE (decl), 1))
10497     return;
10498
10499   bitpos_int = int_bit_position (decl);
10500
10501   /* Note that the bit offset is always the distance (in bits) from the
10502      highest-order bit of the "containing object" to the highest-order bit of
10503      the bit-field itself.  Since the "high-order end" of any object or field
10504      is different on big-endian and little-endian machines, the computation
10505      below must take account of these differences.  */
10506   highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
10507   highest_order_field_bit_offset = bitpos_int;
10508
10509   if (! BYTES_BIG_ENDIAN)
10510     {
10511       highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0);
10512       highest_order_object_bit_offset += simple_type_size_in_bits (type);
10513     }
10514
10515   bit_offset
10516     = (! BYTES_BIG_ENDIAN
10517        ? highest_order_object_bit_offset - highest_order_field_bit_offset
10518        : highest_order_field_bit_offset - highest_order_object_bit_offset);
10519
10520   add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
10521 }
10522
10523 /* For a FIELD_DECL node which represents a bit field, output an attribute
10524    which specifies the length in bits of the given field.  */
10525
10526 static inline void
10527 add_bit_size_attribute (dw_die_ref die, tree decl)
10528 {
10529   /* Must be a field and a bit field.  */
10530   gcc_assert (TREE_CODE (decl) == FIELD_DECL
10531               && DECL_BIT_FIELD_TYPE (decl));
10532
10533   if (host_integerp (DECL_SIZE (decl), 1))
10534     add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
10535 }
10536
10537 /* If the compiled language is ANSI C, then add a 'prototyped'
10538    attribute, if arg types are given for the parameters of a function.  */
10539
10540 static inline void
10541 add_prototyped_attribute (dw_die_ref die, tree func_type)
10542 {
10543   if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
10544       && TYPE_ARG_TYPES (func_type) != NULL)
10545     add_AT_flag (die, DW_AT_prototyped, 1);
10546 }
10547
10548 /* Add an 'abstract_origin' attribute below a given DIE.  The DIE is found
10549    by looking in either the type declaration or object declaration
10550    equate table.  */
10551
10552 static inline void
10553 add_abstract_origin_attribute (dw_die_ref die, tree origin)
10554 {
10555   dw_die_ref origin_die = NULL;
10556
10557   if (TREE_CODE (origin) != FUNCTION_DECL)
10558     {
10559       /* We may have gotten separated from the block for the inlined
10560          function, if we're in an exception handler or some such; make
10561          sure that the abstract function has been written out.
10562
10563          Doing this for nested functions is wrong, however; functions are
10564          distinct units, and our context might not even be inline.  */
10565       tree fn = origin;
10566
10567       if (TYPE_P (fn))
10568         fn = TYPE_STUB_DECL (fn);
10569
10570       fn = decl_function_context (fn);
10571       if (fn)
10572         dwarf2out_abstract_function (fn);
10573     }
10574
10575   if (DECL_P (origin))
10576     origin_die = lookup_decl_die (origin);
10577   else if (TYPE_P (origin))
10578     origin_die = lookup_type_die (origin);
10579
10580   /* XXX: Functions that are never lowered don't always have correct block
10581      trees (in the case of java, they simply have no block tree, in some other
10582      languages).  For these functions, there is nothing we can really do to
10583      output correct debug info for inlined functions in all cases.  Rather
10584      than abort, we'll just produce deficient debug info now, in that we will
10585      have variables without a proper abstract origin.  In the future, when all
10586      functions are lowered, we should re-add a gcc_assert (origin_die)
10587      here.  */
10588
10589   if (origin_die)
10590       add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
10591 }
10592
10593 /* We do not currently support the pure_virtual attribute.  */
10594
10595 static inline void
10596 add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
10597 {
10598   if (DECL_VINDEX (func_decl))
10599     {
10600       add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
10601
10602       if (host_integerp (DECL_VINDEX (func_decl), 0))
10603         add_AT_loc (die, DW_AT_vtable_elem_location,
10604                     new_loc_descr (DW_OP_constu,
10605                                    tree_low_cst (DECL_VINDEX (func_decl), 0),
10606                                    0));
10607
10608       /* GNU extension: Record what type this method came from originally.  */
10609       if (debug_info_level > DINFO_LEVEL_TERSE)
10610         add_AT_die_ref (die, DW_AT_containing_type,
10611                         lookup_type_die (DECL_CONTEXT (func_decl)));
10612     }
10613 }
10614 \f
10615 /* Add source coordinate attributes for the given decl.  */
10616
10617 static void
10618 add_src_coords_attributes (dw_die_ref die, tree decl)
10619 {
10620   expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
10621   unsigned file_index = lookup_filename (s.file);
10622
10623   add_AT_unsigned (die, DW_AT_decl_file, file_index);
10624   add_AT_unsigned (die, DW_AT_decl_line, s.line);
10625 }
10626
10627 /* Add a DW_AT_name attribute and source coordinate attribute for the
10628    given decl, but only if it actually has a name.  */
10629
10630 static void
10631 add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
10632 {
10633   tree decl_name;
10634
10635   decl_name = DECL_NAME (decl);
10636   if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
10637     {
10638       add_name_attribute (die, dwarf2_name (decl, 0));
10639       if (! DECL_ARTIFICIAL (decl))
10640         add_src_coords_attributes (die, decl);
10641
10642       if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
10643           && TREE_PUBLIC (decl)
10644           && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)
10645           && !DECL_ABSTRACT (decl))
10646         add_AT_string (die, DW_AT_MIPS_linkage_name,
10647                        IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
10648     }
10649
10650 #ifdef VMS_DEBUGGING_INFO
10651   /* Get the function's name, as described by its RTL.  This may be different
10652      from the DECL_NAME name used in the source file.  */
10653   if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
10654     {
10655       add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
10656                    XEXP (DECL_RTL (decl), 0));
10657       VARRAY_PUSH_RTX (used_rtx_varray, XEXP (DECL_RTL (decl), 0));
10658     }
10659 #endif
10660 }
10661
10662 /* Push a new declaration scope.  */
10663
10664 static void
10665 push_decl_scope (tree scope)
10666 {
10667   VARRAY_PUSH_TREE (decl_scope_table, scope);
10668 }
10669
10670 /* Pop a declaration scope.  */
10671
10672 static inline void
10673 pop_decl_scope (void)
10674 {
10675   gcc_assert (VARRAY_ACTIVE_SIZE (decl_scope_table) > 0);
10676
10677   VARRAY_POP (decl_scope_table);
10678 }
10679
10680 /* Return the DIE for the scope that immediately contains this type.
10681    Non-named types get global scope.  Named types nested in other
10682    types get their containing scope if it's open, or global scope
10683    otherwise.  All other types (i.e. function-local named types) get
10684    the current active scope.  */
10685
10686 static dw_die_ref
10687 scope_die_for (tree t, dw_die_ref context_die)
10688 {
10689   dw_die_ref scope_die = NULL;
10690   tree containing_scope;
10691   int i;
10692
10693   /* Non-types always go in the current scope.  */
10694   gcc_assert (TYPE_P (t));
10695
10696   containing_scope = TYPE_CONTEXT (t);
10697
10698   /* Use the containing namespace if it was passed in (for a declaration).  */
10699   if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
10700     {
10701       if (context_die == lookup_decl_die (containing_scope))
10702         /* OK */;
10703       else
10704         containing_scope = NULL_TREE;
10705     }
10706
10707   /* Ignore function type "scopes" from the C frontend.  They mean that
10708      a tagged type is local to a parmlist of a function declarator, but
10709      that isn't useful to DWARF.  */
10710   if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
10711     containing_scope = NULL_TREE;
10712
10713   if (containing_scope == NULL_TREE)
10714     scope_die = comp_unit_die;
10715   else if (TYPE_P (containing_scope))
10716     {
10717       /* For types, we can just look up the appropriate DIE.  But
10718          first we check to see if we're in the middle of emitting it
10719          so we know where the new DIE should go.  */
10720       for (i = VARRAY_ACTIVE_SIZE (decl_scope_table) - 1; i >= 0; --i)
10721         if (VARRAY_TREE (decl_scope_table, i) == containing_scope)
10722           break;
10723
10724       if (i < 0)
10725         {
10726           gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE
10727                       || TREE_ASM_WRITTEN (containing_scope));
10728
10729           /* If none of the current dies are suitable, we get file scope.  */
10730           scope_die = comp_unit_die;
10731         }
10732       else
10733         scope_die = lookup_type_die (containing_scope);
10734     }
10735   else
10736     scope_die = context_die;
10737
10738   return scope_die;
10739 }
10740
10741 /* Returns nonzero if CONTEXT_DIE is internal to a function.  */
10742
10743 static inline int
10744 local_scope_p (dw_die_ref context_die)
10745 {
10746   for (; context_die; context_die = context_die->die_parent)
10747     if (context_die->die_tag == DW_TAG_inlined_subroutine
10748         || context_die->die_tag == DW_TAG_subprogram)
10749       return 1;
10750
10751   return 0;
10752 }
10753
10754 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
10755    whether or not to treat a DIE in this context as a declaration.  */
10756
10757 static inline int
10758 class_or_namespace_scope_p (dw_die_ref context_die)
10759 {
10760   return (context_die
10761           && (context_die->die_tag == DW_TAG_structure_type
10762               || context_die->die_tag == DW_TAG_union_type
10763               || context_die->die_tag == DW_TAG_namespace));
10764 }
10765
10766 /* Many forms of DIEs require a "type description" attribute.  This
10767    routine locates the proper "type descriptor" die for the type given
10768    by 'type', and adds a DW_AT_type attribute below the given die.  */
10769
10770 static void
10771 add_type_attribute (dw_die_ref object_die, tree type, int decl_const,
10772                     int decl_volatile, dw_die_ref context_die)
10773 {
10774   enum tree_code code  = TREE_CODE (type);
10775   dw_die_ref type_die  = NULL;
10776
10777   /* ??? If this type is an unnamed subrange type of an integral or
10778      floating-point type, use the inner type.  This is because we have no
10779      support for unnamed types in base_type_die.  This can happen if this is
10780      an Ada subrange type.  Correct solution is emit a subrange type die.  */
10781   if ((code == INTEGER_TYPE || code == REAL_TYPE)
10782       && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
10783     type = TREE_TYPE (type), code = TREE_CODE (type);
10784
10785   if (code == ERROR_MARK
10786       /* Handle a special case.  For functions whose return type is void, we
10787          generate *no* type attribute.  (Note that no object may have type
10788          `void', so this only applies to function return types).  */
10789       || code == VOID_TYPE)
10790     return;
10791
10792   type_die = modified_type_die (type,
10793                                 decl_const || TYPE_READONLY (type),
10794                                 decl_volatile || TYPE_VOLATILE (type),
10795                                 context_die);
10796
10797   if (type_die != NULL)
10798     add_AT_die_ref (object_die, DW_AT_type, type_die);
10799 }
10800
10801 /* Given an object die, add the calling convention attribute for the
10802    function call type.  */
10803 static void
10804 add_calling_convention_attribute (dw_die_ref subr_die, tree type)
10805 {
10806   enum dwarf_calling_convention value = DW_CC_normal;
10807
10808   value = targetm.dwarf_calling_convention (type);
10809
10810   /* Only add the attribute if the backend requests it, and
10811      is not DW_CC_normal.  */
10812   if (value && (value != DW_CC_normal))
10813     add_AT_unsigned (subr_die, DW_AT_calling_convention, value);
10814 }
10815
10816 /* Given a tree pointer to a struct, class, union, or enum type node, return
10817    a pointer to the (string) tag name for the given type, or zero if the type
10818    was declared without a tag.  */
10819
10820 static const char *
10821 type_tag (tree type)
10822 {
10823   const char *name = 0;
10824
10825   if (TYPE_NAME (type) != 0)
10826     {
10827       tree t = 0;
10828
10829       /* Find the IDENTIFIER_NODE for the type name.  */
10830       if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
10831         t = TYPE_NAME (type);
10832
10833       /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
10834          a TYPE_DECL node, regardless of whether or not a `typedef' was
10835          involved.  */
10836       else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10837                && ! DECL_IGNORED_P (TYPE_NAME (type)))
10838         t = DECL_NAME (TYPE_NAME (type));
10839
10840       /* Now get the name as a string, or invent one.  */
10841       if (t != 0)
10842         name = IDENTIFIER_POINTER (t);
10843     }
10844
10845   return (name == 0 || *name == '\0') ? 0 : name;
10846 }
10847
10848 /* Return the type associated with a data member, make a special check
10849    for bit field types.  */
10850
10851 static inline tree
10852 member_declared_type (tree member)
10853 {
10854   return (DECL_BIT_FIELD_TYPE (member)
10855           ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
10856 }
10857
10858 /* Get the decl's label, as described by its RTL. This may be different
10859    from the DECL_NAME name used in the source file.  */
10860
10861 #if 0
10862 static const char *
10863 decl_start_label (tree decl)
10864 {
10865   rtx x;
10866   const char *fnname;
10867
10868   x = DECL_RTL (decl);
10869   gcc_assert (MEM_P (x));
10870
10871   x = XEXP (x, 0);
10872   gcc_assert (GET_CODE (x) == SYMBOL_REF);
10873
10874   fnname = XSTR (x, 0);
10875   return fnname;
10876 }
10877 #endif
10878 \f
10879 /* These routines generate the internal representation of the DIE's for
10880    the compilation unit.  Debugging information is collected by walking
10881    the declaration trees passed in from dwarf2out_decl().  */
10882
10883 static void
10884 gen_array_type_die (tree type, dw_die_ref context_die)
10885 {
10886   dw_die_ref scope_die = scope_die_for (type, context_die);
10887   dw_die_ref array_die;
10888   tree element_type;
10889
10890   /* ??? The SGI dwarf reader fails for array of array of enum types unless
10891      the inner array type comes before the outer array type.  Thus we must
10892      call gen_type_die before we call new_die.  See below also.  */
10893 #ifdef MIPS_DEBUGGING_INFO
10894   gen_type_die (TREE_TYPE (type), context_die);
10895 #endif
10896
10897   array_die = new_die (DW_TAG_array_type, scope_die, type);
10898   add_name_attribute (array_die, type_tag (type));
10899   equate_type_number_to_die (type, array_die);
10900
10901   if (TREE_CODE (type) == VECTOR_TYPE)
10902     {
10903       /* The frontend feeds us a representation for the vector as a struct
10904          containing an array.  Pull out the array type.  */
10905       type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
10906       add_AT_flag (array_die, DW_AT_GNU_vector, 1);
10907     }
10908
10909 #if 0
10910   /* We default the array ordering.  SDB will probably do
10911      the right things even if DW_AT_ordering is not present.  It's not even
10912      an issue until we start to get into multidimensional arrays anyway.  If
10913      SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
10914      then we'll have to put the DW_AT_ordering attribute back in.  (But if
10915      and when we find out that we need to put these in, we will only do so
10916      for multidimensional arrays.  */
10917   add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
10918 #endif
10919
10920 #ifdef MIPS_DEBUGGING_INFO
10921   /* The SGI compilers handle arrays of unknown bound by setting
10922      AT_declaration and not emitting any subrange DIEs.  */
10923   if (! TYPE_DOMAIN (type))
10924     add_AT_flag (array_die, DW_AT_declaration, 1);
10925   else
10926 #endif
10927     add_subscript_info (array_die, type);
10928
10929   /* Add representation of the type of the elements of this array type.  */
10930   element_type = TREE_TYPE (type);
10931
10932   /* ??? The SGI dwarf reader fails for multidimensional arrays with a
10933      const enum type.  E.g. const enum machine_mode insn_operand_mode[2][10].
10934      We work around this by disabling this feature.  See also
10935      add_subscript_info.  */
10936 #ifndef MIPS_DEBUGGING_INFO
10937   while (TREE_CODE (element_type) == ARRAY_TYPE)
10938     element_type = TREE_TYPE (element_type);
10939
10940   gen_type_die (element_type, context_die);
10941 #endif
10942
10943   add_type_attribute (array_die, element_type, 0, 0, context_die);
10944 }
10945
10946 #if 0
10947 static void
10948 gen_entry_point_die (tree decl, dw_die_ref context_die)
10949 {
10950   tree origin = decl_ultimate_origin (decl);
10951   dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
10952
10953   if (origin != NULL)
10954     add_abstract_origin_attribute (decl_die, origin);
10955   else
10956     {
10957       add_name_and_src_coords_attributes (decl_die, decl);
10958       add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
10959                           0, 0, context_die);
10960     }
10961
10962   if (DECL_ABSTRACT (decl))
10963     equate_decl_number_to_die (decl, decl_die);
10964   else
10965     add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
10966 }
10967 #endif
10968
10969 /* Walk through the list of incomplete types again, trying once more to
10970    emit full debugging info for them.  */
10971
10972 static void
10973 retry_incomplete_types (void)
10974 {
10975   int i;
10976
10977   for (i = VARRAY_ACTIVE_SIZE (incomplete_types) - 1; i >= 0; i--)
10978     gen_type_die (VARRAY_TREE (incomplete_types, i), comp_unit_die);
10979 }
10980
10981 /* Generate a DIE to represent an inlined instance of an enumeration type.  */
10982
10983 static void
10984 gen_inlined_enumeration_type_die (tree type, dw_die_ref context_die)
10985 {
10986   dw_die_ref type_die = new_die (DW_TAG_enumeration_type, context_die, type);
10987
10988   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
10989      be incomplete and such types are not marked.  */
10990   add_abstract_origin_attribute (type_die, type);
10991 }
10992
10993 /* Generate a DIE to represent an inlined instance of a structure type.  */
10994
10995 static void
10996 gen_inlined_structure_type_die (tree type, dw_die_ref context_die)
10997 {
10998   dw_die_ref type_die = new_die (DW_TAG_structure_type, context_die, type);
10999
11000   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11001      be incomplete and such types are not marked.  */
11002   add_abstract_origin_attribute (type_die, type);
11003 }
11004
11005 /* Generate a DIE to represent an inlined instance of a union type.  */
11006
11007 static void
11008 gen_inlined_union_type_die (tree type, dw_die_ref context_die)
11009 {
11010   dw_die_ref type_die = new_die (DW_TAG_union_type, context_die, type);
11011
11012   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11013      be incomplete and such types are not marked.  */
11014   add_abstract_origin_attribute (type_die, type);
11015 }
11016
11017 /* Generate a DIE to represent an enumeration type.  Note that these DIEs
11018    include all of the information about the enumeration values also. Each
11019    enumerated type name/value is listed as a child of the enumerated type
11020    DIE.  */
11021
11022 static dw_die_ref
11023 gen_enumeration_type_die (tree type, dw_die_ref context_die)
11024 {
11025   dw_die_ref type_die = lookup_type_die (type);
11026
11027   if (type_die == NULL)
11028     {
11029       type_die = new_die (DW_TAG_enumeration_type,
11030                           scope_die_for (type, context_die), type);
11031       equate_type_number_to_die (type, type_die);
11032       add_name_attribute (type_die, type_tag (type));
11033     }
11034   else if (! TYPE_SIZE (type))
11035     return type_die;
11036   else
11037     remove_AT (type_die, DW_AT_declaration);
11038
11039   /* Handle a GNU C/C++ extension, i.e. incomplete enum types.  If the
11040      given enum type is incomplete, do not generate the DW_AT_byte_size
11041      attribute or the DW_AT_element_list attribute.  */
11042   if (TYPE_SIZE (type))
11043     {
11044       tree link;
11045
11046       TREE_ASM_WRITTEN (type) = 1;
11047       add_byte_size_attribute (type_die, type);
11048       if (TYPE_STUB_DECL (type) != NULL_TREE)
11049         add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
11050
11051       /* If the first reference to this type was as the return type of an
11052          inline function, then it may not have a parent.  Fix this now.  */
11053       if (type_die->die_parent == NULL)
11054         add_child_die (scope_die_for (type, context_die), type_die);
11055
11056       for (link = TYPE_VALUES (type);
11057            link != NULL; link = TREE_CHAIN (link))
11058         {
11059           dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
11060           tree value = TREE_VALUE (link);
11061
11062           add_name_attribute (enum_die,
11063                               IDENTIFIER_POINTER (TREE_PURPOSE (link)));
11064
11065           if (host_integerp (value, TYPE_UNSIGNED (TREE_TYPE (value))))
11066             /* DWARF2 does not provide a way of indicating whether or
11067                not enumeration constants are signed or unsigned.  GDB
11068                always assumes the values are signed, so we output all
11069                values as if they were signed.  That means that
11070                enumeration constants with very large unsigned values
11071                will appear to have negative values in the debugger.  */
11072             add_AT_int (enum_die, DW_AT_const_value,
11073                         tree_low_cst (value, tree_int_cst_sgn (value) > 0));
11074         }
11075     }
11076   else
11077     add_AT_flag (type_die, DW_AT_declaration, 1);
11078
11079   return type_die;
11080 }
11081
11082 /* Generate a DIE to represent either a real live formal parameter decl or to
11083    represent just the type of some formal parameter position in some function
11084    type.
11085
11086    Note that this routine is a bit unusual because its argument may be a
11087    ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
11088    represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
11089    node.  If it's the former then this function is being called to output a
11090    DIE to represent a formal parameter object (or some inlining thereof).  If
11091    it's the latter, then this function is only being called to output a
11092    DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
11093    argument type of some subprogram type.  */
11094
11095 static dw_die_ref
11096 gen_formal_parameter_die (tree node, dw_die_ref context_die)
11097 {
11098   dw_die_ref parm_die
11099     = new_die (DW_TAG_formal_parameter, context_die, node);
11100   tree origin;
11101
11102   switch (TREE_CODE_CLASS (TREE_CODE (node)))
11103     {
11104     case tcc_declaration:
11105       origin = decl_ultimate_origin (node);
11106       if (origin != NULL)
11107         add_abstract_origin_attribute (parm_die, origin);
11108       else
11109         {
11110           add_name_and_src_coords_attributes (parm_die, node);
11111           add_type_attribute (parm_die, TREE_TYPE (node),
11112                               TREE_READONLY (node),
11113                               TREE_THIS_VOLATILE (node),
11114                               context_die);
11115           if (DECL_ARTIFICIAL (node))
11116             add_AT_flag (parm_die, DW_AT_artificial, 1);
11117         }
11118
11119       equate_decl_number_to_die (node, parm_die);
11120       if (! DECL_ABSTRACT (node))
11121         add_location_or_const_value_attribute (parm_die, node, DW_AT_location);
11122
11123       break;
11124
11125     case tcc_type:
11126       /* We were called with some kind of a ..._TYPE node.  */
11127       add_type_attribute (parm_die, node, 0, 0, context_die);
11128       break;
11129
11130     default:
11131       gcc_unreachable ();
11132     }
11133
11134   return parm_die;
11135 }
11136
11137 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
11138    at the end of an (ANSI prototyped) formal parameters list.  */
11139
11140 static void
11141 gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
11142 {
11143   new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
11144 }
11145
11146 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
11147    DW_TAG_unspecified_parameters DIE) to represent the types of the formal
11148    parameters as specified in some function type specification (except for
11149    those which appear as part of a function *definition*).  */
11150
11151 static void
11152 gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
11153 {
11154   tree link;
11155   tree formal_type = NULL;
11156   tree first_parm_type;
11157   tree arg;
11158
11159   if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
11160     {
11161       arg = DECL_ARGUMENTS (function_or_method_type);
11162       function_or_method_type = TREE_TYPE (function_or_method_type);
11163     }
11164   else
11165     arg = NULL_TREE;
11166
11167   first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
11168
11169   /* Make our first pass over the list of formal parameter types and output a
11170      DW_TAG_formal_parameter DIE for each one.  */
11171   for (link = first_parm_type; link; )
11172     {
11173       dw_die_ref parm_die;
11174
11175       formal_type = TREE_VALUE (link);
11176       if (formal_type == void_type_node)
11177         break;
11178
11179       /* Output a (nameless) DIE to represent the formal parameter itself.  */
11180       parm_die = gen_formal_parameter_die (formal_type, context_die);
11181       if ((TREE_CODE (function_or_method_type) == METHOD_TYPE
11182            && link == first_parm_type)
11183           || (arg && DECL_ARTIFICIAL (arg)))
11184         add_AT_flag (parm_die, DW_AT_artificial, 1);
11185
11186       link = TREE_CHAIN (link);
11187       if (arg)
11188         arg = TREE_CHAIN (arg);
11189     }
11190
11191   /* If this function type has an ellipsis, add a
11192      DW_TAG_unspecified_parameters DIE to the end of the parameter list.  */
11193   if (formal_type != void_type_node)
11194     gen_unspecified_parameters_die (function_or_method_type, context_die);
11195
11196   /* Make our second (and final) pass over the list of formal parameter types
11197      and output DIEs to represent those types (as necessary).  */
11198   for (link = TYPE_ARG_TYPES (function_or_method_type);
11199        link && TREE_VALUE (link);
11200        link = TREE_CHAIN (link))
11201     gen_type_die (TREE_VALUE (link), context_die);
11202 }
11203
11204 /* We want to generate the DIE for TYPE so that we can generate the
11205    die for MEMBER, which has been defined; we will need to refer back
11206    to the member declaration nested within TYPE.  If we're trying to
11207    generate minimal debug info for TYPE, processing TYPE won't do the
11208    trick; we need to attach the member declaration by hand.  */
11209
11210 static void
11211 gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
11212 {
11213   gen_type_die (type, context_die);
11214
11215   /* If we're trying to avoid duplicate debug info, we may not have
11216      emitted the member decl for this function.  Emit it now.  */
11217   if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
11218       && ! lookup_decl_die (member))
11219     {
11220       dw_die_ref type_die;
11221       gcc_assert (!decl_ultimate_origin (member));
11222
11223       push_decl_scope (type);
11224       type_die = lookup_type_die (type);
11225       if (TREE_CODE (member) == FUNCTION_DECL)
11226         gen_subprogram_die (member, type_die);
11227       else if (TREE_CODE (member) == FIELD_DECL)
11228         {
11229           /* Ignore the nameless fields that are used to skip bits but handle
11230              C++ anonymous unions and structs.  */
11231           if (DECL_NAME (member) != NULL_TREE
11232               || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE
11233               || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE)
11234             {
11235               gen_type_die (member_declared_type (member), type_die);
11236               gen_field_die (member, type_die);
11237             }
11238         }
11239       else
11240         gen_variable_die (member, type_die);
11241
11242       pop_decl_scope ();
11243     }
11244 }
11245
11246 /* Generate the DWARF2 info for the "abstract" instance of a function which we
11247    may later generate inlined and/or out-of-line instances of.  */
11248
11249 static void
11250 dwarf2out_abstract_function (tree decl)
11251 {
11252   dw_die_ref old_die;
11253   tree save_fn;
11254   tree context;
11255   int was_abstract = DECL_ABSTRACT (decl);
11256
11257   /* Make sure we have the actual abstract inline, not a clone.  */
11258   decl = DECL_ORIGIN (decl);
11259
11260   old_die = lookup_decl_die (decl);
11261   if (old_die && get_AT (old_die, DW_AT_inline))
11262     /* We've already generated the abstract instance.  */
11263     return;
11264
11265   /* Be sure we've emitted the in-class declaration DIE (if any) first, so
11266      we don't get confused by DECL_ABSTRACT.  */
11267   if (debug_info_level > DINFO_LEVEL_TERSE)
11268     {
11269       context = decl_class_context (decl);
11270       if (context)
11271         gen_type_die_for_member
11272           (context, decl, decl_function_context (decl) ? NULL : comp_unit_die);
11273     }
11274
11275   /* Pretend we've just finished compiling this function.  */
11276   save_fn = current_function_decl;
11277   current_function_decl = decl;
11278
11279   set_decl_abstract_flags (decl, 1);
11280   dwarf2out_decl (decl);
11281   if (! was_abstract)
11282     set_decl_abstract_flags (decl, 0);
11283
11284   current_function_decl = save_fn;
11285 }
11286
11287 /* Generate a DIE to represent a declared function (either file-scope or
11288    block-local).  */
11289
11290 static void
11291 gen_subprogram_die (tree decl, dw_die_ref context_die)
11292 {
11293   char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
11294   tree origin = decl_ultimate_origin (decl);
11295   dw_die_ref subr_die;
11296   rtx fp_reg;
11297   tree fn_arg_types;
11298   tree outer_scope;
11299   dw_die_ref old_die = lookup_decl_die (decl);
11300   int declaration = (current_function_decl != decl
11301                      || class_or_namespace_scope_p (context_die));
11302
11303   /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
11304      started to generate the abstract instance of an inline, decided to output
11305      its containing class, and proceeded to emit the declaration of the inline
11306      from the member list for the class.  If so, DECLARATION takes priority;
11307      we'll get back to the abstract instance when done with the class.  */
11308
11309   /* The class-scope declaration DIE must be the primary DIE.  */
11310   if (origin && declaration && class_or_namespace_scope_p (context_die))
11311     {
11312       origin = NULL;
11313       gcc_assert (!old_die);
11314     }
11315
11316   if (origin != NULL)
11317     {
11318       gcc_assert (!declaration || local_scope_p (context_die));
11319
11320       /* Fixup die_parent for the abstract instance of a nested
11321          inline function.  */
11322       if (old_die && old_die->die_parent == NULL)
11323         add_child_die (context_die, old_die);
11324
11325       subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11326       add_abstract_origin_attribute (subr_die, origin);
11327     }
11328   else if (old_die)
11329     {
11330       expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
11331       unsigned file_index = lookup_filename (s.file);
11332
11333       if (!get_AT_flag (old_die, DW_AT_declaration)
11334           /* We can have a normal definition following an inline one in the
11335              case of redefinition of GNU C extern inlines.
11336              It seems reasonable to use AT_specification in this case.  */
11337           && !get_AT (old_die, DW_AT_inline))
11338         {
11339           /* Detect and ignore this case, where we are trying to output
11340              something we have already output.  */
11341           return;
11342         }
11343
11344       /* If the definition comes from the same place as the declaration,
11345          maybe use the old DIE.  We always want the DIE for this function
11346          that has the *_pc attributes to be under comp_unit_die so the
11347          debugger can find it.  We also need to do this for abstract
11348          instances of inlines, since the spec requires the out-of-line copy
11349          to have the same parent.  For local class methods, this doesn't
11350          apply; we just use the old DIE.  */
11351       if ((old_die->die_parent == comp_unit_die || context_die == NULL)
11352           && (DECL_ARTIFICIAL (decl)
11353               || (get_AT_unsigned (old_die, DW_AT_decl_file) == file_index
11354                   && (get_AT_unsigned (old_die, DW_AT_decl_line)
11355                       == (unsigned) s.line))))
11356         {
11357           subr_die = old_die;
11358
11359           /* Clear out the declaration attribute and the formal parameters.
11360              Do not remove all children, because it is possible that this
11361              declaration die was forced using force_decl_die(). In such
11362              cases die that forced declaration die (e.g. TAG_imported_module)
11363              is one of the children that we do not want to remove.  */
11364           remove_AT (subr_die, DW_AT_declaration);
11365           remove_child_TAG (subr_die, DW_TAG_formal_parameter);
11366         }
11367       else
11368         {
11369           subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11370           add_AT_specification (subr_die, old_die);
11371           if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
11372             add_AT_unsigned (subr_die, DW_AT_decl_file, file_index);
11373           if (get_AT_unsigned (old_die, DW_AT_decl_line)
11374               != (unsigned) s.line)
11375             add_AT_unsigned
11376               (subr_die, DW_AT_decl_line, s.line);
11377         }
11378     }
11379   else
11380     {
11381       subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11382
11383       if (TREE_PUBLIC (decl))
11384         add_AT_flag (subr_die, DW_AT_external, 1);
11385
11386       add_name_and_src_coords_attributes (subr_die, decl);
11387       if (debug_info_level > DINFO_LEVEL_TERSE)
11388         {
11389           add_prototyped_attribute (subr_die, TREE_TYPE (decl));
11390           add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
11391                               0, 0, context_die);
11392         }
11393
11394       add_pure_or_virtual_attribute (subr_die, decl);
11395       if (DECL_ARTIFICIAL (decl))
11396         add_AT_flag (subr_die, DW_AT_artificial, 1);
11397
11398       if (TREE_PROTECTED (decl))
11399         add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
11400       else if (TREE_PRIVATE (decl))
11401         add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
11402     }
11403
11404   if (declaration)
11405     {
11406       if (!old_die || !get_AT (old_die, DW_AT_inline))
11407         {
11408           add_AT_flag (subr_die, DW_AT_declaration, 1);
11409
11410           /* The first time we see a member function, it is in the context of
11411              the class to which it belongs.  We make sure of this by emitting
11412              the class first.  The next time is the definition, which is
11413              handled above.  The two may come from the same source text.
11414
11415              Note that force_decl_die() forces function declaration die. It is
11416              later reused to represent definition.  */
11417             equate_decl_number_to_die (decl, subr_die);
11418         }
11419     }
11420   else if (DECL_ABSTRACT (decl))
11421     {
11422       if (DECL_DECLARED_INLINE_P (decl))
11423         {
11424           if (cgraph_function_possibly_inlined_p (decl))
11425             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
11426           else
11427             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
11428         }
11429       else
11430         {
11431           if (cgraph_function_possibly_inlined_p (decl))
11432             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
11433           else
11434             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
11435         }
11436
11437       equate_decl_number_to_die (decl, subr_die);
11438     }
11439   else if (!DECL_EXTERNAL (decl))
11440     {
11441       if (!old_die || !get_AT (old_die, DW_AT_inline))
11442         equate_decl_number_to_die (decl, subr_die);
11443
11444       if (!flag_reorder_blocks_and_partition)
11445         {
11446           ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
11447                                        current_function_funcdef_no);
11448           add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
11449           ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
11450                                        current_function_funcdef_no);
11451           add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
11452
11453           add_pubname (decl, subr_die);
11454           add_arange (decl, subr_die);
11455         }
11456       else
11457         {  /* Do nothing for now; maybe need to duplicate die, one for
11458               hot section and ond for cold section, then use the hot/cold
11459               section begin/end labels to generate the aranges...  */
11460           /*
11461             add_AT_lbl_id (subr_die, DW_AT_low_pc, hot_section_label);
11462             add_AT_lbl_id (subr_die, DW_AT_high_pc, hot_section_end_label);
11463             add_AT_lbl_id (subr_die, DW_AT_lo_user, unlikely_section_label);
11464             add_AT_lbl_id (subr_die, DW_AT_hi_user, cold_section_end_label);
11465
11466             add_pubname (decl, subr_die);
11467             add_arange (decl, subr_die);
11468             add_arange (decl, subr_die);
11469            */
11470         }
11471
11472 #ifdef MIPS_DEBUGGING_INFO
11473       /* Add a reference to the FDE for this routine.  */
11474       add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
11475 #endif
11476
11477       /* Define the "frame base" location for this routine.  We use the
11478          frame pointer or stack pointer registers, since the RTL for local
11479          variables is relative to one of them.  */
11480       if (frame_base_decl && lookup_decl_loc (frame_base_decl) != NULL)
11481         {
11482           add_location_or_const_value_attribute (subr_die, frame_base_decl,
11483                                                  DW_AT_frame_base);
11484         }
11485       else
11486         {
11487           fp_reg
11488             = frame_pointer_needed ? hard_frame_pointer_rtx : stack_pointer_rtx;
11489           add_AT_loc (subr_die, DW_AT_frame_base, reg_loc_descriptor (fp_reg));
11490         }
11491
11492       if (cfun->static_chain_decl)
11493         add_AT_location_description (subr_die, DW_AT_static_link,
11494                  loc_descriptor_from_tree (cfun->static_chain_decl));
11495     }
11496
11497   /* Now output descriptions of the arguments for this function. This gets
11498      (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
11499      for a FUNCTION_DECL doesn't indicate cases where there was a trailing
11500      `...' at the end of the formal parameter list.  In order to find out if
11501      there was a trailing ellipsis or not, we must instead look at the type
11502      associated with the FUNCTION_DECL.  This will be a node of type
11503      FUNCTION_TYPE. If the chain of type nodes hanging off of this
11504      FUNCTION_TYPE node ends with a void_type_node then there should *not* be
11505      an ellipsis at the end.  */
11506
11507   /* In the case where we are describing a mere function declaration, all we
11508      need to do here (and all we *can* do here) is to describe the *types* of
11509      its formal parameters.  */
11510   if (debug_info_level <= DINFO_LEVEL_TERSE)
11511     ;
11512   else if (declaration)
11513     gen_formal_types_die (decl, subr_die);
11514   else
11515     {
11516       /* Generate DIEs to represent all known formal parameters.  */
11517       tree arg_decls = DECL_ARGUMENTS (decl);
11518       tree parm;
11519
11520       /* When generating DIEs, generate the unspecified_parameters DIE
11521          instead if we come across the arg "__builtin_va_alist" */
11522       for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
11523         if (TREE_CODE (parm) == PARM_DECL)
11524           {
11525             if (DECL_NAME (parm)
11526                 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
11527                             "__builtin_va_alist"))
11528               gen_unspecified_parameters_die (parm, subr_die);
11529             else
11530               gen_decl_die (parm, subr_die);
11531           }
11532
11533       /* Decide whether we need an unspecified_parameters DIE at the end.
11534          There are 2 more cases to do this for: 1) the ansi ... declaration -
11535          this is detectable when the end of the arg list is not a
11536          void_type_node 2) an unprototyped function declaration (not a
11537          definition).  This just means that we have no info about the
11538          parameters at all.  */
11539       fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
11540       if (fn_arg_types != NULL)
11541         {
11542           /* This is the prototyped case, check for....  */
11543           if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
11544             gen_unspecified_parameters_die (decl, subr_die);
11545         }
11546       else if (DECL_INITIAL (decl) == NULL_TREE)
11547         gen_unspecified_parameters_die (decl, subr_die);
11548     }
11549
11550   /* Output Dwarf info for all of the stuff within the body of the function
11551      (if it has one - it may be just a declaration).  */
11552   outer_scope = DECL_INITIAL (decl);
11553
11554   /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
11555      a function.  This BLOCK actually represents the outermost binding contour
11556      for the function, i.e. the contour in which the function's formal
11557      parameters and labels get declared. Curiously, it appears that the front
11558      end doesn't actually put the PARM_DECL nodes for the current function onto
11559      the BLOCK_VARS list for this outer scope, but are strung off of the
11560      DECL_ARGUMENTS list for the function instead.
11561
11562      The BLOCK_VARS list for the `outer_scope' does provide us with a list of
11563      the LABEL_DECL nodes for the function however, and we output DWARF info
11564      for those in decls_for_scope.  Just within the `outer_scope' there will be
11565      a BLOCK node representing the function's outermost pair of curly braces,
11566      and any blocks used for the base and member initializers of a C++
11567      constructor function.  */
11568   if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
11569     {
11570       /* Emit a DW_TAG_variable DIE for a named return value.  */
11571       if (DECL_NAME (DECL_RESULT (decl)))
11572         gen_decl_die (DECL_RESULT (decl), subr_die);
11573
11574       current_function_has_inlines = 0;
11575       decls_for_scope (outer_scope, subr_die, 0);
11576
11577 #if 0 && defined (MIPS_DEBUGGING_INFO)
11578       if (current_function_has_inlines)
11579         {
11580           add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
11581           if (! comp_unit_has_inlines)
11582             {
11583               add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
11584               comp_unit_has_inlines = 1;
11585             }
11586         }
11587 #endif
11588     }
11589   /* Add the calling convention attribute if requested.  */
11590   add_calling_convention_attribute (subr_die, TREE_TYPE (decl));
11591
11592 }
11593
11594 /* Generate a DIE to represent a declared data object.  */
11595
11596 static void
11597 gen_variable_die (tree decl, dw_die_ref context_die)
11598 {
11599   tree origin = decl_ultimate_origin (decl);
11600   dw_die_ref var_die = new_die (DW_TAG_variable, context_die, decl);
11601
11602   dw_die_ref old_die = lookup_decl_die (decl);
11603   int declaration = (DECL_EXTERNAL (decl)
11604                      || class_or_namespace_scope_p (context_die));
11605
11606   if (origin != NULL)
11607     add_abstract_origin_attribute (var_die, origin);
11608
11609   /* Loop unrolling can create multiple blocks that refer to the same
11610      static variable, so we must test for the DW_AT_declaration flag.
11611
11612      ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
11613      copy decls and set the DECL_ABSTRACT flag on them instead of
11614      sharing them.
11615
11616      ??? Duplicated blocks have been rewritten to use .debug_ranges.  */
11617   else if (old_die && TREE_STATIC (decl)
11618            && get_AT_flag (old_die, DW_AT_declaration) == 1)
11619     {
11620       /* This is a definition of a C++ class level static.  */
11621       add_AT_specification (var_die, old_die);
11622       if (DECL_NAME (decl))
11623         {
11624           expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
11625           unsigned file_index = lookup_filename (s.file);
11626
11627           if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
11628             add_AT_unsigned (var_die, DW_AT_decl_file, file_index);
11629
11630           if (get_AT_unsigned (old_die, DW_AT_decl_line)
11631               != (unsigned) s.line)
11632
11633             add_AT_unsigned (var_die, DW_AT_decl_line, s.line);
11634         }
11635     }
11636   else
11637     {
11638       add_name_and_src_coords_attributes (var_die, decl);
11639       add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl),
11640                           TREE_THIS_VOLATILE (decl), context_die);
11641
11642       if (TREE_PUBLIC (decl))
11643         add_AT_flag (var_die, DW_AT_external, 1);
11644
11645       if (DECL_ARTIFICIAL (decl))
11646         add_AT_flag (var_die, DW_AT_artificial, 1);
11647
11648       if (TREE_PROTECTED (decl))
11649         add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
11650       else if (TREE_PRIVATE (decl))
11651         add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
11652     }
11653
11654   if (declaration)
11655     add_AT_flag (var_die, DW_AT_declaration, 1);
11656
11657   if (DECL_ABSTRACT (decl) || declaration)
11658     equate_decl_number_to_die (decl, var_die);
11659
11660   if (! declaration && ! DECL_ABSTRACT (decl))
11661     {
11662       add_location_or_const_value_attribute (var_die, decl, DW_AT_location);
11663       add_pubname (decl, var_die);
11664     }
11665   else
11666     tree_add_const_value_attribute (var_die, decl);
11667 }
11668
11669 /* Generate a DIE to represent a label identifier.  */
11670
11671 static void
11672 gen_label_die (tree decl, dw_die_ref context_die)
11673 {
11674   tree origin = decl_ultimate_origin (decl);
11675   dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
11676   rtx insn;
11677   char label[MAX_ARTIFICIAL_LABEL_BYTES];
11678
11679   if (origin != NULL)
11680     add_abstract_origin_attribute (lbl_die, origin);
11681   else
11682     add_name_and_src_coords_attributes (lbl_die, decl);
11683
11684   if (DECL_ABSTRACT (decl))
11685     equate_decl_number_to_die (decl, lbl_die);
11686   else
11687     {
11688       insn = DECL_RTL_IF_SET (decl);
11689
11690       /* Deleted labels are programmer specified labels which have been
11691          eliminated because of various optimizations.  We still emit them
11692          here so that it is possible to put breakpoints on them.  */
11693       if (insn
11694           && (LABEL_P (insn)
11695               || ((NOTE_P (insn)
11696                    && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL))))
11697         {
11698           /* When optimization is enabled (via -O) some parts of the compiler
11699              (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
11700              represent source-level labels which were explicitly declared by
11701              the user.  This really shouldn't be happening though, so catch
11702              it if it ever does happen.  */
11703           gcc_assert (!INSN_DELETED_P (insn));
11704
11705           ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
11706           add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
11707         }
11708     }
11709 }
11710
11711 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
11712    Add low_pc and high_pc attributes to the DIE for a block STMT.  */
11713
11714 static inline void
11715 add_high_low_attributes (tree stmt, dw_die_ref die)
11716 {
11717   char label[MAX_ARTIFICIAL_LABEL_BYTES];
11718
11719   if (BLOCK_FRAGMENT_CHAIN (stmt))
11720     {
11721       tree chain;
11722
11723       add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt));
11724
11725       chain = BLOCK_FRAGMENT_CHAIN (stmt);
11726       do
11727         {
11728           add_ranges (chain);
11729           chain = BLOCK_FRAGMENT_CHAIN (chain);
11730         }
11731       while (chain);
11732       add_ranges (NULL);
11733     }
11734   else
11735     {
11736       ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
11737                                    BLOCK_NUMBER (stmt));
11738       add_AT_lbl_id (die, DW_AT_low_pc, label);
11739       ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
11740                                    BLOCK_NUMBER (stmt));
11741       add_AT_lbl_id (die, DW_AT_high_pc, label);
11742     }
11743 }
11744
11745 /* Generate a DIE for a lexical block.  */
11746
11747 static void
11748 gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth)
11749 {
11750   dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
11751
11752   if (! BLOCK_ABSTRACT (stmt))
11753     add_high_low_attributes (stmt, stmt_die);
11754
11755   decls_for_scope (stmt, stmt_die, depth);
11756 }
11757
11758 /* Generate a DIE for an inlined subprogram.  */
11759
11760 static void
11761 gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth)
11762 {
11763   tree decl = block_ultimate_origin (stmt);
11764
11765   /* Emit info for the abstract instance first, if we haven't yet.  We
11766      must emit this even if the block is abstract, otherwise when we
11767      emit the block below (or elsewhere), we may end up trying to emit
11768      a die whose origin die hasn't been emitted, and crashing.  */
11769   dwarf2out_abstract_function (decl);
11770
11771   if (! BLOCK_ABSTRACT (stmt))
11772     {
11773       dw_die_ref subr_die
11774         = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
11775
11776       add_abstract_origin_attribute (subr_die, decl);
11777       add_high_low_attributes (stmt, subr_die);
11778
11779       decls_for_scope (stmt, subr_die, depth);
11780       current_function_has_inlines = 1;
11781     }
11782   else
11783     /* We may get here if we're the outer block of function A that was
11784        inlined into function B that was inlined into function C.  When
11785        generating debugging info for C, dwarf2out_abstract_function(B)
11786        would mark all inlined blocks as abstract, including this one.
11787        So, we wouldn't (and shouldn't) expect labels to be generated
11788        for this one.  Instead, just emit debugging info for
11789        declarations within the block.  This is particularly important
11790        in the case of initializers of arguments passed from B to us:
11791        if they're statement expressions containing declarations, we
11792        wouldn't generate dies for their abstract variables, and then,
11793        when generating dies for the real variables, we'd die (pun
11794        intended :-)  */
11795     gen_lexical_block_die (stmt, context_die, depth);
11796 }
11797
11798 /* Generate a DIE for a field in a record, or structure.  */
11799
11800 static void
11801 gen_field_die (tree decl, dw_die_ref context_die)
11802 {
11803   dw_die_ref decl_die;
11804
11805   if (TREE_TYPE (decl) == error_mark_node)
11806     return;
11807
11808   decl_die = new_die (DW_TAG_member, context_die, decl);
11809   add_name_and_src_coords_attributes (decl_die, decl);
11810   add_type_attribute (decl_die, member_declared_type (decl),
11811                       TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
11812                       context_die);
11813
11814   if (DECL_BIT_FIELD_TYPE (decl))
11815     {
11816       add_byte_size_attribute (decl_die, decl);
11817       add_bit_size_attribute (decl_die, decl);
11818       add_bit_offset_attribute (decl_die, decl);
11819     }
11820
11821   if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
11822     add_data_member_location_attribute (decl_die, decl);
11823
11824   if (DECL_ARTIFICIAL (decl))
11825     add_AT_flag (decl_die, DW_AT_artificial, 1);
11826
11827   if (TREE_PROTECTED (decl))
11828     add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
11829   else if (TREE_PRIVATE (decl))
11830     add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
11831
11832   /* Equate decl number to die, so that we can look up this decl later on.  */
11833   equate_decl_number_to_die (decl, decl_die);
11834 }
11835
11836 #if 0
11837 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
11838    Use modified_type_die instead.
11839    We keep this code here just in case these types of DIEs may be needed to
11840    represent certain things in other languages (e.g. Pascal) someday.  */
11841
11842 static void
11843 gen_pointer_type_die (tree type, dw_die_ref context_die)
11844 {
11845   dw_die_ref ptr_die
11846     = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
11847
11848   equate_type_number_to_die (type, ptr_die);
11849   add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
11850   add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
11851 }
11852
11853 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
11854    Use modified_type_die instead.
11855    We keep this code here just in case these types of DIEs may be needed to
11856    represent certain things in other languages (e.g. Pascal) someday.  */
11857
11858 static void
11859 gen_reference_type_die (tree type, dw_die_ref context_die)
11860 {
11861   dw_die_ref ref_die
11862     = new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type);
11863
11864   equate_type_number_to_die (type, ref_die);
11865   add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
11866   add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
11867 }
11868 #endif
11869
11870 /* Generate a DIE for a pointer to a member type.  */
11871
11872 static void
11873 gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
11874 {
11875   dw_die_ref ptr_die
11876     = new_die (DW_TAG_ptr_to_member_type,
11877                scope_die_for (type, context_die), type);
11878
11879   equate_type_number_to_die (type, ptr_die);
11880   add_AT_die_ref (ptr_die, DW_AT_containing_type,
11881                   lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
11882   add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
11883 }
11884
11885 /* Generate the DIE for the compilation unit.  */
11886
11887 static dw_die_ref
11888 gen_compile_unit_die (const char *filename)
11889 {
11890   dw_die_ref die;
11891   char producer[250];
11892   const char *language_string = lang_hooks.name;
11893   int language;
11894
11895   die = new_die (DW_TAG_compile_unit, NULL, NULL);
11896
11897   if (filename)
11898     {
11899       add_name_attribute (die, filename);
11900       /* Don't add cwd for <built-in>.  */
11901       if (filename[0] != DIR_SEPARATOR && filename[0] != '<')
11902         add_comp_dir_attribute (die);
11903     }
11904
11905   sprintf (producer, "%s %s", language_string, version_string);
11906
11907 #ifdef MIPS_DEBUGGING_INFO
11908   /* The MIPS/SGI compilers place the 'cc' command line options in the producer
11909      string.  The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
11910      not appear in the producer string, the debugger reaches the conclusion
11911      that the object file is stripped and has no debugging information.
11912      To get the MIPS/SGI debugger to believe that there is debugging
11913      information in the object file, we add a -g to the producer string.  */
11914   if (debug_info_level > DINFO_LEVEL_TERSE)
11915     strcat (producer, " -g");
11916 #endif
11917
11918   add_AT_string (die, DW_AT_producer, producer);
11919
11920   if (strcmp (language_string, "GNU C++") == 0)
11921     language = DW_LANG_C_plus_plus;
11922   else if (strcmp (language_string, "GNU Ada") == 0)
11923     language = DW_LANG_Ada95;
11924   else if (strcmp (language_string, "GNU F77") == 0)
11925     language = DW_LANG_Fortran77;
11926   else if (strcmp (language_string, "GNU F95") == 0)
11927     language = DW_LANG_Fortran95;
11928   else if (strcmp (language_string, "GNU Pascal") == 0)
11929     language = DW_LANG_Pascal83;
11930   else if (strcmp (language_string, "GNU Java") == 0)
11931     language = DW_LANG_Java;
11932   else
11933     language = DW_LANG_C89;
11934
11935   add_AT_unsigned (die, DW_AT_language, language);
11936   return die;
11937 }
11938
11939 /* Generate a DIE for a string type.  */
11940
11941 static void
11942 gen_string_type_die (tree type, dw_die_ref context_die)
11943 {
11944   dw_die_ref type_die
11945     = new_die (DW_TAG_string_type, scope_die_for (type, context_die), type);
11946
11947   equate_type_number_to_die (type, type_die);
11948
11949   /* ??? Fudge the string length attribute for now.
11950      TODO: add string length info.  */
11951 #if 0
11952   string_length_attribute (TYPE_MAX_VALUE (TYPE_DOMAIN (type)));
11953   bound_representation (upper_bound, 0, 'u');
11954 #endif
11955 }
11956
11957 /* Generate the DIE for a base class.  */
11958
11959 static void
11960 gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
11961 {
11962   dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
11963
11964   add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
11965   add_data_member_location_attribute (die, binfo);
11966
11967   if (BINFO_VIRTUAL_P (binfo))
11968     add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
11969
11970   if (access == access_public_node)
11971     add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
11972   else if (access == access_protected_node)
11973     add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
11974 }
11975
11976 /* Generate a DIE for a class member.  */
11977
11978 static void
11979 gen_member_die (tree type, dw_die_ref context_die)
11980 {
11981   tree member;
11982   tree binfo = TYPE_BINFO (type);
11983   dw_die_ref child;
11984
11985   /* If this is not an incomplete type, output descriptions of each of its
11986      members. Note that as we output the DIEs necessary to represent the
11987      members of this record or union type, we will also be trying to output
11988      DIEs to represent the *types* of those members. However the `type'
11989      function (above) will specifically avoid generating type DIEs for member
11990      types *within* the list of member DIEs for this (containing) type except
11991      for those types (of members) which are explicitly marked as also being
11992      members of this (containing) type themselves.  The g++ front- end can
11993      force any given type to be treated as a member of some other (containing)
11994      type by setting the TYPE_CONTEXT of the given (member) type to point to
11995      the TREE node representing the appropriate (containing) type.  */
11996
11997   /* First output info about the base classes.  */
11998   if (binfo)
11999     {
12000       VEC (tree) *accesses = BINFO_BASE_ACCESSES (binfo);
12001       int i;
12002       tree base;
12003
12004       for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++)
12005         gen_inheritance_die (base,
12006                              (accesses ? VEC_index (tree, accesses, i)
12007                               : access_public_node), context_die);
12008     }
12009
12010   /* Now output info about the data members and type members.  */
12011   for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
12012     {
12013       /* If we thought we were generating minimal debug info for TYPE
12014          and then changed our minds, some of the member declarations
12015          may have already been defined.  Don't define them again, but
12016          do put them in the right order.  */
12017
12018       child = lookup_decl_die (member);
12019       if (child)
12020         splice_child_die (context_die, child);
12021       else
12022         gen_decl_die (member, context_die);
12023     }
12024
12025   /* Now output info about the function members (if any).  */
12026   for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
12027     {
12028       /* Don't include clones in the member list.  */
12029       if (DECL_ABSTRACT_ORIGIN (member))
12030         continue;
12031
12032       child = lookup_decl_die (member);
12033       if (child)
12034         splice_child_die (context_die, child);
12035       else
12036         gen_decl_die (member, context_die);
12037     }
12038 }
12039
12040 /* Generate a DIE for a structure or union type.  If TYPE_DECL_SUPPRESS_DEBUG
12041    is set, we pretend that the type was never defined, so we only get the
12042    member DIEs needed by later specification DIEs.  */
12043
12044 static void
12045 gen_struct_or_union_type_die (tree type, dw_die_ref context_die)
12046 {
12047   dw_die_ref type_die = lookup_type_die (type);
12048   dw_die_ref scope_die = 0;
12049   int nested = 0;
12050   int complete = (TYPE_SIZE (type)
12051                   && (! TYPE_STUB_DECL (type)
12052                       || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
12053   int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace);
12054
12055   if (type_die && ! complete)
12056     return;
12057
12058   if (TYPE_CONTEXT (type) != NULL_TREE
12059       && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
12060           || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL))
12061     nested = 1;
12062
12063   scope_die = scope_die_for (type, context_die);
12064
12065   if (! type_die || (nested && scope_die == comp_unit_die))
12066     /* First occurrence of type or toplevel definition of nested class.  */
12067     {
12068       dw_die_ref old_die = type_die;
12069
12070       type_die = new_die (TREE_CODE (type) == RECORD_TYPE
12071                           ? DW_TAG_structure_type : DW_TAG_union_type,
12072                           scope_die, type);
12073       equate_type_number_to_die (type, type_die);
12074       if (old_die)
12075         add_AT_specification (type_die, old_die);
12076       else
12077         add_name_attribute (type_die, type_tag (type));
12078     }
12079   else
12080     remove_AT (type_die, DW_AT_declaration);
12081
12082   /* If this type has been completed, then give it a byte_size attribute and
12083      then give a list of members.  */
12084   if (complete && !ns_decl)
12085     {
12086       /* Prevent infinite recursion in cases where the type of some member of
12087          this type is expressed in terms of this type itself.  */
12088       TREE_ASM_WRITTEN (type) = 1;
12089       add_byte_size_attribute (type_die, type);
12090       if (TYPE_STUB_DECL (type) != NULL_TREE)
12091         add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
12092
12093       /* If the first reference to this type was as the return type of an
12094          inline function, then it may not have a parent.  Fix this now.  */
12095       if (type_die->die_parent == NULL)
12096         add_child_die (scope_die, type_die);
12097
12098       push_decl_scope (type);
12099       gen_member_die (type, type_die);
12100       pop_decl_scope ();
12101
12102       /* GNU extension: Record what type our vtable lives in.  */
12103       if (TYPE_VFIELD (type))
12104         {
12105           tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
12106
12107           gen_type_die (vtype, context_die);
12108           add_AT_die_ref (type_die, DW_AT_containing_type,
12109                           lookup_type_die (vtype));
12110         }
12111     }
12112   else
12113     {
12114       add_AT_flag (type_die, DW_AT_declaration, 1);
12115
12116       /* We don't need to do this for function-local types.  */
12117       if (TYPE_STUB_DECL (type)
12118           && ! decl_function_context (TYPE_STUB_DECL (type)))
12119         VARRAY_PUSH_TREE (incomplete_types, type);
12120     }
12121 }
12122
12123 /* Generate a DIE for a subroutine _type_.  */
12124
12125 static void
12126 gen_subroutine_type_die (tree type, dw_die_ref context_die)
12127 {
12128   tree return_type = TREE_TYPE (type);
12129   dw_die_ref subr_die
12130     = new_die (DW_TAG_subroutine_type,
12131                scope_die_for (type, context_die), type);
12132
12133   equate_type_number_to_die (type, subr_die);
12134   add_prototyped_attribute (subr_die, type);
12135   add_type_attribute (subr_die, return_type, 0, 0, context_die);
12136   gen_formal_types_die (type, subr_die);
12137 }
12138
12139 /* Generate a DIE for a type definition.  */
12140
12141 static void
12142 gen_typedef_die (tree decl, dw_die_ref context_die)
12143 {
12144   dw_die_ref type_die;
12145   tree origin;
12146
12147   if (TREE_ASM_WRITTEN (decl))
12148     return;
12149
12150   TREE_ASM_WRITTEN (decl) = 1;
12151   type_die = new_die (DW_TAG_typedef, context_die, decl);
12152   origin = decl_ultimate_origin (decl);
12153   if (origin != NULL)
12154     add_abstract_origin_attribute (type_die, origin);
12155   else
12156     {
12157       tree type;
12158
12159       add_name_and_src_coords_attributes (type_die, decl);
12160       if (DECL_ORIGINAL_TYPE (decl))
12161         {
12162           type = DECL_ORIGINAL_TYPE (decl);
12163
12164           gcc_assert (type != TREE_TYPE (decl));
12165           equate_type_number_to_die (TREE_TYPE (decl), type_die);
12166         }
12167       else
12168         type = TREE_TYPE (decl);
12169
12170       add_type_attribute (type_die, type, TREE_READONLY (decl),
12171                           TREE_THIS_VOLATILE (decl), context_die);
12172     }
12173
12174   if (DECL_ABSTRACT (decl))
12175     equate_decl_number_to_die (decl, type_die);
12176 }
12177
12178 /* Generate a type description DIE.  */
12179
12180 static void
12181 gen_type_die (tree type, dw_die_ref context_die)
12182 {
12183   int need_pop;
12184
12185   if (type == NULL_TREE || type == error_mark_node)
12186     return;
12187
12188   if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
12189       && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
12190     {
12191       if (TREE_ASM_WRITTEN (type))
12192         return;
12193
12194       /* Prevent broken recursion; we can't hand off to the same type.  */
12195       gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
12196
12197       TREE_ASM_WRITTEN (type) = 1;
12198       gen_decl_die (TYPE_NAME (type), context_die);
12199       return;
12200     }
12201
12202   /* We are going to output a DIE to represent the unqualified version
12203      of this type (i.e. without any const or volatile qualifiers) so
12204      get the main variant (i.e. the unqualified version) of this type
12205      now.  (Vectors are special because the debugging info is in the
12206      cloned type itself).  */
12207   if (TREE_CODE (type) != VECTOR_TYPE)
12208     type = type_main_variant (type);
12209
12210   if (TREE_ASM_WRITTEN (type))
12211     return;
12212
12213   switch (TREE_CODE (type))
12214     {
12215     case ERROR_MARK:
12216       break;
12217
12218     case POINTER_TYPE:
12219     case REFERENCE_TYPE:
12220       /* We must set TREE_ASM_WRITTEN in case this is a recursive type.  This
12221          ensures that the gen_type_die recursion will terminate even if the
12222          type is recursive.  Recursive types are possible in Ada.  */
12223       /* ??? We could perhaps do this for all types before the switch
12224          statement.  */
12225       TREE_ASM_WRITTEN (type) = 1;
12226
12227       /* For these types, all that is required is that we output a DIE (or a
12228          set of DIEs) to represent the "basis" type.  */
12229       gen_type_die (TREE_TYPE (type), context_die);
12230       break;
12231
12232     case OFFSET_TYPE:
12233       /* This code is used for C++ pointer-to-data-member types.
12234          Output a description of the relevant class type.  */
12235       gen_type_die (TYPE_OFFSET_BASETYPE (type), context_die);
12236
12237       /* Output a description of the type of the object pointed to.  */
12238       gen_type_die (TREE_TYPE (type), context_die);
12239
12240       /* Now output a DIE to represent this pointer-to-data-member type
12241          itself.  */
12242       gen_ptr_to_mbr_type_die (type, context_die);
12243       break;
12244
12245     case FUNCTION_TYPE:
12246       /* Force out return type (in case it wasn't forced out already).  */
12247       gen_type_die (TREE_TYPE (type), context_die);
12248       gen_subroutine_type_die (type, context_die);
12249       break;
12250
12251     case METHOD_TYPE:
12252       /* Force out return type (in case it wasn't forced out already).  */
12253       gen_type_die (TREE_TYPE (type), context_die);
12254       gen_subroutine_type_die (type, context_die);
12255       break;
12256
12257     case ARRAY_TYPE:
12258       if (TYPE_STRING_FLAG (type) && TREE_CODE (TREE_TYPE (type)) == CHAR_TYPE)
12259         {
12260           gen_type_die (TREE_TYPE (type), context_die);
12261           gen_string_type_die (type, context_die);
12262         }
12263       else
12264         gen_array_type_die (type, context_die);
12265       break;
12266
12267     case VECTOR_TYPE:
12268       gen_array_type_die (type, context_die);
12269       break;
12270
12271     case ENUMERAL_TYPE:
12272     case RECORD_TYPE:
12273     case UNION_TYPE:
12274     case QUAL_UNION_TYPE:
12275       /* If this is a nested type whose containing class hasn't been written
12276          out yet, writing it out will cover this one, too.  This does not apply
12277          to instantiations of member class templates; they need to be added to
12278          the containing class as they are generated.  FIXME: This hurts the
12279          idea of combining type decls from multiple TUs, since we can't predict
12280          what set of template instantiations we'll get.  */
12281       if (TYPE_CONTEXT (type)
12282           && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
12283           && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
12284         {
12285           gen_type_die (TYPE_CONTEXT (type), context_die);
12286
12287           if (TREE_ASM_WRITTEN (type))
12288             return;
12289
12290           /* If that failed, attach ourselves to the stub.  */
12291           push_decl_scope (TYPE_CONTEXT (type));
12292           context_die = lookup_type_die (TYPE_CONTEXT (type));
12293           need_pop = 1;
12294         }
12295       else
12296         {
12297           declare_in_namespace (type, context_die);
12298           need_pop = 0;
12299         }
12300
12301       if (TREE_CODE (type) == ENUMERAL_TYPE)
12302         gen_enumeration_type_die (type, context_die);
12303       else
12304         gen_struct_or_union_type_die (type, context_die);
12305
12306       if (need_pop)
12307         pop_decl_scope ();
12308
12309       /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
12310          it up if it is ever completed.  gen_*_type_die will set it for us
12311          when appropriate.  */
12312       return;
12313
12314     case VOID_TYPE:
12315     case INTEGER_TYPE:
12316     case REAL_TYPE:
12317     case COMPLEX_TYPE:
12318     case BOOLEAN_TYPE:
12319     case CHAR_TYPE:
12320       /* No DIEs needed for fundamental types.  */
12321       break;
12322
12323     case LANG_TYPE:
12324       /* No Dwarf representation currently defined.  */
12325       break;
12326
12327     default:
12328       gcc_unreachable ();
12329     }
12330
12331   TREE_ASM_WRITTEN (type) = 1;
12332 }
12333
12334 /* Generate a DIE for a tagged type instantiation.  */
12335
12336 static void
12337 gen_tagged_type_instantiation_die (tree type, dw_die_ref context_die)
12338 {
12339   if (type == NULL_TREE || type == error_mark_node)
12340     return;
12341
12342   /* We are going to output a DIE to represent the unqualified version of
12343      this type (i.e. without any const or volatile qualifiers) so make sure
12344      that we have the main variant (i.e. the unqualified version) of this
12345      type now.  */
12346   gcc_assert (type == type_main_variant (type));
12347
12348   /* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is
12349      an instance of an unresolved type.  */
12350
12351   switch (TREE_CODE (type))
12352     {
12353     case ERROR_MARK:
12354       break;
12355
12356     case ENUMERAL_TYPE:
12357       gen_inlined_enumeration_type_die (type, context_die);
12358       break;
12359
12360     case RECORD_TYPE:
12361       gen_inlined_structure_type_die (type, context_die);
12362       break;
12363
12364     case UNION_TYPE:
12365     case QUAL_UNION_TYPE:
12366       gen_inlined_union_type_die (type, context_die);
12367       break;
12368
12369     default:
12370       gcc_unreachable ();
12371     }
12372 }
12373
12374 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
12375    things which are local to the given block.  */
12376
12377 static void
12378 gen_block_die (tree stmt, dw_die_ref context_die, int depth)
12379 {
12380   int must_output_die = 0;
12381   tree origin;
12382   tree decl;
12383   enum tree_code origin_code;
12384
12385   /* Ignore blocks that are NULL.  */
12386   if (stmt == NULL_TREE)
12387     return;
12388
12389   /* If the block is one fragment of a non-contiguous block, do not
12390      process the variables, since they will have been done by the
12391      origin block.  Do process subblocks.  */
12392   if (BLOCK_FRAGMENT_ORIGIN (stmt))
12393     {
12394       tree sub;
12395
12396       for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
12397         gen_block_die (sub, context_die, depth + 1);
12398
12399       return;
12400     }
12401
12402   /* Determine the "ultimate origin" of this block.  This block may be an
12403      inlined instance of an inlined instance of inline function, so we have
12404      to trace all of the way back through the origin chain to find out what
12405      sort of node actually served as the original seed for the creation of
12406      the current block.  */
12407   origin = block_ultimate_origin (stmt);
12408   origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;
12409
12410   /* Determine if we need to output any Dwarf DIEs at all to represent this
12411      block.  */
12412   if (origin_code == FUNCTION_DECL)
12413     /* The outer scopes for inlinings *must* always be represented.  We
12414        generate DW_TAG_inlined_subroutine DIEs for them.  (See below.) */
12415     must_output_die = 1;
12416   else
12417     {
12418       /* In the case where the current block represents an inlining of the
12419          "body block" of an inline function, we must *NOT* output any DIE for
12420          this block because we have already output a DIE to represent the whole
12421          inlined function scope and the "body block" of any function doesn't
12422          really represent a different scope according to ANSI C rules.  So we
12423          check here to make sure that this block does not represent a "body
12424          block inlining" before trying to set the MUST_OUTPUT_DIE flag.  */
12425       if (! is_body_block (origin ? origin : stmt))
12426         {
12427           /* Determine if this block directly contains any "significant"
12428              local declarations which we will need to output DIEs for.  */
12429           if (debug_info_level > DINFO_LEVEL_TERSE)
12430             /* We are not in terse mode so *any* local declaration counts
12431                as being a "significant" one.  */
12432             must_output_die = (BLOCK_VARS (stmt) != NULL
12433                                && (TREE_USED (stmt)
12434                                    || TREE_ASM_WRITTEN (stmt)
12435                                    || BLOCK_ABSTRACT (stmt)));
12436           else
12437             /* We are in terse mode, so only local (nested) function
12438                definitions count as "significant" local declarations.  */
12439             for (decl = BLOCK_VARS (stmt);
12440                  decl != NULL; decl = TREE_CHAIN (decl))
12441               if (TREE_CODE (decl) == FUNCTION_DECL
12442                   && DECL_INITIAL (decl))
12443                 {
12444                   must_output_die = 1;
12445                   break;
12446                 }
12447         }
12448     }
12449
12450   /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
12451      DIE for any block which contains no significant local declarations at
12452      all.  Rather, in such cases we just call `decls_for_scope' so that any
12453      needed Dwarf info for any sub-blocks will get properly generated. Note
12454      that in terse mode, our definition of what constitutes a "significant"
12455      local declaration gets restricted to include only inlined function
12456      instances and local (nested) function definitions.  */
12457   if (must_output_die)
12458     {
12459       if (origin_code == FUNCTION_DECL)
12460         gen_inlined_subroutine_die (stmt, context_die, depth);
12461       else
12462         gen_lexical_block_die (stmt, context_die, depth);
12463     }
12464   else
12465     decls_for_scope (stmt, context_die, depth);
12466 }
12467
12468 /* Generate all of the decls declared within a given scope and (recursively)
12469    all of its sub-blocks.  */
12470
12471 static void
12472 decls_for_scope (tree stmt, dw_die_ref context_die, int depth)
12473 {
12474   tree decl;
12475   tree subblocks;
12476
12477   /* Ignore NULL blocks.  */
12478   if (stmt == NULL_TREE)
12479     return;
12480
12481   if (TREE_USED (stmt))
12482     {
12483       /* Output the DIEs to represent all of the data objects and typedefs
12484          declared directly within this block but not within any nested
12485          sub-blocks.  Also, nested function and tag DIEs have been
12486          generated with a parent of NULL; fix that up now.  */
12487       for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl))
12488         {
12489           dw_die_ref die;
12490
12491           if (TREE_CODE (decl) == FUNCTION_DECL)
12492             die = lookup_decl_die (decl);
12493           else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))
12494             die = lookup_type_die (TREE_TYPE (decl));
12495           else
12496             die = NULL;
12497
12498           if (die != NULL && die->die_parent == NULL)
12499             add_child_die (context_die, die);
12500           else
12501             gen_decl_die (decl, context_die);
12502         }
12503     }
12504
12505   /* If we're at -g1, we're not interested in subblocks.  */
12506   if (debug_info_level <= DINFO_LEVEL_TERSE)
12507     return;
12508
12509   /* Output the DIEs to represent all sub-blocks (and the items declared
12510      therein) of this block.  */
12511   for (subblocks = BLOCK_SUBBLOCKS (stmt);
12512        subblocks != NULL;
12513        subblocks = BLOCK_CHAIN (subblocks))
12514     gen_block_die (subblocks, context_die, depth + 1);
12515 }
12516
12517 /* Is this a typedef we can avoid emitting?  */
12518
12519 static inline int
12520 is_redundant_typedef (tree decl)
12521 {
12522   if (TYPE_DECL_IS_STUB (decl))
12523     return 1;
12524
12525   if (DECL_ARTIFICIAL (decl)
12526       && DECL_CONTEXT (decl)
12527       && is_tagged_type (DECL_CONTEXT (decl))
12528       && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
12529       && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
12530     /* Also ignore the artificial member typedef for the class name.  */
12531     return 1;
12532
12533   return 0;
12534 }
12535
12536 /* Returns the DIE for decl or aborts.  */
12537
12538 static dw_die_ref
12539 force_decl_die (tree decl)
12540 {
12541   dw_die_ref decl_die;
12542   unsigned saved_external_flag;
12543   tree save_fn = NULL_TREE;
12544   decl_die = lookup_decl_die (decl);
12545   if (!decl_die)
12546     {
12547       dw_die_ref context_die;
12548       tree decl_context = DECL_CONTEXT (decl);
12549       if (decl_context)
12550         {
12551           /* Find die that represents this context.  */
12552           if (TYPE_P (decl_context))
12553             context_die = force_type_die (decl_context);
12554           else
12555             context_die = force_decl_die (decl_context);
12556         }
12557       else
12558         context_die = comp_unit_die;
12559
12560       switch (TREE_CODE (decl))
12561         {
12562         case FUNCTION_DECL:
12563           /* Clear current_function_decl, so that gen_subprogram_die thinks
12564              that this is a declaration. At this point, we just want to force
12565              declaration die.  */
12566           save_fn = current_function_decl;
12567           current_function_decl = NULL_TREE;
12568           gen_subprogram_die (decl, context_die);
12569           current_function_decl = save_fn;
12570           break;
12571
12572         case VAR_DECL:
12573           /* Set external flag to force declaration die. Restore it after
12574            gen_decl_die() call.  */
12575           saved_external_flag = DECL_EXTERNAL (decl);
12576           DECL_EXTERNAL (decl) = 1;
12577           gen_decl_die (decl, context_die);
12578           DECL_EXTERNAL (decl) = saved_external_flag;
12579           break;
12580
12581         case NAMESPACE_DECL:
12582           dwarf2out_decl (decl);
12583           break;
12584
12585         default:
12586           gcc_unreachable ();
12587         }
12588
12589       /* See if we can find the die for this deci now.
12590          If not then abort.  */
12591       if (!decl_die)
12592         decl_die = lookup_decl_die (decl);
12593       gcc_assert (decl_die);
12594     }
12595
12596   return decl_die;
12597 }
12598
12599 /* Returns the DIE for decl or aborts.  */
12600
12601 static dw_die_ref
12602 force_type_die (tree type)
12603 {
12604   dw_die_ref type_die;
12605
12606   type_die = lookup_type_die (type);
12607   if (!type_die)
12608     {
12609       dw_die_ref context_die;
12610       if (TYPE_CONTEXT (type))
12611         if (TYPE_P (TYPE_CONTEXT (type)))
12612           context_die = force_type_die (TYPE_CONTEXT (type));
12613         else
12614           context_die = force_decl_die (TYPE_CONTEXT (type));
12615       else
12616         context_die = comp_unit_die;
12617
12618       gen_type_die (type, context_die);
12619       type_die = lookup_type_die (type);
12620       gcc_assert (type_die);
12621     }
12622   return type_die;
12623 }
12624
12625 /* Force out any required namespaces to be able to output DECL,
12626    and return the new context_die for it, if it's changed.  */
12627
12628 static dw_die_ref
12629 setup_namespace_context (tree thing, dw_die_ref context_die)
12630 {
12631   tree context = (DECL_P (thing)
12632                   ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
12633   if (context && TREE_CODE (context) == NAMESPACE_DECL)
12634     /* Force out the namespace.  */
12635     context_die = force_decl_die (context);
12636
12637   return context_die;
12638 }
12639
12640 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
12641    type) within its namespace, if appropriate.
12642
12643    For compatibility with older debuggers, namespace DIEs only contain
12644    declarations; all definitions are emitted at CU scope.  */
12645
12646 static void
12647 declare_in_namespace (tree thing, dw_die_ref context_die)
12648 {
12649   dw_die_ref ns_context;
12650
12651   if (debug_info_level <= DINFO_LEVEL_TERSE)
12652     return;
12653
12654   /* If this decl is from an inlined function, then don't try to emit it in its
12655      namespace, as we will get confused.  It would have already been emitted
12656      when the abstract instance of the inline function was emitted anyways.  */
12657   if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing))
12658     return;
12659
12660   ns_context = setup_namespace_context (thing, context_die);
12661
12662   if (ns_context != context_die)
12663     {
12664       if (DECL_P (thing))
12665         gen_decl_die (thing, ns_context);
12666       else
12667         gen_type_die (thing, ns_context);
12668     }
12669 }
12670
12671 /* Generate a DIE for a namespace or namespace alias.  */
12672
12673 static void
12674 gen_namespace_die (tree decl)
12675 {
12676   dw_die_ref context_die = setup_namespace_context (decl, comp_unit_die);
12677
12678   /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
12679      they are an alias of.  */
12680   if (DECL_ABSTRACT_ORIGIN (decl) == NULL)
12681     {
12682       /* Output a real namespace.  */
12683       dw_die_ref namespace_die
12684         = new_die (DW_TAG_namespace, context_die, decl);
12685       add_name_and_src_coords_attributes (namespace_die, decl);
12686       equate_decl_number_to_die (decl, namespace_die);
12687     }
12688   else
12689     {
12690       /* Output a namespace alias.  */
12691
12692       /* Force out the namespace we are an alias of, if necessary.  */
12693       dw_die_ref origin_die
12694         = force_decl_die (DECL_ABSTRACT_ORIGIN (decl));
12695
12696       /* Now create the namespace alias DIE.  */
12697       dw_die_ref namespace_die
12698         = new_die (DW_TAG_imported_declaration, context_die, decl);
12699       add_name_and_src_coords_attributes (namespace_die, decl);
12700       add_AT_die_ref (namespace_die, DW_AT_import, origin_die);
12701       equate_decl_number_to_die (decl, namespace_die);
12702     }
12703 }
12704
12705 /* Generate Dwarf debug information for a decl described by DECL.  */
12706
12707 static void
12708 gen_decl_die (tree decl, dw_die_ref context_die)
12709 {
12710   tree origin;
12711
12712   if (DECL_P (decl) && DECL_IGNORED_P (decl))
12713     return;
12714
12715   switch (TREE_CODE (decl))
12716     {
12717     case ERROR_MARK:
12718       break;
12719
12720     case CONST_DECL:
12721       /* The individual enumerators of an enum type get output when we output
12722          the Dwarf representation of the relevant enum type itself.  */
12723       break;
12724
12725     case FUNCTION_DECL:
12726       /* Don't output any DIEs to represent mere function declarations,
12727          unless they are class members or explicit block externs.  */
12728       if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE
12729           && (current_function_decl == NULL_TREE || DECL_ARTIFICIAL (decl)))
12730         break;
12731
12732 #if 0
12733       /* FIXME */
12734       /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
12735          on local redeclarations of global functions.  That seems broken.  */
12736       if (current_function_decl != decl)
12737         /* This is only a declaration.  */;
12738 #endif
12739
12740       /* If we're emitting a clone, emit info for the abstract instance.  */
12741       if (DECL_ORIGIN (decl) != decl)
12742         dwarf2out_abstract_function (DECL_ABSTRACT_ORIGIN (decl));
12743
12744       /* If we're emitting an out-of-line copy of an inline function,
12745          emit info for the abstract instance and set up to refer to it.  */
12746       else if (cgraph_function_possibly_inlined_p (decl)
12747                && ! DECL_ABSTRACT (decl)
12748                && ! class_or_namespace_scope_p (context_die)
12749                /* dwarf2out_abstract_function won't emit a die if this is just
12750                   a declaration.  We must avoid setting DECL_ABSTRACT_ORIGIN in
12751                   that case, because that works only if we have a die.  */
12752                && DECL_INITIAL (decl) != NULL_TREE)
12753         {
12754           dwarf2out_abstract_function (decl);
12755           set_decl_origin_self (decl);
12756         }
12757
12758       /* Otherwise we're emitting the primary DIE for this decl.  */
12759       else if (debug_info_level > DINFO_LEVEL_TERSE)
12760         {
12761           /* Before we describe the FUNCTION_DECL itself, make sure that we
12762              have described its return type.  */
12763           gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
12764
12765           /* And its virtual context.  */
12766           if (DECL_VINDEX (decl) != NULL_TREE)
12767             gen_type_die (DECL_CONTEXT (decl), context_die);
12768
12769           /* And its containing type.  */
12770           origin = decl_class_context (decl);
12771           if (origin != NULL_TREE)
12772             gen_type_die_for_member (origin, decl, context_die);
12773
12774           /* And its containing namespace.  */
12775           declare_in_namespace (decl, context_die);
12776         }
12777
12778       /* Now output a DIE to represent the function itself.  */
12779       gen_subprogram_die (decl, context_die);
12780       break;
12781
12782     case TYPE_DECL:
12783       /* If we are in terse mode, don't generate any DIEs to represent any
12784          actual typedefs.  */
12785       if (debug_info_level <= DINFO_LEVEL_TERSE)
12786         break;
12787
12788       /* In the special case of a TYPE_DECL node representing the declaration
12789          of some type tag, if the given TYPE_DECL is marked as having been
12790          instantiated from some other (original) TYPE_DECL node (e.g. one which
12791          was generated within the original definition of an inline function) we
12792          have to generate a special (abbreviated) DW_TAG_structure_type,
12793          DW_TAG_union_type, or DW_TAG_enumeration_type DIE here.  */
12794       if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
12795         {
12796           gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
12797           break;
12798         }
12799
12800       if (is_redundant_typedef (decl))
12801         gen_type_die (TREE_TYPE (decl), context_die);
12802       else
12803         /* Output a DIE to represent the typedef itself.  */
12804         gen_typedef_die (decl, context_die);
12805       break;
12806
12807     case LABEL_DECL:
12808       if (debug_info_level >= DINFO_LEVEL_NORMAL)
12809         gen_label_die (decl, context_die);
12810       break;
12811
12812     case VAR_DECL:
12813     case RESULT_DECL:
12814       /* If we are in terse mode, don't generate any DIEs to represent any
12815          variable declarations or definitions.  */
12816       if (debug_info_level <= DINFO_LEVEL_TERSE)
12817         break;
12818
12819       /* Output any DIEs that are needed to specify the type of this data
12820          object.  */
12821       gen_type_die (TREE_TYPE (decl), context_die);
12822
12823       /* And its containing type.  */
12824       origin = decl_class_context (decl);
12825       if (origin != NULL_TREE)
12826         gen_type_die_for_member (origin, decl, context_die);
12827
12828       /* And its containing namespace.  */
12829       declare_in_namespace (decl, context_die);
12830
12831       /* Now output the DIE to represent the data object itself.  This gets
12832          complicated because of the possibility that the VAR_DECL really
12833          represents an inlined instance of a formal parameter for an inline
12834          function.  */
12835       origin = decl_ultimate_origin (decl);
12836       if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
12837         gen_formal_parameter_die (decl, context_die);
12838       else
12839         gen_variable_die (decl, context_die);
12840       break;
12841
12842     case FIELD_DECL:
12843       /* Ignore the nameless fields that are used to skip bits but handle C++
12844          anonymous unions and structs.  */
12845       if (DECL_NAME (decl) != NULL_TREE
12846           || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
12847           || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
12848         {
12849           gen_type_die (member_declared_type (decl), context_die);
12850           gen_field_die (decl, context_die);
12851         }
12852       break;
12853
12854     case PARM_DECL:
12855       gen_type_die (TREE_TYPE (decl), context_die);
12856       gen_formal_parameter_die (decl, context_die);
12857       break;
12858
12859     case NAMESPACE_DECL:
12860       gen_namespace_die (decl);
12861       break;
12862
12863     default:
12864       /* Probably some frontend-internal decl.  Assume we don't care.  */
12865       gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
12866       break;
12867     }
12868 }
12869 \f
12870 /* Add Ada "use" clause information for SGI Workshop debugger.  */
12871
12872 void
12873 dwarf2out_add_library_unit_info (const char *filename, const char *context_list)
12874 {
12875   unsigned int file_index;
12876
12877   if (filename != NULL)
12878     {
12879       dw_die_ref unit_die = new_die (DW_TAG_module, comp_unit_die, NULL);
12880       tree context_list_decl
12881         = build_decl (LABEL_DECL, get_identifier (context_list),
12882                       void_type_node);
12883
12884       TREE_PUBLIC (context_list_decl) = TRUE;
12885       add_name_attribute (unit_die, context_list);
12886       file_index = lookup_filename (filename);
12887       add_AT_unsigned (unit_die, DW_AT_decl_file, file_index);
12888       add_pubname (context_list_decl, unit_die);
12889     }
12890 }
12891
12892 /* Output debug information for global decl DECL.  Called from toplev.c after
12893    compilation proper has finished.  */
12894
12895 static void
12896 dwarf2out_global_decl (tree decl)
12897 {
12898   /* Output DWARF2 information for file-scope tentative data object
12899      declarations, file-scope (extern) function declarations (which had no
12900      corresponding body) and file-scope tagged type declarations and
12901      definitions which have not yet been forced out.  */
12902   if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
12903     dwarf2out_decl (decl);
12904 }
12905
12906 /* Output debug information for type decl DECL.  Called from toplev.c
12907    and from language front ends (to record built-in types).  */
12908 static void
12909 dwarf2out_type_decl (tree decl, int local)
12910 {
12911   if (!local)
12912     dwarf2out_decl (decl);
12913 }
12914
12915 /* Output debug information for imported module or decl.  */
12916
12917 static void
12918 dwarf2out_imported_module_or_decl (tree decl, tree context)
12919 {
12920   dw_die_ref imported_die, at_import_die;
12921   dw_die_ref scope_die;
12922   unsigned file_index;
12923   expanded_location xloc;
12924
12925   if (debug_info_level <= DINFO_LEVEL_TERSE)
12926     return;
12927
12928   gcc_assert (decl);
12929
12930   /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
12931      We need decl DIE for reference and scope die. First, get DIE for the decl
12932      itself.  */
12933
12934   /* Get the scope die for decl context. Use comp_unit_die for global module
12935      or decl. If die is not found for non globals, force new die.  */
12936   if (!context)
12937     scope_die = comp_unit_die;
12938   else if (TYPE_P (context))
12939     scope_die = force_type_die (context);
12940   else
12941     scope_die = force_decl_die (context);
12942
12943   /* For TYPE_DECL or CONST_DECL, lookup TREE_TYPE.  */
12944   if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL)
12945     at_import_die = force_type_die (TREE_TYPE (decl));
12946   else
12947     {
12948       at_import_die = lookup_decl_die (decl);
12949       if (!at_import_die)
12950         {
12951           /* If we're trying to avoid duplicate debug info, we may not have
12952              emitted the member decl for this field.  Emit it now.  */
12953           if (TREE_CODE (decl) == FIELD_DECL)
12954             {
12955               tree type = DECL_CONTEXT (decl);
12956               dw_die_ref type_context_die;
12957
12958               if (TYPE_CONTEXT (type))
12959                 if (TYPE_P (TYPE_CONTEXT (type)))
12960                   type_context_die = force_type_die (TYPE_CONTEXT (type));
12961               else
12962                 type_context_die = force_decl_die (TYPE_CONTEXT (type));
12963               else
12964                 type_context_die = comp_unit_die;
12965               gen_type_die_for_member (type, decl, type_context_die);
12966             }
12967           at_import_die = force_decl_die (decl);
12968         }
12969     }
12970
12971   /* OK, now we have DIEs for decl as well as scope. Emit imported die.  */
12972   if (TREE_CODE (decl) == NAMESPACE_DECL)
12973     imported_die = new_die (DW_TAG_imported_module, scope_die, context);
12974   else
12975     imported_die = new_die (DW_TAG_imported_declaration, scope_die, context);
12976
12977   xloc = expand_location (input_location);
12978   file_index = lookup_filename (xloc.file);
12979   add_AT_unsigned (imported_die, DW_AT_decl_file, file_index);
12980   add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line);
12981   add_AT_die_ref (imported_die, DW_AT_import, at_import_die);
12982 }
12983
12984 /* Write the debugging output for DECL.  */
12985
12986 void
12987 dwarf2out_decl (tree decl)
12988 {
12989   dw_die_ref context_die = comp_unit_die;
12990
12991   switch (TREE_CODE (decl))
12992     {
12993     case ERROR_MARK:
12994       return;
12995
12996     case FUNCTION_DECL:
12997       /* What we would really like to do here is to filter out all mere
12998          file-scope declarations of file-scope functions which are never
12999          referenced later within this translation unit (and keep all of ones
13000          that *are* referenced later on) but we aren't clairvoyant, so we have
13001          no idea which functions will be referenced in the future (i.e. later
13002          on within the current translation unit). So here we just ignore all
13003          file-scope function declarations which are not also definitions.  If
13004          and when the debugger needs to know something about these functions,
13005          it will have to hunt around and find the DWARF information associated
13006          with the definition of the function.
13007
13008          We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
13009          nodes represent definitions and which ones represent mere
13010          declarations.  We have to check DECL_INITIAL instead. That's because
13011          the C front-end supports some weird semantics for "extern inline"
13012          function definitions.  These can get inlined within the current
13013          translation unit (an thus, we need to generate Dwarf info for their
13014          abstract instances so that the Dwarf info for the concrete inlined
13015          instances can have something to refer to) but the compiler never
13016          generates any out-of-lines instances of such things (despite the fact
13017          that they *are* definitions).
13018
13019          The important point is that the C front-end marks these "extern
13020          inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
13021          them anyway. Note that the C++ front-end also plays some similar games
13022          for inline function definitions appearing within include files which
13023          also contain `#pragma interface' pragmas.  */
13024       if (DECL_INITIAL (decl) == NULL_TREE)
13025         return;
13026
13027       /* If we're a nested function, initially use a parent of NULL; if we're
13028          a plain function, this will be fixed up in decls_for_scope.  If
13029          we're a method, it will be ignored, since we already have a DIE.  */
13030       if (decl_function_context (decl)
13031           /* But if we're in terse mode, we don't care about scope.  */
13032           && debug_info_level > DINFO_LEVEL_TERSE)
13033         context_die = NULL;
13034       break;
13035
13036     case VAR_DECL:
13037       /* Ignore this VAR_DECL if it refers to a file-scope extern data object
13038          declaration and if the declaration was never even referenced from
13039          within this entire compilation unit.  We suppress these DIEs in
13040          order to save space in the .debug section (by eliminating entries
13041          which are probably useless).  Note that we must not suppress
13042          block-local extern declarations (whether used or not) because that
13043          would screw-up the debugger's name lookup mechanism and cause it to
13044          miss things which really ought to be in scope at a given point.  */
13045       if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
13046         return;
13047
13048       /* If we are in terse mode, don't generate any DIEs to represent any
13049          variable declarations or definitions.  */
13050       if (debug_info_level <= DINFO_LEVEL_TERSE)
13051         return;
13052       break;
13053
13054     case NAMESPACE_DECL:
13055       if (debug_info_level <= DINFO_LEVEL_TERSE)
13056         return;
13057       if (lookup_decl_die (decl) != NULL)
13058         return;
13059       break;
13060
13061     case TYPE_DECL:
13062       /* Don't emit stubs for types unless they are needed by other DIEs.  */
13063       if (TYPE_DECL_SUPPRESS_DEBUG (decl))
13064         return;
13065
13066       /* Don't bother trying to generate any DIEs to represent any of the
13067          normal built-in types for the language we are compiling.  */
13068       if (DECL_IS_BUILTIN (decl))
13069         {
13070           /* OK, we need to generate one for `bool' so GDB knows what type
13071              comparisons have.  */
13072           if ((get_AT_unsigned (comp_unit_die, DW_AT_language)
13073                == DW_LANG_C_plus_plus)
13074               && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE
13075               && ! DECL_IGNORED_P (decl))
13076             modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
13077
13078           return;
13079         }
13080
13081       /* If we are in terse mode, don't generate any DIEs for types.  */
13082       if (debug_info_level <= DINFO_LEVEL_TERSE)
13083         return;
13084
13085       /* If we're a function-scope tag, initially use a parent of NULL;
13086          this will be fixed up in decls_for_scope.  */
13087       if (decl_function_context (decl))
13088         context_die = NULL;
13089
13090       break;
13091
13092     default:
13093       return;
13094     }
13095
13096   gen_decl_die (decl, context_die);
13097 }
13098
13099 /* Output a marker (i.e. a label) for the beginning of the generated code for
13100    a lexical block.  */
13101
13102 static void
13103 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
13104                        unsigned int blocknum)
13105 {
13106   current_function_section (current_function_decl);
13107   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
13108 }
13109
13110 /* Output a marker (i.e. a label) for the end of the generated code for a
13111    lexical block.  */
13112
13113 static void
13114 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
13115 {
13116   current_function_section (current_function_decl);
13117   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
13118 }
13119
13120 /* Returns nonzero if it is appropriate not to emit any debugging
13121    information for BLOCK, because it doesn't contain any instructions.
13122
13123    Don't allow this for blocks with nested functions or local classes
13124    as we would end up with orphans, and in the presence of scheduling
13125    we may end up calling them anyway.  */
13126
13127 static bool
13128 dwarf2out_ignore_block (tree block)
13129 {
13130   tree decl;
13131
13132   for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
13133     if (TREE_CODE (decl) == FUNCTION_DECL
13134         || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
13135       return 0;
13136
13137   return 1;
13138 }
13139
13140 /* Lookup FILE_NAME (in the list of filenames that we know about here in
13141    dwarf2out.c) and return its "index".  The index of each (known) filename is
13142    just a unique number which is associated with only that one filename.  We
13143    need such numbers for the sake of generating labels (in the .debug_sfnames
13144    section) and references to those files numbers (in the .debug_srcinfo
13145    and.debug_macinfo sections).  If the filename given as an argument is not
13146    found in our current list, add it to the list and assign it the next
13147    available unique index number.  In order to speed up searches, we remember
13148    the index of the filename was looked up last.  This handles the majority of
13149    all searches.  */
13150
13151 static unsigned
13152 lookup_filename (const char *file_name)
13153 {
13154   size_t i, n;
13155   char *save_file_name;
13156
13157   /* Check to see if the file name that was searched on the previous
13158      call matches this file name.  If so, return the index.  */
13159   if (file_table_last_lookup_index != 0)
13160     {
13161       const char *last
13162         = VARRAY_CHAR_PTR (file_table, file_table_last_lookup_index);
13163       if (strcmp (file_name, last) == 0)
13164         return file_table_last_lookup_index;
13165     }
13166
13167   /* Didn't match the previous lookup, search the table.  */
13168   n = VARRAY_ACTIVE_SIZE (file_table);
13169   for (i = 1; i < n; i++)
13170     if (strcmp (file_name, VARRAY_CHAR_PTR (file_table, i)) == 0)
13171       {
13172         file_table_last_lookup_index = i;
13173         return i;
13174       }
13175
13176   /* Add the new entry to the end of the filename table.  */
13177   file_table_last_lookup_index = n;
13178   save_file_name = (char *) ggc_strdup (file_name);
13179   VARRAY_PUSH_CHAR_PTR (file_table, save_file_name);
13180   VARRAY_PUSH_UINT (file_table_emitted, 0);
13181
13182   return i;
13183 }
13184
13185 static int
13186 maybe_emit_file (int fileno)
13187 {
13188   if (DWARF2_ASM_LINE_DEBUG_INFO && fileno > 0)
13189     {
13190       if (!VARRAY_UINT (file_table_emitted, fileno))
13191         {
13192           VARRAY_UINT (file_table_emitted, fileno) = ++emitcount;
13193           fprintf (asm_out_file, "\t.file %u ",
13194                    VARRAY_UINT (file_table_emitted, fileno));
13195           output_quoted_string (asm_out_file,
13196                                 VARRAY_CHAR_PTR (file_table, fileno));
13197           fputc ('\n', asm_out_file);
13198         }
13199       return VARRAY_UINT (file_table_emitted, fileno);
13200     }
13201   else
13202     return fileno;
13203 }
13204
13205 static void
13206 init_file_table (void)
13207 {
13208   /* Allocate the initial hunk of the file_table.  */
13209   VARRAY_CHAR_PTR_INIT (file_table, 64, "file_table");
13210   VARRAY_UINT_INIT (file_table_emitted, 64, "file_table_emitted");
13211
13212   /* Skip the first entry - file numbers begin at 1.  */
13213   VARRAY_PUSH_CHAR_PTR (file_table, NULL);
13214   VARRAY_PUSH_UINT (file_table_emitted, 0);
13215   file_table_last_lookup_index = 0;
13216 }
13217
13218 /* Called by the final INSN scan whenever we see a var location.  We
13219    use it to drop labels in the right places, and throw the location in
13220    our lookup table.  */
13221
13222 static void
13223 dwarf2out_var_location (rtx loc_note)
13224 {
13225   char loclabel[MAX_ARTIFICIAL_LABEL_BYTES];
13226   struct var_loc_node *newloc;
13227   rtx prev_insn;
13228   static rtx last_insn;
13229   static const char *last_label;
13230   tree decl;
13231   struct function *cfun = DECL_STRUCT_FUNCTION (current_function_decl);
13232
13233   if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note)))
13234     return;
13235   prev_insn = PREV_INSN (loc_note);
13236
13237   newloc = ggc_alloc_cleared (sizeof (struct var_loc_node));
13238   /* If the insn we processed last time is the previous insn
13239      and it is also a var location note, use the label we emitted
13240      last time.  */
13241   if (last_insn != NULL_RTX
13242       && last_insn == prev_insn
13243       && NOTE_P (prev_insn)
13244       && NOTE_LINE_NUMBER (prev_insn) == NOTE_INSN_VAR_LOCATION)
13245     {
13246       newloc->label = last_label;
13247     }
13248   else
13249     {
13250       ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num);
13251       ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num);
13252       loclabel_num++;
13253       newloc->label = ggc_strdup (loclabel);
13254     }
13255   newloc->var_loc_note = loc_note;
13256   newloc->next = NULL;
13257
13258   if (last_text_section == in_unlikely_executed_text
13259       || (last_text_section == in_named
13260           && last_text_section_name == cfun->unlikely_text_section_name))
13261     newloc->section_label = cfun->cold_section_label;
13262   else
13263     newloc->section_label = text_section_label;
13264
13265   last_insn = loc_note;
13266   last_label = newloc->label;
13267   decl = NOTE_VAR_LOCATION_DECL (loc_note);
13268   if (DECL_DEBUG_EXPR (decl) && DECL_DEBUG_EXPR_IS_FROM (decl)
13269       && DECL_P (DECL_DEBUG_EXPR (decl)))
13270     decl = DECL_DEBUG_EXPR (decl);
13271   add_var_loc_to_decl (decl, newloc);
13272 }
13273
13274 /* We need to reset the locations at the beginning of each
13275    function. We can't do this in the end_function hook, because the
13276    declarations that use the locations won't have been outputted when
13277    that hook is called.  */
13278
13279 static void
13280 dwarf2out_begin_function (tree unused ATTRIBUTE_UNUSED)
13281 {
13282   htab_empty (decl_loc_table);
13283 }
13284
13285 /* Output a label to mark the beginning of a source code line entry
13286    and record information relating to this source line, in
13287    'line_info_table' for later output of the .debug_line section.  */
13288
13289 static void
13290 dwarf2out_source_line (unsigned int line, const char *filename)
13291 {
13292   if (debug_info_level >= DINFO_LEVEL_NORMAL
13293       && line != 0)
13294     {
13295       current_function_section (current_function_decl);
13296
13297       /* If requested, emit something human-readable.  */
13298       if (flag_debug_asm)
13299         fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START,
13300                  filename, line);
13301
13302       if (DWARF2_ASM_LINE_DEBUG_INFO)
13303         {
13304           unsigned file_num = lookup_filename (filename);
13305
13306           file_num = maybe_emit_file (file_num);
13307
13308           /* Emit the .loc directive understood by GNU as.  */
13309           fprintf (asm_out_file, "\t.loc %d %d 0\n", file_num, line);
13310
13311           /* Indicate that line number info exists.  */
13312           line_info_table_in_use++;
13313
13314           /* Indicate that multiple line number tables exist.  */
13315           if (DECL_SECTION_NAME (current_function_decl))
13316             separate_line_info_table_in_use++;
13317         }
13318       else if (DECL_SECTION_NAME (current_function_decl))
13319         {
13320           dw_separate_line_info_ref line_info;
13321           targetm.asm_out.internal_label (asm_out_file, SEPARATE_LINE_CODE_LABEL,
13322                                      separate_line_info_table_in_use);
13323
13324           /* Expand the line info table if necessary.  */
13325           if (separate_line_info_table_in_use
13326               == separate_line_info_table_allocated)
13327             {
13328               separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
13329               separate_line_info_table
13330                 = ggc_realloc (separate_line_info_table,
13331                                separate_line_info_table_allocated
13332                                * sizeof (dw_separate_line_info_entry));
13333               memset (separate_line_info_table
13334                        + separate_line_info_table_in_use,
13335                       0,
13336                       (LINE_INFO_TABLE_INCREMENT
13337                        * sizeof (dw_separate_line_info_entry)));
13338             }
13339
13340           /* Add the new entry at the end of the line_info_table.  */
13341           line_info
13342             = &separate_line_info_table[separate_line_info_table_in_use++];
13343           line_info->dw_file_num = lookup_filename (filename);
13344           line_info->dw_line_num = line;
13345           line_info->function = current_function_funcdef_no;
13346         }
13347       else
13348         {
13349           dw_line_info_ref line_info;
13350
13351           targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL,
13352                                      line_info_table_in_use);
13353
13354           /* Expand the line info table if necessary.  */
13355           if (line_info_table_in_use == line_info_table_allocated)
13356             {
13357               line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
13358               line_info_table
13359                 = ggc_realloc (line_info_table,
13360                                (line_info_table_allocated
13361                                 * sizeof (dw_line_info_entry)));
13362               memset (line_info_table + line_info_table_in_use, 0,
13363                       LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
13364             }
13365
13366           /* Add the new entry at the end of the line_info_table.  */
13367           line_info = &line_info_table[line_info_table_in_use++];
13368           line_info->dw_file_num = lookup_filename (filename);
13369           line_info->dw_line_num = line;
13370         }
13371     }
13372 }
13373
13374 /* Record the beginning of a new source file.  */
13375
13376 static void
13377 dwarf2out_start_source_file (unsigned int lineno, const char *filename)
13378 {
13379   if (flag_eliminate_dwarf2_dups)
13380     {
13381       /* Record the beginning of the file for break_out_includes.  */
13382       dw_die_ref bincl_die;
13383
13384       bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL);
13385       add_AT_string (bincl_die, DW_AT_name, filename);
13386     }
13387
13388   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13389     {
13390       named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
13391       dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
13392       dw2_asm_output_data_uleb128 (lineno, "Included from line number %d",
13393                                    lineno);
13394       maybe_emit_file (lookup_filename (filename));
13395       dw2_asm_output_data_uleb128 (lookup_filename (filename),
13396                                    "Filename we just started");
13397     }
13398 }
13399
13400 /* Record the end of a source file.  */
13401
13402 static void
13403 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
13404 {
13405   if (flag_eliminate_dwarf2_dups)
13406     /* Record the end of the file for break_out_includes.  */
13407     new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL);
13408
13409   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13410     {
13411       named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
13412       dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
13413     }
13414 }
13415
13416 /* Called from debug_define in toplev.c.  The `buffer' parameter contains
13417    the tail part of the directive line, i.e. the part which is past the
13418    initial whitespace, #, whitespace, directive-name, whitespace part.  */
13419
13420 static void
13421 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
13422                   const char *buffer ATTRIBUTE_UNUSED)
13423 {
13424   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13425     {
13426       named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
13427       dw2_asm_output_data (1, DW_MACINFO_define, "Define macro");
13428       dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
13429       dw2_asm_output_nstring (buffer, -1, "The macro");
13430     }
13431 }
13432
13433 /* Called from debug_undef in toplev.c.  The `buffer' parameter contains
13434    the tail part of the directive line, i.e. the part which is past the
13435    initial whitespace, #, whitespace, directive-name, whitespace part.  */
13436
13437 static void
13438 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
13439                  const char *buffer ATTRIBUTE_UNUSED)
13440 {
13441   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13442     {
13443       named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
13444       dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro");
13445       dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
13446       dw2_asm_output_nstring (buffer, -1, "The macro");
13447     }
13448 }
13449
13450 /* Set up for Dwarf output at the start of compilation.  */
13451
13452 static void
13453 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
13454 {
13455   init_file_table ();
13456
13457   /* Allocate the decl_die_table.  */
13458   decl_die_table = htab_create_ggc (10, decl_die_table_hash,
13459                                     decl_die_table_eq, NULL);
13460
13461   /* Allocate the decl_loc_table.  */
13462   decl_loc_table = htab_create_ggc (10, decl_loc_table_hash,
13463                                     decl_loc_table_eq, NULL);
13464
13465   /* Allocate the initial hunk of the decl_scope_table.  */
13466   VARRAY_TREE_INIT (decl_scope_table, 256, "decl_scope_table");
13467
13468   /* Allocate the initial hunk of the abbrev_die_table.  */
13469   abbrev_die_table = ggc_alloc_cleared (ABBREV_DIE_TABLE_INCREMENT
13470                                         * sizeof (dw_die_ref));
13471   abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
13472   /* Zero-th entry is allocated, but unused.  */
13473   abbrev_die_table_in_use = 1;
13474
13475   /* Allocate the initial hunk of the line_info_table.  */
13476   line_info_table = ggc_alloc_cleared (LINE_INFO_TABLE_INCREMENT
13477                                        * sizeof (dw_line_info_entry));
13478   line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
13479
13480   /* Zero-th entry is allocated, but unused.  */
13481   line_info_table_in_use = 1;
13482
13483   /* Generate the initial DIE for the .debug section.  Note that the (string)
13484      value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
13485      will (typically) be a relative pathname and that this pathname should be
13486      taken as being relative to the directory from which the compiler was
13487      invoked when the given (base) source file was compiled.  We will fill
13488      in this value in dwarf2out_finish.  */
13489   comp_unit_die = gen_compile_unit_die (NULL);
13490
13491   VARRAY_TREE_INIT (incomplete_types, 64, "incomplete_types");
13492
13493   VARRAY_RTX_INIT (used_rtx_varray, 32, "used_rtx_varray");
13494
13495   ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
13496   ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
13497                                DEBUG_ABBREV_SECTION_LABEL, 0);
13498   ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
13499   ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
13500                                COLD_TEXT_SECTION_LABEL, 0);
13501   ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);
13502
13503   ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
13504                                DEBUG_INFO_SECTION_LABEL, 0);
13505   ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
13506                                DEBUG_LINE_SECTION_LABEL, 0);
13507   ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
13508                                DEBUG_RANGES_SECTION_LABEL, 0);
13509   named_section_flags (DEBUG_ABBREV_SECTION, SECTION_DEBUG);
13510   ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
13511   named_section_flags (DEBUG_INFO_SECTION, SECTION_DEBUG);
13512   ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
13513   named_section_flags (DEBUG_LINE_SECTION, SECTION_DEBUG);
13514   ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
13515
13516   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13517     {
13518       named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
13519       ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
13520                                    DEBUG_MACINFO_SECTION_LABEL, 0);
13521       ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
13522     }
13523
13524   text_section ();
13525   ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
13526   if (flag_reorder_blocks_and_partition)
13527     {
13528       unlikely_text_section ();
13529       ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
13530     }
13531 }
13532
13533 /* A helper function for dwarf2out_finish called through
13534    ht_forall.  Emit one queued .debug_str string.  */
13535
13536 static int
13537 output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
13538 {
13539   struct indirect_string_node *node = (struct indirect_string_node *) *h;
13540
13541   if (node->form == DW_FORM_strp)
13542     {
13543       named_section_flags (DEBUG_STR_SECTION, DEBUG_STR_SECTION_FLAGS);
13544       ASM_OUTPUT_LABEL (asm_out_file, node->label);
13545       assemble_string (node->str, strlen (node->str) + 1);
13546     }
13547
13548   return 1;
13549 }
13550
13551
13552
13553 /* Clear the marks for a die and its children.
13554    Be cool if the mark isn't set.  */
13555
13556 static void
13557 prune_unmark_dies (dw_die_ref die)
13558 {
13559   dw_die_ref c;
13560   die->die_mark = 0;
13561   for (c = die->die_child; c; c = c->die_sib)
13562     prune_unmark_dies (c);
13563 }
13564
13565
13566 /* Given DIE that we're marking as used, find any other dies
13567    it references as attributes and mark them as used.  */
13568
13569 static void
13570 prune_unused_types_walk_attribs (dw_die_ref die)
13571 {
13572   dw_attr_ref a;
13573
13574   for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
13575     {
13576       if (a->dw_attr_val.val_class == dw_val_class_die_ref)
13577         {
13578           /* A reference to another DIE.
13579              Make sure that it will get emitted.  */
13580           prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
13581         }
13582       else if (a->dw_attr == DW_AT_decl_file)
13583         {
13584           /* A reference to a file.  Make sure the file name is emitted.  */
13585           a->dw_attr_val.v.val_unsigned =
13586             maybe_emit_file (a->dw_attr_val.v.val_unsigned);
13587         }
13588     }
13589 }
13590
13591
13592 /* Mark DIE as being used.  If DOKIDS is true, then walk down
13593    to DIE's children.  */
13594
13595 static void
13596 prune_unused_types_mark (dw_die_ref die, int dokids)
13597 {
13598   dw_die_ref c;
13599
13600   if (die->die_mark == 0)
13601     {
13602       /* We haven't done this node yet.  Mark it as used.  */
13603       die->die_mark = 1;
13604
13605       /* We also have to mark its parents as used.
13606          (But we don't want to mark our parents' kids due to this.)  */
13607       if (die->die_parent)
13608         prune_unused_types_mark (die->die_parent, 0);
13609
13610       /* Mark any referenced nodes.  */
13611       prune_unused_types_walk_attribs (die);
13612
13613       /* If this node is a specification,
13614          also mark the definition, if it exists.  */
13615       if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
13616         prune_unused_types_mark (die->die_definition, 1);
13617     }
13618
13619   if (dokids && die->die_mark != 2)
13620     {
13621       /* We need to walk the children, but haven't done so yet.
13622          Remember that we've walked the kids.  */
13623       die->die_mark = 2;
13624
13625       /* Walk them.  */
13626       for (c = die->die_child; c; c = c->die_sib)
13627         {
13628           /* If this is an array type, we need to make sure our
13629              kids get marked, even if they're types.  */
13630           if (die->die_tag == DW_TAG_array_type)
13631             prune_unused_types_mark (c, 1);
13632           else
13633             prune_unused_types_walk (c);
13634         }
13635     }
13636 }
13637
13638
13639 /* Walk the tree DIE and mark types that we actually use.  */
13640
13641 static void
13642 prune_unused_types_walk (dw_die_ref die)
13643 {
13644   dw_die_ref c;
13645
13646   /* Don't do anything if this node is already marked.  */
13647   if (die->die_mark)
13648     return;
13649
13650   switch (die->die_tag) {
13651   case DW_TAG_const_type:
13652   case DW_TAG_packed_type:
13653   case DW_TAG_pointer_type:
13654   case DW_TAG_reference_type:
13655   case DW_TAG_volatile_type:
13656   case DW_TAG_typedef:
13657   case DW_TAG_array_type:
13658   case DW_TAG_structure_type:
13659   case DW_TAG_union_type:
13660   case DW_TAG_class_type:
13661   case DW_TAG_friend:
13662   case DW_TAG_variant_part:
13663   case DW_TAG_enumeration_type:
13664   case DW_TAG_subroutine_type:
13665   case DW_TAG_string_type:
13666   case DW_TAG_set_type:
13667   case DW_TAG_subrange_type:
13668   case DW_TAG_ptr_to_member_type:
13669   case DW_TAG_file_type:
13670     /* It's a type node --- don't mark it.  */
13671     return;
13672
13673   default:
13674     /* Mark everything else.  */
13675     break;
13676   }
13677
13678   die->die_mark = 1;
13679
13680   /* Now, mark any dies referenced from here.  */
13681   prune_unused_types_walk_attribs (die);
13682
13683   /* Mark children.  */
13684   for (c = die->die_child; c; c = c->die_sib)
13685     prune_unused_types_walk (c);
13686 }
13687
13688
13689 /* Remove from the tree DIE any dies that aren't marked.  */
13690
13691 static void
13692 prune_unused_types_prune (dw_die_ref die)
13693 {
13694   dw_die_ref c, p, n;
13695
13696   gcc_assert (die->die_mark);
13697
13698   p = NULL;
13699   for (c = die->die_child; c; c = n)
13700     {
13701       n = c->die_sib;
13702       if (c->die_mark)
13703         {
13704           prune_unused_types_prune (c);
13705           p = c;
13706         }
13707       else
13708         {
13709           if (p)
13710             p->die_sib = n;
13711           else
13712             die->die_child = n;
13713           free_die (c);
13714         }
13715     }
13716 }
13717
13718
13719 /* Remove dies representing declarations that we never use.  */
13720
13721 static void
13722 prune_unused_types (void)
13723 {
13724   unsigned int i;
13725   limbo_die_node *node;
13726
13727   /* Clear all the marks.  */
13728   prune_unmark_dies (comp_unit_die);
13729   for (node = limbo_die_list; node; node = node->next)
13730     prune_unmark_dies (node->die);
13731
13732   /* Set the mark on nodes that are actually used.  */
13733   prune_unused_types_walk (comp_unit_die);
13734   for (node = limbo_die_list; node; node = node->next)
13735     prune_unused_types_walk (node->die);
13736
13737   /* Also set the mark on nodes referenced from the
13738      pubname_table or arange_table.  */
13739   for (i = 0; i < pubname_table_in_use; i++)
13740     prune_unused_types_mark (pubname_table[i].die, 1);
13741   for (i = 0; i < arange_table_in_use; i++)
13742     prune_unused_types_mark (arange_table[i], 1);
13743
13744   /* Get rid of nodes that aren't marked.  */
13745   prune_unused_types_prune (comp_unit_die);
13746   for (node = limbo_die_list; node; node = node->next)
13747     prune_unused_types_prune (node->die);
13748
13749   /* Leave the marks clear.  */
13750   prune_unmark_dies (comp_unit_die);
13751   for (node = limbo_die_list; node; node = node->next)
13752     prune_unmark_dies (node->die);
13753 }
13754
13755 /* Output stuff that dwarf requires at the end of every file,
13756    and generate the DWARF-2 debugging info.  */
13757
13758 static void
13759 dwarf2out_finish (const char *filename)
13760 {
13761   limbo_die_node *node, *next_node;
13762   dw_die_ref die = 0;
13763
13764   /* Add the name for the main input file now.  We delayed this from
13765      dwarf2out_init to avoid complications with PCH.  */
13766   add_name_attribute (comp_unit_die, filename);
13767   if (filename[0] != DIR_SEPARATOR)
13768     add_comp_dir_attribute (comp_unit_die);
13769   else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL)
13770     {
13771       size_t i;
13772       for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
13773         if (VARRAY_CHAR_PTR (file_table, i)[0] != DIR_SEPARATOR
13774             /* Don't add cwd for <built-in>.  */
13775             && VARRAY_CHAR_PTR (file_table, i)[0] != '<')
13776           {
13777             add_comp_dir_attribute (comp_unit_die);
13778             break;
13779           }
13780     }
13781
13782   /* Traverse the limbo die list, and add parent/child links.  The only
13783      dies without parents that should be here are concrete instances of
13784      inline functions, and the comp_unit_die.  We can ignore the comp_unit_die.
13785      For concrete instances, we can get the parent die from the abstract
13786      instance.  */
13787   for (node = limbo_die_list; node; node = next_node)
13788     {
13789       next_node = node->next;
13790       die = node->die;
13791
13792       if (die->die_parent == NULL)
13793         {
13794           dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
13795
13796           if (origin)
13797             add_child_die (origin->die_parent, die);
13798           else if (die == comp_unit_die)
13799             ;
13800           else if (errorcount > 0 || sorrycount > 0)
13801             /* It's OK to be confused by errors in the input.  */
13802             add_child_die (comp_unit_die, die);
13803           else
13804             {
13805               /* In certain situations, the lexical block containing a
13806                  nested function can be optimized away, which results
13807                  in the nested function die being orphaned.  Likewise
13808                  with the return type of that nested function.  Force
13809                  this to be a child of the containing function.
13810
13811                  It may happen that even the containing function got fully
13812                  inlined and optimized out.  In that case we are lost and
13813                  assign the empty child.  This should not be big issue as
13814                  the function is likely unreachable too.  */
13815               tree context = NULL_TREE;
13816
13817               gcc_assert (node->created_for);
13818
13819               if (DECL_P (node->created_for))
13820                 context = DECL_CONTEXT (node->created_for);
13821               else if (TYPE_P (node->created_for))
13822                 context = TYPE_CONTEXT (node->created_for);
13823
13824               gcc_assert (context && TREE_CODE (context) == FUNCTION_DECL);
13825
13826               origin = lookup_decl_die (context);
13827               if (origin)
13828                 add_child_die (origin, die);
13829               else
13830                 add_child_die (comp_unit_die, die);
13831             }
13832         }
13833     }
13834
13835   limbo_die_list = NULL;
13836
13837   /* Walk through the list of incomplete types again, trying once more to
13838      emit full debugging info for them.  */
13839   retry_incomplete_types ();
13840
13841   /* We need to reverse all the dies before break_out_includes, or
13842      we'll see the end of an include file before the beginning.  */
13843   reverse_all_dies (comp_unit_die);
13844
13845   if (flag_eliminate_unused_debug_types)
13846     prune_unused_types ();
13847
13848   /* Generate separate CUs for each of the include files we've seen.
13849      They will go into limbo_die_list.  */
13850   if (flag_eliminate_dwarf2_dups)
13851     break_out_includes (comp_unit_die);
13852
13853   /* Traverse the DIE's and add add sibling attributes to those DIE's
13854      that have children.  */
13855   add_sibling_attributes (comp_unit_die);
13856   for (node = limbo_die_list; node; node = node->next)
13857     add_sibling_attributes (node->die);
13858
13859   /* Output a terminator label for the .text section.  */
13860   text_section ();
13861   targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
13862   if (flag_reorder_blocks_and_partition)
13863     {
13864       unlikely_text_section ();
13865       targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0);
13866     }
13867
13868   /* Output the source line correspondence table.  We must do this
13869      even if there is no line information.  Otherwise, on an empty
13870      translation unit, we will generate a present, but empty,
13871      .debug_info section.  IRIX 6.5 `nm' will then complain when
13872      examining the file.  */
13873   if (! DWARF2_ASM_LINE_DEBUG_INFO)
13874     {
13875       named_section_flags (DEBUG_LINE_SECTION, SECTION_DEBUG);
13876       output_line_info ();
13877     }
13878
13879   /* Output location list section if necessary.  */
13880   if (have_location_lists)
13881     {
13882       /* Output the location lists info.  */
13883       named_section_flags (DEBUG_LOC_SECTION, SECTION_DEBUG);
13884       ASM_GENERATE_INTERNAL_LABEL (loc_section_label,
13885                                    DEBUG_LOC_SECTION_LABEL, 0);
13886       ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
13887       output_location_lists (die);
13888       have_location_lists = 0;
13889     }
13890
13891   /* We can only use the low/high_pc attributes if all of the code was
13892      in .text.  */
13893   if (separate_line_info_table_in_use == 0)
13894     {
13895       add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
13896       add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
13897     }
13898
13899   /* If it wasn't, we need to give .debug_loc and .debug_ranges an appropriate
13900      "base address".  Use zero so that these addresses become absolute.  */
13901   else if (have_location_lists || ranges_table_in_use)
13902     add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx);
13903
13904   if (debug_info_level >= DINFO_LEVEL_NORMAL)
13905     add_AT_lbl_offset (comp_unit_die, DW_AT_stmt_list,
13906                        debug_line_section_label);
13907
13908   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13909     add_AT_lbl_offset (comp_unit_die, DW_AT_macro_info, macinfo_section_label);
13910
13911   /* Output all of the compilation units.  We put the main one last so that
13912      the offsets are available to output_pubnames.  */
13913   for (node = limbo_die_list; node; node = node->next)
13914     output_comp_unit (node->die, 0);
13915
13916   output_comp_unit (comp_unit_die, 0);
13917
13918   /* Output the abbreviation table.  */
13919   named_section_flags (DEBUG_ABBREV_SECTION, SECTION_DEBUG);
13920   output_abbrev_section ();
13921
13922   /* Output public names table if necessary.  */
13923   if (pubname_table_in_use)
13924     {
13925       named_section_flags (DEBUG_PUBNAMES_SECTION, SECTION_DEBUG);
13926       output_pubnames ();
13927     }
13928
13929   /* Output the address range information.  We only put functions in the arange
13930      table, so don't write it out if we don't have any.  */
13931   if (fde_table_in_use)
13932     {
13933       named_section_flags (DEBUG_ARANGES_SECTION, SECTION_DEBUG);
13934       output_aranges ();
13935     }
13936
13937   /* Output ranges section if necessary.  */
13938   if (ranges_table_in_use)
13939     {
13940       named_section_flags (DEBUG_RANGES_SECTION, SECTION_DEBUG);
13941       ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
13942       output_ranges ();
13943     }
13944
13945   /* Have to end the macro section.  */
13946   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13947     {
13948       named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
13949       dw2_asm_output_data (1, 0, "End compilation unit");
13950     }
13951
13952   /* If we emitted any DW_FORM_strp form attribute, output the string
13953      table too.  */
13954   if (debug_str_hash)
13955     htab_traverse (debug_str_hash, output_indirect_string, NULL);
13956 }
13957 #else
13958
13959 /* This should never be used, but its address is needed for comparisons.  */
13960 const struct gcc_debug_hooks dwarf2_debug_hooks;
13961
13962 #endif /* DWARF2_DEBUGGING_INFO */
13963
13964 #include "gt-dwarf2out.h"