gcc/dwarf2out.c

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