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