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