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 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_fp_regnum ()
 418 {
 419   return GEN_INT (DWARF_FRAME_REGNUM (HARD_FRAME_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           any_eh_needed = true;
1945
1946       if (! any_eh_needed)
1947         return;
1948     }
1949
1950   /* We're going to be generating comments, so turn on app.  */
1951   if (flag_debug_asm)
1952     app_enable ();
1953
1954   if (for_eh)
1955     (*targetm.asm_out.eh_frame_section) ();
1956   else
1957     named_section_flags (DEBUG_FRAME_SECTION, SECTION_DEBUG);
1958
1959   ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
1960   ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
1961
1962   /* Output the CIE.  */
1963   ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
1964   ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
1965   dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
1966                         "Length of Common Information Entry");
1967   ASM_OUTPUT_LABEL (asm_out_file, l1);
1968
1969   /* Now that the CIE pointer is PC-relative for EH,
1970      use 0 to identify the CIE.  */
1971   dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
1972                        (for_eh ? 0 : DW_CIE_ID),
1973                        "CIE Identifier Tag");
1974
1975   dw2_asm_output_data (1, DW_CIE_VERSION, "CIE Version");
1976
1977   augmentation[0] = 0;
1978   augmentation_size = 0;
1979   if (for_eh)
1980     {
1981       char *p;
1982
1983       /* Augmentation:
1984          z      Indicates that a uleb128 is present to size the
1985                 augmentation section.
1986          L      Indicates the encoding (and thus presence) of
1987                 an LSDA pointer in the FDE augmentation.
1988          R      Indicates a non-default pointer encoding for
1989                 FDE code pointers.
1990          P      Indicates the presence of an encoding + language
1991                 personality routine in the CIE augmentation.  */
1992
1993       fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
1994       per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
1995       lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
1996
1997       p = augmentation + 1;
1998       if (eh_personality_libfunc)
1999         {
2000           *p++ = 'P';
2001           augmentation_size += 1 + size_of_encoded_value (per_encoding);
2002         }
2003       if (any_lsda_needed)
2004         {
2005           *p++ = 'L';
2006           augmentation_size += 1;
2007         }
2008       if (fde_encoding != DW_EH_PE_absptr)
2009         {
2010           *p++ = 'R';
2011           augmentation_size += 1;
2012         }
2013       if (p > augmentation + 1)
2014         {
2015           augmentation[0] = 'z';
2016           *p = '\0';
2017         }
2018
2019       /* Ug.  Some platforms can't do unaligned dynamic relocations at all.  */
2020       if (eh_personality_libfunc && per_encoding == DW_EH_PE_aligned)
2021         {
2022           int offset = (  4             /* Length */
2023                         + 4             /* CIE Id */
2024                         + 1             /* CIE version */
2025                         + strlen (augmentation) + 1     /* Augmentation */
2026                         + size_of_uleb128 (1)           /* Code alignment */
2027                         + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
2028                         + 1             /* RA column */
2029                         + 1             /* Augmentation size */
2030                         + 1             /* Personality encoding */ );
2031           int pad = -offset & (PTR_SIZE - 1);
2032
2033           augmentation_size += pad;
2034
2035           /* Augmentations should be small, so there's scarce need to
2036              iterate for a solution.  Die if we exceed one uleb128 byte.  */
2037           if (size_of_uleb128 (augmentation_size) != 1)
2038             abort ();
2039         }
2040     }
2041
2042   dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
2043   dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
2044   dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
2045                                "CIE Data Alignment Factor");
2046   dw2_asm_output_data (1, DWARF_FRAME_RETURN_COLUMN, "CIE RA Column");
2047
2048   if (augmentation[0])
2049     {
2050       dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
2051       if (eh_personality_libfunc)
2052         {
2053           dw2_asm_output_data (1, per_encoding, "Personality (%s)",
2054                                eh_data_format_name (per_encoding));
2055           dw2_asm_output_encoded_addr_rtx (per_encoding,
2056                                            eh_personality_libfunc, NULL);
2057         }
2058
2059       if (any_lsda_needed)
2060         dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
2061                              eh_data_format_name (lsda_encoding));
2062
2063       if (fde_encoding != DW_EH_PE_absptr)
2064         dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
2065                              eh_data_format_name (fde_encoding));
2066     }
2067
2068   for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
2069     output_cfi (cfi, NULL, for_eh);
2070
2071   /* Pad the CIE out to an address sized boundary.  */
2072   ASM_OUTPUT_ALIGN (asm_out_file,
2073                     floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
2074   ASM_OUTPUT_LABEL (asm_out_file, l2);
2075
2076   /* Loop through all of the FDE's.  */
2077   for (i = 0; i < fde_table_in_use; i++)
2078     {
2079       fde = &fde_table[i];
2080
2081       /* Don't emit EH unwind info for leaf functions that don't need it.  */
2082       if (for_eh && !flag_asynchronous_unwind_tables && flag_exceptions
2083           && (fde->nothrow || fde->all_throwers_are_sibcalls)
2084           && !fde->uses_eh_lsda)
2085         continue;
2086
2087       (*targetm.asm_out.internal_label) (asm_out_file, FDE_LABEL, for_eh + i * 2);
2088       ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i * 2);
2089       ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i * 2);
2090       dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
2091                             "FDE Length");
2092       ASM_OUTPUT_LABEL (asm_out_file, l1);
2093
2094       if (for_eh)
2095         dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
2096       else
2097         dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
2098                                "FDE CIE offset");
2099
2100       if (for_eh)
2101         {
2102           dw2_asm_output_encoded_addr_rtx (fde_encoding,
2103                    gen_rtx_SYMBOL_REF (Pmode, fde->dw_fde_begin),
2104                    "FDE initial location");
2105           dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2106                                 fde->dw_fde_end, fde->dw_fde_begin,
2107                                 "FDE address range");
2108         }
2109       else
2110         {
2111           dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin,
2112                                "FDE initial location");
2113           dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2114                                 fde->dw_fde_end, fde->dw_fde_begin,
2115                                 "FDE address range");
2116         }
2117
2118       if (augmentation[0])
2119         {
2120           if (any_lsda_needed)
2121             {
2122               int size = size_of_encoded_value (lsda_encoding);
2123
2124               if (lsda_encoding == DW_EH_PE_aligned)
2125                 {
2126                   int offset = (  4             /* Length */
2127                                 + 4             /* CIE offset */
2128                                 + 2 * size_of_encoded_value (fde_encoding)
2129                                 + 1             /* Augmentation size */ );
2130                   int pad = -offset & (PTR_SIZE - 1);
2131
2132                   size += pad;
2133                   if (size_of_uleb128 (size) != 1)
2134                     abort ();
2135                 }
2136
2137               dw2_asm_output_data_uleb128 (size, "Augmentation size");
2138
2139               if (fde->uses_eh_lsda)
2140                 {
2141                   ASM_GENERATE_INTERNAL_LABEL (l1, "LLSDA",
2142                                                fde->funcdef_number);
2143                   dw2_asm_output_encoded_addr_rtx (
2144                         lsda_encoding, gen_rtx_SYMBOL_REF (Pmode, l1),
2145                         "Language Specific Data Area");
2146                 }
2147               else
2148                 {
2149                   if (lsda_encoding == DW_EH_PE_aligned)
2150                     ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
2151                   dw2_asm_output_data
2152                     (size_of_encoded_value (lsda_encoding), 0,
2153                      "Language Specific Data Area (none)");
2154                 }
2155             }
2156           else
2157             dw2_asm_output_data_uleb128 (0, "Augmentation size");
2158         }
2159
2160       /* Loop through the Call Frame Instructions associated with
2161          this FDE.  */
2162       fde->dw_fde_current_label = fde->dw_fde_begin;
2163       for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
2164         output_cfi (cfi, fde, for_eh);
2165
2166       /* Pad the FDE out to an address sized boundary.  */
2167       ASM_OUTPUT_ALIGN (asm_out_file,
2168                         floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
2169       ASM_OUTPUT_LABEL (asm_out_file, l2);
2170     }
2171
2172   if (for_eh && targetm.terminate_dw2_eh_frame_info)
2173     dw2_asm_output_data (4, 0, "End of Table");
2174 #ifdef MIPS_DEBUGGING_INFO
2175   /* Work around Irix 6 assembler bug whereby labels at the end of a section
2176      get a value of 0.  Putting .align 0 after the label fixes it.  */
2177   ASM_OUTPUT_ALIGN (asm_out_file, 0);
2178 #endif
2179
2180   /* Turn off app to make assembly quicker.  */
2181   if (flag_debug_asm)
2182     app_disable ();
2183 }
2184
2185 /* Output a marker (i.e. a label) for the beginning of a function, before
2186    the prologue.  */
2187
2188 void
2189 dwarf2out_begin_prologue (line, file)
2190      unsigned int line ATTRIBUTE_UNUSED;
2191      const char *file ATTRIBUTE_UNUSED;
2192 {
2193   char label[MAX_ARTIFICIAL_LABEL_BYTES];
2194   dw_fde_ref fde;
2195
2196   current_function_func_begin_label = 0;
2197
2198 #ifdef IA64_UNWIND_INFO
2199   /* ??? current_function_func_begin_label is also used by except.c
2200      for call-site information.  We must emit this label if it might
2201      be used.  */
2202   if ((! flag_exceptions || USING_SJLJ_EXCEPTIONS)
2203       && ! dwarf2out_do_frame ())
2204     return;
2205 #else
2206   if (! dwarf2out_do_frame ())
2207     return;
2208 #endif
2209
2210   function_section (current_function_decl);
2211   ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
2212                                current_function_funcdef_no);
2213   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
2214                           current_function_funcdef_no);
2215   current_function_func_begin_label = get_identifier (label);
2216
2217 #ifdef IA64_UNWIND_INFO
2218   /* We can elide the fde allocation if we're not emitting debug info.  */
2219   if (! dwarf2out_do_frame ())
2220     return;
2221 #endif
2222
2223   /* Expand the fde table if necessary.  */
2224   if (fde_table_in_use == fde_table_allocated)
2225     {
2226       fde_table_allocated += FDE_TABLE_INCREMENT;
2227       fde_table = ggc_realloc (fde_table,
2228                                fde_table_allocated * sizeof (dw_fde_node));
2229       memset (fde_table + fde_table_in_use, 0,
2230               FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
2231     }
2232
2233   /* Record the FDE associated with this function.  */
2234   current_funcdef_fde = fde_table_in_use;
2235
2236   /* Add the new FDE at the end of the fde_table.  */
2237   fde = &fde_table[fde_table_in_use++];
2238   fde->dw_fde_begin = xstrdup (label);
2239   fde->dw_fde_current_label = NULL;
2240   fde->dw_fde_end = NULL;
2241   fde->dw_fde_cfi = NULL;
2242   fde->funcdef_number = current_function_funcdef_no;
2243   fde->nothrow = current_function_nothrow;
2244   fde->uses_eh_lsda = cfun->uses_eh_lsda;
2245   fde->all_throwers_are_sibcalls = cfun->all_throwers_are_sibcalls;
2246
2247   args_size = old_args_size = 0;
2248
2249   /* We only want to output line number information for the genuine dwarf2
2250      prologue case, not the eh frame case.  */
2251 #ifdef DWARF2_DEBUGGING_INFO
2252   if (file)
2253     dwarf2out_source_line (line, file);
2254 #endif
2255 }
2256
2257 /* Output a marker (i.e. a label) for the absolute end of the generated code
2258    for a function definition.  This gets called *after* the epilogue code has
2259    been generated.  */
2260
2261 void
2262 dwarf2out_end_epilogue (line, file)
2263      unsigned int line ATTRIBUTE_UNUSED;
2264      const char *file ATTRIBUTE_UNUSED;
2265 {
2266   dw_fde_ref fde;
2267   char label[MAX_ARTIFICIAL_LABEL_BYTES];
2268
2269   /* Output a label to mark the endpoint of the code generated for this
2270      function.  */
2271   ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
2272                                current_function_funcdef_no);
2273   ASM_OUTPUT_LABEL (asm_out_file, label);
2274   fde = &fde_table[fde_table_in_use - 1];
2275   fde->dw_fde_end = xstrdup (label);
2276 }
2277
2278 void
2279 dwarf2out_frame_init ()
2280 {
2281   /* Allocate the initial hunk of the fde_table.  */
2282   fde_table = (dw_fde_ref) ggc_alloc_cleared (FDE_TABLE_INCREMENT
2283                                               * sizeof (dw_fde_node));
2284   fde_table_allocated = FDE_TABLE_INCREMENT;
2285   fde_table_in_use = 0;
2286
2287   /* Generate the CFA instructions common to all FDE's.  Do it now for the
2288      sake of lookup_cfa.  */
2289
2290 #ifdef DWARF2_UNWIND_INFO
2291   /* On entry, the Canonical Frame Address is at SP.  */
2292   dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
2293   initial_return_save (INCOMING_RETURN_ADDR_RTX);
2294 #endif
2295 }
2296
2297 void
2298 dwarf2out_frame_finish ()
2299 {
2300   /* Output call frame information.  */
2301   if (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
2302     output_call_frame_info (0);
2303
2304   if (! USING_SJLJ_EXCEPTIONS && (flag_unwind_tables || flag_exceptions))
2305     output_call_frame_info (1);
2306 }
2307 #endif
2308 \f
2309 /* And now, the subset of the debugging information support code necessary
2310    for emitting location expressions.  */
2311
2312 /* We need some way to distinguish DW_OP_addr with a direct symbol
2313    relocation from DW_OP_addr with a dtp-relative symbol relocation.  */
2314 #define INTERNAL_DW_OP_tls_addr         (0x100 + DW_OP_addr)
2315
2316
2317 typedef struct dw_val_struct *dw_val_ref;
2318 typedef struct die_struct *dw_die_ref;
2319 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
2320 typedef struct dw_loc_list_struct *dw_loc_list_ref;
2321
2322 /* Each DIE may have a series of attribute/value pairs.  Values
2323    can take on several forms.  The forms that are used in this
2324    implementation are listed below.  */
2325
2326 enum dw_val_class
2327 {
2328   dw_val_class_addr,
2329   dw_val_class_offset,
2330   dw_val_class_loc,
2331   dw_val_class_loc_list,
2332   dw_val_class_range_list,
2333   dw_val_class_const,
2334   dw_val_class_unsigned_const,
2335   dw_val_class_long_long,
2336   dw_val_class_float,
2337   dw_val_class_flag,
2338   dw_val_class_die_ref,
2339   dw_val_class_fde_ref,
2340   dw_val_class_lbl_id,
2341   dw_val_class_lbl_offset,
2342   dw_val_class_str
2343 };
2344
2345 /* Describe a double word constant value.  */
2346 /* ??? Every instance of long_long in the code really means CONST_DOUBLE.  */
2347
2348 typedef struct dw_long_long_struct GTY(())
2349 {
2350   unsigned long hi;
2351   unsigned long low;
2352 }
2353 dw_long_long_const;
2354
2355 /* Describe a floating point constant value.  */
2356
2357 typedef struct dw_fp_struct GTY(())
2358 {
2359   long * GTY((length ("%h.length"))) array;
2360   unsigned length;
2361 }
2362 dw_float_const;
2363
2364 /* The dw_val_node describes an attribute's value, as it is
2365    represented internally.  */
2366
2367 typedef struct dw_val_struct GTY(())
2368 {
2369   enum dw_val_class val_class;
2370   union dw_val_struct_union
2371     {
2372       rtx GTY ((tag ("dw_val_class_addr"))) val_addr;
2373       long unsigned GTY ((tag ("dw_val_class_offset"))) val_offset;
2374       dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list;
2375       dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc;
2376       long int GTY ((default (""))) val_int;
2377       long unsigned GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned;
2378       dw_long_long_const GTY ((tag ("dw_val_class_long_long"))) val_long_long;
2379       dw_float_const GTY ((tag ("dw_val_class_float"))) val_float;
2380       struct dw_val_die_union
2381         {
2382           dw_die_ref die;
2383           int external;
2384         } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref;
2385       unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index;
2386       struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str;
2387       char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id;
2388       unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag;
2389     }
2390   GTY ((desc ("%1.val_class"))) v;
2391 }
2392 dw_val_node;
2393
2394 /* Locations in memory are described using a sequence of stack machine
2395    operations.  */
2396
2397 typedef struct dw_loc_descr_struct GTY(())
2398 {
2399   dw_loc_descr_ref dw_loc_next;
2400   enum dwarf_location_atom dw_loc_opc;
2401   dw_val_node dw_loc_oprnd1;
2402   dw_val_node dw_loc_oprnd2;
2403   int dw_loc_addr;
2404 }
2405 dw_loc_descr_node;
2406
2407 /* Location lists are ranges + location descriptions for that range,
2408    so you can track variables that are in different places over
2409    their entire life.  */
2410 typedef struct dw_loc_list_struct GTY(())
2411 {
2412   dw_loc_list_ref dw_loc_next;
2413   const char *begin; /* Label for begin address of range */
2414   const char *end;  /* Label for end address of range */
2415   char *ll_symbol; /* Label for beginning of location list.
2416                       Only on head of list */
2417   const char *section; /* Section this loclist is relative to */
2418   dw_loc_descr_ref expr;
2419 } dw_loc_list_node;
2420
2421 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
2422
2423 static const char *dwarf_stack_op_name  PARAMS ((unsigned));
2424 static dw_loc_descr_ref new_loc_descr   PARAMS ((enum dwarf_location_atom,
2425                                                  unsigned long,
2426                                                  unsigned long));
2427 static void add_loc_descr               PARAMS ((dw_loc_descr_ref *,
2428                                                  dw_loc_descr_ref));
2429 static unsigned long size_of_loc_descr  PARAMS ((dw_loc_descr_ref));
2430 static unsigned long size_of_locs       PARAMS ((dw_loc_descr_ref));
2431 static void output_loc_operands         PARAMS ((dw_loc_descr_ref));
2432 static void output_loc_sequence         PARAMS ((dw_loc_descr_ref));
2433
2434 /* Convert a DWARF stack opcode into its string name.  */
2435
2436 static const char *
2437 dwarf_stack_op_name (op)
2438      unsigned op;
2439 {
2440   switch (op)
2441     {
2442     case DW_OP_addr:
2443     case INTERNAL_DW_OP_tls_addr:
2444       return "DW_OP_addr";
2445     case DW_OP_deref:
2446       return "DW_OP_deref";
2447     case DW_OP_const1u:
2448       return "DW_OP_const1u";
2449     case DW_OP_const1s:
2450       return "DW_OP_const1s";
2451     case DW_OP_const2u:
2452       return "DW_OP_const2u";
2453     case DW_OP_const2s:
2454       return "DW_OP_const2s";
2455     case DW_OP_const4u:
2456       return "DW_OP_const4u";
2457     case DW_OP_const4s:
2458       return "DW_OP_const4s";
2459     case DW_OP_const8u:
2460       return "DW_OP_const8u";
2461     case DW_OP_const8s:
2462       return "DW_OP_const8s";
2463     case DW_OP_constu:
2464       return "DW_OP_constu";
2465     case DW_OP_consts:
2466       return "DW_OP_consts";
2467     case DW_OP_dup:
2468       return "DW_OP_dup";
2469     case DW_OP_drop:
2470       return "DW_OP_drop";
2471     case DW_OP_over:
2472       return "DW_OP_over";
2473     case DW_OP_pick:
2474       return "DW_OP_pick";
2475     case DW_OP_swap:
2476       return "DW_OP_swap";
2477     case DW_OP_rot:
2478       return "DW_OP_rot";
2479     case DW_OP_xderef:
2480       return "DW_OP_xderef";
2481     case DW_OP_abs:
2482       return "DW_OP_abs";
2483     case DW_OP_and:
2484       return "DW_OP_and";
2485     case DW_OP_div:
2486       return "DW_OP_div";
2487     case DW_OP_minus:
2488       return "DW_OP_minus";
2489     case DW_OP_mod:
2490       return "DW_OP_mod";
2491     case DW_OP_mul:
2492       return "DW_OP_mul";
2493     case DW_OP_neg:
2494       return "DW_OP_neg";
2495     case DW_OP_not:
2496       return "DW_OP_not";
2497     case DW_OP_or:
2498       return "DW_OP_or";
2499     case DW_OP_plus:
2500       return "DW_OP_plus";
2501     case DW_OP_plus_uconst:
2502       return "DW_OP_plus_uconst";
2503     case DW_OP_shl:
2504       return "DW_OP_shl";
2505     case DW_OP_shr:
2506       return "DW_OP_shr";
2507     case DW_OP_shra:
2508       return "DW_OP_shra";
2509     case DW_OP_xor:
2510       return "DW_OP_xor";
2511     case DW_OP_bra:
2512       return "DW_OP_bra";
2513     case DW_OP_eq:
2514       return "DW_OP_eq";
2515     case DW_OP_ge:
2516       return "DW_OP_ge";
2517     case DW_OP_gt:
2518       return "DW_OP_gt";
2519     case DW_OP_le:
2520       return "DW_OP_le";
2521     case DW_OP_lt:
2522       return "DW_OP_lt";
2523     case DW_OP_ne:
2524       return "DW_OP_ne";
2525     case DW_OP_skip:
2526       return "DW_OP_skip";
2527     case DW_OP_lit0:
2528       return "DW_OP_lit0";
2529     case DW_OP_lit1:
2530       return "DW_OP_lit1";
2531     case DW_OP_lit2:
2532       return "DW_OP_lit2";
2533     case DW_OP_lit3:
2534       return "DW_OP_lit3";
2535     case DW_OP_lit4:
2536       return "DW_OP_lit4";
2537     case DW_OP_lit5:
2538       return "DW_OP_lit5";
2539     case DW_OP_lit6:
2540       return "DW_OP_lit6";
2541     case DW_OP_lit7:
2542       return "DW_OP_lit7";
2543     case DW_OP_lit8:
2544       return "DW_OP_lit8";
2545     case DW_OP_lit9:
2546       return "DW_OP_lit9";
2547     case DW_OP_lit10:
2548       return "DW_OP_lit10";
2549     case DW_OP_lit11:
2550       return "DW_OP_lit11";
2551     case DW_OP_lit12:
2552       return "DW_OP_lit12";
2553     case DW_OP_lit13:
2554       return "DW_OP_lit13";
2555     case DW_OP_lit14:
2556       return "DW_OP_lit14";
2557     case DW_OP_lit15:
2558       return "DW_OP_lit15";
2559     case DW_OP_lit16:
2560       return "DW_OP_lit16";
2561     case DW_OP_lit17:
2562       return "DW_OP_lit17";
2563     case DW_OP_lit18:
2564       return "DW_OP_lit18";
2565     case DW_OP_lit19:
2566       return "DW_OP_lit19";
2567     case DW_OP_lit20:
2568       return "DW_OP_lit20";
2569     case DW_OP_lit21:
2570       return "DW_OP_lit21";
2571     case DW_OP_lit22:
2572       return "DW_OP_lit22";
2573     case DW_OP_lit23:
2574       return "DW_OP_lit23";
2575     case DW_OP_lit24:
2576       return "DW_OP_lit24";
2577     case DW_OP_lit25:
2578       return "DW_OP_lit25";
2579     case DW_OP_lit26:
2580       return "DW_OP_lit26";
2581     case DW_OP_lit27:
2582       return "DW_OP_lit27";
2583     case DW_OP_lit28:
2584       return "DW_OP_lit28";
2585     case DW_OP_lit29:
2586       return "DW_OP_lit29";
2587     case DW_OP_lit30:
2588       return "DW_OP_lit30";
2589     case DW_OP_lit31:
2590       return "DW_OP_lit31";
2591     case DW_OP_reg0:
2592       return "DW_OP_reg0";
2593     case DW_OP_reg1:
2594       return "DW_OP_reg1";
2595     case DW_OP_reg2:
2596       return "DW_OP_reg2";
2597     case DW_OP_reg3:
2598       return "DW_OP_reg3";
2599     case DW_OP_reg4:
2600       return "DW_OP_reg4";
2601     case DW_OP_reg5:
2602       return "DW_OP_reg5";
2603     case DW_OP_reg6:
2604       return "DW_OP_reg6";
2605     case DW_OP_reg7:
2606       return "DW_OP_reg7";
2607     case DW_OP_reg8:
2608       return "DW_OP_reg8";
2609     case DW_OP_reg9:
2610       return "DW_OP_reg9";
2611     case DW_OP_reg10:
2612       return "DW_OP_reg10";
2613     case DW_OP_reg11:
2614       return "DW_OP_reg11";
2615     case DW_OP_reg12:
2616       return "DW_OP_reg12";
2617     case DW_OP_reg13:
2618       return "DW_OP_reg13";
2619     case DW_OP_reg14:
2620       return "DW_OP_reg14";
2621     case DW_OP_reg15:
2622       return "DW_OP_reg15";
2623     case DW_OP_reg16:
2624       return "DW_OP_reg16";
2625     case DW_OP_reg17:
2626       return "DW_OP_reg17";
2627     case DW_OP_reg18:
2628       return "DW_OP_reg18";
2629     case DW_OP_reg19:
2630       return "DW_OP_reg19";
2631     case DW_OP_reg20:
2632       return "DW_OP_reg20";
2633     case DW_OP_reg21:
2634       return "DW_OP_reg21";
2635     case DW_OP_reg22:
2636       return "DW_OP_reg22";
2637     case DW_OP_reg23:
2638       return "DW_OP_reg23";
2639     case DW_OP_reg24:
2640       return "DW_OP_reg24";
2641     case DW_OP_reg25:
2642       return "DW_OP_reg25";
2643     case DW_OP_reg26:
2644       return "DW_OP_reg26";
2645     case DW_OP_reg27:
2646       return "DW_OP_reg27";
2647     case DW_OP_reg28:
2648       return "DW_OP_reg28";
2649     case DW_OP_reg29:
2650       return "DW_OP_reg29";
2651     case DW_OP_reg30:
2652       return "DW_OP_reg30";
2653     case DW_OP_reg31:
2654       return "DW_OP_reg31";
2655     case DW_OP_breg0:
2656       return "DW_OP_breg0";
2657     case DW_OP_breg1:
2658       return "DW_OP_breg1";
2659     case DW_OP_breg2:
2660       return "DW_OP_breg2";
2661     case DW_OP_breg3:
2662       return "DW_OP_breg3";
2663     case DW_OP_breg4:
2664       return "DW_OP_breg4";
2665     case DW_OP_breg5:
2666       return "DW_OP_breg5";
2667     case DW_OP_breg6:
2668       return "DW_OP_breg6";
2669     case DW_OP_breg7:
2670       return "DW_OP_breg7";
2671     case DW_OP_breg8:
2672       return "DW_OP_breg8";
2673     case DW_OP_breg9:
2674       return "DW_OP_breg9";
2675     case DW_OP_breg10:
2676       return "DW_OP_breg10";
2677     case DW_OP_breg11:
2678       return "DW_OP_breg11";
2679     case DW_OP_breg12:
2680       return "DW_OP_breg12";
2681     case DW_OP_breg13:
2682       return "DW_OP_breg13";
2683     case DW_OP_breg14:
2684       return "DW_OP_breg14";
2685     case DW_OP_breg15:
2686       return "DW_OP_breg15";
2687     case DW_OP_breg16:
2688       return "DW_OP_breg16";
2689     case DW_OP_breg17:
2690       return "DW_OP_breg17";
2691     case DW_OP_breg18:
2692       return "DW_OP_breg18";
2693     case DW_OP_breg19:
2694       return "DW_OP_breg19";
2695     case DW_OP_breg20:
2696       return "DW_OP_breg20";
2697     case DW_OP_breg21:
2698       return "DW_OP_breg21";
2699     case DW_OP_breg22:
2700       return "DW_OP_breg22";
2701     case DW_OP_breg23:
2702       return "DW_OP_breg23";
2703     case DW_OP_breg24:
2704       return "DW_OP_breg24";
2705     case DW_OP_breg25:
2706       return "DW_OP_breg25";
2707     case DW_OP_breg26:
2708       return "DW_OP_breg26";
2709     case DW_OP_breg27:
2710       return "DW_OP_breg27";
2711     case DW_OP_breg28:
2712       return "DW_OP_breg28";
2713     case DW_OP_breg29:
2714       return "DW_OP_breg29";
2715     case DW_OP_breg30:
2716       return "DW_OP_breg30";
2717     case DW_OP_breg31:
2718       return "DW_OP_breg31";
2719     case DW_OP_regx:
2720       return "DW_OP_regx";
2721     case DW_OP_fbreg:
2722       return "DW_OP_fbreg";
2723     case DW_OP_bregx:
2724       return "DW_OP_bregx";
2725     case DW_OP_piece:
2726       return "DW_OP_piece";
2727     case DW_OP_deref_size:
2728       return "DW_OP_deref_size";
2729     case DW_OP_xderef_size:
2730       return "DW_OP_xderef_size";
2731     case DW_OP_nop:
2732       return "DW_OP_nop";
2733     case DW_OP_push_object_address:
2734       return "DW_OP_push_object_address";
2735     case DW_OP_call2:
2736       return "DW_OP_call2";
2737     case DW_OP_call4:
2738       return "DW_OP_call4";
2739     case DW_OP_call_ref:
2740       return "DW_OP_call_ref";
2741     case DW_OP_GNU_push_tls_address:
2742       return "DW_OP_GNU_push_tls_address";
2743     default:
2744       return "OP_<unknown>";
2745     }
2746 }
2747
2748 /* Return a pointer to a newly allocated location description.  Location
2749    descriptions are simple expression terms that can be strung
2750    together to form more complicated location (address) descriptions.  */
2751
2752 static inline dw_loc_descr_ref
2753 new_loc_descr (op, oprnd1, oprnd2)
2754      enum dwarf_location_atom op;
2755      unsigned long oprnd1;
2756      unsigned long oprnd2;
2757 {
2758   dw_loc_descr_ref descr
2759     = (dw_loc_descr_ref) ggc_alloc_cleared (sizeof (dw_loc_descr_node));
2760
2761   descr->dw_loc_opc = op;
2762   descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
2763   descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
2764   descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
2765   descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
2766
2767   return descr;
2768 }
2769
2770
2771 /* Add a location description term to a location description expression.  */
2772
2773 static inline void
2774 add_loc_descr (list_head, descr)
2775      dw_loc_descr_ref *list_head;
2776      dw_loc_descr_ref descr;
2777 {
2778   dw_loc_descr_ref *d;
2779
2780   /* Find the end of the chain.  */
2781   for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
2782     ;
2783
2784   *d = descr;
2785 }
2786
2787 /* Return the size of a location descriptor.  */
2788
2789 static unsigned long
2790 size_of_loc_descr (loc)
2791      dw_loc_descr_ref loc;
2792 {
2793   unsigned long size = 1;
2794
2795   switch (loc->dw_loc_opc)
2796     {
2797     case DW_OP_addr:
2798     case INTERNAL_DW_OP_tls_addr:
2799       size += DWARF2_ADDR_SIZE;
2800       break;
2801     case DW_OP_const1u:
2802     case DW_OP_const1s:
2803       size += 1;
2804       break;
2805     case DW_OP_const2u:
2806     case DW_OP_const2s:
2807       size += 2;
2808       break;
2809     case DW_OP_const4u:
2810     case DW_OP_const4s:
2811       size += 4;
2812       break;
2813     case DW_OP_const8u:
2814     case DW_OP_const8s:
2815       size += 8;
2816       break;
2817     case DW_OP_constu:
2818       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
2819       break;
2820     case DW_OP_consts:
2821       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
2822       break;
2823     case DW_OP_pick:
2824       size += 1;
2825       break;
2826     case DW_OP_plus_uconst:
2827       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
2828       break;
2829     case DW_OP_skip:
2830     case DW_OP_bra:
2831       size += 2;
2832       break;
2833     case DW_OP_breg0:
2834     case DW_OP_breg1:
2835     case DW_OP_breg2:
2836     case DW_OP_breg3:
2837     case DW_OP_breg4:
2838     case DW_OP_breg5:
2839     case DW_OP_breg6:
2840     case DW_OP_breg7:
2841     case DW_OP_breg8:
2842     case DW_OP_breg9:
2843     case DW_OP_breg10:
2844     case DW_OP_breg11:
2845     case DW_OP_breg12:
2846     case DW_OP_breg13:
2847     case DW_OP_breg14:
2848     case DW_OP_breg15:
2849     case DW_OP_breg16:
2850     case DW_OP_breg17:
2851     case DW_OP_breg18:
2852     case DW_OP_breg19:
2853     case DW_OP_breg20:
2854     case DW_OP_breg21:
2855     case DW_OP_breg22:
2856     case DW_OP_breg23:
2857     case DW_OP_breg24:
2858     case DW_OP_breg25:
2859     case DW_OP_breg26:
2860     case DW_OP_breg27:
2861     case DW_OP_breg28:
2862     case DW_OP_breg29:
2863     case DW_OP_breg30:
2864     case DW_OP_breg31:
2865       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
2866       break;
2867     case DW_OP_regx:
2868       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
2869       break;
2870     case DW_OP_fbreg:
2871       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
2872       break;
2873     case DW_OP_bregx:
2874       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
2875       size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
2876       break;
2877     case DW_OP_piece:
2878       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
2879       break;
2880     case DW_OP_deref_size:
2881     case DW_OP_xderef_size:
2882       size += 1;
2883       break;
2884     case DW_OP_call2:
2885       size += 2;
2886       break;
2887     case DW_OP_call4:
2888       size += 4;
2889       break;
2890     case DW_OP_call_ref:
2891       size += DWARF2_ADDR_SIZE;
2892       break;
2893     default:
2894       break;
2895     }
2896
2897   return size;
2898 }
2899
2900 /* Return the size of a series of location descriptors.  */
2901
2902 static unsigned long
2903 size_of_locs (loc)
2904      dw_loc_descr_ref loc;
2905 {
2906   unsigned long size;
2907
2908   for (size = 0; loc != NULL; loc = loc->dw_loc_next)
2909     {
2910       loc->dw_loc_addr = size;
2911       size += size_of_loc_descr (loc);
2912     }
2913
2914   return size;
2915 }
2916
2917 /* Output location description stack opcode's operands (if any).  */
2918
2919 static void
2920 output_loc_operands (loc)
2921      dw_loc_descr_ref loc;
2922 {
2923   dw_val_ref val1 = &loc->dw_loc_oprnd1;
2924   dw_val_ref val2 = &loc->dw_loc_oprnd2;
2925
2926   switch (loc->dw_loc_opc)
2927     {
2928 #ifdef DWARF2_DEBUGGING_INFO
2929     case DW_OP_addr:
2930       dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
2931       break;
2932     case DW_OP_const2u:
2933     case DW_OP_const2s:
2934       dw2_asm_output_data (2, val1->v.val_int, NULL);
2935       break;
2936     case DW_OP_const4u:
2937     case DW_OP_const4s:
2938       dw2_asm_output_data (4, val1->v.val_int, NULL);
2939       break;
2940     case DW_OP_const8u:
2941     case DW_OP_const8s:
2942       if (HOST_BITS_PER_LONG < 64)
2943         abort ();
2944       dw2_asm_output_data (8, val1->v.val_int, NULL);
2945       break;
2946     case DW_OP_skip:
2947     case DW_OP_bra:
2948       {
2949         int offset;
2950
2951         if (val1->val_class == dw_val_class_loc)
2952           offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
2953         else
2954           abort ();
2955
2956         dw2_asm_output_data (2, offset, NULL);
2957       }
2958       break;
2959 #else
2960     case DW_OP_addr:
2961     case DW_OP_const2u:
2962     case DW_OP_const2s:
2963     case DW_OP_const4u:
2964     case DW_OP_const4s:
2965     case DW_OP_const8u:
2966     case DW_OP_const8s:
2967     case DW_OP_skip:
2968     case DW_OP_bra:
2969       /* We currently don't make any attempt to make sure these are
2970          aligned properly like we do for the main unwind info, so
2971          don't support emitting things larger than a byte if we're
2972          only doing unwinding.  */
2973       abort ();
2974 #endif
2975     case DW_OP_const1u:
2976     case DW_OP_const1s:
2977       dw2_asm_output_data (1, val1->v.val_int, NULL);
2978       break;
2979     case DW_OP_constu:
2980       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2981       break;
2982     case DW_OP_consts:
2983       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
2984       break;
2985     case DW_OP_pick:
2986       dw2_asm_output_data (1, val1->v.val_int, NULL);
2987       break;
2988     case DW_OP_plus_uconst:
2989       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2990       break;
2991     case DW_OP_breg0:
2992     case DW_OP_breg1:
2993     case DW_OP_breg2:
2994     case DW_OP_breg3:
2995     case DW_OP_breg4:
2996     case DW_OP_breg5:
2997     case DW_OP_breg6:
2998     case DW_OP_breg7:
2999     case DW_OP_breg8:
3000     case DW_OP_breg9:
3001     case DW_OP_breg10:
3002     case DW_OP_breg11:
3003     case DW_OP_breg12:
3004     case DW_OP_breg13:
3005     case DW_OP_breg14:
3006     case DW_OP_breg15:
3007     case DW_OP_breg16:
3008     case DW_OP_breg17:
3009     case DW_OP_breg18:
3010     case DW_OP_breg19:
3011     case DW_OP_breg20:
3012     case DW_OP_breg21:
3013     case DW_OP_breg22:
3014     case DW_OP_breg23:
3015     case DW_OP_breg24:
3016     case DW_OP_breg25:
3017     case DW_OP_breg26:
3018     case DW_OP_breg27:
3019     case DW_OP_breg28:
3020     case DW_OP_breg29:
3021     case DW_OP_breg30:
3022     case DW_OP_breg31:
3023       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3024       break;
3025     case DW_OP_regx:
3026       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3027       break;
3028     case DW_OP_fbreg:
3029       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3030       break;
3031     case DW_OP_bregx:
3032       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3033       dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
3034       break;
3035     case DW_OP_piece:
3036       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3037       break;
3038     case DW_OP_deref_size:
3039     case DW_OP_xderef_size:
3040       dw2_asm_output_data (1, val1->v.val_int, NULL);
3041       break;
3042
3043     case INTERNAL_DW_OP_tls_addr:
3044 #ifdef ASM_OUTPUT_DWARF_DTPREL
3045       ASM_OUTPUT_DWARF_DTPREL (asm_out_file, DWARF2_ADDR_SIZE,
3046                                val1->v.val_addr);
3047       fputc ('\n', asm_out_file);
3048 #else
3049       abort ();
3050 #endif
3051       break;
3052
3053     default:
3054       /* Other codes have no operands.  */
3055       break;
3056     }
3057 }
3058
3059 /* Output a sequence of location operations.  */
3060
3061 static void
3062 output_loc_sequence (loc)
3063      dw_loc_descr_ref loc;
3064 {
3065   for (; loc != NULL; loc = loc->dw_loc_next)
3066     {
3067       /* Output the opcode.  */
3068       dw2_asm_output_data (1, loc->dw_loc_opc,
3069                            "%s", dwarf_stack_op_name (loc->dw_loc_opc));
3070
3071       /* Output the operand(s) (if any).  */
3072       output_loc_operands (loc);
3073     }
3074 }
3075
3076 /* This routine will generate the correct assembly data for a location
3077    description based on a cfi entry with a complex address.  */
3078
3079 static void
3080 output_cfa_loc (cfi)
3081      dw_cfi_ref cfi;
3082 {
3083   dw_loc_descr_ref loc;
3084   unsigned long size;
3085
3086   /* Output the size of the block.  */
3087   loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
3088   size = size_of_locs (loc);
3089   dw2_asm_output_data_uleb128 (size, NULL);
3090
3091   /* Now output the operations themselves.  */
3092   output_loc_sequence (loc);
3093 }
3094
3095 /* This function builds a dwarf location descriptor sequence from
3096    a dw_cfa_location.  */
3097
3098 static struct dw_loc_descr_struct *
3099 build_cfa_loc (cfa)
3100      dw_cfa_location *cfa;
3101 {
3102   struct dw_loc_descr_struct *head, *tmp;
3103
3104   if (cfa->indirect == 0)
3105     abort ();
3106
3107   if (cfa->base_offset)
3108     {
3109       if (cfa->reg <= 31)
3110         head = new_loc_descr (DW_OP_breg0 + cfa->reg, cfa->base_offset, 0);
3111       else
3112         head = new_loc_descr (DW_OP_bregx, cfa->reg, cfa->base_offset);
3113     }
3114   else if (cfa->reg <= 31)
3115     head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0);
3116   else
3117     head = new_loc_descr (DW_OP_regx, cfa->reg, 0);
3118
3119   head->dw_loc_oprnd1.val_class = dw_val_class_const;
3120   tmp = new_loc_descr (DW_OP_deref, 0, 0);
3121   add_loc_descr (&head, tmp);
3122   if (cfa->offset != 0)
3123     {
3124       tmp = new_loc_descr (DW_OP_plus_uconst, cfa->offset, 0);
3125       add_loc_descr (&head, tmp);
3126     }
3127
3128   return head;
3129 }
3130
3131 /* This function fills in aa dw_cfa_location structure from a dwarf location
3132    descriptor sequence.  */
3133
3134 static void
3135 get_cfa_from_loc_descr (cfa, loc)
3136      dw_cfa_location *cfa;
3137      struct dw_loc_descr_struct *loc;
3138 {
3139   struct dw_loc_descr_struct *ptr;
3140   cfa->offset = 0;
3141   cfa->base_offset = 0;
3142   cfa->indirect = 0;
3143   cfa->reg = -1;
3144
3145   for (ptr = loc; ptr != NULL; ptr = ptr->dw_loc_next)
3146     {
3147       enum dwarf_location_atom op = ptr->dw_loc_opc;
3148
3149       switch (op)
3150         {
3151         case DW_OP_reg0:
3152         case DW_OP_reg1:
3153         case DW_OP_reg2:
3154         case DW_OP_reg3:
3155         case DW_OP_reg4:
3156         case DW_OP_reg5:
3157         case DW_OP_reg6:
3158         case DW_OP_reg7:
3159         case DW_OP_reg8:
3160         case DW_OP_reg9:
3161         case DW_OP_reg10:
3162         case DW_OP_reg11:
3163         case DW_OP_reg12:
3164         case DW_OP_reg13:
3165         case DW_OP_reg14:
3166         case DW_OP_reg15:
3167         case DW_OP_reg16:
3168         case DW_OP_reg17:
3169         case DW_OP_reg18:
3170         case DW_OP_reg19:
3171         case DW_OP_reg20:
3172         case DW_OP_reg21:
3173         case DW_OP_reg22:
3174         case DW_OP_reg23:
3175         case DW_OP_reg24:
3176         case DW_OP_reg25:
3177         case DW_OP_reg26:
3178         case DW_OP_reg27:
3179         case DW_OP_reg28:
3180         case DW_OP_reg29:
3181         case DW_OP_reg30:
3182         case DW_OP_reg31:
3183           cfa->reg = op - DW_OP_reg0;
3184           break;
3185         case DW_OP_regx:
3186           cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
3187           break;
3188         case DW_OP_breg0:
3189         case DW_OP_breg1:
3190         case DW_OP_breg2:
3191         case DW_OP_breg3:
3192         case DW_OP_breg4:
3193         case DW_OP_breg5:
3194         case DW_OP_breg6:
3195         case DW_OP_breg7:
3196         case DW_OP_breg8:
3197         case DW_OP_breg9:
3198         case DW_OP_breg10:
3199         case DW_OP_breg11:
3200         case DW_OP_breg12:
3201         case DW_OP_breg13:
3202         case DW_OP_breg14:
3203         case DW_OP_breg15:
3204         case DW_OP_breg16:
3205         case DW_OP_breg17:
3206         case DW_OP_breg18:
3207         case DW_OP_breg19:
3208         case DW_OP_breg20:
3209         case DW_OP_breg21:
3210         case DW_OP_breg22:
3211         case DW_OP_breg23:
3212         case DW_OP_breg24:
3213         case DW_OP_breg25:
3214         case DW_OP_breg26:
3215         case DW_OP_breg27:
3216         case DW_OP_breg28:
3217         case DW_OP_breg29:
3218         case DW_OP_breg30:
3219         case DW_OP_breg31:
3220           cfa->reg = op - DW_OP_breg0;
3221           cfa->base_offset = ptr->dw_loc_oprnd1.v.val_int;
3222           break;
3223         case DW_OP_bregx:
3224           cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
3225           cfa->base_offset = ptr->dw_loc_oprnd2.v.val_int;
3226           break;
3227         case DW_OP_deref:
3228           cfa->indirect = 1;
3229           break;
3230         case DW_OP_plus_uconst:
3231           cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned;
3232           break;
3233         default:
3234           internal_error ("DW_LOC_OP %s not implemented\n",
3235                           dwarf_stack_op_name (ptr->dw_loc_opc));
3236         }
3237     }
3238 }
3239 #endif /* .debug_frame support */
3240 \f
3241 /* And now, the support for symbolic debugging information.  */
3242 #ifdef DWARF2_DEBUGGING_INFO
3243
3244 /* .debug_str support.  */
3245 static int output_indirect_string       PARAMS ((void **, void *));
3246
3247 static void dwarf2out_init              PARAMS ((const char *));
3248 static void dwarf2out_finish            PARAMS ((const char *));
3249 static void dwarf2out_define            PARAMS ((unsigned int, const char *));
3250 static void dwarf2out_undef             PARAMS ((unsigned int, const char *));
3251 static void dwarf2out_start_source_file PARAMS ((unsigned, const char *));
3252 static void dwarf2out_end_source_file   PARAMS ((unsigned));
3253 static void dwarf2out_begin_block       PARAMS ((unsigned, unsigned));
3254 static void dwarf2out_end_block         PARAMS ((unsigned, unsigned));
3255 static bool dwarf2out_ignore_block      PARAMS ((tree));
3256 static void dwarf2out_global_decl       PARAMS ((tree));
3257 static void dwarf2out_abstract_function PARAMS ((tree));
3258
3259 /* The debug hooks structure.  */
3260
3261 const struct gcc_debug_hooks dwarf2_debug_hooks =
3262 {
3263   dwarf2out_init,
3264   dwarf2out_finish,
3265   dwarf2out_define,
3266   dwarf2out_undef,
3267   dwarf2out_start_source_file,
3268   dwarf2out_end_source_file,
3269   dwarf2out_begin_block,
3270   dwarf2out_end_block,
3271   dwarf2out_ignore_block,
3272   dwarf2out_source_line,
3273   dwarf2out_begin_prologue,
3274   debug_nothing_int_charstar,   /* end_prologue */
3275   dwarf2out_end_epilogue,
3276   debug_nothing_tree,           /* begin_function */
3277   debug_nothing_int,            /* end_function */
3278   dwarf2out_decl,               /* function_decl */
3279   dwarf2out_global_decl,
3280   debug_nothing_tree,           /* deferred_inline_function */
3281   /* The DWARF 2 backend tries to reduce debugging bloat by not
3282      emitting the abstract description of inline functions until
3283      something tries to reference them.  */
3284   dwarf2out_abstract_function,  /* outlining_inline_function */
3285   debug_nothing_rtx,            /* label */
3286   debug_nothing_int             /* handle_pch */
3287 };
3288 #endif
3289 \f
3290 /* NOTE: In the comments in this file, many references are made to
3291    "Debugging Information Entries".  This term is abbreviated as `DIE'
3292    throughout the remainder of this file.  */
3293
3294 /* An internal representation of the DWARF output is built, and then
3295    walked to generate the DWARF debugging info.  The walk of the internal
3296    representation is done after the entire program has been compiled.
3297    The types below are used to describe the internal representation.  */
3298
3299 /* Various DIE's use offsets relative to the beginning of the
3300    .debug_info section to refer to each other.  */
3301
3302 typedef long int dw_offset;
3303
3304 /* Define typedefs here to avoid circular dependencies.  */
3305
3306 typedef struct dw_attr_struct *dw_attr_ref;
3307 typedef struct dw_line_info_struct *dw_line_info_ref;
3308 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
3309 typedef struct pubname_struct *pubname_ref;
3310 typedef struct dw_ranges_struct *dw_ranges_ref;
3311
3312 /* Each entry in the line_info_table maintains the file and
3313    line number associated with the label generated for that
3314    entry.  The label gives the PC value associated with
3315    the line number entry.  */
3316
3317 typedef struct dw_line_info_struct GTY(())
3318 {
3319   unsigned long dw_file_num;
3320   unsigned long dw_line_num;
3321 }
3322 dw_line_info_entry;
3323
3324 /* Line information for functions in separate sections; each one gets its
3325    own sequence.  */
3326 typedef struct dw_separate_line_info_struct GTY(())
3327 {
3328   unsigned long dw_file_num;
3329   unsigned long dw_line_num;
3330   unsigned long function;
3331 }
3332 dw_separate_line_info_entry;
3333
3334 /* Each DIE attribute has a field specifying the attribute kind,
3335    a link to the next attribute in the chain, and an attribute value.
3336    Attributes are typically linked below the DIE they modify.  */
3337
3338 typedef struct dw_attr_struct GTY(())
3339 {
3340   enum dwarf_attribute dw_attr;
3341   dw_attr_ref dw_attr_next;
3342   dw_val_node dw_attr_val;
3343 }
3344 dw_attr_node;
3345
3346 /* The Debugging Information Entry (DIE) structure */
3347
3348 typedef struct die_struct GTY(())
3349 {
3350   enum dwarf_tag die_tag;
3351   char *die_symbol;
3352   dw_attr_ref die_attr;
3353   dw_die_ref die_parent;
3354   dw_die_ref die_child;
3355   dw_die_ref die_sib;
3356   dw_offset die_offset;
3357   unsigned long die_abbrev;
3358   int die_mark;
3359 }
3360 die_node;
3361
3362 /* The pubname structure */
3363
3364 typedef struct pubname_struct GTY(())
3365 {
3366   dw_die_ref die;
3367   char *name;
3368 }
3369 pubname_entry;
3370
3371 struct dw_ranges_struct GTY(())
3372 {
3373   int block_num;
3374 };
3375
3376 /* The limbo die list structure.  */
3377 typedef struct limbo_die_struct GTY(())
3378 {
3379   dw_die_ref die;
3380   tree created_for;
3381   struct limbo_die_struct *next;
3382 }
3383 limbo_die_node;
3384
3385 /* How to start an assembler comment.  */
3386 #ifndef ASM_COMMENT_START
3387 #define ASM_COMMENT_START ";#"
3388 #endif
3389
3390 /* Define a macro which returns nonzero for a TYPE_DECL which was
3391    implicitly generated for a tagged type.
3392
3393    Note that unlike the gcc front end (which generates a NULL named
3394    TYPE_DECL node for each complete tagged type, each array type, and
3395    each function type node created) the g++ front end generates a
3396    _named_ TYPE_DECL node for each tagged type node created.
3397    These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
3398    generate a DW_TAG_typedef DIE for them.  */
3399
3400 #define TYPE_DECL_IS_STUB(decl)                         \
3401   (DECL_NAME (decl) == NULL_TREE                        \
3402    || (DECL_ARTIFICIAL (decl)                           \
3403        && is_tagged_type (TREE_TYPE (decl))             \
3404        && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl)))  \
3405            /* This is necessary for stub decls that     \
3406               appear in nested inline functions.  */    \
3407            || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
3408                && (decl_ultimate_origin (decl)          \
3409                    == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
3410
3411 /* Information concerning the compilation unit's programming
3412    language, and compiler version.  */
3413
3414 /* Fixed size portion of the DWARF compilation unit header.  */
3415 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
3416   (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
3417
3418 /* Fixed size portion of public names info.  */
3419 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
3420
3421 /* Fixed size portion of the address range info.  */
3422 #define DWARF_ARANGES_HEADER_SIZE                                       \
3423   (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4,      \
3424                 DWARF2_ADDR_SIZE * 2)                                   \
3425    - DWARF_INITIAL_LENGTH_SIZE)
3426
3427 /* Size of padding portion in the address range info.  It must be
3428    aligned to twice the pointer size.  */
3429 #define DWARF_ARANGES_PAD_SIZE \
3430   (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3431                 DWARF2_ADDR_SIZE * 2) \
3432    - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
3433
3434 /* Use assembler line directives if available.  */
3435 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
3436 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
3437 #define DWARF2_ASM_LINE_DEBUG_INFO 1
3438 #else
3439 #define DWARF2_ASM_LINE_DEBUG_INFO 0
3440 #endif
3441 #endif
3442
3443 /* Minimum line offset in a special line info. opcode.
3444    This value was chosen to give a reasonable range of values.  */
3445 #define DWARF_LINE_BASE  -10
3446
3447 /* First special line opcode - leave room for the standard opcodes.  */
3448 #define DWARF_LINE_OPCODE_BASE  10
3449
3450 /* Range of line offsets in a special line info. opcode.  */
3451 #define DWARF_LINE_RANGE  (254-DWARF_LINE_OPCODE_BASE+1)
3452
3453 /* Flag that indicates the initial value of the is_stmt_start flag.
3454    In the present implementation, we do not mark any lines as
3455    the beginning of a source statement, because that information
3456    is not made available by the GCC front-end.  */
3457 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
3458
3459 #ifdef DWARF2_DEBUGGING_INFO
3460 /* This location is used by calc_die_sizes() to keep track
3461    the offset of each DIE within the .debug_info section.  */
3462 static unsigned long next_die_offset;
3463 #endif
3464
3465 /* Record the root of the DIE's built for the current compilation unit.  */
3466 static GTY(()) dw_die_ref comp_unit_die;
3467
3468 #ifdef DWARF2_DEBUGGING_INFO
3469 /* We need special handling in dwarf2out_start_source_file if it is
3470    first one.  */
3471 static int is_main_source;
3472 #endif
3473
3474 /* A list of DIEs with a NULL parent waiting to be relocated.  */
3475 static GTY(()) limbo_die_node *limbo_die_list;
3476
3477 /* Filenames referenced by this compilation unit.  */
3478 static GTY(()) varray_type file_table;
3479 static GTY(()) varray_type file_table_emitted;
3480 static GTY(()) size_t file_table_last_lookup_index;
3481
3482 /* A pointer to the base of a table of references to DIE's that describe
3483    declarations.  The table is indexed by DECL_UID() which is a unique
3484    number identifying each decl.  */
3485 static GTY((length ("decl_die_table_allocated"))) dw_die_ref *decl_die_table;
3486
3487 /* Number of elements currently allocated for the decl_die_table.  */
3488 static unsigned decl_die_table_allocated;
3489
3490 #ifdef DWARF2_DEBUGGING_INFO
3491 /* Number of elements in decl_die_table currently in use.  */
3492 static unsigned decl_die_table_in_use;
3493 #endif
3494
3495 /* Size (in elements) of increments by which we may expand the
3496    decl_die_table.  */
3497 #define DECL_DIE_TABLE_INCREMENT 256
3498
3499 /* A pointer to the base of a list of references to DIE's that
3500    are uniquely identified by their tag, presence/absence of
3501    children DIE's, and list of attribute/value pairs.  */
3502 static GTY((length ("abbrev_die_table_allocated")))
3503   dw_die_ref *abbrev_die_table;
3504
3505 /* Number of elements currently allocated for abbrev_die_table.  */
3506 static unsigned abbrev_die_table_allocated;
3507
3508 #ifdef DWARF2_DEBUGGING_INFO
3509 /* Number of elements in type_die_table currently in use.  */
3510 static unsigned abbrev_die_table_in_use;
3511 #endif
3512
3513 /* Size (in elements) of increments by which we may expand the
3514    abbrev_die_table.  */
3515 #define ABBREV_DIE_TABLE_INCREMENT 256
3516
3517 /* A pointer to the base of a table that contains line information
3518    for each source code line in .text in the compilation unit.  */
3519 static GTY((length ("line_info_table_allocated")))
3520      dw_line_info_ref line_info_table;
3521
3522 /* Number of elements currently allocated for line_info_table.  */
3523 static unsigned line_info_table_allocated;
3524
3525 #ifdef DWARF2_DEBUGGING_INFO
3526 /* Number of elements in line_info_table currently in use.  */
3527 static unsigned line_info_table_in_use;
3528 #endif
3529
3530 /* A pointer to the base of a table that contains line information
3531    for each source code line outside of .text in the compilation unit.  */
3532 static GTY ((length ("separate_line_info_table_allocated")))
3533      dw_separate_line_info_ref separate_line_info_table;
3534
3535 /* Number of elements currently allocated for separate_line_info_table.  */
3536 static unsigned separate_line_info_table_allocated;
3537
3538 #ifdef DWARF2_DEBUGGING_INFO
3539 /* Number of elements in separate_line_info_table currently in use.  */
3540 static unsigned separate_line_info_table_in_use;
3541 #endif
3542
3543 /* Size (in elements) of increments by which we may expand the
3544    line_info_table.  */
3545 #define LINE_INFO_TABLE_INCREMENT 1024
3546
3547 /* A pointer to the base of a table that contains a list of publicly
3548    accessible names.  */
3549 static GTY ((length ("pubname_table_allocated"))) pubname_ref pubname_table;
3550
3551 /* Number of elements currently allocated for pubname_table.  */
3552 static unsigned pubname_table_allocated;
3553
3554 #ifdef DWARF2_DEBUGGING_INFO
3555 /* Number of elements in pubname_table currently in use.  */
3556 static unsigned pubname_table_in_use;
3557 #endif
3558
3559 /* Size (in elements) of increments by which we may expand the
3560    pubname_table.  */
3561 #define PUBNAME_TABLE_INCREMENT 64
3562
3563 /* Array of dies for which we should generate .debug_arange info.  */
3564 static GTY((length ("arange_table_allocated"))) dw_die_ref *arange_table;
3565
3566 /* Number of elements currently allocated for arange_table.  */
3567 static unsigned arange_table_allocated;
3568
3569 #ifdef DWARF2_DEBUGGING_INFO
3570 /* Number of elements in arange_table currently in use.  */
3571 static unsigned arange_table_in_use;
3572 #endif
3573
3574 /* Size (in elements) of increments by which we may expand the
3575    arange_table.  */
3576 #define ARANGE_TABLE_INCREMENT 64
3577
3578 /* Array of dies for which we should generate .debug_ranges info.  */
3579 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;
3580
3581 /* Number of elements currently allocated for ranges_table.  */
3582 static unsigned ranges_table_allocated;
3583
3584 #ifdef DWARF2_DEBUGGING_INFO
3585 /* Number of elements in ranges_table currently in use.  */
3586 static unsigned ranges_table_in_use;
3587
3588 /* Size (in elements) of increments by which we may expand the
3589    ranges_table.  */
3590 #define RANGES_TABLE_INCREMENT 64
3591
3592 /* Whether we have location lists that need outputting */
3593 static unsigned have_location_lists;
3594
3595 /* Record whether the function being analyzed contains inlined functions.  */
3596 static int current_function_has_inlines;
3597 #endif
3598 #if 0 && defined (MIPS_DEBUGGING_INFO)
3599 static int comp_unit_has_inlines;
3600 #endif
3601
3602 #ifdef DWARF2_DEBUGGING_INFO
3603
3604 /* Forward declarations for functions defined in this file.  */
3605
3606 static int is_pseudo_reg                PARAMS ((rtx));
3607 static tree type_main_variant           PARAMS ((tree));
3608 static int is_tagged_type               PARAMS ((tree));
3609 static const char *dwarf_tag_name       PARAMS ((unsigned));
3610 static const char *dwarf_attr_name      PARAMS ((unsigned));
3611 static const char *dwarf_form_name      PARAMS ((unsigned));
3612 #if 0
3613 static const char *dwarf_type_encoding_name PARAMS ((unsigned));
3614 #endif
3615 static tree decl_ultimate_origin        PARAMS ((tree));
3616 static tree block_ultimate_origin       PARAMS ((tree));
3617 static tree decl_class_context          PARAMS ((tree));
3618 static void add_dwarf_attr              PARAMS ((dw_die_ref, dw_attr_ref));
3619 static inline enum dw_val_class AT_class        PARAMS ((dw_attr_ref));
3620 static void add_AT_flag                 PARAMS ((dw_die_ref,
3621                                                  enum dwarf_attribute,
3622                                                  unsigned));
3623 static inline unsigned AT_flag          PARAMS ((dw_attr_ref));
3624 static void add_AT_int                  PARAMS ((dw_die_ref,
3625                                                  enum dwarf_attribute, long));
3626 static inline long int AT_int           PARAMS ((dw_attr_ref));
3627 static void add_AT_unsigned             PARAMS ((dw_die_ref,
3628                                                  enum dwarf_attribute,
3629                                                  unsigned long));
3630 static inline unsigned long             AT_unsigned PARAMS ((dw_attr_ref));
3631 static void add_AT_long_long            PARAMS ((dw_die_ref,
3632                                                  enum dwarf_attribute,
3633                                                  unsigned long,
3634                                                  unsigned long));
3635 static void add_AT_float                PARAMS ((dw_die_ref,
3636                                                  enum dwarf_attribute,
3637                                                  unsigned, long *));
3638 static hashval_t debug_str_do_hash      PARAMS ((const void *));
3639 static int debug_str_eq                 PARAMS ((const void *, const void *));
3640 static void add_AT_string               PARAMS ((dw_die_ref,
3641                                                  enum dwarf_attribute,
3642                                                  const char *));
3643 static inline const char *AT_string     PARAMS ((dw_attr_ref));
3644 static int AT_string_form               PARAMS ((dw_attr_ref));
3645 static void add_AT_die_ref              PARAMS ((dw_die_ref,
3646                                                  enum dwarf_attribute,
3647                                                  dw_die_ref));
3648 static inline dw_die_ref AT_ref         PARAMS ((dw_attr_ref));
3649 static inline int AT_ref_external       PARAMS ((dw_attr_ref));
3650 static inline void set_AT_ref_external  PARAMS ((dw_attr_ref, int));
3651 static void add_AT_fde_ref              PARAMS ((dw_die_ref,
3652                                                  enum dwarf_attribute,
3653                                                  unsigned));
3654 static void add_AT_loc                  PARAMS ((dw_die_ref,
3655                                                  enum dwarf_attribute,
3656                                                  dw_loc_descr_ref));
3657 static inline dw_loc_descr_ref AT_loc   PARAMS ((dw_attr_ref));
3658 static void add_AT_loc_list             PARAMS ((dw_die_ref,
3659                                                  enum dwarf_attribute,
3660                                                  dw_loc_list_ref));
3661 static inline dw_loc_list_ref AT_loc_list PARAMS ((dw_attr_ref));
3662 static void add_AT_addr                 PARAMS ((dw_die_ref,
3663                                                  enum dwarf_attribute,
3664                                                  rtx));
3665 static inline rtx AT_addr               PARAMS ((dw_attr_ref));
3666 static void add_AT_lbl_id               PARAMS ((dw_die_ref,
3667                                                  enum dwarf_attribute,
3668                                                  const char *));
3669 static void add_AT_lbl_offset           PARAMS ((dw_die_ref,
3670                                                  enum dwarf_attribute,
3671                                                  const char *));
3672 static void add_AT_offset               PARAMS ((dw_die_ref,
3673                                                  enum dwarf_attribute,
3674                                                  unsigned long));
3675 static void add_AT_range_list           PARAMS ((dw_die_ref,
3676                                                  enum dwarf_attribute,
3677                                                  unsigned long));
3678 static inline const char *AT_lbl        PARAMS ((dw_attr_ref));
3679 static dw_attr_ref get_AT               PARAMS ((dw_die_ref,
3680                                                  enum dwarf_attribute));
3681 static const char *get_AT_low_pc        PARAMS ((dw_die_ref));
3682 static const char *get_AT_hi_pc         PARAMS ((dw_die_ref));
3683 static const char *get_AT_string        PARAMS ((dw_die_ref,
3684                                                  enum dwarf_attribute));
3685 static int get_AT_flag                  PARAMS ((dw_die_ref,
3686                                                  enum dwarf_attribute));
3687 static unsigned get_AT_unsigned         PARAMS ((dw_die_ref,
3688                                                  enum dwarf_attribute));
3689 static inline dw_die_ref get_AT_ref     PARAMS ((dw_die_ref,
3690                                                  enum dwarf_attribute));
3691 static int is_c_family                  PARAMS ((void));
3692 static int is_cxx                       PARAMS ((void));
3693 static int is_java                      PARAMS ((void));
3694 static int is_fortran                   PARAMS ((void));
3695 static void remove_AT                   PARAMS ((dw_die_ref,
3696                                                  enum dwarf_attribute));
3697 static inline void free_die             PARAMS ((dw_die_ref));
3698 static void remove_children             PARAMS ((dw_die_ref));
3699 static void add_child_die               PARAMS ((dw_die_ref, dw_die_ref));
3700 static dw_die_ref new_die               PARAMS ((enum dwarf_tag, dw_die_ref,
3701                                                  tree));
3702 static dw_die_ref lookup_type_die       PARAMS ((tree));
3703 static void equate_type_number_to_die   PARAMS ((tree, dw_die_ref));
3704 static dw_die_ref lookup_decl_die       PARAMS ((tree));
3705 static void equate_decl_number_to_die   PARAMS ((tree, dw_die_ref));
3706 static void print_spaces                PARAMS ((FILE *));
3707 static void print_die                   PARAMS ((dw_die_ref, FILE *));
3708 static void print_dwarf_line_table      PARAMS ((FILE *));
3709 static void reverse_die_lists           PARAMS ((dw_die_ref));
3710 static void reverse_all_dies            PARAMS ((dw_die_ref));
3711 static dw_die_ref push_new_compile_unit PARAMS ((dw_die_ref, dw_die_ref));
3712 static dw_die_ref pop_compile_unit      PARAMS ((dw_die_ref));
3713 static void loc_checksum                PARAMS ((dw_loc_descr_ref,
3714                                                  struct md5_ctx *));
3715 static void attr_checksum               PARAMS ((dw_attr_ref,
3716                                                  struct md5_ctx *,
3717                                                  int *));
3718 static void die_checksum                PARAMS ((dw_die_ref,
3719                                                  struct md5_ctx *,
3720                                                  int *));
3721 static int same_loc_p                   PARAMS ((dw_loc_descr_ref,
3722                                                  dw_loc_descr_ref, int *));
3723 static int same_dw_val_p                PARAMS ((dw_val_node *, dw_val_node *,
3724                                                  int *));
3725 static int same_attr_p                  PARAMS ((dw_attr_ref, dw_attr_ref, int *));
3726 static int same_die_p                   PARAMS ((dw_die_ref, dw_die_ref, int *));
3727 static int same_die_p_wrap              PARAMS ((dw_die_ref, dw_die_ref));
3728 static void compute_section_prefix      PARAMS ((dw_die_ref));
3729 static int is_type_die                  PARAMS ((dw_die_ref));
3730 static int is_comdat_die                PARAMS ((dw_die_ref));
3731 static int is_symbol_die                PARAMS ((dw_die_ref));
3732 static void assign_symbol_names         PARAMS ((dw_die_ref));
3733 static void break_out_includes          PARAMS ((dw_die_ref));
3734 static hashval_t htab_cu_hash           PARAMS ((const void *));
3735 static int htab_cu_eq                   PARAMS ((const void *, const void *));
3736 static void htab_cu_del                 PARAMS ((void *));
3737 static int check_duplicate_cu           PARAMS ((dw_die_ref, htab_t, unsigned *));
3738 static void record_comdat_symbol_number PARAMS ((dw_die_ref, htab_t, unsigned));
3739 static void add_sibling_attributes      PARAMS ((dw_die_ref));
3740 static void build_abbrev_table          PARAMS ((dw_die_ref));
3741 static void output_location_lists       PARAMS ((dw_die_ref));
3742 static int constant_size                PARAMS ((long unsigned));
3743 static unsigned long size_of_die        PARAMS ((dw_die_ref));
3744 static void calc_die_sizes              PARAMS ((dw_die_ref));
3745 static void mark_dies                   PARAMS ((dw_die_ref));
3746 static void unmark_dies                 PARAMS ((dw_die_ref));
3747 static void unmark_all_dies             PARAMS ((dw_die_ref));
3748 static unsigned long size_of_pubnames   PARAMS ((void));
3749 static unsigned long size_of_aranges    PARAMS ((void));
3750 static enum dwarf_form value_format     PARAMS ((dw_attr_ref));
3751 static void output_value_format         PARAMS ((dw_attr_ref));
3752 static void output_abbrev_section       PARAMS ((void));
3753 static void output_die_symbol           PARAMS ((dw_die_ref));
3754 static void output_die                  PARAMS ((dw_die_ref));
3755 static void output_compilation_unit_header PARAMS ((void));
3756 static void output_comp_unit            PARAMS ((dw_die_ref, int));
3757 static const char *dwarf2_name          PARAMS ((tree, int));
3758 static void add_pubname                 PARAMS ((tree, dw_die_ref));
3759 static void output_pubnames             PARAMS ((void));
3760 static void add_arange                  PARAMS ((tree, dw_die_ref));
3761 static void output_aranges              PARAMS ((void));
3762 static unsigned int add_ranges          PARAMS ((tree));
3763 static void output_ranges               PARAMS ((void));
3764 static void output_line_info            PARAMS ((void));
3765 static void output_file_names           PARAMS ((void));
3766 static dw_die_ref base_type_die         PARAMS ((tree));
3767 static tree root_type                   PARAMS ((tree));
3768 static int is_base_type                 PARAMS ((tree));
3769 static dw_die_ref modified_type_die     PARAMS ((tree, int, int, dw_die_ref));
3770 static int type_is_enum                 PARAMS ((tree));
3771 static unsigned int reg_number          PARAMS ((rtx));
3772 static dw_loc_descr_ref reg_loc_descriptor PARAMS ((rtx));
3773 static dw_loc_descr_ref one_reg_loc_descriptor PARAMS ((unsigned int));
3774 static dw_loc_descr_ref multiple_reg_loc_descriptor PARAMS ((rtx, rtx));
3775 static dw_loc_descr_ref int_loc_descriptor PARAMS ((HOST_WIDE_INT));
3776 static dw_loc_descr_ref based_loc_descr PARAMS ((unsigned, long));
3777 static int is_based_loc                 PARAMS ((rtx));
3778 static dw_loc_descr_ref mem_loc_descriptor PARAMS ((rtx, enum machine_mode mode));
3779 static dw_loc_descr_ref concat_loc_descriptor PARAMS ((rtx, rtx));
3780 static dw_loc_descr_ref loc_descriptor  PARAMS ((rtx));
3781 static dw_loc_descr_ref loc_descriptor_from_tree PARAMS ((tree, int));
3782 static HOST_WIDE_INT ceiling            PARAMS ((HOST_WIDE_INT, unsigned int));
3783 static tree field_type                  PARAMS ((tree));
3784 static unsigned int simple_type_align_in_bits PARAMS ((tree));
3785 static unsigned int simple_decl_align_in_bits PARAMS ((tree));
3786 static unsigned HOST_WIDE_INT simple_type_size_in_bits PARAMS ((tree));
3787 static HOST_WIDE_INT field_byte_offset  PARAMS ((tree));
3788 static void add_AT_location_description PARAMS ((dw_die_ref,
3789                                                  enum dwarf_attribute,
3790                                                  dw_loc_descr_ref));
3791 static void add_data_member_location_attribute PARAMS ((dw_die_ref, tree));
3792 static void add_const_value_attribute   PARAMS ((dw_die_ref, rtx));
3793 static rtx rtl_for_decl_location        PARAMS ((tree));
3794 static void add_location_or_const_value_attribute PARAMS ((dw_die_ref, tree));
3795 static void tree_add_const_value_attribute PARAMS ((dw_die_ref, tree));
3796 static void add_name_attribute          PARAMS ((dw_die_ref, const char *));
3797 static void add_comp_dir_attribute      PARAMS ((dw_die_ref));
3798 static void add_bound_info              PARAMS ((dw_die_ref,
3799                                                  enum dwarf_attribute, tree));
3800 static void add_subscript_info          PARAMS ((dw_die_ref, tree));
3801 static void add_byte_size_attribute     PARAMS ((dw_die_ref, tree));
3802 static void add_bit_offset_attribute    PARAMS ((dw_die_ref, tree));
3803 static void add_bit_size_attribute      PARAMS ((dw_die_ref, tree));
3804 static void add_prototyped_attribute    PARAMS ((dw_die_ref, tree));
3805 static void add_abstract_origin_attribute PARAMS ((dw_die_ref, tree));
3806 static void add_pure_or_virtual_attribute PARAMS ((dw_die_ref, tree));
3807 static void add_src_coords_attributes   PARAMS ((dw_die_ref, tree));
3808 static void add_name_and_src_coords_attributes PARAMS ((dw_die_ref, tree));
3809 static void push_decl_scope             PARAMS ((tree));
3810 static void pop_decl_scope              PARAMS ((void));
3811 static dw_die_ref scope_die_for         PARAMS ((tree, dw_die_ref));
3812 static inline int local_scope_p         PARAMS ((dw_die_ref));
3813 static inline int class_scope_p         PARAMS ((dw_die_ref));
3814 static void add_type_attribute          PARAMS ((dw_die_ref, tree, int, int,
3815                                                  dw_die_ref));
3816 static const char *type_tag             PARAMS ((tree));
3817 static tree member_declared_type        PARAMS ((tree));
3818 #if 0
3819 static const char *decl_start_label     PARAMS ((tree));
3820 #endif
3821 static void gen_array_type_die          PARAMS ((tree, dw_die_ref));
3822 static void gen_set_type_die            PARAMS ((tree, dw_die_ref));
3823 #if 0
3824 static void gen_entry_point_die         PARAMS ((tree, dw_die_ref));
3825 #endif
3826 static void gen_inlined_enumeration_type_die PARAMS ((tree, dw_die_ref));
3827 static void gen_inlined_structure_type_die PARAMS ((tree, dw_die_ref));
3828 static void gen_inlined_union_type_die  PARAMS ((tree, dw_die_ref));
3829 static void gen_enumeration_type_die    PARAMS ((tree, dw_die_ref));
3830 static dw_die_ref gen_formal_parameter_die PARAMS ((tree, dw_die_ref));
3831 static void gen_unspecified_parameters_die PARAMS ((tree, dw_die_ref));
3832 static void gen_formal_types_die        PARAMS ((tree, dw_die_ref));
3833 static void gen_subprogram_die          PARAMS ((tree, dw_die_ref));
3834 static void gen_variable_die            PARAMS ((tree, dw_die_ref));
3835 static void gen_label_die               PARAMS ((tree, dw_die_ref));
3836 static void gen_lexical_block_die       PARAMS ((tree, dw_die_ref, int));
3837 static void gen_inlined_subroutine_die  PARAMS ((tree, dw_die_ref, int));
3838 static void gen_field_die               PARAMS ((tree, dw_die_ref));
3839 static void gen_ptr_to_mbr_type_die     PARAMS ((tree, dw_die_ref));
3840 static dw_die_ref gen_compile_unit_die  PARAMS ((const char *));
3841 static void gen_string_type_die         PARAMS ((tree, dw_die_ref));
3842 static void gen_inheritance_die         PARAMS ((tree, tree, dw_die_ref));
3843 static void gen_member_die              PARAMS ((tree, dw_die_ref));
3844 static void gen_struct_or_union_type_die PARAMS ((tree, dw_die_ref));
3845 static void gen_subroutine_type_die     PARAMS ((tree, dw_die_ref));
3846 static void gen_typedef_die             PARAMS ((tree, dw_die_ref));
3847 static void gen_type_die                PARAMS ((tree, dw_die_ref));
3848 static void gen_tagged_type_instantiation_die PARAMS ((tree, dw_die_ref));
3849 static void gen_block_die               PARAMS ((tree, dw_die_ref, int));
3850 static void decls_for_scope             PARAMS ((tree, dw_die_ref, int));
3851 static int is_redundant_typedef         PARAMS ((tree));
3852 static void gen_decl_die                PARAMS ((tree, dw_die_ref));
3853 static unsigned lookup_filename         PARAMS ((const char *));
3854 static void init_file_table             PARAMS ((void));
3855 static void retry_incomplete_types      PARAMS ((void));
3856 static void gen_type_die_for_member     PARAMS ((tree, tree, dw_die_ref));
3857 static void splice_child_die            PARAMS ((dw_die_ref, dw_die_ref));
3858 static int file_info_cmp                PARAMS ((const void *, const void *));
3859 static dw_loc_list_ref new_loc_list     PARAMS ((dw_loc_descr_ref,
3860                                                  const char *, const char *,
3861                                                  const char *, unsigned));
3862 static void add_loc_descr_to_loc_list   PARAMS ((dw_loc_list_ref *,
3863                                                  dw_loc_descr_ref,
3864                                                  const char *, const char *, const char *));
3865 static void output_loc_list             PARAMS ((dw_loc_list_ref));
3866 static char *gen_internal_sym           PARAMS ((const char *));
3867
3868 static void prune_unmark_dies           PARAMS ((dw_die_ref));
3869 static void prune_unused_types_mark     PARAMS ((dw_die_ref, int));
3870 static void prune_unused_types_walk     PARAMS ((dw_die_ref));
3871 static void prune_unused_types_walk_attribs PARAMS ((dw_die_ref));
3872 static void prune_unused_types_prune    PARAMS ((dw_die_ref));
3873 static void prune_unused_types          PARAMS ((void));
3874 static int maybe_emit_file              PARAMS ((int));
3875
3876 /* Section names used to hold DWARF debugging information.  */
3877 #ifndef DEBUG_INFO_SECTION
3878 #define DEBUG_INFO_SECTION      ".debug_info"
3879 #endif
3880 #ifndef DEBUG_ABBREV_SECTION
3881 #define DEBUG_ABBREV_SECTION    ".debug_abbrev"
3882 #endif
3883 #ifndef DEBUG_ARANGES_SECTION
3884 #define DEBUG_ARANGES_SECTION   ".debug_aranges"
3885 #endif
3886 #ifndef DEBUG_MACINFO_SECTION
3887 #define DEBUG_MACINFO_SECTION   ".debug_macinfo"
3888 #endif
3889 #ifndef DEBUG_LINE_SECTION
3890 #define DEBUG_LINE_SECTION      ".debug_line"
3891 #endif
3892 #ifndef DEBUG_LOC_SECTION
3893 #define DEBUG_LOC_SECTION       ".debug_loc"
3894 #endif
3895 #ifndef DEBUG_PUBNAMES_SECTION
3896 #define DEBUG_PUBNAMES_SECTION  ".debug_pubnames"
3897 #endif
3898 #ifndef DEBUG_STR_SECTION
3899 #define DEBUG_STR_SECTION       ".debug_str"
3900 #endif
3901 #ifndef DEBUG_RANGES_SECTION
3902 #define DEBUG_RANGES_SECTION    ".debug_ranges"
3903 #endif
3904
3905 /* Standard ELF section names for compiled code and data.  */
3906 #ifndef TEXT_SECTION_NAME
3907 #define TEXT_SECTION_NAME       ".text"
3908 #endif
3909
3910 /* Section flags for .debug_str section.  */
3911 #ifdef HAVE_GAS_SHF_MERGE
3912 #define DEBUG_STR_SECTION_FLAGS \
3913   (SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1)
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 static inline int
5094 is_c_family ()
5095 {
5096   unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5097
5098   return (lang == DW_LANG_C || lang == DW_LANG_C89
5099           || lang == DW_LANG_C_plus_plus);
5100 }
5101
5102 static inline int
5103 is_cxx ()
5104 {
5105   return (get_AT_unsigned (comp_unit_die, DW_AT_language)
5106           == DW_LANG_C_plus_plus);
5107 }
5108
5109 static inline int
5110 is_fortran ()
5111 {
5112   unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5113
5114   return (lang == DW_LANG_Fortran77 || lang == DW_LANG_Fortran90);
5115 }
5116
5117 static inline int
5118 is_java ()
5119 {
5120   unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5121
5122   return (lang == DW_LANG_Java);
5123 }
5124
5125 /* Free up the memory used by A.  */
5126
5127 static inline void free_AT PARAMS ((dw_attr_ref));
5128 static inline void
5129 free_AT (a)
5130      dw_attr_ref a;
5131 {
5132   if (AT_class (a) == dw_val_class_str)
5133     if (a->dw_attr_val.v.val_str->refcount)
5134       a->dw_attr_val.v.val_str->refcount--;
5135 }
5136
5137 /* Remove the specified attribute if present.  */
5138
5139 static void
5140 remove_AT (die, attr_kind)
5141      dw_die_ref die;
5142      enum dwarf_attribute attr_kind;
5143 {
5144   dw_attr_ref *p;
5145   dw_attr_ref removed = NULL;
5146
5147   if (die != NULL)
5148     {
5149       for (p = &(die->die_attr); *p; p = &((*p)->dw_attr_next))
5150         if ((*p)->dw_attr == attr_kind)
5151           {
5152             removed = *p;
5153             *p = (*p)->dw_attr_next;
5154             break;
5155           }
5156
5157       if (removed != 0)
5158         free_AT (removed);
5159     }
5160 }
5161
5162 /* Free up the memory used by DIE.  */
5163
5164 static inline void
5165 free_die (die)
5166      dw_die_ref die;
5167 {
5168   remove_children (die);
5169 }
5170
5171 /* Discard the children of this DIE.  */
5172
5173 static void
5174 remove_children (die)
5175      dw_die_ref die;
5176 {
5177   dw_die_ref child_die = die->die_child;
5178
5179   die->die_child = NULL;
5180
5181   while (child_die != NULL)
5182     {
5183       dw_die_ref tmp_die = child_die;
5184       dw_attr_ref a;
5185
5186       child_die = child_die->die_sib;
5187
5188       for (a = tmp_die->die_attr; a != NULL;)
5189         {
5190           dw_attr_ref tmp_a = a;
5191
5192           a = a->dw_attr_next;
5193           free_AT (tmp_a);
5194         }
5195
5196       free_die (tmp_die);
5197     }
5198 }
5199
5200 /* Add a child DIE below its parent.  We build the lists up in reverse
5201    addition order, and correct that in reverse_all_dies.  */
5202
5203 static inline void
5204 add_child_die (die, child_die)
5205      dw_die_ref die;
5206      dw_die_ref child_die;
5207 {
5208   if (die != NULL && child_die != NULL)
5209     {
5210       if (die == child_die)
5211         abort ();
5212
5213       child_die->die_parent = die;
5214       child_die->die_sib = die->die_child;
5215       die->die_child = child_die;
5216     }
5217 }
5218
5219 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
5220    is the specification, to the front of PARENT's list of children.  */
5221
5222 static void
5223 splice_child_die (parent, child)
5224      dw_die_ref parent, child;
5225 {
5226   dw_die_ref *p;
5227
5228   /* We want the declaration DIE from inside the class, not the
5229      specification DIE at toplevel.  */
5230   if (child->die_parent != parent)
5231     {
5232       dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
5233
5234       if (tmp)
5235         child = tmp;
5236     }
5237
5238   if (child->die_parent != parent
5239       && child->die_parent != get_AT_ref (parent, DW_AT_specification))
5240     abort ();
5241
5242   for (p = &(child->die_parent->die_child); *p; p = &((*p)->die_sib))
5243     if (*p == child)
5244       {
5245         *p = child->die_sib;
5246         break;
5247       }
5248
5249   child->die_parent = parent;
5250   child->die_sib = parent->die_child;
5251   parent->die_child = child;
5252 }
5253
5254 /* Return a pointer to a newly created DIE node.  */
5255
5256 static inline dw_die_ref
5257 new_die (tag_value, parent_die, t)
5258      enum dwarf_tag tag_value;
5259      dw_die_ref parent_die;
5260      tree t;
5261 {
5262   dw_die_ref die = (dw_die_ref) ggc_alloc_cleared (sizeof (die_node));
5263
5264   die->die_tag = tag_value;
5265
5266   if (parent_die != NULL)
5267     add_child_die (parent_die, die);
5268   else
5269     {
5270       limbo_die_node *limbo_node;
5271
5272       limbo_node = ggc_alloc_cleared (sizeof (limbo_die_node));
5273       limbo_node->die = die;
5274       limbo_node->created_for = t;
5275       limbo_node->next = limbo_die_list;
5276       limbo_die_list = limbo_node;
5277     }
5278
5279   return die;
5280 }
5281
5282 /* Return the DIE associated with the given type specifier.  */
5283
5284 static inline dw_die_ref
5285 lookup_type_die (type)
5286      tree type;
5287 {
5288   return TYPE_SYMTAB_DIE (type);
5289 }
5290
5291 /* Equate a DIE to a given type specifier.  */
5292
5293 static inline void
5294 equate_type_number_to_die (type, type_die)
5295      tree type;
5296      dw_die_ref type_die;
5297 {
5298   TYPE_SYMTAB_DIE (type) = type_die;
5299 }
5300
5301 /* Return the DIE associated with a given declaration.  */
5302
5303 static inline dw_die_ref
5304 lookup_decl_die (decl)
5305      tree decl;
5306 {
5307   unsigned decl_id = DECL_UID (decl);
5308
5309   return (decl_id < decl_die_table_in_use ? decl_die_table[decl_id] : NULL);
5310 }
5311
5312 /* Equate a DIE to a particular declaration.  */
5313
5314 static void
5315 equate_decl_number_to_die (decl, decl_die)
5316      tree decl;
5317      dw_die_ref decl_die;
5318 {
5319   unsigned int decl_id = DECL_UID (decl);
5320   unsigned int num_allocated;
5321
5322   if (decl_id >= decl_die_table_allocated)
5323     {
5324       num_allocated
5325         = ((decl_id + 1 + DECL_DIE_TABLE_INCREMENT - 1)
5326            / DECL_DIE_TABLE_INCREMENT)
5327           * DECL_DIE_TABLE_INCREMENT;
5328
5329       decl_die_table = ggc_realloc (decl_die_table,
5330                                     sizeof (dw_die_ref) * num_allocated);
5331
5332       memset ((char *) &decl_die_table[decl_die_table_allocated], 0,
5333              (num_allocated - decl_die_table_allocated) * sizeof (dw_die_ref));
5334       decl_die_table_allocated = num_allocated;
5335     }
5336
5337   if (decl_id >= decl_die_table_in_use)
5338     decl_die_table_in_use = (decl_id + 1);
5339
5340   decl_die_table[decl_id] = decl_die;
5341 }
5342 \f
5343 /* Keep track of the number of spaces used to indent the
5344    output of the debugging routines that print the structure of
5345    the DIE internal representation.  */
5346 static int print_indent;
5347
5348 /* Indent the line the number of spaces given by print_indent.  */
5349
5350 static inline void
5351 print_spaces (outfile)
5352      FILE *outfile;
5353 {
5354   fprintf (outfile, "%*s", print_indent, "");
5355 }
5356
5357 /* Print the information associated with a given DIE, and its children.
5358    This routine is a debugging aid only.  */
5359
5360 static void
5361 print_die (die, outfile)
5362      dw_die_ref die;
5363      FILE *outfile;
5364 {
5365   dw_attr_ref a;
5366   dw_die_ref c;
5367
5368   print_spaces (outfile);
5369   fprintf (outfile, "DIE %4lu: %s\n",
5370            die->die_offset, dwarf_tag_name (die->die_tag));
5371   print_spaces (outfile);
5372   fprintf (outfile, "  abbrev id: %lu", die->die_abbrev);
5373   fprintf (outfile, " offset: %lu\n", die->die_offset);
5374
5375   for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
5376     {
5377       print_spaces (outfile);
5378       fprintf (outfile, "  %s: ", dwarf_attr_name (a->dw_attr));
5379
5380       switch (AT_class (a))
5381         {
5382         case dw_val_class_addr:
5383           fprintf (outfile, "address");
5384           break;
5385         case dw_val_class_offset:
5386           fprintf (outfile, "offset");
5387           break;
5388         case dw_val_class_loc:
5389           fprintf (outfile, "location descriptor");
5390           break;
5391         case dw_val_class_loc_list:
5392           fprintf (outfile, "location list -> label:%s",
5393                    AT_loc_list (a)->ll_symbol);
5394           break;
5395         case dw_val_class_range_list:
5396           fprintf (outfile, "range list");
5397           break;
5398         case dw_val_class_const:
5399           fprintf (outfile, "%ld", AT_int (a));
5400           break;
5401         case dw_val_class_unsigned_const:
5402           fprintf (outfile, "%lu", AT_unsigned (a));
5403           break;
5404         case dw_val_class_long_long:
5405           fprintf (outfile, "constant (%lu,%lu)",
5406                    a->dw_attr_val.v.val_long_long.hi,
5407                    a->dw_attr_val.v.val_long_long.low);
5408           break;
5409         case dw_val_class_float:
5410           fprintf (outfile, "floating-point constant");
5411           break;
5412         case dw_val_class_flag:
5413           fprintf (outfile, "%u", AT_flag (a));
5414           break;
5415         case dw_val_class_die_ref:
5416           if (AT_ref (a) != NULL)
5417             {
5418               if (AT_ref (a)->die_symbol)
5419                 fprintf (outfile, "die -> label: %s", AT_ref (a)->die_symbol);
5420               else
5421                 fprintf (outfile, "die -> %lu", AT_ref (a)->die_offset);
5422             }
5423           else
5424             fprintf (outfile, "die -> <null>");
5425           break;
5426         case dw_val_class_lbl_id:
5427         case dw_val_class_lbl_offset:
5428           fprintf (outfile, "label: %s", AT_lbl (a));
5429           break;
5430         case dw_val_class_str:
5431           if (AT_string (a) != NULL)
5432             fprintf (outfile, "\"%s\"", AT_string (a));
5433           else
5434             fprintf (outfile, "<null>");
5435           break;
5436         default:
5437           break;
5438         }
5439
5440       fprintf (outfile, "\n");
5441     }
5442
5443   if (die->die_child != NULL)
5444     {
5445       print_indent += 4;
5446       for (c = die->die_child; c != NULL; c = c->die_sib)
5447         print_die (c, outfile);
5448
5449       print_indent -= 4;
5450     }
5451   if (print_indent == 0)
5452     fprintf (outfile, "\n");
5453 }
5454
5455 /* Print the contents of the source code line number correspondence table.
5456    This routine is a debugging aid only.  */
5457
5458 static void
5459 print_dwarf_line_table (outfile)
5460      FILE *outfile;
5461 {
5462   unsigned i;
5463   dw_line_info_ref line_info;
5464
5465   fprintf (outfile, "\n\nDWARF source line information\n");
5466   for (i = 1; i < line_info_table_in_use; i++)
5467     {
5468       line_info = &line_info_table[i];
5469       fprintf (outfile, "%5d: ", i);
5470       fprintf (outfile, "%-20s",
5471                VARRAY_CHAR_PTR (file_table, line_info->dw_file_num));
5472       fprintf (outfile, "%6ld", line_info->dw_line_num);
5473       fprintf (outfile, "\n");
5474     }
5475
5476   fprintf (outfile, "\n\n");
5477 }
5478
5479 /* Print the information collected for a given DIE.  */
5480
5481 void
5482 debug_dwarf_die (die)
5483      dw_die_ref die;
5484 {
5485   print_die (die, stderr);
5486 }
5487
5488 /* Print all DWARF information collected for the compilation unit.
5489    This routine is a debugging aid only.  */
5490
5491 void
5492 debug_dwarf ()
5493 {
5494   print_indent = 0;
5495   print_die (comp_unit_die, stderr);
5496   if (! DWARF2_ASM_LINE_DEBUG_INFO)
5497     print_dwarf_line_table (stderr);
5498 }
5499 \f
5500 /* We build up the lists of children and attributes by pushing new ones
5501    onto the beginning of the list.  Reverse the lists for DIE so that
5502    they are in order of addition.  */
5503
5504 static void
5505 reverse_die_lists (die)
5506      dw_die_ref die;
5507 {
5508   dw_die_ref c, cp, cn;
5509   dw_attr_ref a, ap, an;
5510
5511   for (a = die->die_attr, ap = 0; a; a = an)
5512     {
5513       an = a->dw_attr_next;
5514       a->dw_attr_next = ap;
5515       ap = a;
5516     }
5517
5518   die->die_attr = ap;
5519
5520   for (c = die->die_child, cp = 0; c; c = cn)
5521     {
5522       cn = c->die_sib;
5523       c->die_sib = cp;
5524       cp = c;
5525     }
5526
5527   die->die_child = cp;
5528 }
5529
5530 /* reverse_die_lists only reverses the single die you pass it. Since we used to
5531    reverse all dies in add_sibling_attributes, which runs through all the dies,
5532    it would reverse all the dies.  Now, however, since we don't call
5533    reverse_die_lists in add_sibling_attributes, we need a routine to
5534    recursively reverse all the dies. This is that routine.  */
5535
5536 static void
5537 reverse_all_dies (die)
5538      dw_die_ref die;
5539 {
5540   dw_die_ref c;
5541
5542   reverse_die_lists (die);
5543
5544   for (c = die->die_child; c; c = c->die_sib)
5545     reverse_all_dies (c);
5546 }
5547
5548 /* Start a new compilation unit DIE for an include file.  OLD_UNIT is the CU
5549    for the enclosing include file, if any.  BINCL_DIE is the DW_TAG_GNU_BINCL
5550    DIE that marks the start of the DIEs for this include file.  */
5551
5552 static dw_die_ref
5553 push_new_compile_unit (old_unit, bincl_die)
5554      dw_die_ref old_unit, bincl_die;
5555 {
5556   const char *filename = get_AT_string (bincl_die, DW_AT_name);
5557   dw_die_ref new_unit = gen_compile_unit_die (filename);
5558
5559   new_unit->die_sib = old_unit;
5560   return new_unit;
5561 }
5562
5563 /* Close an include-file CU and reopen the enclosing one.  */
5564
5565 static dw_die_ref
5566 pop_compile_unit (old_unit)
5567      dw_die_ref old_unit;
5568 {
5569   dw_die_ref new_unit = old_unit->die_sib;
5570
5571   old_unit->die_sib = NULL;
5572   return new_unit;
5573 }
5574
5575 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5576 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
5577
5578 /* Calculate the checksum of a location expression.  */
5579
5580 static inline void
5581 loc_checksum (loc, ctx)
5582      dw_loc_descr_ref loc;
5583      struct md5_ctx *ctx;
5584 {
5585   CHECKSUM (loc->dw_loc_opc);
5586   CHECKSUM (loc->dw_loc_oprnd1);
5587   CHECKSUM (loc->dw_loc_oprnd2);
5588 }
5589
5590 /* Calculate the checksum of an attribute.  */
5591
5592 static void
5593 attr_checksum (at, ctx, mark)
5594      dw_attr_ref at;
5595      struct md5_ctx *ctx;
5596      int *mark;
5597 {
5598   dw_loc_descr_ref loc;
5599   rtx r;
5600
5601   CHECKSUM (at->dw_attr);
5602
5603   /* We don't care about differences in file numbering.  */
5604   if (at->dw_attr == DW_AT_decl_file
5605       /* Or that this was compiled with a different compiler snapshot; if
5606          the output is the same, that's what matters.  */
5607       || at->dw_attr == DW_AT_producer)
5608     return;
5609
5610   switch (AT_class (at))
5611     {
5612     case dw_val_class_const:
5613       CHECKSUM (at->dw_attr_val.v.val_int);
5614       break;
5615     case dw_val_class_unsigned_const:
5616       CHECKSUM (at->dw_attr_val.v.val_unsigned);
5617       break;
5618     case dw_val_class_long_long:
5619       CHECKSUM (at->dw_attr_val.v.val_long_long);
5620       break;
5621     case dw_val_class_float:
5622       CHECKSUM (at->dw_attr_val.v.val_float);
5623       break;
5624     case dw_val_class_flag:
5625       CHECKSUM (at->dw_attr_val.v.val_flag);
5626       break;
5627     case dw_val_class_str:
5628       CHECKSUM_STRING (AT_string (at));
5629       break;
5630
5631     case dw_val_class_addr:
5632       r = AT_addr (at);
5633       switch (GET_CODE (r))
5634         {
5635         case SYMBOL_REF:
5636           CHECKSUM_STRING (XSTR (r, 0));
5637           break;
5638
5639         default:
5640           abort ();
5641         }
5642       break;
5643
5644     case dw_val_class_offset:
5645       CHECKSUM (at->dw_attr_val.v.val_offset);
5646       break;
5647
5648     case dw_val_class_loc:
5649       for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
5650         loc_checksum (loc, ctx);
5651       break;
5652
5653     case dw_val_class_die_ref:
5654       die_checksum (AT_ref (at), ctx, mark);
5655       break;
5656
5657     case dw_val_class_fde_ref:
5658     case dw_val_class_lbl_id:
5659     case dw_val_class_lbl_offset:
5660       break;
5661
5662     default:
5663       break;
5664     }
5665 }
5666
5667 /* Calculate the checksum of a DIE.  */
5668
5669 static void
5670 die_checksum (die, ctx, mark)
5671      dw_die_ref die;
5672      struct md5_ctx *ctx;
5673      int *mark;
5674 {
5675   dw_die_ref c;
5676   dw_attr_ref a;
5677
5678   /* To avoid infinite recursion.  */
5679   if (die->die_mark)
5680     {
5681       CHECKSUM (die->die_mark);
5682       return;
5683     }
5684   die->die_mark = ++(*mark);
5685
5686   CHECKSUM (die->die_tag);
5687
5688   for (a = die->die_attr; a; a = a->dw_attr_next)
5689     attr_checksum (a, ctx, mark);
5690
5691   for (c = die->die_child; c; c = c->die_sib)
5692     die_checksum (c, ctx, mark);
5693 }
5694
5695 #undef CHECKSUM
5696 #undef CHECKSUM_STRING
5697
5698 /* Do the location expressions look same?  */
5699 static inline int
5700 same_loc_p (loc1, loc2, mark)
5701      dw_loc_descr_ref loc1;
5702      dw_loc_descr_ref loc2;
5703      int *mark;
5704 {
5705   return loc1->dw_loc_opc == loc2->dw_loc_opc
5706          && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
5707          && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
5708 }
5709
5710 /* Do the values look the same?  */
5711 static int
5712 same_dw_val_p (v1, v2, mark)
5713      dw_val_node *v1;
5714      dw_val_node *v2;
5715      int *mark;
5716 {
5717   dw_loc_descr_ref loc1, loc2;
5718   rtx r1, r2;
5719   unsigned i;
5720
5721   if (v1->val_class != v2->val_class)
5722     return 0;
5723
5724   switch (v1->val_class)
5725     {
5726     case dw_val_class_const:
5727       return v1->v.val_int == v2->v.val_int;
5728     case dw_val_class_unsigned_const:
5729       return v1->v.val_unsigned == v2->v.val_unsigned;
5730     case dw_val_class_long_long:
5731       return v1->v.val_long_long.hi == v2->v.val_long_long.hi
5732              && v1->v.val_long_long.low == v2->v.val_long_long.low;
5733     case dw_val_class_float:
5734       if (v1->v.val_float.length != v2->v.val_float.length)
5735         return 0;
5736       for (i = 0; i < v1->v.val_float.length; i++)
5737         if (v1->v.val_float.array[i] != v2->v.val_float.array[i])
5738           return 0;
5739       return 1;
5740     case dw_val_class_flag:
5741       return v1->v.val_flag == v2->v.val_flag;
5742     case dw_val_class_str:
5743       return !strcmp(v1->v.val_str->str, v2->v.val_str->str);
5744
5745     case dw_val_class_addr:
5746       r1 = v1->v.val_addr;
5747       r2 = v2->v.val_addr;
5748       if (GET_CODE (r1) != GET_CODE (r2))
5749         return 0;
5750       switch (GET_CODE (r1))
5751         {
5752         case SYMBOL_REF:
5753           return !strcmp (XSTR (r1, 0), XSTR (r2, 0));
5754
5755         default:
5756           abort ();
5757         }
5758
5759     case dw_val_class_offset:
5760       return v1->v.val_offset == v2->v.val_offset;
5761
5762     case dw_val_class_loc:
5763       for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
5764            loc1 && loc2;
5765            loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
5766         if (!same_loc_p (loc1, loc2, mark))
5767           return 0;
5768       return !loc1 && !loc2;
5769
5770     case dw_val_class_die_ref:
5771       return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
5772
5773     case dw_val_class_fde_ref:
5774     case dw_val_class_lbl_id:
5775     case dw_val_class_lbl_offset:
5776       return 1;
5777
5778     default:
5779       return 1;
5780     }
5781 }
5782
5783 /* Do the attributes look the same?  */
5784
5785 static int
5786 same_attr_p (at1, at2, mark)
5787      dw_attr_ref at1;
5788      dw_attr_ref at2;
5789      int *mark;
5790 {
5791   if (at1->dw_attr != at2->dw_attr)
5792     return 0;
5793
5794   /* We don't care about differences in file numbering.  */
5795   if (at1->dw_attr == DW_AT_decl_file
5796       /* Or that this was compiled with a different compiler snapshot; if
5797          the output is the same, that's what matters.  */
5798       || at1->dw_attr == DW_AT_producer)
5799     return 1;
5800
5801   return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
5802 }
5803
5804 /* Do the dies look the same?  */
5805
5806 static int
5807 same_die_p (die1, die2, mark)
5808      dw_die_ref die1;
5809      dw_die_ref die2;
5810      int *mark;
5811 {
5812   dw_die_ref c1, c2;
5813   dw_attr_ref a1, a2;
5814
5815   /* To avoid infinite recursion.  */
5816   if (die1->die_mark)
5817     return die1->die_mark == die2->die_mark;
5818   die1->die_mark = die2->die_mark = ++(*mark);
5819
5820   if (die1->die_tag != die2->die_tag)
5821     return 0;
5822
5823   for (a1 = die1->die_attr, a2 = die2->die_attr;
5824        a1 && a2;
5825        a1 = a1->dw_attr_next, a2 = a2->dw_attr_next)
5826     if (!same_attr_p (a1, a2, mark))
5827       return 0;
5828   if (a1 || a2)
5829     return 0;
5830
5831   for (c1 = die1->die_child, c2 = die2->die_child;
5832        c1 && c2;
5833        c1 = c1->die_sib, c2 = c2->die_sib)
5834     if (!same_die_p (c1, c2, mark))
5835       return 0;
5836   if (c1 || c2)
5837     return 0;
5838
5839   return 1;
5840 }
5841
5842 /* Do the dies look the same?  Wrapper around same_die_p.  */
5843
5844 static int
5845 same_die_p_wrap (die1, die2)
5846      dw_die_ref die1;
5847      dw_die_ref die2;
5848 {
5849   int mark = 0;
5850   int ret = same_die_p (die1, die2, &mark);
5851
5852   unmark_all_dies (die1);
5853   unmark_all_dies (die2);
5854
5855   return ret;
5856 }
5857
5858 /* The prefix to attach to symbols on DIEs in the current comdat debug
5859    info section.  */
5860 static char *comdat_symbol_id;
5861
5862 /* The index of the current symbol within the current comdat CU.  */
5863 static unsigned int comdat_symbol_number;
5864
5865 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
5866    children, and set comdat_symbol_id accordingly.  */
5867
5868 static void
5869 compute_section_prefix (unit_die)
5870      dw_die_ref unit_die;
5871 {
5872   const char *die_name = get_AT_string (unit_die, DW_AT_name);
5873   const char *base = die_name ? lbasename (die_name) : "anonymous";
5874   char *name = (char *) alloca (strlen (base) + 64);
5875   char *p;
5876   int i, mark;
5877   unsigned char checksum[16];
5878   struct md5_ctx ctx;
5879
5880   /* Compute the checksum of the DIE, then append part of it as hex digits to
5881      the name filename of the unit.  */
5882
5883   md5_init_ctx (&ctx);
5884   mark = 0;
5885   die_checksum (unit_die, &ctx, &mark);
5886   unmark_all_dies (unit_die);
5887   md5_finish_ctx (&ctx, checksum);
5888
5889   sprintf (name, "%s.", base);
5890   clean_symbol_name (name);
5891
5892   p = name + strlen (name);
5893   for (i = 0; i < 4; i++)
5894     {
5895       sprintf (p, "%.2x", checksum[i]);
5896       p += 2;
5897     }
5898
5899   comdat_symbol_id = unit_die->die_symbol = xstrdup (name);
5900   comdat_symbol_number = 0;
5901 }
5902
5903 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P.  */
5904
5905 static int
5906 is_type_die (die)
5907      dw_die_ref die;
5908 {
5909   switch (die->die_tag)
5910     {
5911     case DW_TAG_array_type:
5912     case DW_TAG_class_type:
5913     case DW_TAG_enumeration_type:
5914     case DW_TAG_pointer_type:
5915     case DW_TAG_reference_type:
5916     case DW_TAG_string_type:
5917     case DW_TAG_structure_type:
5918     case DW_TAG_subroutine_type:
5919     case DW_TAG_union_type:
5920     case DW_TAG_ptr_to_member_type:
5921     case DW_TAG_set_type:
5922     case DW_TAG_subrange_type:
5923     case DW_TAG_base_type:
5924     case DW_TAG_const_type:
5925     case DW_TAG_file_type:
5926     case DW_TAG_packed_type:
5927     case DW_TAG_volatile_type:
5928     case DW_TAG_typedef:
5929       return 1;
5930     default:
5931       return 0;
5932     }
5933 }
5934
5935 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
5936    Basically, we want to choose the bits that are likely to be shared between
5937    compilations (types) and leave out the bits that are specific to individual
5938    compilations (functions).  */
5939
5940 static int
5941 is_comdat_die (c)
5942      dw_die_ref c;
5943 {
5944   /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
5945      we do for stabs.  The advantage is a greater likelihood of sharing between
5946      objects that don't include headers in the same order (and therefore would
5947      put the base types in a different comdat).  jason 8/28/00 */
5948
5949   if (c->die_tag == DW_TAG_base_type)
5950     return 0;
5951
5952   if (c->die_tag == DW_TAG_pointer_type
5953       || c->die_tag == DW_TAG_reference_type
5954       || c->die_tag == DW_TAG_const_type
5955       || c->die_tag == DW_TAG_volatile_type)
5956     {
5957       dw_die_ref t = get_AT_ref (c, DW_AT_type);
5958
5959       return t ? is_comdat_die (t) : 0;
5960     }
5961
5962   return is_type_die (c);
5963 }
5964
5965 /* Returns 1 iff C is the sort of DIE that might be referred to from another
5966    compilation unit.  */
5967
5968 static int
5969 is_symbol_die (c)
5970      dw_die_ref c;
5971 {
5972   return (is_type_die (c)
5973           || (get_AT (c, DW_AT_declaration)
5974               && !get_AT (c, DW_AT_specification)));
5975 }
5976
5977 static char *
5978 gen_internal_sym (prefix)
5979      const char *prefix;
5980 {
5981   char buf[256];
5982   static int label_num;
5983
5984   ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
5985   return xstrdup (buf);
5986 }
5987
5988 /* Assign symbols to all worthy DIEs under DIE.  */
5989
5990 static void
5991 assign_symbol_names (die)
5992      dw_die_ref die;
5993 {
5994   dw_die_ref c;
5995
5996   if (is_symbol_die (die))
5997     {
5998       if (comdat_symbol_id)
5999         {
6000           char *p = alloca (strlen (comdat_symbol_id) + 64);
6001
6002           sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
6003                    comdat_symbol_id, comdat_symbol_number++);
6004           die->die_symbol = xstrdup (p);
6005         }
6006       else
6007         die->die_symbol = gen_internal_sym ("LDIE");
6008     }
6009
6010   for (c = die->die_child; c != NULL; c = c->die_sib)
6011     assign_symbol_names (c);
6012 }
6013
6014 struct cu_hash_table_entry
6015 {
6016   dw_die_ref cu;
6017   unsigned min_comdat_num, max_comdat_num;
6018   struct cu_hash_table_entry *next;
6019 };
6020
6021 /* Routines to manipulate hash table of CUs.  */
6022 static hashval_t
6023 htab_cu_hash (of)
6024      const void *of;
6025 {
6026   const struct cu_hash_table_entry *entry = of;
6027
6028   return htab_hash_string (entry->cu->die_symbol);
6029 }
6030
6031 static int
6032 htab_cu_eq (of1, of2)
6033      const void *of1;
6034      const void *of2;
6035 {
6036   const struct cu_hash_table_entry *entry1 = of1;
6037   const struct die_struct *entry2 = of2;
6038
6039   return !strcmp (entry1->cu->die_symbol, entry2->die_symbol);
6040 }
6041
6042 static void
6043 htab_cu_del (what)
6044      void *what;
6045 {
6046   struct cu_hash_table_entry *next, *entry = what;
6047
6048   while (entry)
6049     {
6050       next = entry->next;
6051       free (entry);
6052       entry = next;
6053     }
6054 }
6055
6056 /* Check whether we have already seen this CU and set up SYM_NUM
6057    accordingly.  */
6058 static int
6059 check_duplicate_cu (cu, htable, sym_num)
6060      dw_die_ref cu;
6061      htab_t htable;
6062      unsigned *sym_num;
6063 {
6064   struct cu_hash_table_entry dummy;
6065   struct cu_hash_table_entry **slot, *entry, *last = &dummy;
6066
6067   dummy.max_comdat_num = 0;
6068
6069   slot = (struct cu_hash_table_entry **)
6070     htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
6071         INSERT);
6072   entry = *slot;
6073
6074   for (; entry; last = entry, entry = entry->next)
6075     {
6076       if (same_die_p_wrap (cu, entry->cu))
6077         break;
6078     }
6079
6080   if (entry)
6081     {
6082       *sym_num = entry->min_comdat_num;
6083       return 1;
6084     }
6085
6086   entry = xcalloc (1, sizeof (struct cu_hash_table_entry));
6087   entry->cu = cu;
6088   entry->min_comdat_num = *sym_num = last->max_comdat_num;
6089   entry->next = *slot;
6090   *slot = entry;
6091
6092   return 0;
6093 }
6094
6095 /* Record SYM_NUM to record of CU in HTABLE.  */
6096 static void
6097 record_comdat_symbol_number (cu, htable, sym_num)
6098      dw_die_ref cu;
6099      htab_t htable;
6100      unsigned sym_num;
6101 {
6102   struct cu_hash_table_entry **slot, *entry;
6103
6104   slot = (struct cu_hash_table_entry **)
6105     htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
6106         NO_INSERT);
6107   entry = *slot;
6108
6109   entry->max_comdat_num = sym_num;
6110 }
6111
6112 /* Traverse the DIE (which is always comp_unit_die), and set up
6113    additional compilation units for each of the include files we see
6114    bracketed by BINCL/EINCL.  */
6115
6116 static void
6117 break_out_includes (die)
6118      dw_die_ref die;
6119 {
6120   dw_die_ref *ptr;
6121   dw_die_ref unit = NULL;
6122   limbo_die_node *node, **pnode;
6123   htab_t cu_hash_table;
6124
6125   for (ptr = &(die->die_child); *ptr;)
6126     {
6127       dw_die_ref c = *ptr;
6128
6129       if (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL
6130           || (unit && is_comdat_die (c)))
6131         {
6132           /* This DIE is for a secondary CU; remove it from the main one.  */
6133           *ptr = c->die_sib;
6134
6135           if (c->die_tag == DW_TAG_GNU_BINCL)
6136             {
6137               unit = push_new_compile_unit (unit, c);
6138               free_die (c);
6139             }
6140           else if (c->die_tag == DW_TAG_GNU_EINCL)
6141             {
6142               unit = pop_compile_unit (unit);
6143               free_die (c);
6144             }
6145           else
6146             add_child_die (unit, c);
6147         }
6148       else
6149         {
6150           /* Leave this DIE in the main CU.  */
6151           ptr = &(c->die_sib);
6152           continue;
6153         }
6154     }
6155
6156 #if 0
6157   /* We can only use this in debugging, since the frontend doesn't check
6158      to make sure that we leave every include file we enter.  */
6159   if (unit != NULL)
6160     abort ();
6161 #endif
6162
6163   assign_symbol_names (die);
6164   cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del);
6165   for (node = limbo_die_list, pnode = &limbo_die_list;
6166        node;
6167        node = node->next)
6168     {
6169       int is_dupl;
6170
6171       compute_section_prefix (node->die);
6172       is_dupl = check_duplicate_cu (node->die, cu_hash_table,
6173                         &comdat_symbol_number);
6174       assign_symbol_names (node->die);
6175       if (is_dupl)
6176         *pnode = node->next;
6177       else
6178         {
6179           pnode = &node->next;
6180           record_comdat_symbol_number (node->die, cu_hash_table,
6181                 comdat_symbol_number);
6182         }
6183     }
6184   htab_delete (cu_hash_table);
6185 }
6186
6187 /* Traverse the DIE and add a sibling attribute if it may have the
6188    effect of speeding up access to siblings.  To save some space,
6189    avoid generating sibling attributes for DIE's without children.  */
6190
6191 static void
6192 add_sibling_attributes (die)
6193      dw_die_ref die;
6194 {
6195   dw_die_ref c;
6196
6197   if (die->die_tag != DW_TAG_compile_unit
6198       && die->die_sib && die->die_child != NULL)
6199     /* Add the sibling link to the front of the attribute list.  */
6200     add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
6201
6202   for (c = die->die_child; c != NULL; c = c->die_sib)
6203     add_sibling_attributes (c);
6204 }
6205
6206 /* Output all location lists for the DIE and its children.  */
6207
6208 static void
6209 output_location_lists (die)
6210      dw_die_ref die;
6211 {
6212   dw_die_ref c;
6213   dw_attr_ref d_attr;
6214
6215   for (d_attr = die->die_attr; d_attr; d_attr = d_attr->dw_attr_next)
6216     if (AT_class (d_attr) == dw_val_class_loc_list)
6217       output_loc_list (AT_loc_list (d_attr));
6218
6219   for (c = die->die_child; c != NULL; c = c->die_sib)
6220     output_location_lists (c);
6221
6222 }
6223
6224 /* The format of each DIE (and its attribute value pairs) is encoded in an
6225    abbreviation table.  This routine builds the abbreviation table and assigns
6226    a unique abbreviation id for each abbreviation entry.  The children of each
6227    die are visited recursively.  */
6228
6229 static void
6230 build_abbrev_table (die)
6231      dw_die_ref die;
6232 {
6233   unsigned long abbrev_id;
6234   unsigned int n_alloc;
6235   dw_die_ref c;
6236   dw_attr_ref d_attr, a_attr;
6237
6238   /* Scan the DIE references, and mark as external any that refer to
6239      DIEs from other CUs (i.e. those which are not marked).  */
6240   for (d_attr = die->die_attr; d_attr; d_attr = d_attr->dw_attr_next)
6241     if (AT_class (d_attr) == dw_val_class_die_ref
6242         && AT_ref (d_attr)->die_mark == 0)
6243       {
6244         if (AT_ref (d_attr)->die_symbol == 0)
6245           abort ();
6246
6247         set_AT_ref_external (d_attr, 1);
6248       }
6249
6250   for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
6251     {
6252       dw_die_ref abbrev = abbrev_die_table[abbrev_id];
6253
6254       if (abbrev->die_tag == die->die_tag)
6255         {
6256           if ((abbrev->die_child != NULL) == (die->die_child != NULL))
6257             {
6258               a_attr = abbrev->die_attr;
6259               d_attr = die->die_attr;
6260
6261               while (a_attr != NULL && d_attr != NULL)
6262                 {
6263                   if ((a_attr->dw_attr != d_attr->dw_attr)
6264                       || (value_format (a_attr) != value_format (d_attr)))
6265                     break;
6266
6267                   a_attr = a_attr->dw_attr_next;
6268                   d_attr = d_attr->dw_attr_next;
6269                 }
6270
6271               if (a_attr == NULL && d_attr == NULL)
6272                 break;
6273             }
6274         }
6275     }
6276
6277   if (abbrev_id >= abbrev_die_table_in_use)
6278     {
6279       if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
6280         {
6281           n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
6282           abbrev_die_table = ggc_realloc (abbrev_die_table,
6283                                           sizeof (dw_die_ref) * n_alloc);
6284
6285           memset ((char *) &abbrev_die_table[abbrev_die_table_allocated], 0,
6286                  (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
6287           abbrev_die_table_allocated = n_alloc;
6288         }
6289
6290       ++abbrev_die_table_in_use;
6291       abbrev_die_table[abbrev_id] = die;
6292     }
6293
6294   die->die_abbrev = abbrev_id;
6295   for (c = die->die_child; c != NULL; c = c->die_sib)
6296     build_abbrev_table (c);
6297 }
6298 \f
6299 /* Return the power-of-two number of bytes necessary to represent VALUE.  */
6300
6301 static int
6302 constant_size (value)
6303      long unsigned value;
6304 {
6305   int log;
6306
6307   if (value == 0)
6308     log = 0;
6309   else
6310     log = floor_log2 (value);
6311
6312   log = log / 8;
6313   log = 1 << (floor_log2 (log) + 1);
6314
6315   return log;
6316 }
6317
6318 /* Return the size of a DIE as it is represented in the
6319    .debug_info section.  */
6320
6321 static unsigned long
6322 size_of_die (die)
6323      dw_die_ref die;
6324 {
6325   unsigned long size = 0;
6326   dw_attr_ref a;
6327
6328   size += size_of_uleb128 (die->die_abbrev);
6329   for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
6330     {
6331       switch (AT_class (a))
6332         {
6333         case dw_val_class_addr:
6334           size += DWARF2_ADDR_SIZE;
6335           break;
6336         case dw_val_class_offset:
6337           size += DWARF_OFFSET_SIZE;
6338           break;
6339         case dw_val_class_loc:
6340           {
6341             unsigned long lsize = size_of_locs (AT_loc (a));
6342
6343             /* Block length.  */
6344             size += constant_size (lsize);
6345             size += lsize;
6346           }
6347           break;
6348         case dw_val_class_loc_list:
6349           size += DWARF_OFFSET_SIZE;
6350           break;
6351         case dw_val_class_range_list:
6352           size += DWARF_OFFSET_SIZE;
6353           break;
6354         case dw_val_class_const:
6355           size += size_of_sleb128 (AT_int (a));
6356           break;
6357         case dw_val_class_unsigned_const:
6358           size += constant_size (AT_unsigned (a));
6359           break;
6360         case dw_val_class_long_long:
6361           size += 1 + 2*HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR; /* block */
6362           break;
6363         case dw_val_class_float:
6364           size += 1 + a->dw_attr_val.v.val_float.length * 4; /* block */
6365           break;
6366         case dw_val_class_flag:
6367           size += 1;
6368           break;
6369         case dw_val_class_die_ref:
6370           if (AT_ref_external (a))
6371             size += DWARF2_ADDR_SIZE;
6372           else
6373             size += DWARF_OFFSET_SIZE;
6374           break;
6375         case dw_val_class_fde_ref:
6376           size += DWARF_OFFSET_SIZE;
6377           break;
6378         case dw_val_class_lbl_id:
6379           size += DWARF2_ADDR_SIZE;
6380           break;
6381         case dw_val_class_lbl_offset:
6382           size += DWARF_OFFSET_SIZE;
6383           break;
6384         case dw_val_class_str:
6385           if (AT_string_form (a) == DW_FORM_strp)
6386             size += DWARF_OFFSET_SIZE;
6387           else
6388             size += strlen (a->dw_attr_val.v.val_str->str) + 1;
6389           break;
6390         default:
6391           abort ();
6392         }
6393     }
6394
6395   return size;
6396 }
6397
6398 /* Size the debugging information associated with a given DIE.  Visits the
6399    DIE's children recursively.  Updates the global variable next_die_offset, on
6400    each time through.  Uses the current value of next_die_offset to update the
6401    die_offset field in each DIE.  */
6402
6403 static void
6404 calc_die_sizes (die)
6405      dw_die_ref die;
6406 {
6407   dw_die_ref c;
6408
6409   die->die_offset = next_die_offset;
6410   next_die_offset += size_of_die (die);
6411
6412   for (c = die->die_child; c != NULL; c = c->die_sib)
6413     calc_die_sizes (c);
6414
6415   if (die->die_child != NULL)
6416     /* Count the null byte used to terminate sibling lists.  */
6417     next_die_offset += 1;
6418 }
6419
6420 /* Set the marks for a die and its children.  We do this so
6421    that we know whether or not a reference needs to use FORM_ref_addr; only
6422    DIEs in the same CU will be marked.  We used to clear out the offset
6423    and use that as the flag, but ran into ordering problems.  */
6424
6425 static void
6426 mark_dies (die)
6427      dw_die_ref die;
6428 {
6429   dw_die_ref c;
6430
6431   if (die->die_mark)
6432     abort ();
6433
6434   die->die_mark = 1;
6435   for (c = die->die_child; c; c = c->die_sib)
6436     mark_dies (c);
6437 }
6438
6439 /* Clear the marks for a die and its children.  */
6440
6441 static void
6442 unmark_dies (die)
6443      dw_die_ref die;
6444 {
6445   dw_die_ref c;
6446
6447   if (!die->die_mark)
6448     abort ();
6449
6450   die->die_mark = 0;
6451   for (c = die->die_child; c; c = c->die_sib)
6452     unmark_dies (c);
6453 }
6454
6455 /* Clear the marks for a die, its children and referred dies.  */
6456
6457 static void
6458 unmark_all_dies (die)
6459      dw_die_ref die;
6460 {
6461   dw_die_ref c;
6462   dw_attr_ref a;
6463
6464   if (!die->die_mark)
6465     return;
6466   die->die_mark = 0;
6467
6468   for (c = die->die_child; c; c = c->die_sib)
6469     unmark_all_dies (c);
6470
6471   for (a = die->die_attr; a; a = a->dw_attr_next)
6472     if (AT_class (a) == dw_val_class_die_ref)
6473       unmark_all_dies (AT_ref (a));
6474 }
6475
6476 /* Return the size of the .debug_pubnames table  generated for the
6477    compilation unit.  */
6478
6479 static unsigned long
6480 size_of_pubnames ()
6481 {
6482   unsigned long size;
6483   unsigned i;
6484
6485   size = DWARF_PUBNAMES_HEADER_SIZE;
6486   for (i = 0; i < pubname_table_in_use; i++)
6487     {
6488       pubname_ref p = &pubname_table[i];
6489       size += DWARF_OFFSET_SIZE + strlen (p->name) + 1;
6490     }
6491
6492   size += DWARF_OFFSET_SIZE;
6493   return size;
6494 }
6495
6496 /* Return the size of the information in the .debug_aranges section.  */
6497
6498 static unsigned long
6499 size_of_aranges ()
6500 {
6501   unsigned long size;
6502
6503   size = DWARF_ARANGES_HEADER_SIZE;
6504
6505   /* Count the address/length pair for this compilation unit.  */
6506   size += 2 * DWARF2_ADDR_SIZE;
6507   size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use;
6508
6509   /* Count the two zero words used to terminated the address range table.  */
6510   size += 2 * DWARF2_ADDR_SIZE;
6511   return size;
6512 }
6513 \f
6514 /* Select the encoding of an attribute value.  */
6515
6516 static enum dwarf_form
6517 value_format (a)
6518      dw_attr_ref a;
6519 {
6520   switch (a->dw_attr_val.val_class)
6521     {
6522     case dw_val_class_addr:
6523       return DW_FORM_addr;
6524     case dw_val_class_range_list:
6525     case dw_val_class_offset:
6526       if (DWARF_OFFSET_SIZE == 4)
6527         return DW_FORM_data4;
6528       if (DWARF_OFFSET_SIZE == 8)
6529         return DW_FORM_data8;
6530       abort ();
6531     case dw_val_class_loc_list:
6532       /* FIXME: Could be DW_FORM_data8, with a > 32 bit size
6533          .debug_loc section */
6534       return DW_FORM_data4;
6535     case dw_val_class_loc:
6536       switch (constant_size (size_of_locs (AT_loc (a))))
6537         {
6538         case 1:
6539           return DW_FORM_block1;
6540         case 2:
6541           return DW_FORM_block2;
6542         default:
6543           abort ();
6544         }
6545     case dw_val_class_const:
6546       return DW_FORM_sdata;
6547     case dw_val_class_unsigned_const:
6548       switch (constant_size (AT_unsigned (a)))
6549         {
6550         case 1:
6551           return DW_FORM_data1;
6552         case 2:
6553           return DW_FORM_data2;
6554         case 4:
6555           return DW_FORM_data4;
6556         case 8:
6557           return DW_FORM_data8;
6558         default:
6559           abort ();
6560         }
6561     case dw_val_class_long_long:
6562       return DW_FORM_block1;
6563     case dw_val_class_float:
6564       return DW_FORM_block1;
6565     case dw_val_class_flag:
6566       return DW_FORM_flag;
6567     case dw_val_class_die_ref:
6568       if (AT_ref_external (a))
6569         return DW_FORM_ref_addr;
6570       else
6571         return DW_FORM_ref;
6572     case dw_val_class_fde_ref:
6573       return DW_FORM_data;
6574     case dw_val_class_lbl_id:
6575       return DW_FORM_addr;
6576     case dw_val_class_lbl_offset:
6577       return DW_FORM_data;
6578     case dw_val_class_str:
6579       return AT_string_form (a);
6580
6581     default:
6582       abort ();
6583     }
6584 }
6585
6586 /* Output the encoding of an attribute value.  */
6587
6588 static void
6589 output_value_format (a)
6590      dw_attr_ref a;
6591 {
6592   enum dwarf_form form = value_format (a);
6593
6594   dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
6595 }
6596
6597 /* Output the .debug_abbrev section which defines the DIE abbreviation
6598    table.  */
6599
6600 static void
6601 output_abbrev_section ()
6602 {
6603   unsigned long abbrev_id;
6604
6605   dw_attr_ref a_attr;
6606
6607   for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
6608     {
6609       dw_die_ref abbrev = abbrev_die_table[abbrev_id];
6610
6611       dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
6612       dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
6613                                    dwarf_tag_name (abbrev->die_tag));
6614
6615       if (abbrev->die_child != NULL)
6616         dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
6617       else
6618         dw2_asm_output_data (1, DW_children_no, "DW_children_no");
6619
6620       for (a_attr = abbrev->die_attr; a_attr != NULL;
6621            a_attr = a_attr->dw_attr_next)
6622         {
6623           dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
6624                                        dwarf_attr_name (a_attr->dw_attr));
6625           output_value_format (a_attr);
6626         }
6627
6628       dw2_asm_output_data (1, 0, NULL);
6629       dw2_asm_output_data (1, 0, NULL);
6630     }
6631
6632   /* Terminate the table.  */
6633   dw2_asm_output_data (1, 0, NULL);
6634 }
6635
6636 /* Output a symbol we can use to refer to this DIE from another CU.  */
6637
6638 static inline void
6639 output_die_symbol (die)
6640      dw_die_ref die;
6641 {
6642   char *sym = die->die_symbol;
6643
6644   if (sym == 0)
6645     return;
6646
6647   if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
6648     /* We make these global, not weak; if the target doesn't support
6649        .linkonce, it doesn't support combining the sections, so debugging
6650        will break.  */
6651     (*targetm.asm_out.globalize_label) (asm_out_file, sym);
6652
6653   ASM_OUTPUT_LABEL (asm_out_file, sym);
6654 }
6655
6656 /* Return a new location list, given the begin and end range, and the
6657    expression. gensym tells us whether to generate a new internal symbol for
6658    this location list node, which is done for the head of the list only.  */
6659
6660 static inline dw_loc_list_ref
6661 new_loc_list (expr, begin, end, section, gensym)
6662      dw_loc_descr_ref expr;
6663      const char *begin;
6664      const char *end;
6665      const char *section;
6666      unsigned gensym;
6667 {
6668   dw_loc_list_ref retlist = ggc_alloc_cleared (sizeof (dw_loc_list_node));
6669
6670   retlist->begin = begin;
6671   retlist->end = end;
6672   retlist->expr = expr;
6673   retlist->section = section;
6674   if (gensym)
6675     retlist->ll_symbol = gen_internal_sym ("LLST");
6676
6677   return retlist;
6678 }
6679
6680 /* Add a location description expression to a location list */
6681
6682 static inline void
6683 add_loc_descr_to_loc_list (list_head, descr, begin, end, section)
6684      dw_loc_list_ref *list_head;
6685      dw_loc_descr_ref descr;
6686      const char *begin;
6687      const char *end;
6688      const char *section;
6689 {
6690   dw_loc_list_ref *d;
6691
6692   /* Find the end of the chain.  */
6693   for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
6694     ;
6695
6696   /* Add a new location list node to the list */
6697   *d = new_loc_list (descr, begin, end, section, 0);
6698 }
6699
6700 /* Output the location list given to us */
6701
6702 static void
6703 output_loc_list (list_head)
6704      dw_loc_list_ref list_head;
6705 {
6706   dw_loc_list_ref curr = list_head;
6707
6708   ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
6709
6710   /* ??? This shouldn't be needed now that we've forced the
6711      compilation unit base address to zero when there is code
6712      in more than one section.  */
6713   if (strcmp (curr->section, ".text") == 0)
6714     {
6715       /* dw2_asm_output_data will mask off any extra bits in the ~0.  */
6716       dw2_asm_output_data (DWARF2_ADDR_SIZE, ~(unsigned HOST_WIDE_INT) 0,
6717                            "Location list base address specifier fake entry");
6718       dw2_asm_output_offset (DWARF2_ADDR_SIZE, curr->section,
6719                              "Location list base address specifier base");
6720     }
6721
6722   for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
6723     {
6724       unsigned long size;
6725
6726       dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
6727                             "Location list begin address (%s)",
6728                             list_head->ll_symbol);
6729       dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
6730                             "Location list end address (%s)",
6731                             list_head->ll_symbol);
6732       size = size_of_locs (curr->expr);
6733
6734       /* Output the block length for this list of location operations.  */
6735       if (size > 0xffff)
6736         abort ();
6737       dw2_asm_output_data (2, size, "%s", "Location expression size");
6738
6739       output_loc_sequence (curr->expr);
6740     }
6741
6742   dw2_asm_output_data (DWARF_OFFSET_SIZE, 0,
6743                        "Location list terminator begin (%s)",
6744                        list_head->ll_symbol);
6745   dw2_asm_output_data (DWARF_OFFSET_SIZE, 0,
6746                        "Location list terminator end (%s)",
6747                        list_head->ll_symbol);
6748 }
6749
6750 /* Output the DIE and its attributes.  Called recursively to generate
6751    the definitions of each child DIE.  */
6752
6753 static void
6754 output_die (die)
6755      dw_die_ref die;
6756 {
6757   dw_attr_ref a;
6758   dw_die_ref c;
6759   unsigned long size;
6760
6761   /* If someone in another CU might refer to us, set up a symbol for
6762      them to point to.  */
6763   if (die->die_symbol)
6764     output_die_symbol (die);
6765
6766   dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (0x%lx) %s)",
6767                                die->die_offset, dwarf_tag_name (die->die_tag));
6768
6769   for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
6770     {
6771       const char *name = dwarf_attr_name (a->dw_attr);
6772
6773       switch (AT_class (a))
6774         {
6775         case dw_val_class_addr:
6776           dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
6777           break;
6778
6779         case dw_val_class_offset:
6780           dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
6781                                "%s", name);
6782           break;
6783
6784         case dw_val_class_range_list:
6785           {
6786             char *p = strchr (ranges_section_label, '\0');
6787
6788             sprintf (p, "+0x%lx", a->dw_attr_val.v.val_offset);
6789             dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
6790                                    "%s", name);
6791             *p = '\0';
6792           }
6793           break;
6794
6795         case dw_val_class_loc:
6796           size = size_of_locs (AT_loc (a));
6797
6798           /* Output the block length for this list of location operations.  */
6799           dw2_asm_output_data (constant_size (size), size, "%s", name);
6800
6801           output_loc_sequence (AT_loc (a));
6802           break;
6803
6804         case dw_val_class_const:
6805           /* ??? It would be slightly more efficient to use a scheme like is
6806              used for unsigned constants below, but gdb 4.x does not sign
6807              extend.  Gdb 5.x does sign extend.  */
6808           dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
6809           break;
6810
6811         case dw_val_class_unsigned_const:
6812           dw2_asm_output_data (constant_size (AT_unsigned (a)),
6813                                AT_unsigned (a), "%s", name);
6814           break;
6815
6816         case dw_val_class_long_long:
6817           {
6818             unsigned HOST_WIDE_INT first, second;
6819
6820             dw2_asm_output_data (1,
6821                                  2 * HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
6822                                  "%s", name);
6823
6824             if (WORDS_BIG_ENDIAN)
6825               {
6826                 first = a->dw_attr_val.v.val_long_long.hi;
6827                 second = a->dw_attr_val.v.val_long_long.low;
6828               }
6829             else
6830               {
6831                 first = a->dw_attr_val.v.val_long_long.low;
6832                 second = a->dw_attr_val.v.val_long_long.hi;
6833               }
6834
6835             dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
6836                                  first, "long long constant");
6837             dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
6838                                  second, NULL);
6839           }
6840           break;
6841
6842         case dw_val_class_float:
6843           {
6844             unsigned int i;
6845
6846             dw2_asm_output_data (1, a->dw_attr_val.v.val_float.length * 4,
6847                                  "%s", name);
6848
6849             for (i = 0; i < a->dw_attr_val.v.val_float.length; i++)
6850               dw2_asm_output_data (4, a->dw_attr_val.v.val_float.array[i],
6851                                    "fp constant word %u", i);
6852             break;
6853           }
6854
6855         case dw_val_class_flag:
6856           dw2_asm_output_data (1, AT_flag (a), "%s", name);
6857           break;
6858
6859         case dw_val_class_loc_list:
6860           {
6861             char *sym = AT_loc_list (a)->ll_symbol;
6862
6863             if (sym == 0)
6864               abort ();
6865             dw2_asm_output_delta (DWARF_OFFSET_SIZE, sym,
6866                                   loc_section_label, "%s", name);
6867           }
6868           break;
6869
6870         case dw_val_class_die_ref:
6871           if (AT_ref_external (a))
6872             {
6873               char *sym = AT_ref (a)->die_symbol;
6874
6875               if (sym == 0)
6876                 abort ();
6877               dw2_asm_output_offset (DWARF2_ADDR_SIZE, sym, "%s", name);
6878             }
6879           else if (AT_ref (a)->die_offset == 0)
6880             abort ();
6881           else
6882             dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
6883                                  "%s", name);
6884           break;
6885
6886         case dw_val_class_fde_ref:
6887           {
6888             char l1[20];
6889
6890             ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
6891                                          a->dw_attr_val.v.val_fde_index * 2);
6892             dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, "%s", name);
6893           }
6894           break;
6895
6896         case dw_val_class_lbl_id:
6897           dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
6898           break;
6899
6900         case dw_val_class_lbl_offset:
6901           dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a), "%s", name);
6902           break;
6903
6904         case dw_val_class_str:
6905           if (AT_string_form (a) == DW_FORM_strp)
6906             dw2_asm_output_offset (DWARF_OFFSET_SIZE,
6907                                    a->dw_attr_val.v.val_str->label,
6908                                    "%s: \"%s\"", name, AT_string (a));
6909           else
6910             dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
6911           break;
6912
6913         default:
6914           abort ();
6915         }
6916     }
6917
6918   for (c = die->die_child; c != NULL; c = c->die_sib)
6919     output_die (c);
6920
6921   /* Add null byte to terminate sibling list.  */
6922   if (die->die_child != NULL)
6923     dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx",
6924                          die->die_offset);
6925 }
6926
6927 /* Output the compilation unit that appears at the beginning of the
6928    .debug_info section, and precedes the DIE descriptions.  */
6929
6930 static void
6931 output_compilation_unit_header ()
6932 {
6933   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
6934     dw2_asm_output_data (4, 0xffffffff,
6935       "Initial length escape value indicating 64-bit DWARF extension");
6936   dw2_asm_output_data (DWARF_OFFSET_SIZE,
6937                        next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
6938                        "Length of Compilation Unit Info");
6939   dw2_asm_output_data (2, DWARF_VERSION, "DWARF version number");
6940   dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
6941                          "Offset Into Abbrev. Section");
6942   dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
6943 }
6944
6945 /* Output the compilation unit DIE and its children.  */
6946
6947 static void
6948 output_comp_unit (die, output_if_empty)
6949      dw_die_ref die;
6950      int output_if_empty;
6951 {
6952   const char *secname;
6953   char *oldsym, *tmp;
6954
6955   /* Unless we are outputting main CU, we may throw away empty ones.  */
6956   if (!output_if_empty && die->die_child == NULL)
6957     return;
6958
6959   /* Even if there are no children of this DIE, we must output the information
6960      about the compilation unit.  Otherwise, on an empty translation unit, we
6961      will generate a present, but empty, .debug_info section.  IRIX 6.5 `nm'
6962      will then complain when examining the file.  First mark all the DIEs in
6963      this CU so we know which get local refs.  */
6964   mark_dies (die);
6965
6966   build_abbrev_table (die);
6967
6968   /* Initialize the beginning DIE offset - and calculate sizes/offsets.  */
6969   next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
6970   calc_die_sizes (die);
6971
6972   oldsym = die->die_symbol;
6973   if (oldsym)
6974     {
6975       tmp = (char *) alloca (strlen (oldsym) + 24);
6976
6977       sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
6978       secname = tmp;
6979       die->die_symbol = NULL;
6980     }
6981   else
6982     secname = (const char *) DEBUG_INFO_SECTION;
6983
6984   /* Output debugging information.  */
6985   named_section_flags (secname, SECTION_DEBUG);
6986   output_compilation_unit_header ();
6987   output_die (die);
6988
6989   /* Leave the marks on the main CU, so we can check them in
6990      output_pubnames.  */
6991   if (oldsym)
6992     {
6993       unmark_dies (die);
6994       die->die_symbol = oldsym;
6995     }
6996 }
6997
6998 /* The DWARF2 pubname for a nested thingy looks like "A::f".  The
6999    output of lang_hooks.decl_printable_name for C++ looks like
7000    "A::f(int)".  Let's drop the argument list, and maybe the scope.  */
7001
7002 static const char *
7003 dwarf2_name (decl, scope)
7004      tree decl;
7005      int scope;
7006 {
7007   return (*lang_hooks.decl_printable_name) (decl, scope ? 1 : 0);
7008 }
7009
7010 /* Add a new entry to .debug_pubnames if appropriate.  */
7011
7012 static void
7013 add_pubname (decl, die)
7014      tree decl;
7015      dw_die_ref die;
7016 {
7017   pubname_ref p;
7018
7019   if (! TREE_PUBLIC (decl))
7020     return;
7021
7022   if (pubname_table_in_use == pubname_table_allocated)
7023     {
7024       pubname_table_allocated += PUBNAME_TABLE_INCREMENT;
7025       pubname_table
7026         = (pubname_ref) ggc_realloc (pubname_table,
7027                                      (pubname_table_allocated
7028                                       * sizeof (pubname_entry)));
7029       memset (pubname_table + pubname_table_in_use, 0,
7030               PUBNAME_TABLE_INCREMENT * sizeof (pubname_entry));
7031     }
7032
7033   p = &pubname_table[pubname_table_in_use++];
7034   p->die = die;
7035   p->name = xstrdup (dwarf2_name (decl, 1));
7036 }
7037
7038 /* Output the public names table used to speed up access to externally
7039    visible names.  For now, only generate entries for externally
7040    visible procedures.  */
7041
7042 static void
7043 output_pubnames ()
7044 {
7045   unsigned i;
7046   unsigned long pubnames_length = size_of_pubnames ();
7047
7048   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7049     dw2_asm_output_data (4, 0xffffffff,
7050       "Initial length escape value indicating 64-bit DWARF extension");
7051   dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
7052                        "Length of Public Names Info");
7053   dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7054   dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
7055                          "Offset of Compilation Unit Info");
7056   dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
7057                        "Compilation Unit Length");
7058
7059   for (i = 0; i < pubname_table_in_use; i++)
7060     {
7061       pubname_ref pub = &pubname_table[i];
7062
7063       /* We shouldn't see pubnames for DIEs outside of the main CU.  */
7064       if (pub->die->die_mark == 0)
7065         abort ();
7066
7067       dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset,
7068                            "DIE offset");
7069
7070       dw2_asm_output_nstring (pub->name, -1, "external name");
7071     }
7072
7073   dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
7074 }
7075
7076 /* Add a new entry to .debug_aranges if appropriate.  */
7077
7078 static void
7079 add_arange (decl, die)
7080      tree decl;
7081      dw_die_ref die;
7082 {
7083   if (! DECL_SECTION_NAME (decl))
7084     return;
7085
7086   if (arange_table_in_use == arange_table_allocated)
7087     {
7088       arange_table_allocated += ARANGE_TABLE_INCREMENT;
7089       arange_table = ggc_realloc (arange_table,
7090                                   (arange_table_allocated
7091                                    * sizeof (dw_die_ref)));
7092       memset (arange_table + arange_table_in_use, 0,
7093               ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref));
7094     }
7095
7096   arange_table[arange_table_in_use++] = die;
7097 }
7098
7099 /* Output the information that goes into the .debug_aranges table.
7100    Namely, define the beginning and ending address range of the
7101    text section generated for this compilation unit.  */
7102
7103 static void
7104 output_aranges ()
7105 {
7106   unsigned i;
7107   unsigned long aranges_length = size_of_aranges ();
7108
7109   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7110     dw2_asm_output_data (4, 0xffffffff,
7111       "Initial length escape value indicating 64-bit DWARF extension");
7112   dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
7113                        "Length of Address Ranges Info");
7114   dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7115   dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
7116                          "Offset of Compilation Unit Info");
7117   dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
7118   dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
7119
7120   /* We need to align to twice the pointer size here.  */
7121   if (DWARF_ARANGES_PAD_SIZE)
7122     {
7123       /* Pad using a 2 byte words so that padding is correct for any
7124          pointer size.  */
7125       dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
7126                            2 * DWARF2_ADDR_SIZE);
7127       for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
7128         dw2_asm_output_data (2, 0, NULL);
7129     }
7130
7131   dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
7132   dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
7133                         text_section_label, "Length");
7134
7135   for (i = 0; i < arange_table_in_use; i++)
7136     {
7137       dw_die_ref die = arange_table[i];
7138
7139       /* We shouldn't see aranges for DIEs outside of the main CU.  */
7140       if (die->die_mark == 0)
7141         abort ();
7142
7143       if (die->die_tag == DW_TAG_subprogram)
7144         {
7145           dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die),
7146                                "Address");
7147           dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die),
7148                                 get_AT_low_pc (die), "Length");
7149         }
7150       else
7151         {
7152           /* A static variable; extract the symbol from DW_AT_location.
7153              Note that this code isn't currently hit, as we only emit
7154              aranges for functions (jason 9/23/99).  */
7155           dw_attr_ref a = get_AT (die, DW_AT_location);
7156           dw_loc_descr_ref loc;
7157
7158           if (! a || AT_class (a) != dw_val_class_loc)
7159             abort ();
7160
7161           loc = AT_loc (a);
7162           if (loc->dw_loc_opc != DW_OP_addr)
7163             abort ();
7164
7165           dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE,
7166                                    loc->dw_loc_oprnd1.v.val_addr, "Address");
7167           dw2_asm_output_data (DWARF2_ADDR_SIZE,
7168                                get_AT_unsigned (die, DW_AT_byte_size),
7169                                "Length");
7170         }
7171     }
7172
7173   /* Output the terminator words.  */
7174   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7175   dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7176 }
7177
7178 /* Add a new entry to .debug_ranges.  Return the offset at which it
7179    was placed.  */
7180
7181 static unsigned int
7182 add_ranges (block)
7183      tree block;
7184 {
7185   unsigned int in_use = ranges_table_in_use;
7186
7187   if (in_use == ranges_table_allocated)
7188     {
7189       ranges_table_allocated += RANGES_TABLE_INCREMENT;
7190       ranges_table = (dw_ranges_ref)
7191         ggc_realloc (ranges_table, (ranges_table_allocated
7192                                     * sizeof (struct dw_ranges_struct)));
7193       memset (ranges_table + ranges_table_in_use, 0,
7194               RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
7195     }
7196
7197   ranges_table[in_use].block_num = (block ? BLOCK_NUMBER (block) : 0);
7198   ranges_table_in_use = in_use + 1;
7199
7200   return in_use * 2 * DWARF2_ADDR_SIZE;
7201 }
7202
7203 static void
7204 output_ranges ()
7205 {
7206   unsigned i;
7207   static const char *const start_fmt = "Offset 0x%x";
7208   const char *fmt = start_fmt;
7209
7210   for (i = 0; i < ranges_table_in_use; i++)
7211     {
7212       int block_num = ranges_table[i].block_num;
7213
7214       if (block_num)
7215         {
7216           char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
7217           char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
7218
7219           ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
7220           ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
7221
7222           /* If all code is in the text section, then the compilation
7223              unit base address defaults to DW_AT_low_pc, which is the
7224              base of the text section.  */
7225           if (separate_line_info_table_in_use == 0)
7226             {
7227               dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
7228                                     text_section_label,
7229                                     fmt, i * 2 * DWARF2_ADDR_SIZE);
7230               dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
7231                                     text_section_label, NULL);
7232             }
7233
7234           /* Otherwise, we add a DW_AT_entry_pc attribute to force the
7235              compilation unit base address to zero, which allows us to
7236              use absolute addresses, and not worry about whether the
7237              target supports cross-section arithmetic.  */
7238           else
7239             {
7240               dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
7241                                    fmt, i * 2 * DWARF2_ADDR_SIZE);
7242               dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
7243             }
7244
7245           fmt = NULL;
7246         }
7247       else
7248         {
7249           dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7250           dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7251           fmt = start_fmt;
7252         }
7253     }
7254 }
7255
7256 /* Data structure containing information about input files.  */
7257 struct file_info
7258 {
7259   char *path;           /* Complete file name.  */
7260   char *fname;          /* File name part.  */
7261   int length;           /* Length of entire string.  */
7262   int file_idx;         /* Index in input file table.  */
7263   int dir_idx;          /* Index in directory table.  */
7264 };
7265
7266 /* Data structure containing information about directories with source
7267    files.  */
7268 struct dir_info
7269 {
7270   char *path;           /* Path including directory name.  */
7271   int length;           /* Path length.  */
7272   int prefix;           /* Index of directory entry which is a prefix.  */
7273   int count;            /* Number of files in this directory.  */
7274   int dir_idx;          /* Index of directory used as base.  */
7275   int used;             /* Used in the end?  */
7276 };
7277
7278 /* Callback function for file_info comparison.  We sort by looking at
7279    the directories in the path.  */
7280
7281 static int
7282 file_info_cmp (p1, p2)
7283      const void *p1;
7284      const void *p2;
7285 {
7286   const struct file_info *s1 = p1;
7287   const struct file_info *s2 = p2;
7288   unsigned char *cp1;
7289   unsigned char *cp2;
7290
7291   /* Take care of file names without directories.  We need to make sure that
7292      we return consistent values to qsort since some will get confused if
7293      we return the same value when identical operands are passed in opposite
7294      orders.  So if neither has a directory, return 0 and otherwise return
7295      1 or -1 depending on which one has the directory.  */
7296   if ((s1->path == s1->fname || s2->path == s2->fname))
7297     return (s2->path == s2->fname) - (s1->path == s1->fname);
7298
7299   cp1 = (unsigned char *) s1->path;
7300   cp2 = (unsigned char *) s2->path;
7301
7302   while (1)
7303     {
7304       ++cp1;
7305       ++cp2;
7306       /* Reached the end of the first path?  If so, handle like above.  */
7307       if ((cp1 == (unsigned char *) s1->fname)
7308           || (cp2 == (unsigned char *) s2->fname))
7309         return ((cp2 == (unsigned char *) s2->fname)
7310                 - (cp1 == (unsigned char *) s1->fname));
7311
7312       /* Character of current path component the same?  */
7313       else if (*cp1 != *cp2)
7314         return *cp1 - *cp2;
7315     }
7316 }
7317
7318 /* Output the directory table and the file name table.  We try to minimize
7319    the total amount of memory needed.  A heuristic is used to avoid large
7320    slowdowns with many input files.  */
7321
7322 static void
7323 output_file_names ()
7324 {
7325   struct file_info *files;
7326   struct dir_info *dirs;
7327   int *saved;
7328   int *savehere;
7329   int *backmap;
7330   size_t ndirs;
7331   int idx_offset;
7332   size_t i;
7333   int idx;
7334
7335   /* Handle the case where file_table is empty.  */
7336   if (VARRAY_ACTIVE_SIZE (file_table) <= 1)
7337     {
7338       dw2_asm_output_data (1, 0, "End directory table");
7339       dw2_asm_output_data (1, 0, "End file name table");
7340       return;
7341     }
7342
7343   /* Allocate the various arrays we need.  */
7344   files = (struct file_info *) alloca (VARRAY_ACTIVE_SIZE (file_table)
7345                                        * sizeof (struct file_info));
7346   dirs = (struct dir_info *) alloca (VARRAY_ACTIVE_SIZE (file_table)
7347                                      * sizeof (struct dir_info));
7348
7349   /* Sort the file names.  */
7350   for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7351     {
7352       char *f;
7353
7354       /* Skip all leading "./".  */
7355       f = VARRAY_CHAR_PTR (file_table, i);
7356       while (f[0] == '.' && f[1] == '/')
7357         f += 2;
7358
7359       /* Create a new array entry.  */
7360       files[i].path = f;
7361       files[i].length = strlen (f);
7362       files[i].file_idx = i;
7363
7364       /* Search for the file name part.  */
7365       f = strrchr (f, '/');
7366       files[i].fname = f == NULL ? files[i].path : f + 1;
7367     }
7368
7369   qsort (files + 1, VARRAY_ACTIVE_SIZE (file_table) - 1,
7370          sizeof (files[0]), file_info_cmp);
7371
7372   /* Find all the different directories used.  */
7373   dirs[0].path = files[1].path;
7374   dirs[0].length = files[1].fname - files[1].path;
7375   dirs[0].prefix = -1;
7376   dirs[0].count = 1;
7377   dirs[0].dir_idx = 0;
7378   dirs[0].used = 0;
7379   files[1].dir_idx = 0;
7380   ndirs = 1;
7381
7382   for (i = 2; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7383     if (files[i].fname - files[i].path == dirs[ndirs - 1].length
7384         && memcmp (dirs[ndirs - 1].path, files[i].path,
7385                    dirs[ndirs - 1].length) == 0)
7386       {
7387         /* Same directory as last entry.  */
7388         files[i].dir_idx = ndirs - 1;
7389         ++dirs[ndirs - 1].count;
7390       }
7391     else
7392       {
7393         size_t j;
7394
7395         /* This is a new directory.  */
7396         dirs[ndirs].path = files[i].path;
7397         dirs[ndirs].length = files[i].fname - files[i].path;
7398         dirs[ndirs].count = 1;
7399         dirs[ndirs].dir_idx = ndirs;
7400         dirs[ndirs].used = 0;
7401         files[i].dir_idx = ndirs;
7402
7403         /* Search for a prefix.  */
7404         dirs[ndirs].prefix = -1;
7405         for (j = 0; j < ndirs; j++)
7406           if (dirs[j].length < dirs[ndirs].length
7407               && dirs[j].length > 1
7408               && (dirs[ndirs].prefix == -1
7409                   || dirs[j].length > dirs[dirs[ndirs].prefix].length)
7410               && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
7411             dirs[ndirs].prefix = j;
7412
7413         ++ndirs;
7414       }
7415
7416   /* Now to the actual work.  We have to find a subset of the directories which
7417      allow expressing the file name using references to the directory table
7418      with the least amount of characters.  We do not do an exhaustive search
7419      where we would have to check out every combination of every single
7420      possible prefix.  Instead we use a heuristic which provides nearly optimal
7421      results in most cases and never is much off.  */
7422   saved = (int *) alloca (ndirs * sizeof (int));
7423   savehere = (int *) alloca (ndirs * sizeof (int));
7424
7425   memset (saved, '\0', ndirs * sizeof (saved[0]));
7426   for (i = 0; i < ndirs; i++)
7427     {
7428       size_t j;
7429       int total;
7430
7431       /* We can always save some space for the current directory.  But this
7432          does not mean it will be enough to justify adding the directory.  */
7433       savehere[i] = dirs[i].length;
7434       total = (savehere[i] - saved[i]) * dirs[i].count;
7435
7436       for (j = i + 1; j < ndirs; j++)
7437         {
7438           savehere[j] = 0;
7439           if (saved[j] < dirs[i].length)
7440             {
7441               /* Determine whether the dirs[i] path is a prefix of the
7442                  dirs[j] path.  */
7443               int k;
7444
7445               k = dirs[j].prefix;
7446               while (k != -1 && k != (int) i)
7447                 k = dirs[k].prefix;
7448
7449               if (k == (int) i)
7450                 {
7451                   /* Yes it is.  We can possibly safe some memory but
7452                      writing the filenames in dirs[j] relative to
7453                      dirs[i].  */
7454                   savehere[j] = dirs[i].length;
7455                   total += (savehere[j] - saved[j]) * dirs[j].count;
7456                 }
7457             }
7458         }
7459
7460       /* Check whether we can safe enough to justify adding the dirs[i]
7461          directory.  */
7462       if (total > dirs[i].length + 1)
7463         {
7464           /* It's worthwhile adding.  */
7465           for (j = i; j < ndirs; j++)
7466             if (savehere[j] > 0)
7467               {
7468                 /* Remember how much we saved for this directory so far.  */
7469                 saved[j] = savehere[j];
7470
7471                 /* Remember the prefix directory.  */
7472                 dirs[j].dir_idx = i;
7473               }
7474         }
7475     }
7476
7477   /* We have to emit them in the order they appear in the file_table array
7478      since the index is used in the debug info generation.  To do this
7479      efficiently we generate a back-mapping of the indices first.  */
7480   backmap = (int *) alloca (VARRAY_ACTIVE_SIZE (file_table) * sizeof (int));
7481   for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7482     {
7483       backmap[files[i].file_idx] = i;
7484
7485       /* Mark this directory as used.  */
7486       dirs[dirs[files[i].dir_idx].dir_idx].used = 1;
7487     }
7488
7489   /* That was it.  We are ready to emit the information.  First emit the
7490      directory name table.  We have to make sure the first actually emitted
7491      directory name has index one; zero is reserved for the current working
7492      directory.  Make sure we do not confuse these indices with the one for the
7493      constructed table (even though most of the time they are identical).  */
7494   idx = 1;
7495   idx_offset = dirs[0].length > 0 ? 1 : 0;
7496   for (i = 1 - idx_offset; i < ndirs; i++)
7497     if (dirs[i].used != 0)
7498       {
7499         dirs[i].used = idx++;
7500         dw2_asm_output_nstring (dirs[i].path, dirs[i].length - 1,
7501                                 "Directory Entry: 0x%x", dirs[i].used);
7502       }
7503
7504   dw2_asm_output_data (1, 0, "End directory table");
7505
7506   /* Correct the index for the current working directory entry if it
7507      exists.  */
7508   if (idx_offset == 0)
7509     dirs[0].used = 0;
7510
7511   /* Now write all the file names.  */
7512   for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7513     {
7514       int file_idx = backmap[i];
7515       int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
7516
7517       dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
7518                               "File Entry: 0x%lx", (unsigned long) i);
7519
7520       /* Include directory index.  */
7521       dw2_asm_output_data_uleb128 (dirs[dir_idx].used, NULL);
7522
7523       /* Modification time.  */
7524       dw2_asm_output_data_uleb128 (0, NULL);
7525
7526       /* File length in bytes.  */
7527       dw2_asm_output_data_uleb128 (0, NULL);
7528     }
7529
7530   dw2_asm_output_data (1, 0, "End file name table");
7531 }
7532
7533
7534 /* Output the source line number correspondence information.  This
7535    information goes into the .debug_line section.  */
7536
7537 static void
7538 output_line_info ()
7539 {
7540   char l1[20], l2[20], p1[20], p2[20];
7541   char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
7542   char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
7543   unsigned opc;
7544   unsigned n_op_args;
7545   unsigned long lt_index;
7546   unsigned long current_line;
7547   long line_offset;
7548   long line_delta;
7549   unsigned long current_file;
7550   unsigned long function;
7551
7552   ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
7553   ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
7554   ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
7555   ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);
7556
7557   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7558     dw2_asm_output_data (4, 0xffffffff,
7559       "Initial length escape value indicating 64-bit DWARF extension");
7560   dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
7561                         "Length of Source Line Info");
7562   ASM_OUTPUT_LABEL (asm_out_file, l1);
7563
7564   dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7565   dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
7566   ASM_OUTPUT_LABEL (asm_out_file, p1);
7567
7568   /* Define the architecture-dependent minimum instruction length (in
7569    bytes).  In this implementation of DWARF, this field is used for
7570    information purposes only.  Since GCC generates assembly language,
7571    we have no a priori knowledge of how many instruction bytes are
7572    generated for each source line, and therefore can use only the
7573    DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
7574    commands.  Accordingly, we fix this as `1', which is "correct
7575    enough" for all architectures, and don't let the target override.  */
7576   dw2_asm_output_data (1, 1,
7577                        "Minimum Instruction Length");
7578
7579   dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
7580                        "Default is_stmt_start flag");
7581   dw2_asm_output_data (1, DWARF_LINE_BASE,
7582                        "Line Base Value (Special Opcodes)");
7583   dw2_asm_output_data (1, DWARF_LINE_RANGE,
7584                        "Line Range Value (Special Opcodes)");
7585   dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
7586                        "Special Opcode Base");
7587
7588   for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
7589     {
7590       switch (opc)
7591         {
7592         case DW_LNS_advance_pc:
7593         case DW_LNS_advance_line:
7594         case DW_LNS_set_file:
7595         case DW_LNS_set_column:
7596         case DW_LNS_fixed_advance_pc:
7597           n_op_args = 1;
7598           break;
7599         default:
7600           n_op_args = 0;
7601           break;
7602         }
7603
7604       dw2_asm_output_data (1, n_op_args, "opcode: 0x%x has %d args",
7605                            opc, n_op_args);
7606     }
7607
7608   /* Write out the information about the files we use.  */
7609   output_file_names ();
7610   ASM_OUTPUT_LABEL (asm_out_file, p2);
7611
7612   /* We used to set the address register to the first location in the text
7613      section here, but that didn't accomplish anything since we already
7614      have a line note for the opening brace of the first function.  */
7615
7616   /* Generate the line number to PC correspondence table, encoded as
7617      a series of state machine operations.  */
7618   current_file = 1;
7619   current_line = 1;
7620   strcpy (prev_line_label, text_section_label);
7621   for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
7622     {
7623       dw_line_info_ref line_info = &line_info_table[lt_index];
7624
7625 #if 0
7626       /* Disable this optimization for now; GDB wants to see two line notes
7627          at the beginning of a function so it can find the end of the
7628          prologue.  */
7629
7630       /* Don't emit anything for redundant notes.  Just updating the
7631          address doesn't accomplish anything, because we already assume
7632          that anything after the last address is this line.  */
7633       if (line_info->dw_line_num == current_line
7634           && line_info->dw_file_num == current_file)
7635         continue;
7636 #endif
7637
7638       /* Emit debug info for the address of the current line.
7639
7640          Unfortunately, we have little choice here currently, and must always
7641          use the most general form.  GCC does not know the address delta
7642          itself, so we can't use DW_LNS_advance_pc.  Many ports do have length
7643          attributes which will give an upper bound on the address range.  We
7644          could perhaps use length attributes to determine when it is safe to
7645          use DW_LNS_fixed_advance_pc.  */
7646
7647       ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
7648       if (0)
7649         {
7650           /* This can handle deltas up to 0xffff.  This takes 3 bytes.  */
7651           dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
7652                                "DW_LNS_fixed_advance_pc");
7653           dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
7654         }
7655       else
7656         {
7657           /* This can handle any delta.  This takes
7658              4+DWARF2_ADDR_SIZE bytes.  */
7659           dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7660           dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7661           dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7662           dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
7663         }
7664
7665       strcpy (prev_line_label, line_label);
7666
7667       /* Emit debug info for the source file of the current line, if
7668          different from the previous line.  */
7669       if (line_info->dw_file_num != current_file)
7670         {
7671           current_file = line_info->dw_file_num;
7672           dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
7673           dw2_asm_output_data_uleb128 (current_file, "(\"%s\")",
7674                                        VARRAY_CHAR_PTR (file_table,
7675                                                         current_file));
7676         }
7677
7678       /* Emit debug info for the current line number, choosing the encoding
7679          that uses the least amount of space.  */
7680       if (line_info->dw_line_num != current_line)
7681         {
7682           line_offset = line_info->dw_line_num - current_line;
7683           line_delta = line_offset - DWARF_LINE_BASE;
7684           current_line = line_info->dw_line_num;
7685           if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
7686             /* This can handle deltas from -10 to 234, using the current
7687                definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.  This
7688                takes 1 byte.  */
7689             dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
7690                                  "line %lu", current_line);
7691           else
7692             {
7693               /* This can handle any delta.  This takes at least 4 bytes,
7694                  depending on the value being encoded.  */
7695               dw2_asm_output_data (1, DW_LNS_advance_line,
7696                                    "advance to line %lu", current_line);
7697               dw2_asm_output_data_sleb128 (line_offset, NULL);
7698               dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
7699             }
7700         }
7701       else
7702         /* We still need to start a new row, so output a copy insn.  */
7703         dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
7704     }
7705
7706   /* Emit debug info for the address of the end of the function.  */
7707   if (0)
7708     {
7709       dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
7710                            "DW_LNS_fixed_advance_pc");
7711       dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL);
7712     }
7713   else
7714     {
7715       dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7716       dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7717       dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7718       dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL);
7719     }
7720
7721   dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
7722   dw2_asm_output_data_uleb128 (1, NULL);
7723   dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
7724
7725   function = 0;
7726   current_file = 1;
7727   current_line = 1;
7728   for (lt_index = 0; lt_index < separate_line_info_table_in_use;)
7729     {
7730       dw_separate_line_info_ref line_info
7731         = &separate_line_info_table[lt_index];
7732
7733 #if 0
7734       /* Don't emit anything for redundant notes.  */
7735       if (line_info->dw_line_num == current_line
7736           && line_info->dw_file_num == current_file
7737           && line_info->function == function)
7738         goto cont;
7739 #endif
7740
7741       /* Emit debug info for the address of the current line.  If this is
7742          a new function, or the first line of a function, then we need
7743          to handle it differently.  */
7744       ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
7745                                    lt_index);
7746       if (function != line_info->function)
7747         {
7748           function = line_info->function;
7749
7750           /* Set the address register to the first line in the function */
7751           dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7752           dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7753           dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7754           dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
7755         }
7756       else
7757         {
7758           /* ??? See the DW_LNS_advance_pc comment above.  */
7759           if (0)
7760             {
7761               dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
7762                                    "DW_LNS_fixed_advance_pc");
7763               dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
7764             }
7765           else
7766             {
7767               dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7768               dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7769               dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7770               dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
7771             }
7772         }
7773
7774       strcpy (prev_line_label, line_label);
7775
7776       /* Emit debug info for the source file of the current line, if
7777          different from the previous line.  */
7778       if (line_info->dw_file_num != current_file)
7779         {
7780           current_file = line_info->dw_file_num;
7781           dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
7782           dw2_asm_output_data_uleb128 (current_file, "(\"%s\")",
7783                                        VARRAY_CHAR_PTR (file_table,
7784                                                         current_file));
7785         }
7786
7787       /* Emit debug info for the current line number, choosing the encoding
7788          that uses the least amount of space.  */
7789       if (line_info->dw_line_num != current_line)
7790         {
7791           line_offset = line_info->dw_line_num - current_line;
7792           line_delta = line_offset - DWARF_LINE_BASE;
7793           current_line = line_info->dw_line_num;
7794           if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
7795             dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
7796                                  "line %lu", current_line);
7797           else
7798             {
7799               dw2_asm_output_data (1, DW_LNS_advance_line,
7800                                    "advance to line %lu", current_line);
7801               dw2_asm_output_data_sleb128 (line_offset, NULL);
7802               dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
7803             }
7804         }
7805       else
7806         dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
7807
7808 #if 0
7809     cont:
7810 #endif
7811
7812       lt_index++;
7813
7814       /* If we're done with a function, end its sequence.  */
7815       if (lt_index == separate_line_info_table_in_use
7816           || separate_line_info_table[lt_index].function != function)
7817         {
7818           current_file = 1;
7819           current_line = 1;
7820
7821           /* Emit debug info for the address of the end of the function.  */
7822           ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
7823           if (0)
7824             {
7825               dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
7826                                    "DW_LNS_fixed_advance_pc");
7827               dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
7828             }
7829           else
7830             {
7831               dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7832               dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7833               dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7834               dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
7835             }
7836
7837           /* Output the marker for the end of this sequence.  */
7838           dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
7839           dw2_asm_output_data_uleb128 (1, NULL);
7840           dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
7841         }
7842     }
7843
7844   /* Output the marker for the end of the line number info.  */
7845   ASM_OUTPUT_LABEL (asm_out_file, l2);
7846 }
7847 \f
7848 /* Given a pointer to a tree node for some base type, return a pointer to
7849    a DIE that describes the given type.
7850
7851    This routine must only be called for GCC type nodes that correspond to
7852    Dwarf base (fundamental) types.  */
7853
7854 static dw_die_ref
7855 base_type_die (type)
7856      tree type;
7857 {
7858   dw_die_ref base_type_result;
7859   const char *type_name;
7860   enum dwarf_type encoding;
7861   tree name = TYPE_NAME (type);
7862
7863   if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE)
7864     return 0;
7865
7866   if (name)
7867     {
7868       if (TREE_CODE (name) == TYPE_DECL)
7869         name = DECL_NAME (name);
7870
7871       type_name = IDENTIFIER_POINTER (name);
7872     }
7873   else
7874     type_name = "__unknown__";
7875
7876   switch (TREE_CODE (type))
7877     {
7878     case INTEGER_TYPE:
7879       /* Carefully distinguish the C character types, without messing
7880          up if the language is not C. Note that we check only for the names
7881          that contain spaces; other names might occur by coincidence in other
7882          languages.  */
7883       if (! (TYPE_PRECISION (type) == CHAR_TYPE_SIZE
7884              && (type == char_type_node
7885                  || ! strcmp (type_name, "signed char")
7886                  || ! strcmp (type_name, "unsigned char"))))
7887         {
7888           if (TREE_UNSIGNED (type))
7889             encoding = DW_ATE_unsigned;
7890           else
7891             encoding = DW_ATE_signed;
7892           break;
7893         }
7894       /* else fall through.  */
7895
7896     case CHAR_TYPE:
7897       /* GNU Pascal/Ada CHAR type.  Not used in C.  */
7898       if (TREE_UNSIGNED (type))
7899         encoding = DW_ATE_unsigned_char;
7900       else
7901         encoding = DW_ATE_signed_char;
7902       break;
7903
7904     case REAL_TYPE:
7905       encoding = DW_ATE_float;
7906       break;
7907
7908       /* Dwarf2 doesn't know anything about complex ints, so use
7909          a user defined type for it.  */
7910     case COMPLEX_TYPE:
7911       if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
7912         encoding = DW_ATE_complex_float;
7913       else
7914         encoding = DW_ATE_lo_user;
7915       break;
7916
7917     case BOOLEAN_TYPE:
7918       /* GNU FORTRAN/Ada/C++ BOOLEAN type.  */
7919       encoding = DW_ATE_boolean;
7920       break;
7921
7922     default:
7923       /* No other TREE_CODEs are Dwarf fundamental types.  */
7924       abort ();
7925     }
7926
7927   base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type);
7928   if (demangle_name_func)
7929     type_name = (*demangle_name_func) (type_name);
7930
7931   add_AT_string (base_type_result, DW_AT_name, type_name);
7932   add_AT_unsigned (base_type_result, DW_AT_byte_size,
7933                    int_size_in_bytes (type));
7934   add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
7935
7936   return base_type_result;
7937 }
7938
7939 /* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
7940    the Dwarf "root" type for the given input type.  The Dwarf "root" type of
7941    a given type is generally the same as the given type, except that if the
7942    given type is a pointer or reference type, then the root type of the given
7943    type is the root type of the "basis" type for the pointer or reference
7944    type.  (This definition of the "root" type is recursive.) Also, the root
7945    type of a `const' qualified type or a `volatile' qualified type is the
7946    root type of the given type without the qualifiers.  */
7947
7948 static tree
7949 root_type (type)
7950      tree type;
7951 {
7952   if (TREE_CODE (type) == ERROR_MARK)
7953     return error_mark_node;
7954
7955   switch (TREE_CODE (type))
7956     {
7957     case ERROR_MARK:
7958       return error_mark_node;
7959
7960     case POINTER_TYPE:
7961     case REFERENCE_TYPE:
7962       return type_main_variant (root_type (TREE_TYPE (type)));
7963
7964     default:
7965       return type_main_variant (type);
7966     }
7967 }
7968
7969 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
7970    given input type is a Dwarf "fundamental" type.  Otherwise return null.  */
7971
7972 static inline int
7973 is_base_type (type)
7974      tree type;
7975 {
7976   switch (TREE_CODE (type))
7977     {
7978     case ERROR_MARK:
7979     case VOID_TYPE:
7980     case INTEGER_TYPE:
7981     case REAL_TYPE:
7982     case COMPLEX_TYPE:
7983     case BOOLEAN_TYPE:
7984     case CHAR_TYPE:
7985       return 1;
7986
7987     case SET_TYPE:
7988     case ARRAY_TYPE:
7989     case RECORD_TYPE:
7990     case UNION_TYPE:
7991     case QUAL_UNION_TYPE:
7992     case ENUMERAL_TYPE:
7993     case FUNCTION_TYPE:
7994     case METHOD_TYPE:
7995     case POINTER_TYPE:
7996     case REFERENCE_TYPE:
7997     case FILE_TYPE:
7998     case OFFSET_TYPE:
7999     case LANG_TYPE:
8000     case VECTOR_TYPE:
8001       return 0;
8002
8003     default:
8004       abort ();
8005     }
8006
8007   return 0;
8008 }
8009
8010 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
8011    node, return the size in bits for the type if it is a constant, or else
8012    return the alignment for the type if the type's size is not constant, or
8013    else return BITS_PER_WORD if the type actually turns out to be an
8014    ERROR_MARK node.  */
8015
8016 static inline unsigned HOST_WIDE_INT
8017 simple_type_size_in_bits (type)
8018      tree type;
8019 {
8020
8021   if (TREE_CODE (type) == ERROR_MARK)
8022     return BITS_PER_WORD;
8023   else if (TYPE_SIZE (type) == NULL_TREE)
8024     return 0;
8025   else if (host_integerp (TYPE_SIZE (type), 1))
8026     return tree_low_cst (TYPE_SIZE (type), 1);
8027   else
8028     return TYPE_ALIGN (type);
8029 }
8030
8031 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
8032    entry that chains various modifiers in front of the given type.  */
8033
8034 static dw_die_ref
8035 modified_type_die (type, is_const_type, is_volatile_type, context_die)
8036      tree type;
8037      int is_const_type;
8038      int is_volatile_type;
8039      dw_die_ref context_die;
8040 {
8041   enum tree_code code = TREE_CODE (type);
8042   dw_die_ref mod_type_die = NULL;
8043   dw_die_ref sub_die = NULL;
8044   tree item_type = NULL;
8045
8046   if (code != ERROR_MARK)
8047     {
8048       tree qualified_type;
8049
8050       /* See if we already have the appropriately qualified variant of
8051          this type.  */
8052       qualified_type
8053         = get_qualified_type (type,
8054                               ((is_const_type ? TYPE_QUAL_CONST : 0)
8055                                | (is_volatile_type
8056                                   ? TYPE_QUAL_VOLATILE : 0)));
8057
8058       /* If we do, then we can just use its DIE, if it exists.  */
8059       if (qualified_type)
8060         {
8061           mod_type_die = lookup_type_die (qualified_type);
8062           if (mod_type_die)
8063             return mod_type_die;
8064         }
8065
8066       /* Handle C typedef types.  */
8067       if (qualified_type && TYPE_NAME (qualified_type)
8068           && TREE_CODE (TYPE_NAME (qualified_type)) == TYPE_DECL
8069           && DECL_ORIGINAL_TYPE (TYPE_NAME (qualified_type)))
8070         {
8071           tree type_name = TYPE_NAME (qualified_type);
8072           tree dtype = TREE_TYPE (type_name);
8073
8074           if (qualified_type == dtype)
8075             {
8076               /* For a named type, use the typedef.  */
8077               gen_type_die (qualified_type, context_die);
8078               mod_type_die = lookup_type_die (qualified_type);
8079             }
8080           else if (is_const_type < TYPE_READONLY (dtype)
8081                    || is_volatile_type < TYPE_VOLATILE (dtype))
8082             /* cv-unqualified version of named type.  Just use the unnamed
8083                type to which it refers.  */
8084             mod_type_die
8085               = modified_type_die (DECL_ORIGINAL_TYPE (type_name),
8086                                    is_const_type, is_volatile_type,
8087                                    context_die);
8088
8089           /* Else cv-qualified version of named type; fall through.  */
8090         }
8091
8092       if (mod_type_die)
8093         /* OK.  */
8094         ;
8095       else if (is_const_type)
8096         {
8097           mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type);
8098           sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
8099         }
8100       else if (is_volatile_type)
8101         {
8102           mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type);
8103           sub_die = modified_type_die (type, 0, 0, context_die);
8104         }
8105       else if (code == POINTER_TYPE)
8106         {
8107           mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type);
8108           add_AT_unsigned (mod_type_die, DW_AT_byte_size,
8109                            simple_type_size_in_bits (type) / BITS_PER_UNIT);
8110 #if 0
8111           add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
8112 #endif
8113           item_type = TREE_TYPE (type);
8114         }
8115       else if (code == REFERENCE_TYPE)
8116         {
8117           mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type);
8118           add_AT_unsigned (mod_type_die, DW_AT_byte_size,
8119                            simple_type_size_in_bits (type) / BITS_PER_UNIT);
8120 #if 0
8121           add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
8122 #endif
8123           item_type = TREE_TYPE (type);
8124         }
8125       else if (is_base_type (type))
8126         mod_type_die = base_type_die (type);
8127       else
8128         {
8129           gen_type_die (type, context_die);
8130
8131           /* We have to get the type_main_variant here (and pass that to the
8132              `lookup_type_die' routine) because the ..._TYPE node we have
8133              might simply be a *copy* of some original type node (where the
8134              copy was created to help us keep track of typedef names) and
8135              that copy might have a different TYPE_UID from the original
8136              ..._TYPE node.  */
8137           if (TREE_CODE (type) != VECTOR_TYPE)
8138             mod_type_die = lookup_type_die (type_main_variant (type));
8139           else
8140             /* Vectors have the debugging information in the type,
8141                not the main variant.  */
8142             mod_type_die = lookup_type_die (type);
8143           if (mod_type_die == NULL)
8144             abort ();
8145         }
8146
8147       /* We want to equate the qualified type to the die below.  */
8148       type = qualified_type;
8149     }
8150
8151   if (type)
8152     equate_type_number_to_die (type, mod_type_die);
8153   if (item_type)
8154     /* We must do this after the equate_type_number_to_die call, in case
8155        this is a recursive type.  This ensures that the modified_type_die
8156        recursion will terminate even if the type is recursive.  Recursive
8157        types are possible in Ada.  */
8158     sub_die = modified_type_die (item_type,
8159                                  TYPE_READONLY (item_type),
8160                                  TYPE_VOLATILE (item_type),
8161                                  context_die);
8162
8163   if (sub_die != NULL)
8164     add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
8165
8166   return mod_type_die;
8167 }
8168
8169 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
8170    an enumerated type.  */
8171
8172 static inline int
8173 type_is_enum (type)
8174      tree type;
8175 {
8176   return TREE_CODE (type) == ENUMERAL_TYPE;
8177 }
8178
8179 /* Return the register number described by a given RTL node.  */
8180
8181 static unsigned int
8182 reg_number (rtl)
8183      rtx rtl;
8184 {
8185   unsigned regno = REGNO (rtl);
8186
8187   if (regno >= FIRST_PSEUDO_REGISTER)
8188     abort ();
8189
8190   return DBX_REGISTER_NUMBER (regno);
8191 }
8192
8193 /* Return a location descriptor that designates a machine register or
8194    zero if there is none.  */
8195
8196 static dw_loc_descr_ref
8197 reg_loc_descriptor (rtl)
8198      rtx rtl;
8199 {
8200   unsigned reg;
8201   rtx regs;
8202
8203   if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
8204     return 0;
8205
8206   reg = reg_number (rtl);
8207   regs = (*targetm.dwarf_register_span) (rtl);
8208
8209   if (HARD_REGNO_NREGS (reg, GET_MODE (rtl)) > 1
8210       || regs)
8211     return multiple_reg_loc_descriptor (rtl, regs);
8212   else
8213     return one_reg_loc_descriptor (reg);
8214 }
8215
8216 /* Return a location descriptor that designates a machine register for
8217    a given hard register number.  */
8218
8219 static dw_loc_descr_ref
8220 one_reg_loc_descriptor (regno)
8221      unsigned int regno;
8222 {
8223   if (regno <= 31)
8224     return new_loc_descr (DW_OP_reg0 + regno, 0, 0);
8225   else
8226     return new_loc_descr (DW_OP_regx, regno, 0);
8227 }
8228
8229 /* Given an RTL of a register, return a location descriptor that
8230    designates a value that spans more than one register.  */
8231
8232 static dw_loc_descr_ref
8233 multiple_reg_loc_descriptor (rtl, regs)
8234      rtx rtl, regs;
8235 {
8236   int nregs, size, i;
8237   unsigned reg;
8238   dw_loc_descr_ref loc_result = NULL;
8239
8240   reg = reg_number (rtl);
8241   nregs = HARD_REGNO_NREGS (reg, GET_MODE (rtl));
8242
8243   /* Simple, contiguous registers.  */
8244   if (regs == NULL_RTX)
8245     {
8246       size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;
8247
8248       loc_result = NULL;
8249       while (nregs--)
8250         {
8251           dw_loc_descr_ref t;
8252
8253           t = one_reg_loc_descriptor (reg);
8254           add_loc_descr (&loc_result, t);
8255           add_loc_descr (&loc_result, new_loc_descr (DW_OP_piece, size, 0));
8256           ++reg;
8257         }
8258       return loc_result;
8259     }
8260
8261   /* Now onto stupid register sets in non contiguous locations.  */
8262
8263   if (GET_CODE (regs) != PARALLEL)
8264     abort ();
8265
8266   size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
8267   loc_result = NULL;
8268
8269   for (i = 0; i < XVECLEN (regs, 0); ++i)
8270     {
8271       dw_loc_descr_ref t;
8272
8273       t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i)));
8274       add_loc_descr (&loc_result, t);
8275       size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
8276       add_loc_descr (&loc_result, new_loc_descr (DW_OP_piece, size, 0));
8277     }
8278   return loc_result;
8279 }
8280
8281 /* Return a location descriptor that designates a constant.  */
8282
8283 static dw_loc_descr_ref
8284 int_loc_descriptor (i)
8285      HOST_WIDE_INT i;
8286 {
8287   enum dwarf_location_atom op;
8288
8289   /* Pick the smallest representation of a constant, rather than just
8290      defaulting to the LEB encoding.  */
8291   if (i >= 0)
8292     {
8293       if (i <= 31)
8294         op = DW_OP_lit0 + i;
8295       else if (i <= 0xff)
8296         op = DW_OP_const1u;
8297       else if (i <= 0xffff)
8298         op = DW_OP_const2u;
8299       else if (HOST_BITS_PER_WIDE_INT == 32
8300                || i <= 0xffffffff)
8301         op = DW_OP_const4u;
8302       else
8303         op = DW_OP_constu;
8304     }
8305   else
8306     {
8307       if (i >= -0x80)
8308         op = DW_OP_const1s;
8309       else if (i >= -0x8000)
8310         op = DW_OP_const2s;
8311       else if (HOST_BITS_PER_WIDE_INT == 32
8312                || i >= -0x80000000)
8313         op = DW_OP_const4s;
8314       else
8315         op = DW_OP_consts;
8316     }
8317
8318   return new_loc_descr (op, i, 0);
8319 }
8320
8321 /* Return a location descriptor that designates a base+offset location.  */
8322
8323 static dw_loc_descr_ref
8324 based_loc_descr (reg, offset)
8325      unsigned reg;
8326      long int offset;
8327 {
8328   dw_loc_descr_ref loc_result;
8329   /* For the "frame base", we use the frame pointer or stack pointer
8330      registers, since the RTL for local variables is relative to one of
8331      them.  */
8332   unsigned fp_reg = DBX_REGISTER_NUMBER (frame_pointer_needed
8333                                          ? HARD_FRAME_POINTER_REGNUM
8334                                          : STACK_POINTER_REGNUM);
8335
8336   if (reg == fp_reg)
8337     loc_result = new_loc_descr (DW_OP_fbreg, offset, 0);
8338   else if (reg <= 31)
8339     loc_result = new_loc_descr (DW_OP_breg0 + reg, offset, 0);
8340   else
8341     loc_result = new_loc_descr (DW_OP_bregx, reg, offset);
8342
8343   return loc_result;
8344 }
8345
8346 /* Return true if this RTL expression describes a base+offset calculation.  */
8347
8348 static inline int
8349 is_based_loc (rtl)
8350      rtx rtl;
8351 {
8352   return (GET_CODE (rtl) == PLUS
8353           && ((GET_CODE (XEXP (rtl, 0)) == REG
8354                && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
8355                && GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
8356 }
8357
8358 /* The following routine converts the RTL for a variable or parameter
8359    (resident in memory) into an equivalent Dwarf representation of a
8360    mechanism for getting the address of that same variable onto the top of a
8361    hypothetical "address evaluation" stack.
8362
8363    When creating memory location descriptors, we are effectively transforming
8364    the RTL for a memory-resident object into its Dwarf postfix expression
8365    equivalent.  This routine recursively descends an RTL tree, turning
8366    it into Dwarf postfix code as it goes.
8367
8368    MODE is the mode of the memory reference, needed to handle some
8369    autoincrement addressing modes.
8370
8371    Return 0 if we can't represent the location.  */
8372
8373 static dw_loc_descr_ref
8374 mem_loc_descriptor (rtl, mode)
8375      rtx rtl;
8376      enum machine_mode mode;
8377 {
8378   dw_loc_descr_ref mem_loc_result = NULL;
8379
8380   /* Note that for a dynamically sized array, the location we will generate a
8381      description of here will be the lowest numbered location which is
8382      actually within the array.  That's *not* necessarily the same as the
8383      zeroth element of the array.  */
8384
8385   rtl = (*targetm.delegitimize_address) (rtl);
8386
8387   switch (GET_CODE (rtl))
8388     {
8389     case POST_INC:
8390     case POST_DEC:
8391     case POST_MODIFY:
8392       /* POST_INC and POST_DEC can be handled just like a SUBREG.  So we
8393          just fall into the SUBREG code.  */
8394
8395       /* ... fall through ...  */
8396
8397     case SUBREG:
8398       /* The case of a subreg may arise when we have a local (register)
8399          variable or a formal (register) parameter which doesn't quite fill
8400          up an entire register.  For now, just assume that it is
8401          legitimate to make the Dwarf info refer to the whole register which
8402          contains the given subreg.  */
8403       rtl = SUBREG_REG (rtl);
8404
8405       /* ... fall through ...  */
8406
8407     case REG:
8408       /* Whenever a register number forms a part of the description of the
8409          method for calculating the (dynamic) address of a memory resident
8410          object, DWARF rules require the register number be referred to as
8411          a "base register".  This distinction is not based in any way upon
8412          what category of register the hardware believes the given register
8413          belongs to.  This is strictly DWARF terminology we're dealing with
8414          here. Note that in cases where the location of a memory-resident
8415          data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
8416          OP_CONST (0)) the actual DWARF location descriptor that we generate
8417          may just be OP_BASEREG (basereg).  This may look deceptively like
8418          the object in question was allocated to a register (rather than in
8419          memory) so DWARF consumers need to be aware of the subtle
8420          distinction between OP_REG and OP_BASEREG.  */
8421       if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
8422         mem_loc_result = based_loc_descr (reg_number (rtl), 0);
8423       break;
8424
8425     case MEM:
8426       mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
8427       if (mem_loc_result != 0)
8428         add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
8429       break;
8430
8431     case LO_SUM:
8432          rtl = XEXP (rtl, 1);
8433
8434       /* ... fall through ...  */
8435
8436     case LABEL_REF:
8437       /* Some ports can transform a symbol ref into a label ref, because
8438          the symbol ref is too far away and has to be dumped into a constant
8439          pool.  */
8440     case CONST:
8441     case SYMBOL_REF:
8442       /* Alternatively, the symbol in the constant pool might be referenced
8443          by a different symbol.  */
8444       if (GET_CODE (rtl) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (rtl))
8445         {
8446           bool marked;
8447           rtx tmp = get_pool_constant_mark (rtl, &marked);
8448
8449           if (GET_CODE (tmp) == SYMBOL_REF)
8450             {
8451               rtl = tmp;
8452               if (CONSTANT_POOL_ADDRESS_P (tmp))
8453                 get_pool_constant_mark (tmp, &marked);
8454               else
8455                 marked = true;
8456             }
8457
8458           /* If all references to this pool constant were optimized away,
8459              it was not output and thus we can't represent it.
8460              FIXME: might try to use DW_OP_const_value here, though
8461              DW_OP_piece complicates it.  */
8462           if (!marked)
8463             return 0;
8464         }
8465
8466       mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
8467       mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
8468       mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl;
8469       VARRAY_PUSH_RTX (used_rtx_varray, rtl);
8470       break;
8471
8472     case PRE_MODIFY:
8473       /* Extract the PLUS expression nested inside and fall into
8474          PLUS code below.  */
8475       rtl = XEXP (rtl, 1);
8476       goto plus;
8477
8478     case PRE_INC:
8479     case PRE_DEC:
8480       /* Turn these into a PLUS expression and fall into the PLUS code
8481          below.  */
8482       rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
8483                           GEN_INT (GET_CODE (rtl) == PRE_INC
8484                                    ? GET_MODE_UNIT_SIZE (mode)
8485                                    : -GET_MODE_UNIT_SIZE (mode)));
8486
8487       /* ... fall through ...  */
8488
8489     case PLUS:
8490     plus:
8491       if (is_based_loc (rtl))
8492         mem_loc_result = based_loc_descr (reg_number (XEXP (rtl, 0)),
8493                                           INTVAL (XEXP (rtl, 1)));
8494       else
8495         {
8496           mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode);
8497           if (mem_loc_result == 0)
8498             break;
8499
8500           if (GET_CODE (XEXP (rtl, 1)) == CONST_INT
8501               && INTVAL (XEXP (rtl, 1)) >= 0)
8502             add_loc_descr (&mem_loc_result,
8503                            new_loc_descr (DW_OP_plus_uconst,
8504                                           INTVAL (XEXP (rtl, 1)), 0));
8505           else
8506             {
8507               add_loc_descr (&mem_loc_result,
8508                              mem_loc_descriptor (XEXP (rtl, 1), mode));
8509               add_loc_descr (&mem_loc_result,
8510                              new_loc_descr (DW_OP_plus, 0, 0));
8511             }
8512         }
8513       break;
8514
8515     case MULT:
8516       {
8517         /* If a pseudo-reg is optimized away, it is possible for it to
8518            be replaced with a MEM containing a multiply.  */
8519         dw_loc_descr_ref op0 = mem_loc_descriptor (XEXP (rtl, 0), mode);
8520         dw_loc_descr_ref op1 = mem_loc_descriptor (XEXP (rtl, 1), mode);
8521
8522         if (op0 == 0 || op1 == 0)
8523           break;
8524
8525         mem_loc_result = op0;
8526         add_loc_descr (&mem_loc_result, op1);
8527         add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0));
8528         break;
8529       }
8530
8531     case CONST_INT:
8532       mem_loc_result = int_loc_descriptor (INTVAL (rtl));
8533       break;
8534
8535     case ADDRESSOF:
8536       /* If this is a MEM, return its address.  Otherwise, we can't
8537          represent this.  */
8538       if (GET_CODE (XEXP (rtl, 0)) == MEM)
8539         return mem_loc_descriptor (XEXP (XEXP (rtl, 0), 0), mode);
8540       else
8541         return 0;
8542
8543     default:
8544       abort ();
8545     }
8546
8547   return mem_loc_result;
8548 }
8549
8550 /* Return a descriptor that describes the concatenation of two locations.
8551    This is typically a complex variable.  */
8552
8553 static dw_loc_descr_ref
8554 concat_loc_descriptor (x0, x1)
8555      rtx x0, x1;
8556 {
8557   dw_loc_descr_ref cc_loc_result = NULL;
8558   dw_loc_descr_ref x0_ref = loc_descriptor (x0);
8559   dw_loc_descr_ref x1_ref = loc_descriptor (x1);
8560
8561   if (x0_ref == 0 || x1_ref == 0)
8562     return 0;
8563
8564   cc_loc_result = x0_ref;
8565   add_loc_descr (&cc_loc_result,
8566                  new_loc_descr (DW_OP_piece,
8567                                 GET_MODE_SIZE (GET_MODE (x0)), 0));
8568
8569   add_loc_descr (&cc_loc_result, x1_ref);
8570   add_loc_descr (&cc_loc_result,
8571                  new_loc_descr (DW_OP_piece,
8572                                 GET_MODE_SIZE (GET_MODE (x1)), 0));
8573
8574   return cc_loc_result;
8575 }
8576
8577 /* Output a proper Dwarf location descriptor for a variable or parameter
8578    which is either allocated in a register or in a memory location.  For a
8579    register, we just generate an OP_REG and the register number.  For a
8580    memory location we provide a Dwarf postfix expression describing how to
8581    generate the (dynamic) address of the object onto the address stack.
8582
8583    If we don't know how to describe it, return 0.  */
8584
8585 static dw_loc_descr_ref
8586 loc_descriptor (rtl)
8587      rtx rtl;
8588 {
8589   dw_loc_descr_ref loc_result = NULL;
8590
8591   switch (GET_CODE (rtl))
8592     {
8593     case SUBREG:
8594       /* The case of a subreg may arise when we have a local (register)
8595          variable or a formal (register) parameter which doesn't quite fill
8596          up an entire register.  For now, just assume that it is
8597          legitimate to make the Dwarf info refer to the whole register which
8598          contains the given subreg.  */
8599       rtl = SUBREG_REG (rtl);
8600
8601       /* ... fall through ...  */
8602
8603     case REG:
8604       loc_result = reg_loc_descriptor (rtl);
8605       break;
8606
8607     case MEM:
8608       loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
8609       break;
8610
8611     case CONCAT:
8612       loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1));
8613       break;
8614
8615     default:
8616       abort ();
8617     }
8618
8619   return loc_result;
8620 }
8621
8622 /* Similar, but generate the descriptor from trees instead of rtl.  This comes
8623    up particularly with variable length arrays.  If ADDRESSP is nonzero, we are
8624    looking for an address.  Otherwise, we return a value.  If we can't make a
8625    descriptor, return 0.  */
8626
8627 static dw_loc_descr_ref
8628 loc_descriptor_from_tree (loc, addressp)
8629      tree loc;
8630      int addressp;
8631 {
8632   dw_loc_descr_ref ret, ret1;
8633   int indirect_p = 0;
8634   int unsignedp = TREE_UNSIGNED (TREE_TYPE (loc));
8635   enum dwarf_location_atom op;
8636
8637   /* ??? Most of the time we do not take proper care for sign/zero
8638      extending the values properly.  Hopefully this won't be a real
8639      problem...  */
8640
8641   switch (TREE_CODE (loc))
8642     {
8643     case ERROR_MARK:
8644       return 0;
8645
8646     case WITH_RECORD_EXPR:
8647     case PLACEHOLDER_EXPR:
8648       /* This case involves extracting fields from an object to determine the
8649          position of other fields.  We don't try to encode this here.  The
8650          only user of this is Ada, which encodes the needed information using
8651          the names of types.  */
8652       return 0;
8653
8654     case CALL_EXPR:
8655       return 0;
8656
8657     case ADDR_EXPR:
8658       /* We can support this only if we can look through conversions and
8659          find an INDIRECT_EXPR.  */
8660       for (loc = TREE_OPERAND (loc, 0);
8661            TREE_CODE (loc) == CONVERT_EXPR || TREE_CODE (loc) == NOP_EXPR
8662            || TREE_CODE (loc) == NON_LVALUE_EXPR
8663            || TREE_CODE (loc) == VIEW_CONVERT_EXPR
8664            || TREE_CODE (loc) == SAVE_EXPR;
8665            loc = TREE_OPERAND (loc, 0))
8666         ;
8667
8668        return (TREE_CODE (loc) == INDIRECT_REF
8669                ? loc_descriptor_from_tree (TREE_OPERAND (loc, 0), addressp)
8670                : 0);
8671
8672     case VAR_DECL:
8673       if (DECL_THREAD_LOCAL (loc))
8674         {
8675           rtx rtl;
8676
8677 #ifndef ASM_OUTPUT_DWARF_DTPREL
8678           /* If this is not defined, we have no way to emit the data.  */
8679           return 0;
8680 #endif
8681
8682           /* The way DW_OP_GNU_push_tls_address is specified, we can only
8683              look up addresses of objects in the current module.  */
8684           if (DECL_EXTERNAL (loc))
8685             return 0;
8686
8687           rtl = rtl_for_decl_location (loc);
8688           if (rtl == NULL_RTX)
8689             return 0;
8690
8691           if (GET_CODE (rtl) != MEM)
8692             return 0;
8693           rtl = XEXP (rtl, 0);
8694           if (! CONSTANT_P (rtl))
8695             return 0;
8696
8697           ret = new_loc_descr (INTERNAL_DW_OP_tls_addr, 0, 0);
8698           ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
8699           ret->dw_loc_oprnd1.v.val_addr = rtl;
8700
8701           ret1 = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0);
8702           add_loc_descr (&ret, ret1);
8703
8704           indirect_p = 1;
8705           break;
8706         }
8707       /* FALLTHRU */
8708
8709     case PARM_DECL:
8710       {
8711         rtx rtl = rtl_for_decl_location (loc);
8712
8713         if (rtl == NULL_RTX)
8714           return 0;
8715         else if (CONSTANT_P (rtl))
8716           {
8717             ret = new_loc_descr (DW_OP_addr, 0, 0);
8718             ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
8719             ret->dw_loc_oprnd1.v.val_addr = rtl;
8720             indirect_p = 1;
8721           }
8722         else
8723           {
8724             enum machine_mode mode = GET_MODE (rtl);
8725
8726             if (GET_CODE (rtl) == MEM)
8727               {
8728                 indirect_p = 1;
8729                 rtl = XEXP (rtl, 0);
8730               }
8731
8732             ret = mem_loc_descriptor (rtl, mode);
8733           }
8734       }
8735       break;
8736
8737     case INDIRECT_REF:
8738       ret = loc_descriptor_from_tree (TREE_OPERAND (loc, 0), 0);
8739       indirect_p = 1;
8740       break;
8741
8742     case COMPOUND_EXPR:
8743       return loc_descriptor_from_tree (TREE_OPERAND (loc, 1), addressp);
8744
8745     case NOP_EXPR:
8746     case CONVERT_EXPR:
8747     case NON_LVALUE_EXPR:
8748     case VIEW_CONVERT_EXPR:
8749     case SAVE_EXPR:
8750       return loc_descriptor_from_tree (TREE_OPERAND (loc, 0), addressp);
8751
8752     case COMPONENT_REF:
8753     case BIT_FIELD_REF:
8754     case ARRAY_REF:
8755     case ARRAY_RANGE_REF:
8756       {
8757         tree obj, offset;
8758         HOST_WIDE_INT bitsize, bitpos, bytepos;
8759         enum machine_mode mode;
8760         int volatilep;
8761
8762         obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
8763                                    &unsignedp, &volatilep);
8764
8765         if (obj == loc)
8766           return 0;
8767
8768         ret = loc_descriptor_from_tree (obj, 1);
8769         if (ret == 0
8770             || bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
8771           return 0;
8772
8773         if (offset != NULL_TREE)
8774           {
8775             /* Variable offset.  */
8776             add_loc_descr (&ret, loc_descriptor_from_tree (offset, 0));
8777             add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
8778           }
8779
8780         if (!addressp)
8781           indirect_p = 1;
8782
8783         bytepos = bitpos / BITS_PER_UNIT;
8784         if (bytepos > 0)
8785           add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0));
8786         else if (bytepos < 0)
8787           {
8788             add_loc_descr (&ret, int_loc_descriptor (bytepos));
8789             add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
8790           }
8791         break;
8792       }
8793
8794     case INTEGER_CST:
8795       if (host_integerp (loc, 0))
8796         ret = int_loc_descriptor (tree_low_cst (loc, 0));
8797       else
8798         return 0;
8799       break;
8800
8801     case TRUTH_AND_EXPR:
8802     case TRUTH_ANDIF_EXPR:
8803     case BIT_AND_EXPR:
8804       op = DW_OP_and;
8805       goto do_binop;
8806
8807     case TRUTH_XOR_EXPR:
8808     case BIT_XOR_EXPR:
8809       op = DW_OP_xor;
8810       goto do_binop;
8811
8812     case TRUTH_OR_EXPR:
8813     case TRUTH_ORIF_EXPR:
8814     case BIT_IOR_EXPR:
8815       op = DW_OP_or;
8816       goto do_binop;
8817
8818     case TRUNC_DIV_EXPR:
8819       op = DW_OP_div;
8820       goto do_binop;
8821
8822     case MINUS_EXPR:
8823       op = DW_OP_minus;
8824       goto do_binop;
8825
8826     case TRUNC_MOD_EXPR:
8827       op = DW_OP_mod;
8828       goto do_binop;
8829
8830     case MULT_EXPR:
8831       op = DW_OP_mul;
8832       goto do_binop;
8833
8834     case LSHIFT_EXPR:
8835       op = DW_OP_shl;
8836       goto do_binop;
8837
8838     case RSHIFT_EXPR:
8839       op = (unsignedp ? DW_OP_shr : DW_OP_shra);
8840       goto do_binop;
8841
8842     case PLUS_EXPR:
8843       if (TREE_CODE (TREE_OPERAND (loc, 1)) == INTEGER_CST
8844           && host_integerp (TREE_OPERAND (loc, 1), 0))
8845         {
8846           ret = loc_descriptor_from_tree (TREE_OPERAND (loc, 0), 0);
8847           if (ret == 0)
8848             return 0;
8849
8850           add_loc_descr (&ret,
8851                          new_loc_descr (DW_OP_plus_uconst,
8852                                         tree_low_cst (TREE_OPERAND (loc, 1),
8853                                                       0),
8854                                         0));
8855           break;
8856         }
8857
8858       op = DW_OP_plus;
8859       goto do_binop;
8860
8861     case LE_EXPR:
8862       if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
8863         return 0;
8864
8865       op = DW_OP_le;
8866       goto do_binop;
8867
8868     case GE_EXPR:
8869       if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
8870         return 0;
8871
8872       op = DW_OP_ge;
8873       goto do_binop;
8874
8875     case LT_EXPR:
8876       if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
8877         return 0;
8878
8879       op = DW_OP_lt;
8880       goto do_binop;
8881
8882     case GT_EXPR:
8883       if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
8884         return 0;
8885
8886       op = DW_OP_gt;
8887       goto do_binop;
8888
8889     case EQ_EXPR:
8890       op = DW_OP_eq;
8891       goto do_binop;
8892
8893     case NE_EXPR:
8894       op = DW_OP_ne;
8895       goto do_binop;
8896
8897     do_binop:
8898       ret = loc_descriptor_from_tree (TREE_OPERAND (loc, 0), 0);
8899       ret1 = loc_descriptor_from_tree (TREE_OPERAND (loc, 1), 0);
8900       if (ret == 0 || ret1 == 0)
8901         return 0;
8902
8903       add_loc_descr (&ret, ret1);
8904       add_loc_descr (&ret, new_loc_descr (op, 0, 0));
8905       break;
8906
8907     case TRUTH_NOT_EXPR:
8908     case BIT_NOT_EXPR:
8909       op = DW_OP_not;
8910       goto do_unop;
8911
8912     case ABS_EXPR:
8913       op = DW_OP_abs;
8914       goto do_unop;
8915
8916     case NEGATE_EXPR:
8917       op = DW_OP_neg;
8918       goto do_unop;
8919
8920     do_unop:
8921       ret = loc_descriptor_from_tree (TREE_OPERAND (loc, 0), 0);
8922       if (ret == 0)
8923         return 0;
8924
8925       add_loc_descr (&ret, new_loc_descr (op, 0, 0));
8926       break;
8927
8928     case MAX_EXPR:
8929       loc = build (COND_EXPR, TREE_TYPE (loc),
8930                    build (LT_EXPR, integer_type_node,
8931                           TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
8932                    TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
8933
8934       /* ... fall through ...  */
8935
8936     case COND_EXPR:
8937       {
8938         dw_loc_descr_ref lhs
8939           = loc_descriptor_from_tree (TREE_OPERAND (loc, 1), 0);
8940         dw_loc_descr_ref rhs
8941           = loc_descriptor_from_tree (TREE_OPERAND (loc, 2), 0);
8942         dw_loc_descr_ref bra_node, jump_node, tmp;
8943
8944         ret = loc_descriptor_from_tree (TREE_OPERAND (loc, 0), 0);
8945         if (ret == 0 || lhs == 0 || rhs == 0)
8946           return 0;
8947
8948         bra_node = new_loc_descr (DW_OP_bra, 0, 0);
8949         add_loc_descr (&ret, bra_node);
8950
8951         add_loc_descr (&ret, rhs);
8952         jump_node = new_loc_descr (DW_OP_skip, 0, 0);
8953         add_loc_descr (&ret, jump_node);
8954
8955         add_loc_descr (&ret, lhs);
8956         bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
8957         bra_node->dw_loc_oprnd1.v.val_loc = lhs;
8958
8959         /* ??? Need a node to point the skip at.  Use a nop.  */
8960         tmp = new_loc_descr (DW_OP_nop, 0, 0);
8961         add_loc_descr (&ret, tmp);
8962         jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
8963         jump_node->dw_loc_oprnd1.v.val_loc = tmp;
8964       }
8965       break;
8966
8967     default:
8968       abort ();
8969     }
8970
8971   /* Show if we can't fill the request for an address.  */
8972   if (addressp && indirect_p == 0)
8973     return 0;
8974
8975   /* If we've got an address and don't want one, dereference.  */
8976   if (!addressp && indirect_p > 0)
8977     {
8978       HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
8979
8980       if (size > DWARF2_ADDR_SIZE || size == -1)
8981         return 0;
8982       else if (size == DWARF2_ADDR_SIZE)
8983         op = DW_OP_deref;
8984       else
8985         op = DW_OP_deref_size;
8986
8987       add_loc_descr (&ret, new_loc_descr (op, size, 0));
8988     }
8989
8990   return ret;
8991 }
8992
8993 /* Given a value, round it up to the lowest multiple of `boundary'
8994    which is not less than the value itself.  */
8995
8996 static inline HOST_WIDE_INT
8997 ceiling (value, boundary)
8998      HOST_WIDE_INT value;
8999      unsigned int boundary;
9000 {
9001   return (((value + boundary - 1) / boundary) * boundary);
9002 }
9003
9004 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
9005    pointer to the declared type for the relevant field variable, or return
9006    `integer_type_node' if the given node turns out to be an
9007    ERROR_MARK node.  */
9008
9009 static inline tree
9010 field_type (decl)
9011      tree decl;
9012 {
9013   tree type;
9014
9015   if (TREE_CODE (decl) == ERROR_MARK)
9016     return integer_type_node;
9017
9018   type = DECL_BIT_FIELD_TYPE (decl);
9019   if (type == NULL_TREE)
9020     type = TREE_TYPE (decl);
9021
9022   return type;
9023 }
9024
9025 /* Given a pointer to a tree node, return the alignment in bits for
9026    it, or else return BITS_PER_WORD if the node actually turns out to
9027    be an ERROR_MARK node.  */
9028
9029 static inline unsigned
9030 simple_type_align_in_bits (type)
9031      tree type;
9032 {
9033   return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
9034 }
9035
9036 static inline unsigned
9037 simple_decl_align_in_bits (decl)
9038      tree decl;
9039 {
9040   return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
9041 }
9042
9043 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
9044    lowest addressed byte of the "containing object" for the given FIELD_DECL,
9045    or return 0 if we are unable to determine what that offset is, either
9046    because the argument turns out to be a pointer to an ERROR_MARK node, or
9047    because the offset is actually variable.  (We can't handle the latter case
9048    just yet).  */
9049
9050 static HOST_WIDE_INT
9051 field_byte_offset (decl)
9052      tree decl;
9053 {
9054   unsigned int type_align_in_bits;
9055   unsigned int decl_align_in_bits;
9056   unsigned HOST_WIDE_INT type_size_in_bits;
9057   HOST_WIDE_INT object_offset_in_bits;
9058   tree type;
9059   tree field_size_tree;
9060   HOST_WIDE_INT bitpos_int;
9061   HOST_WIDE_INT deepest_bitpos;
9062   unsigned HOST_WIDE_INT field_size_in_bits;
9063
9064   if (TREE_CODE (decl) == ERROR_MARK)
9065     return 0;
9066   else if (TREE_CODE (decl) != FIELD_DECL)
9067     abort ();
9068
9069   type = field_type (decl);
9070   field_size_tree = DECL_SIZE (decl);
9071
9072   /* The size could be unspecified if there was an error, or for
9073      a flexible array member.  */
9074   if (! field_size_tree)
9075     field_size_tree = bitsize_zero_node;
9076
9077   /* We cannot yet cope with fields whose positions are variable, so
9078      for now, when we see such things, we simply return 0.  Someday, we may
9079      be able to handle such cases, but it will be damn difficult.  */
9080   if (! host_integerp (bit_position (decl), 0))
9081     return 0;
9082
9083   bitpos_int = int_bit_position (decl);
9084
9085   /* If we don't know the size of the field, pretend it's a full word.  */
9086   if (host_integerp (field_size_tree, 1))
9087     field_size_in_bits = tree_low_cst (field_size_tree, 1);
9088   else
9089     field_size_in_bits = BITS_PER_WORD;
9090
9091   type_size_in_bits = simple_type_size_in_bits (type);
9092   type_align_in_bits = simple_type_align_in_bits (type);
9093   decl_align_in_bits = simple_decl_align_in_bits (decl);
9094
9095   /* The GCC front-end doesn't make any attempt to keep track of the starting
9096      bit offset (relative to the start of the containing structure type) of the
9097      hypothetical "containing object" for a bit-field.  Thus, when computing
9098      the byte offset value for the start of the "containing object" of a
9099      bit-field, we must deduce this information on our own. This can be rather
9100      tricky to do in some cases.  For example, handling the following structure
9101      type definition when compiling for an i386/i486 target (which only aligns
9102      long long's to 32-bit boundaries) can be very tricky:
9103
9104          struct S { int field1; long long field2:31; };
9105
9106      Fortunately, there is a simple rule-of-thumb which can be used in such
9107      cases.  When compiling for an i386/i486, GCC will allocate 8 bytes for the
9108      structure shown above.  It decides to do this based upon one simple rule
9109      for bit-field allocation.  GCC allocates each "containing object" for each
9110      bit-field at the first (i.e. lowest addressed) legitimate alignment
9111      boundary (based upon the required minimum alignment for the declared type
9112      of the field) which it can possibly use, subject to the condition that
9113      there is still enough available space remaining in the containing object
9114      (when allocated at the selected point) to fully accommodate all of the
9115      bits of the bit-field itself.
9116
9117      This simple rule makes it obvious why GCC allocates 8 bytes for each
9118      object of the structure type shown above.  When looking for a place to
9119      allocate the "containing object" for `field2', the compiler simply tries
9120      to allocate a 64-bit "containing object" at each successive 32-bit
9121      boundary (starting at zero) until it finds a place to allocate that 64-
9122      bit field such that at least 31 contiguous (and previously unallocated)
9123      bits remain within that selected 64 bit field.  (As it turns out, for the
9124      example above, the compiler finds it is OK to allocate the "containing
9125      object" 64-bit field at bit-offset zero within the structure type.)
9126
9127      Here we attempt to work backwards from the limited set of facts we're
9128      given, and we try to deduce from those facts, where GCC must have believed
9129      that the containing object started (within the structure type). The value
9130      we deduce is then used (by the callers of this routine) to generate
9131      DW_AT_location and DW_AT_bit_offset attributes for fields (both bit-fields
9132      and, in the case of DW_AT_location, regular fields as well).  */
9133
9134   /* Figure out the bit-distance from the start of the structure to the
9135      "deepest" bit of the bit-field.  */
9136   deepest_bitpos = bitpos_int + field_size_in_bits;
9137
9138   /* This is the tricky part.  Use some fancy footwork to deduce where the
9139      lowest addressed bit of the containing object must be.  */
9140   object_offset_in_bits = deepest_bitpos - type_size_in_bits;
9141
9142   /* Round up to type_align by default.  This works best for bitfields.  */
9143   object_offset_in_bits += type_align_in_bits - 1;
9144   object_offset_in_bits /= type_align_in_bits;
9145   object_offset_in_bits *= type_align_in_bits;
9146
9147   if (object_offset_in_bits > bitpos_int)
9148     {
9149       /* Sigh, the decl must be packed.  */
9150       object_offset_in_bits = deepest_bitpos - type_size_in_bits;
9151
9152       /* Round up to decl_align instead.  */
9153       object_offset_in_bits += decl_align_in_bits - 1;
9154       object_offset_in_bits /= decl_align_in_bits;
9155       object_offset_in_bits *= decl_align_in_bits;
9156     }
9157
9158   return object_offset_in_bits / BITS_PER_UNIT;
9159 }
9160 \f
9161 /* The following routines define various Dwarf attributes and any data
9162    associated with them.  */
9163
9164 /* Add a location description attribute value to a DIE.
9165
9166    This emits location attributes suitable for whole variables and
9167    whole parameters.  Note that the location attributes for struct fields are
9168    generated by the routine `data_member_location_attribute' below.  */
9169
9170 static inline void
9171 add_AT_location_description (die, attr_kind, descr)
9172      dw_die_ref die;
9173      enum dwarf_attribute attr_kind;
9174      dw_loc_descr_ref descr;
9175 {
9176   if (descr != 0)
9177     add_AT_loc (die, attr_kind, descr);
9178 }
9179
9180 /* Attach the specialized form of location attribute used for data members of
9181    struct and union types.  In the special case of a FIELD_DECL node which
9182    represents a bit-field, the "offset" part of this special location
9183    descriptor must indicate the distance in bytes from the lowest-addressed
9184    byte of the containing struct or union type to the lowest-addressed byte of
9185    the "containing object" for the bit-field.  (See the `field_byte_offset'
9186    function above).
9187
9188    For any given bit-field, the "containing object" is a hypothetical object
9189    (of some integral or enum type) within which the given bit-field lives.  The
9190    type of this hypothetical "containing object" is always the same as the
9191    declared type of the individual bit-field itself (for GCC anyway... the
9192    DWARF spec doesn't actually mandate this).  Note that it is the size (in
9193    bytes) of the hypothetical "containing object" which will be given in the
9194    DW_AT_byte_size attribute for this bit-field.  (See the
9195    `byte_size_attribute' function below.)  It is also used when calculating the
9196    value of the DW_AT_bit_offset attribute.  (See the `bit_offset_attribute'
9197    function below.)  */
9198
9199 static void
9200 add_data_member_location_attribute (die, decl)
9201      dw_die_ref die;
9202      tree decl;
9203 {
9204   long offset;
9205   dw_loc_descr_ref loc_descr = 0;
9206
9207   if (TREE_CODE (decl) == TREE_VEC)
9208     {
9209       /* We're working on the TAG_inheritance for a base class.  */
9210       if (TREE_VIA_VIRTUAL (decl) && is_cxx ())
9211         {
9212           /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
9213              aren't at a fixed offset from all (sub)objects of the same
9214              type.  We need to extract the appropriate offset from our
9215              vtable.  The following dwarf expression means
9216
9217                BaseAddr = ObAddr + *((*ObAddr) - Offset)
9218
9219              This is specific to the V3 ABI, of course.  */
9220
9221           dw_loc_descr_ref tmp;
9222
9223           /* Make a copy of the object address.  */
9224           tmp = new_loc_descr (DW_OP_dup, 0, 0);
9225           add_loc_descr (&loc_descr, tmp);
9226
9227           /* Extract the vtable address.  */
9228           tmp = new_loc_descr (DW_OP_deref, 0, 0);
9229           add_loc_descr (&loc_descr, tmp);
9230
9231           /* Calculate the address of the offset.  */
9232           offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
9233           if (offset >= 0)
9234             abort ();
9235
9236           tmp = int_loc_descriptor (-offset);
9237           add_loc_descr (&loc_descr, tmp);
9238           tmp = new_loc_descr (DW_OP_minus, 0, 0);
9239           add_loc_descr (&loc_descr, tmp);
9240
9241           /* Extract the offset.  */
9242           tmp = new_loc_descr (DW_OP_deref, 0, 0);
9243           add_loc_descr (&loc_descr, tmp);
9244
9245           /* Add it to the object address.  */
9246           tmp = new_loc_descr (DW_OP_plus, 0, 0);
9247           add_loc_descr (&loc_descr, tmp);
9248         }
9249       else
9250         offset = tree_low_cst (BINFO_OFFSET (decl), 0);
9251     }
9252   else
9253     offset = field_byte_offset (decl);
9254
9255   if (! loc_descr)
9256     {
9257       enum dwarf_location_atom op;
9258
9259       /* The DWARF2 standard says that we should assume that the structure
9260          address is already on the stack, so we can specify a structure field
9261          address by using DW_OP_plus_uconst.  */
9262
9263 #ifdef MIPS_DEBUGGING_INFO
9264       /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
9265          operator correctly.  It works only if we leave the offset on the
9266          stack.  */
9267       op = DW_OP_constu;
9268 #else
9269       op = DW_OP_plus_uconst;
9270 #endif
9271
9272       loc_descr = new_loc_descr (op, offset, 0);
9273     }
9274
9275   add_AT_loc (die, DW_AT_data_member_location, loc_descr);
9276 }
9277
9278 /* Attach an DW_AT_const_value attribute for a variable or a parameter which
9279    does not have a "location" either in memory or in a register.  These
9280    things can arise in GNU C when a constant is passed as an actual parameter
9281    to an inlined function.  They can also arise in C++ where declared
9282    constants do not necessarily get memory "homes".  */
9283
9284 static void
9285 add_const_value_attribute (die, rtl)
9286      dw_die_ref die;
9287      rtx rtl;
9288 {
9289   switch (GET_CODE (rtl))
9290     {
9291     case CONST_INT:
9292       /* Note that a CONST_INT rtx could represent either an integer
9293          or a floating-point constant.  A CONST_INT is used whenever
9294          the constant will fit into a single word.  In all such
9295          cases, the original mode of the constant value is wiped
9296          out, and the CONST_INT rtx is assigned VOIDmode.  */
9297       {
9298         HOST_WIDE_INT val = INTVAL (rtl);
9299
9300         /* ??? We really should be using HOST_WIDE_INT throughout.  */
9301         if (val < 0 && (long) val == val)
9302           add_AT_int (die, DW_AT_const_value, (long) val);
9303         else if ((unsigned long) val == (unsigned HOST_WIDE_INT) val)
9304           add_AT_unsigned (die, DW_AT_const_value, (unsigned long) val);
9305         else
9306           {
9307 #if HOST_BITS_PER_LONG * 2 == HOST_BITS_PER_WIDE_INT
9308             add_AT_long_long (die, DW_AT_const_value,
9309                               val >> HOST_BITS_PER_LONG, val);
9310 #else
9311             abort ();
9312 #endif
9313           }
9314       }
9315       break;
9316
9317     case CONST_DOUBLE:
9318       /* Note that a CONST_DOUBLE rtx could represent either an integer or a
9319          floating-point constant.  A CONST_DOUBLE is used whenever the
9320          constant requires more than one word in order to be adequately
9321          represented.  We output CONST_DOUBLEs as blocks.  */
9322       {
9323         enum machine_mode mode = GET_MODE (rtl);
9324
9325         if (GET_MODE_CLASS (mode) == MODE_FLOAT)
9326           {
9327             unsigned length = GET_MODE_SIZE (mode) / 4;
9328             long *array = (long *) ggc_alloc (sizeof (long) * length);
9329             REAL_VALUE_TYPE rv;
9330
9331             REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
9332             switch (mode)
9333               {
9334               case SFmode:
9335                 REAL_VALUE_TO_TARGET_SINGLE (rv, array[0]);
9336                 break;
9337
9338               case DFmode:
9339                 REAL_VALUE_TO_TARGET_DOUBLE (rv, array);
9340                 break;
9341
9342               case XFmode:
9343               case TFmode:
9344                 REAL_VALUE_TO_TARGET_LONG_DOUBLE (rv, array);
9345                 break;
9346
9347               default:
9348                 abort ();
9349               }
9350
9351             add_AT_float (die, DW_AT_const_value, length, array);
9352           }
9353         else
9354           {
9355             /* ??? We really should be using HOST_WIDE_INT throughout.  */
9356             if (HOST_BITS_PER_LONG != HOST_BITS_PER_WIDE_INT)
9357               abort ();
9358
9359             add_AT_long_long (die, DW_AT_const_value,
9360                               CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
9361           }
9362       }
9363       break;
9364
9365     case CONST_STRING:
9366       add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
9367       break;
9368
9369     case SYMBOL_REF:
9370     case LABEL_REF:
9371     case CONST:
9372       add_AT_addr (die, DW_AT_const_value, rtl);
9373       VARRAY_PUSH_RTX (used_rtx_varray, rtl);
9374       break;
9375
9376     case PLUS:
9377       /* In cases where an inlined instance of an inline function is passed
9378          the address of an `auto' variable (which is local to the caller) we
9379          can get a situation where the DECL_RTL of the artificial local
9380          variable (for the inlining) which acts as a stand-in for the
9381          corresponding formal parameter (of the inline function) will look
9382          like (plus:SI (reg:SI FRAME_PTR) (const_int ...)).  This is not
9383          exactly a compile-time constant expression, but it isn't the address
9384          of the (artificial) local variable either.  Rather, it represents the
9385          *value* which the artificial local variable always has during its
9386          lifetime.  We currently have no way to represent such quasi-constant
9387          values in Dwarf, so for now we just punt and generate nothing.  */
9388       break;
9389
9390     default:
9391       /* No other kinds of rtx should be possible here.  */
9392       abort ();
9393     }
9394
9395 }
9396
9397 static rtx
9398 rtl_for_decl_location (decl)
9399      tree decl;
9400 {
9401   rtx rtl;
9402
9403   /* Here we have to decide where we are going to say the parameter "lives"
9404      (as far as the debugger is concerned).  We only have a couple of
9405      choices.  GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
9406
9407      DECL_RTL normally indicates where the parameter lives during most of the
9408      activation of the function.  If optimization is enabled however, this
9409      could be either NULL or else a pseudo-reg.  Both of those cases indicate
9410      that the parameter doesn't really live anywhere (as far as the code
9411      generation parts of GCC are concerned) during most of the function's
9412      activation.  That will happen (for example) if the parameter is never
9413      referenced within the function.
9414
9415      We could just generate a location descriptor here for all non-NULL
9416      non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
9417      a little nicer than that if we also consider DECL_INCOMING_RTL in cases
9418      where DECL_RTL is NULL or is a pseudo-reg.
9419
9420      Note however that we can only get away with using DECL_INCOMING_RTL as
9421      a backup substitute for DECL_RTL in certain limited cases.  In cases
9422      where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
9423      we can be sure that the parameter was passed using the same type as it is
9424      declared to have within the function, and that its DECL_INCOMING_RTL
9425      points us to a place where a value of that type is passed.
9426
9427      In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
9428      we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
9429      because in these cases DECL_INCOMING_RTL points us to a value of some
9430      type which is *different* from the type of the parameter itself.  Thus,
9431      if we tried to use DECL_INCOMING_RTL to generate a location attribute in
9432      such cases, the debugger would end up (for example) trying to fetch a
9433      `float' from a place which actually contains the first part of a
9434      `double'.  That would lead to really incorrect and confusing
9435      output at debug-time.
9436
9437      So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
9438      in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl).  There
9439      are a couple of exceptions however.  On little-endian machines we can
9440      get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
9441      not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
9442      an integral type that is smaller than TREE_TYPE (decl). These cases arise
9443      when (on a little-endian machine) a non-prototyped function has a
9444      parameter declared to be of type `short' or `char'.  In such cases,
9445      TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
9446      be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
9447      passed `int' value.  If the debugger then uses that address to fetch
9448      a `short' or a `char' (on a little-endian machine) the result will be
9449      the correct data, so we allow for such exceptional cases below.
9450
9451      Note that our goal here is to describe the place where the given formal
9452      parameter lives during most of the function's activation (i.e. between the
9453      end of the prologue and the start of the epilogue).  We'll do that as best
9454      as we can. Note however that if the given formal parameter is modified
9455      sometime during the execution of the function, then a stack backtrace (at
9456      debug-time) will show the function as having been called with the *new*
9457      value rather than the value which was originally passed in.  This happens
9458      rarely enough that it is not a major problem, but it *is* a problem, and
9459      I'd like to fix it.
9460
9461      A future version of dwarf2out.c may generate two additional attributes for
9462      any given DW_TAG_formal_parameter DIE which will describe the "passed
9463      type" and the "passed location" for the given formal parameter in addition
9464      to the attributes we now generate to indicate the "declared type" and the
9465      "active location" for each parameter.  This additional set of attributes
9466      could be used by debuggers for stack backtraces. Separately, note that
9467      sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
9468      This happens (for example) for inlined-instances of inline function formal
9469      parameters which are never referenced.  This really shouldn't be
9470      happening.  All PARM_DECL nodes should get valid non-NULL
9471      DECL_INCOMING_RTL values, but integrate.c doesn't currently generate these
9472      values for inlined instances of inline function parameters, so when we see
9473      such cases, we are just out-of-luck for the time being (until integrate.c
9474      gets fixed).  */
9475
9476   /* Use DECL_RTL as the "location" unless we find something better.  */
9477   rtl = DECL_RTL_IF_SET (decl);
9478
9479   /* When generating abstract instances, ignore everything except
9480      constants, symbols living in memory, and symbols living in
9481      fixed registers.  */
9482   if (! reload_completed)
9483     {
9484       if (rtl
9485           && (CONSTANT_P (rtl)
9486               || (GET_CODE (rtl) == MEM
9487                   && CONSTANT_P (XEXP (rtl, 0)))
9488               || (GET_CODE (rtl) == REG
9489                   && TREE_CODE (decl) == VAR_DECL
9490                   && TREE_STATIC (decl))))
9491         {
9492           rtl = (*targetm.delegitimize_address) (rtl);
9493           return rtl;
9494         }
9495       rtl = NULL_RTX;
9496     }
9497   else if (TREE_CODE (decl) == PARM_DECL)
9498     {
9499       if (rtl == NULL_RTX || is_pseudo_reg (rtl))
9500         {
9501           tree declared_type = type_main_variant (TREE_TYPE (decl));
9502           tree passed_type = type_main_variant (DECL_ARG_TYPE (decl));
9503
9504           /* This decl represents a formal parameter which was optimized out.
9505              Note that DECL_INCOMING_RTL may be NULL in here, but we handle
9506              all cases where (rtl == NULL_RTX) just below.  */
9507           if (declared_type == passed_type)
9508             rtl = DECL_INCOMING_RTL (decl);
9509           else if (! BYTES_BIG_ENDIAN
9510                    && TREE_CODE (declared_type) == INTEGER_TYPE
9511                    && (GET_MODE_SIZE (TYPE_MODE (declared_type))
9512                        <= GET_MODE_SIZE (TYPE_MODE (passed_type))))
9513             rtl = DECL_INCOMING_RTL (decl);
9514         }
9515
9516       /* If the parm was passed in registers, but lives on the stack, then
9517          make a big endian correction if the mode of the type of the
9518          parameter is not the same as the mode of the rtl.  */
9519       /* ??? This is the same series of checks that are made in dbxout.c before
9520          we reach the big endian correction code there.  It isn't clear if all
9521          of these checks are necessary here, but keeping them all is the safe
9522          thing to do.  */
9523       else if (GET_CODE (rtl) == MEM
9524                && XEXP (rtl, 0) != const0_rtx
9525                && ! CONSTANT_P (XEXP (rtl, 0))
9526                /* Not passed in memory.  */
9527                && GET_CODE (DECL_INCOMING_RTL (decl)) != MEM
9528                /* Not passed by invisible reference.  */
9529                && (GET_CODE (XEXP (rtl, 0)) != REG
9530                    || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
9531                    || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
9532 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
9533                    || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
9534 #endif
9535                      )
9536                /* Big endian correction check.  */
9537                && BYTES_BIG_ENDIAN
9538                && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
9539                && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
9540                    < UNITS_PER_WORD))
9541         {
9542           int offset = (UNITS_PER_WORD
9543                         - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
9544
9545           rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
9546                              plus_constant (XEXP (rtl, 0), offset));
9547         }
9548     }
9549
9550   if (rtl != NULL_RTX)
9551     {
9552       rtl = eliminate_regs (rtl, 0, NULL_RTX);
9553 #ifdef LEAF_REG_REMAP
9554       if (current_function_uses_only_leaf_regs)
9555         leaf_renumber_regs_insn (rtl);
9556 #endif
9557     }
9558
9559   /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
9560      and will have been substituted directly into all expressions that use it.
9561      C does not have such a concept, but C++ and other languages do.  */
9562   else if (TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
9563     {
9564       /* If a variable is initialized with a string constant without embedded
9565          zeros, build CONST_STRING.  */
9566       if (TREE_CODE (DECL_INITIAL (decl)) == STRING_CST
9567           && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
9568         {
9569           tree arrtype = TREE_TYPE (decl);
9570           tree enttype = TREE_TYPE (arrtype);
9571           tree domain = TYPE_DOMAIN (arrtype);
9572           tree init = DECL_INITIAL (decl);
9573           enum machine_mode mode = TYPE_MODE (enttype);
9574
9575           if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
9576               && domain
9577               && integer_zerop (TYPE_MIN_VALUE (domain))
9578               && compare_tree_int (TYPE_MAX_VALUE (domain),
9579                                    TREE_STRING_LENGTH (init) - 1) == 0
9580               && ((size_t) TREE_STRING_LENGTH (init)
9581                   == strlen (TREE_STRING_POINTER (init)) + 1))
9582             rtl = gen_rtx_CONST_STRING (VOIDmode, TREE_STRING_POINTER (init));
9583         }
9584       /* If the initializer is something that we know will expand into an
9585          immediate RTL constant, expand it now.  Expanding anything else
9586          tends to produce unresolved symbols; see debug/5770 and c++/6381.  */
9587       else if (TREE_CODE (DECL_INITIAL (decl)) == INTEGER_CST
9588                || TREE_CODE (DECL_INITIAL (decl)) == REAL_CST)
9589         {
9590           rtl = expand_expr (DECL_INITIAL (decl), NULL_RTX, VOIDmode,
9591                              EXPAND_INITIALIZER);
9592           /* If expand_expr returns a MEM, it wasn't immediate.  */
9593           if (rtl && GET_CODE (rtl) == MEM)
9594             abort ();
9595         }
9596     }
9597
9598   if (rtl)
9599     rtl = (*targetm.delegitimize_address) (rtl);
9600
9601   /* If we don't look past the constant pool, we risk emitting a
9602      reference to a constant pool entry that isn't referenced from
9603      code, and thus is not emitted.  */
9604   if (rtl)
9605     rtl = avoid_constant_pool_reference (rtl);
9606
9607   return rtl;
9608 }
9609
9610 /* Generate *either* an DW_AT_location attribute or else an DW_AT_const_value
9611    data attribute for a variable or a parameter.  We generate the
9612    DW_AT_const_value attribute only in those cases where the given variable
9613    or parameter does not have a true "location" either in memory or in a
9614    register.  This can happen (for example) when a constant is passed as an
9615    actual argument in a call to an inline function.  (It's possible that
9616    these things can crop up in other ways also.)  Note that one type of
9617    constant value which can be passed into an inlined function is a constant
9618    pointer.  This can happen for example if an actual argument in an inlined
9619    function call evaluates to a compile-time constant address.  */
9620
9621 static void
9622 add_location_or_const_value_attribute (die, decl)
9623      dw_die_ref die;
9624      tree decl;
9625 {
9626   rtx rtl;
9627   dw_loc_descr_ref descr;
9628
9629   if (TREE_CODE (decl) == ERROR_MARK)
9630     return;
9631   else if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != PARM_DECL)
9632     abort ();
9633
9634   rtl = rtl_for_decl_location (decl);
9635   if (rtl == NULL_RTX)
9636     return;
9637
9638   switch (GET_CODE (rtl))
9639     {
9640     case ADDRESSOF:
9641       /* The address of a variable that was optimized away;
9642          don't emit anything.  */
9643       break;
9644
9645     case CONST_INT:
9646     case CONST_DOUBLE:
9647     case CONST_STRING:
9648     case SYMBOL_REF:
9649     case LABEL_REF:
9650     case CONST:
9651     case PLUS:
9652       /* DECL_RTL could be (plus (reg ...) (const_int ...)) */
9653       add_const_value_attribute (die, rtl);
9654       break;
9655
9656     case MEM:
9657       if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL (decl))
9658         {
9659           /* Need loc_descriptor_from_tree since that's where we know
9660              how to handle TLS variables.  Want the object's address
9661              since the top-level DW_AT_location assumes such.  See
9662              the confusion in loc_descriptor for reference.  */
9663           descr = loc_descriptor_from_tree (decl, 1);
9664         }
9665       else
9666         {
9667         case REG:
9668         case SUBREG:
9669         case CONCAT:
9670           descr = loc_descriptor (rtl);
9671         }
9672       add_AT_location_description (die, DW_AT_location, descr);
9673       break;
9674
9675     default:
9676       abort ();
9677     }
9678 }
9679
9680 /* If we don't have a copy of this variable in memory for some reason (such
9681    as a C++ member constant that doesn't have an out-of-line definition),
9682    we should tell the debugger about the constant value.  */
9683
9684 static void
9685 tree_add_const_value_attribute (var_die, decl)
9686      dw_die_ref var_die;
9687      tree decl;
9688 {
9689   tree init = DECL_INITIAL (decl);
9690   tree type = TREE_TYPE (decl);
9691
9692   if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl) && init
9693       && initializer_constant_valid_p (init, type) == null_pointer_node)
9694     /* OK */;
9695   else
9696     return;
9697
9698   switch (TREE_CODE (type))
9699     {
9700     case INTEGER_TYPE:
9701       if (host_integerp (init, 0))
9702         add_AT_unsigned (var_die, DW_AT_const_value,
9703                          tree_low_cst (init, 0));
9704       else
9705         add_AT_long_long (var_die, DW_AT_const_value,
9706                           TREE_INT_CST_HIGH (init),
9707                           TREE_INT_CST_LOW (init));
9708       break;
9709
9710     default:;
9711     }
9712 }
9713
9714 /* Generate an DW_AT_name attribute given some string value to be included as
9715    the value of the attribute.  */
9716
9717 static void
9718 add_name_attribute (die, name_string)
9719      dw_die_ref die;
9720      const char *name_string;
9721 {
9722   if (name_string != NULL && *name_string != 0)
9723     {
9724       if (demangle_name_func)
9725         name_string = (*demangle_name_func) (name_string);
9726
9727       add_AT_string (die, DW_AT_name, name_string);
9728     }
9729 }
9730
9731 /* Generate an DW_AT_comp_dir attribute for DIE.  */
9732
9733 static void
9734 add_comp_dir_attribute (die)
9735      dw_die_ref die;
9736 {
9737   const char *wd = getpwd ();
9738   if (wd != NULL)
9739     add_AT_string (die, DW_AT_comp_dir, wd);
9740 }
9741
9742 /* Given a tree node describing an array bound (either lower or upper) output
9743    a representation for that bound.  */
9744
9745 static void
9746 add_bound_info (subrange_die, bound_attr, bound)
9747      dw_die_ref subrange_die;
9748      enum dwarf_attribute bound_attr;
9749      tree bound;
9750 {
9751   switch (TREE_CODE (bound))
9752     {
9753     case ERROR_MARK:
9754       return;
9755
9756     /* All fixed-bounds are represented by INTEGER_CST nodes.  */
9757     case INTEGER_CST:
9758       if (! host_integerp (bound, 0)
9759           || (bound_attr == DW_AT_lower_bound
9760               && (((is_c_family () || is_java ()) &&  integer_zerop (bound))
9761                   || (is_fortran () && integer_onep (bound)))))
9762         /* use the default */
9763         ;
9764       else
9765         add_AT_unsigned (subrange_die, bound_attr, tree_low_cst (bound, 0));
9766       break;
9767
9768     case CONVERT_EXPR:
9769     case NOP_EXPR:
9770     case NON_LVALUE_EXPR:
9771     case VIEW_CONVERT_EXPR:
9772       add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
9773       break;
9774
9775     case SAVE_EXPR:
9776       /* If optimization is turned on, the SAVE_EXPRs that describe how to
9777          access the upper bound values may be bogus.  If they refer to a
9778          register, they may only describe how to get at these values at the
9779          points in the generated code right after they have just been
9780          computed.  Worse yet, in the typical case, the upper bound values
9781          will not even *be* computed in the optimized code (though the
9782          number of elements will), so these SAVE_EXPRs are entirely
9783          bogus. In order to compensate for this fact, we check here to see
9784          if optimization is enabled, and if so, we don't add an attribute
9785          for the (unknown and unknowable) upper bound.  This should not
9786          cause too much trouble for existing (stupid?)  debuggers because
9787          they have to deal with empty upper bounds location descriptions
9788          anyway in order to be able to deal with incomplete array types.
9789          Of course an intelligent debugger (GDB?)  should be able to
9790          comprehend that a missing upper bound specification in an array
9791          type used for a storage class `auto' local array variable
9792          indicates that the upper bound is both unknown (at compile- time)
9793          and unknowable (at run-time) due to optimization.
9794
9795          We assume that a MEM rtx is safe because gcc wouldn't put the
9796          value there unless it was going to be used repeatedly in the
9797          function, i.e. for cleanups.  */
9798       if (SAVE_EXPR_RTL (bound)
9799           && (! optimize || GET_CODE (SAVE_EXPR_RTL (bound)) == MEM))
9800         {
9801           dw_die_ref ctx = lookup_decl_die (current_function_decl);
9802           dw_die_ref decl_die = new_die (DW_TAG_variable, ctx, bound);
9803           rtx loc = SAVE_EXPR_RTL (bound);
9804
9805           /* If the RTL for the SAVE_EXPR is memory, handle the case where
9806              it references an outer function's frame.  */
9807           if (GET_CODE (loc) == MEM)
9808             {
9809               rtx new_addr = fix_lexical_addr (XEXP (loc, 0), bound);
9810
9811               if (XEXP (loc, 0) != new_addr)
9812                 loc = gen_rtx_MEM (GET_MODE (loc), new_addr);
9813             }
9814
9815           add_AT_flag (decl_die, DW_AT_artificial, 1);
9816           add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
9817           add_AT_location_description (decl_die, DW_AT_location,
9818                                        loc_descriptor (loc));
9819           add_AT_die_ref (subrange_die, bound_attr, decl_die);
9820         }
9821
9822       /* Else leave out the attribute.  */
9823       break;
9824
9825     case VAR_DECL:
9826     case PARM_DECL:
9827       {
9828         dw_die_ref decl_die = lookup_decl_die (bound);
9829
9830         /* ??? Can this happen, or should the variable have been bound
9831            first?  Probably it can, since I imagine that we try to create
9832            the types of parameters in the order in which they exist in
9833            the list, and won't have created a forward reference to a
9834            later parameter.  */
9835         if (decl_die != NULL)
9836           add_AT_die_ref (subrange_die, bound_attr, decl_die);
9837         break;
9838       }
9839
9840     default:
9841       {
9842         /* Otherwise try to create a stack operation procedure to
9843            evaluate the value of the array bound.  */
9844
9845         dw_die_ref ctx, decl_die;
9846         dw_loc_descr_ref loc;
9847
9848         loc = loc_descriptor_from_tree (bound, 0);
9849         if (loc == NULL)
9850           break;
9851
9852         if (current_function_decl == 0)
9853           ctx = comp_unit_die;
9854         else
9855           ctx = lookup_decl_die (current_function_decl);
9856
9857         /* If we weren't able to find a context, it's most likely the case
9858            that we are processing the return type of the function.  So
9859            make a SAVE_EXPR to point to it and have the limbo DIE code
9860            find the proper die.  The save_expr function doesn't always
9861            make a SAVE_EXPR, so do it ourselves.  */
9862         if (ctx == 0)
9863           bound = build (SAVE_EXPR, TREE_TYPE (bound), bound,
9864                          current_function_decl, NULL_TREE);
9865
9866         decl_die = new_die (DW_TAG_variable, ctx, bound);
9867         add_AT_flag (decl_die, DW_AT_artificial, 1);
9868         add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
9869         add_AT_loc (decl_die, DW_AT_location, loc);
9870
9871         add_AT_die_ref (subrange_die, bound_attr, decl_die);
9872         break;
9873       }
9874     }
9875 }
9876
9877 /* Note that the block of subscript information for an array type also
9878    includes information about the element type of type given array type.  */
9879
9880 static void
9881 add_subscript_info (type_die, type)
9882      dw_die_ref type_die;
9883      tree type;
9884 {
9885 #ifndef MIPS_DEBUGGING_INFO
9886   unsigned dimension_number;
9887 #endif
9888   tree lower, upper;
9889   dw_die_ref subrange_die;
9890
9891   /* The GNU compilers represent multidimensional array types as sequences of
9892      one dimensional array types whose element types are themselves array
9893      types.  Here we squish that down, so that each multidimensional array
9894      type gets only one array_type DIE in the Dwarf debugging info. The draft
9895      Dwarf specification say that we are allowed to do this kind of
9896      compression in C (because there is no difference between an array or
9897      arrays and a multidimensional array in C) but for other source languages
9898      (e.g. Ada) we probably shouldn't do this.  */
9899
9900   /* ??? The SGI dwarf reader fails for multidimensional arrays with a
9901      const enum type.  E.g. const enum machine_mode insn_operand_mode[2][10].
9902      We work around this by disabling this feature.  See also
9903      gen_array_type_die.  */
9904 #ifndef MIPS_DEBUGGING_INFO
9905   for (dimension_number = 0;
9906        TREE_CODE (type) == ARRAY_TYPE;
9907        type = TREE_TYPE (type), dimension_number++)
9908 #endif
9909     {
9910       tree domain = TYPE_DOMAIN (type);
9911
9912       /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
9913          and (in GNU C only) variable bounds.  Handle all three forms
9914          here.  */
9915       subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
9916       if (domain)
9917         {
9918           /* We have an array type with specified bounds.  */
9919           lower = TYPE_MIN_VALUE (domain);
9920           upper = TYPE_MAX_VALUE (domain);
9921
9922           /* define the index type.  */
9923           if (TREE_TYPE (domain))
9924             {
9925               /* ??? This is probably an Ada unnamed subrange type.  Ignore the
9926                  TREE_TYPE field.  We can't emit debug info for this
9927                  because it is an unnamed integral type.  */
9928               if (TREE_CODE (domain) == INTEGER_TYPE
9929                   && TYPE_NAME (domain) == NULL_TREE
9930                   && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
9931                   && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
9932                 ;
9933               else
9934                 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
9935                                     type_die);
9936             }
9937
9938           /* ??? If upper is NULL, the array has unspecified length,
9939              but it does have a lower bound.  This happens with Fortran
9940                dimension arr(N:*)
9941              Since the debugger is definitely going to need to know N
9942              to produce useful results, go ahead and output the lower
9943              bound solo, and hope the debugger can cope.  */
9944
9945           add_bound_info (subrange_die, DW_AT_lower_bound, lower);
9946           if (upper)
9947             add_bound_info (subrange_die, DW_AT_upper_bound, upper);
9948         }
9949
9950       /* Otherwise we have an array type with an unspecified length.  The
9951          DWARF-2 spec does not say how to handle this; let's just leave out the
9952          bounds.  */
9953     }
9954 }
9955
9956 static void
9957 add_byte_size_attribute (die, tree_node)
9958      dw_die_ref die;
9959      tree tree_node;
9960 {
9961   unsigned size;
9962
9963   switch (TREE_CODE (tree_node))
9964     {
9965     case ERROR_MARK:
9966       size = 0;
9967       break;
9968     case ENUMERAL_TYPE:
9969     case RECORD_TYPE:
9970     case UNION_TYPE:
9971     case QUAL_UNION_TYPE:
9972       size = int_size_in_bytes (tree_node);
9973       break;
9974     case FIELD_DECL:
9975       /* For a data member of a struct or union, the DW_AT_byte_size is
9976          generally given as the number of bytes normally allocated for an
9977          object of the *declared* type of the member itself.  This is true
9978          even for bit-fields.  */
9979       size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
9980       break;
9981     default:
9982       abort ();
9983     }
9984
9985   /* Note that `size' might be -1 when we get to this point.  If it is, that
9986      indicates that the byte size of the entity in question is variable.  We
9987      have no good way of expressing this fact in Dwarf at the present time,
9988      so just let the -1 pass on through.  */
9989   add_AT_unsigned (die, DW_AT_byte_size, size);
9990 }
9991
9992 /* For a FIELD_DECL node which represents a bit-field, output an attribute
9993    which specifies the distance in bits from the highest order bit of the
9994    "containing object" for the bit-field to the highest order bit of the
9995    bit-field itself.
9996
9997    For any given bit-field, the "containing object" is a hypothetical object
9998    (of some integral or enum type) within which the given bit-field lives.  The
9999    type of this hypothetical "containing object" is always the same as the
10000    declared type of the individual bit-field itself.  The determination of the
10001    exact location of the "containing object" for a bit-field is rather
10002    complicated.  It's handled by the `field_byte_offset' function (above).
10003
10004    Note that it is the size (in bytes) of the hypothetical "containing object"
10005    which will be given in the DW_AT_byte_size attribute for this bit-field.
10006    (See `byte_size_attribute' above).  */
10007
10008 static inline void
10009 add_bit_offset_attribute (die, decl)
10010      dw_die_ref die;
10011      tree decl;
10012 {
10013   HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
10014   tree type = DECL_BIT_FIELD_TYPE (decl);
10015   HOST_WIDE_INT bitpos_int;
10016   HOST_WIDE_INT highest_order_object_bit_offset;
10017   HOST_WIDE_INT highest_order_field_bit_offset;
10018   HOST_WIDE_INT unsigned bit_offset;
10019
10020   /* Must be a field and a bit field.  */
10021   if (!type
10022       || TREE_CODE (decl) != FIELD_DECL)
10023     abort ();
10024
10025   /* We can't yet handle bit-fields whose offsets are variable, so if we
10026      encounter such things, just return without generating any attribute
10027      whatsoever.  Likewise for variable or too large size.  */
10028   if (! host_integerp (bit_position (decl), 0)
10029       || ! host_integerp (DECL_SIZE (decl), 1))
10030     return;
10031
10032   bitpos_int = int_bit_position (decl);
10033
10034   /* Note that the bit offset is always the distance (in bits) from the
10035      highest-order bit of the "containing object" to the highest-order bit of
10036      the bit-field itself.  Since the "high-order end" of any object or field
10037      is different on big-endian and little-endian machines, the computation
10038      below must take account of these differences.  */
10039   highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
10040   highest_order_field_bit_offset = bitpos_int;
10041
10042   if (! BYTES_BIG_ENDIAN)
10043     {
10044       highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0);
10045       highest_order_object_bit_offset += simple_type_size_in_bits (type);
10046     }
10047
10048   bit_offset
10049     = (! BYTES_BIG_ENDIAN
10050        ? highest_order_object_bit_offset - highest_order_field_bit_offset
10051        : highest_order_field_bit_offset - highest_order_object_bit_offset);
10052
10053   add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
10054 }
10055
10056 /* For a FIELD_DECL node which represents a bit field, output an attribute
10057    which specifies the length in bits of the given field.  */
10058
10059 static inline void
10060 add_bit_size_attribute (die, decl)
10061      dw_die_ref die;
10062      tree decl;
10063 {
10064   /* Must be a field and a bit field.  */
10065   if (TREE_CODE (decl) != FIELD_DECL
10066       || ! DECL_BIT_FIELD_TYPE (decl))
10067     abort ();
10068
10069   if (host_integerp (DECL_SIZE (decl), 1))
10070     add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
10071 }
10072
10073 /* If the compiled language is ANSI C, then add a 'prototyped'
10074    attribute, if arg types are given for the parameters of a function.  */
10075
10076 static inline void
10077 add_prototyped_attribute (die, func_type)
10078      dw_die_ref die;
10079      tree func_type;
10080 {
10081   if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
10082       && TYPE_ARG_TYPES (func_type) != NULL)
10083     add_AT_flag (die, DW_AT_prototyped, 1);
10084 }
10085
10086 /* Add an 'abstract_origin' attribute below a given DIE.  The DIE is found
10087    by looking in either the type declaration or object declaration
10088    equate table.  */
10089
10090 static inline void
10091 add_abstract_origin_attribute (die, origin)
10092      dw_die_ref die;
10093      tree origin;
10094 {
10095   dw_die_ref origin_die = NULL;
10096
10097   if (TREE_CODE (origin) != FUNCTION_DECL)
10098     {
10099       /* We may have gotten separated from the block for the inlined
10100          function, if we're in an exception handler or some such; make
10101          sure that the abstract function has been written out.
10102
10103          Doing this for nested functions is wrong, however; functions are
10104          distinct units, and our context might not even be inline.  */
10105       tree fn = origin;
10106
10107       if (TYPE_P (fn))
10108         fn = TYPE_STUB_DECL (fn);
10109
10110       fn = decl_function_context (fn);
10111       if (fn)
10112         dwarf2out_abstract_function (fn);
10113     }
10114
10115   if (DECL_P (origin))
10116     origin_die = lookup_decl_die (origin);
10117   else if (TYPE_P (origin))
10118     origin_die = lookup_type_die (origin);
10119
10120   if (origin_die == NULL)
10121     abort ();
10122
10123   add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
10124 }
10125
10126 /* We do not currently support the pure_virtual attribute.  */
10127
10128 static inline void
10129 add_pure_or_virtual_attribute (die, func_decl)
10130      dw_die_ref die;
10131      tree func_decl;
10132 {
10133   if (DECL_VINDEX (func_decl))
10134     {
10135       add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
10136
10137       if (host_integerp (DECL_VINDEX (func_decl), 0))
10138         add_AT_loc (die, DW_AT_vtable_elem_location,
10139                     new_loc_descr (DW_OP_constu,
10140                                    tree_low_cst (DECL_VINDEX (func_decl), 0),
10141                                    0));
10142
10143       /* GNU extension: Record what type this method came from originally.  */
10144       if (debug_info_level > DINFO_LEVEL_TERSE)
10145         add_AT_die_ref (die, DW_AT_containing_type,
10146                         lookup_type_die (DECL_CONTEXT (func_decl)));
10147     }
10148 }
10149 \f
10150 /* Add source coordinate attributes for the given decl.  */
10151
10152 static void
10153 add_src_coords_attributes (die, decl)
10154      dw_die_ref die;
10155      tree decl;
10156 {
10157   unsigned file_index = lookup_filename (DECL_SOURCE_FILE (decl));
10158
10159   add_AT_unsigned (die, DW_AT_decl_file, file_index);
10160   add_AT_unsigned (die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
10161 }
10162
10163 /* Add an DW_AT_name attribute and source coordinate attribute for the
10164    given decl, but only if it actually has a name.  */
10165
10166 static void
10167 add_name_and_src_coords_attributes (die, decl)
10168      dw_die_ref die;
10169      tree decl;
10170 {
10171   tree decl_name;
10172
10173   decl_name = DECL_NAME (decl);
10174   if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
10175     {
10176       add_name_attribute (die, dwarf2_name (decl, 0));
10177       if (! DECL_ARTIFICIAL (decl))
10178         add_src_coords_attributes (die, decl);
10179
10180       if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
10181           && TREE_PUBLIC (decl)
10182           && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)
10183           && !DECL_ABSTRACT (decl))
10184         add_AT_string (die, DW_AT_MIPS_linkage_name,
10185                        IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
10186     }
10187
10188 #ifdef VMS_DEBUGGING_INFO
10189   /* Get the function's name, as described by its RTL.  This may be different
10190      from the DECL_NAME name used in the source file.  */
10191   if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
10192     {
10193       add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
10194                    XEXP (DECL_RTL (decl), 0));
10195       VARRAY_PUSH_RTX (used_rtx_varray, XEXP (DECL_RTL (decl), 0));
10196     }
10197 #endif
10198 }
10199
10200 /* Push a new declaration scope.  */
10201
10202 static void
10203 push_decl_scope (scope)
10204      tree scope;
10205 {
10206   VARRAY_PUSH_TREE (decl_scope_table, scope);
10207 }
10208
10209 /* Pop a declaration scope.  */
10210
10211 static inline void
10212 pop_decl_scope ()
10213 {
10214   if (VARRAY_ACTIVE_SIZE (decl_scope_table) <= 0)
10215     abort ();
10216
10217   VARRAY_POP (decl_scope_table);
10218 }
10219
10220 /* Return the DIE for the scope that immediately contains this type.
10221    Non-named types get global scope.  Named types nested in other
10222    types get their containing scope if it's open, or global scope
10223    otherwise.  All other types (i.e. function-local named types) get
10224    the current active scope.  */
10225
10226 static dw_die_ref
10227 scope_die_for (t, context_die)
10228      tree t;
10229      dw_die_ref context_die;
10230 {
10231   dw_die_ref scope_die = NULL;
10232   tree containing_scope;
10233   int i;
10234
10235   /* Non-types always go in the current scope.  */
10236   if (! TYPE_P (t))
10237     abort ();
10238
10239   containing_scope = TYPE_CONTEXT (t);
10240
10241   /* Ignore namespaces for the moment.  */
10242   if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
10243     containing_scope = NULL_TREE;
10244
10245   /* Ignore function type "scopes" from the C frontend.  They mean that
10246      a tagged type is local to a parmlist of a function declarator, but
10247      that isn't useful to DWARF.  */
10248   if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
10249     containing_scope = NULL_TREE;
10250
10251   if (containing_scope == NULL_TREE)
10252     scope_die = comp_unit_die;
10253   else if (TYPE_P (containing_scope))
10254     {
10255       /* For types, we can just look up the appropriate DIE.  But
10256          first we check to see if we're in the middle of emitting it
10257          so we know where the new DIE should go.  */
10258       for (i = VARRAY_ACTIVE_SIZE (decl_scope_table) - 1; i >= 0; --i)
10259         if (VARRAY_TREE (decl_scope_table, i) == containing_scope)
10260           break;
10261
10262       if (i < 0)
10263         {
10264           if (debug_info_level > DINFO_LEVEL_TERSE
10265               && !TREE_ASM_WRITTEN (containing_scope))
10266             abort ();
10267
10268           /* If none of the current dies are suitable, we get file scope.  */
10269           scope_die = comp_unit_die;
10270         }
10271       else
10272         scope_die = lookup_type_die (containing_scope);
10273     }
10274   else
10275     scope_die = context_die;
10276
10277   return scope_die;
10278 }
10279
10280 /* Returns nonzero if CONTEXT_DIE is internal to a function.  */
10281
10282 static inline int
10283 local_scope_p (context_die)
10284      dw_die_ref context_die;
10285 {
10286   for (; context_die; context_die = context_die->die_parent)
10287     if (context_die->die_tag == DW_TAG_inlined_subroutine
10288         || context_die->die_tag == DW_TAG_subprogram)
10289       return 1;
10290
10291   return 0;
10292 }
10293
10294 /* Returns nonzero if CONTEXT_DIE is a class.  */
10295
10296 static inline int
10297 class_scope_p (context_die)
10298      dw_die_ref context_die;
10299 {
10300   return (context_die
10301           && (context_die->die_tag == DW_TAG_structure_type
10302               || context_die->die_tag == DW_TAG_union_type));
10303 }
10304
10305 /* Many forms of DIEs require a "type description" attribute.  This
10306    routine locates the proper "type descriptor" die for the type given
10307    by 'type', and adds an DW_AT_type attribute below the given die.  */
10308
10309 static void
10310 add_type_attribute (object_die, type, decl_const, decl_volatile, context_die)
10311      dw_die_ref object_die;
10312      tree type;
10313      int decl_const;
10314      int decl_volatile;
10315      dw_die_ref context_die;
10316 {
10317   enum tree_code code  = TREE_CODE (type);
10318   dw_die_ref type_die  = NULL;
10319
10320   /* ??? If this type is an unnamed subrange type of an integral or
10321      floating-point type, use the inner type.  This is because we have no
10322      support for unnamed types in base_type_die.  This can happen if this is
10323      an Ada subrange type.  Correct solution is emit a subrange type die.  */
10324   if ((code == INTEGER_TYPE || code == REAL_TYPE)
10325       && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
10326     type = TREE_TYPE (type), code = TREE_CODE (type);
10327
10328   if (code == ERROR_MARK
10329       /* Handle a special case.  For functions whose return type is void, we
10330          generate *no* type attribute.  (Note that no object may have type
10331          `void', so this only applies to function return types).  */
10332       || code == VOID_TYPE)
10333     return;
10334
10335   type_die = modified_type_die (type,
10336                                 decl_const || TYPE_READONLY (type),
10337                                 decl_volatile || TYPE_VOLATILE (type),
10338                                 context_die);
10339
10340   if (type_die != NULL)
10341     add_AT_die_ref (object_die, DW_AT_type, type_die);
10342 }
10343
10344 /* Given a tree pointer to a struct, class, union, or enum type node, return
10345    a pointer to the (string) tag name for the given type, or zero if the type
10346    was declared without a tag.  */
10347
10348 static const char *
10349 type_tag (type)
10350      tree type;
10351 {
10352   const char *name = 0;
10353
10354   if (TYPE_NAME (type) != 0)
10355     {
10356       tree t = 0;
10357
10358       /* Find the IDENTIFIER_NODE for the type name.  */
10359       if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
10360         t = TYPE_NAME (type);
10361
10362       /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
10363          a TYPE_DECL node, regardless of whether or not a `typedef' was
10364          involved.  */
10365       else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10366                && ! DECL_IGNORED_P (TYPE_NAME (type)))
10367         t = DECL_NAME (TYPE_NAME (type));
10368
10369       /* Now get the name as a string, or invent one.  */
10370       if (t != 0)
10371         name = IDENTIFIER_POINTER (t);
10372     }
10373
10374   return (name == 0 || *name == '\0') ? 0 : name;
10375 }
10376
10377 /* Return the type associated with a data member, make a special check
10378    for bit field types.  */
10379
10380 static inline tree
10381 member_declared_type (member)
10382      tree member;
10383 {
10384   return (DECL_BIT_FIELD_TYPE (member)
10385           ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
10386 }
10387
10388 /* Get the decl's label, as described by its RTL. This may be different
10389    from the DECL_NAME name used in the source file.  */
10390
10391 #if 0
10392 static const char *
10393 decl_start_label (decl)
10394      tree decl;
10395 {
10396   rtx x;
10397   const char *fnname;
10398
10399   x = DECL_RTL (decl);
10400   if (GET_CODE (x) != MEM)
10401     abort ();
10402
10403   x = XEXP (x, 0);
10404   if (GET_CODE (x) != SYMBOL_REF)
10405     abort ();
10406
10407   fnname = XSTR (x, 0);
10408   return fnname;
10409 }
10410 #endif
10411 \f
10412 /* These routines generate the internal representation of the DIE's for
10413    the compilation unit.  Debugging information is collected by walking
10414    the declaration trees passed in from dwarf2out_decl().  */
10415
10416 static void
10417 gen_array_type_die (type, context_die)
10418      tree type;
10419      dw_die_ref context_die;
10420 {
10421   dw_die_ref scope_die = scope_die_for (type, context_die);
10422   dw_die_ref array_die;
10423   tree element_type;
10424
10425   /* ??? The SGI dwarf reader fails for array of array of enum types unless
10426      the inner array type comes before the outer array type.  Thus we must
10427      call gen_type_die before we call new_die.  See below also.  */
10428 #ifdef MIPS_DEBUGGING_INFO
10429   gen_type_die (TREE_TYPE (type), context_die);
10430 #endif
10431
10432   array_die = new_die (DW_TAG_array_type, scope_die, type);
10433   add_name_attribute (array_die, type_tag (type));
10434   equate_type_number_to_die (type, array_die);
10435
10436   if (TREE_CODE (type) == VECTOR_TYPE)
10437     {
10438       /* The frontend feeds us a representation for the vector as a struct
10439          containing an array.  Pull out the array type.  */
10440       type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
10441       add_AT_flag (array_die, DW_AT_GNU_vector, 1);
10442     }
10443
10444 #if 0
10445   /* We default the array ordering.  SDB will probably do
10446      the right things even if DW_AT_ordering is not present.  It's not even
10447      an issue until we start to get into multidimensional arrays anyway.  If
10448      SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
10449      then we'll have to put the DW_AT_ordering attribute back in.  (But if
10450      and when we find out that we need to put these in, we will only do so
10451      for multidimensional arrays.  */
10452   add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
10453 #endif
10454
10455 #ifdef MIPS_DEBUGGING_INFO
10456   /* The SGI compilers handle arrays of unknown bound by setting
10457      AT_declaration and not emitting any subrange DIEs.  */
10458   if (! TYPE_DOMAIN (type))
10459     add_AT_unsigned (array_die, DW_AT_declaration, 1);
10460   else
10461 #endif
10462     add_subscript_info (array_die, type);
10463
10464   /* Add representation of the type of the elements of this array type.  */
10465   element_type = TREE_TYPE (type);
10466
10467   /* ??? The SGI dwarf reader fails for multidimensional arrays with a
10468      const enum type.  E.g. const enum machine_mode insn_operand_mode[2][10].
10469      We work around this by disabling this feature.  See also
10470      add_subscript_info.  */
10471 #ifndef MIPS_DEBUGGING_INFO
10472   while (TREE_CODE (element_type) == ARRAY_TYPE)
10473     element_type = TREE_TYPE (element_type);
10474
10475   gen_type_die (element_type, context_die);
10476 #endif
10477
10478   add_type_attribute (array_die, element_type, 0, 0, context_die);
10479 }
10480
10481 static void
10482 gen_set_type_die (type, context_die)
10483      tree type;
10484      dw_die_ref context_die;
10485 {
10486   dw_die_ref type_die
10487     = new_die (DW_TAG_set_type, scope_die_for (type, context_die), type);
10488
10489   equate_type_number_to_die (type, type_die);
10490   add_type_attribute (type_die, TREE_TYPE (type), 0, 0, context_die);
10491 }
10492
10493 #if 0
10494 static void
10495 gen_entry_point_die (decl, context_die)
10496      tree decl;
10497      dw_die_ref context_die;
10498 {
10499   tree origin = decl_ultimate_origin (decl);
10500   dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
10501
10502   if (origin != NULL)
10503     add_abstract_origin_attribute (decl_die, origin);
10504   else
10505     {
10506       add_name_and_src_coords_attributes (decl_die, decl);
10507       add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
10508                           0, 0, context_die);
10509     }
10510
10511   if (DECL_ABSTRACT (decl))
10512     equate_decl_number_to_die (decl, decl_die);
10513   else
10514     add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
10515 }
10516 #endif
10517
10518 /* Walk through the list of incomplete types again, trying once more to
10519    emit full debugging info for them.  */
10520
10521 static void
10522 retry_incomplete_types ()
10523 {
10524   int i;
10525
10526   for (i = VARRAY_ACTIVE_SIZE (incomplete_types) - 1; i >= 0; i--)
10527     gen_type_die (VARRAY_TREE (incomplete_types, i), comp_unit_die);
10528 }
10529
10530 /* Generate a DIE to represent an inlined instance of an enumeration type.  */
10531
10532 static void
10533 gen_inlined_enumeration_type_die (type, context_die)
10534      tree type;
10535      dw_die_ref context_die;
10536 {
10537   dw_die_ref type_die = new_die (DW_TAG_enumeration_type, context_die, type);
10538
10539   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
10540      be incomplete and such types are not marked.  */
10541   add_abstract_origin_attribute (type_die, type);
10542 }
10543
10544 /* Generate a DIE to represent an inlined instance of a structure type.  */
10545
10546 static void
10547 gen_inlined_structure_type_die (type, context_die)
10548      tree type;
10549      dw_die_ref context_die;
10550 {
10551   dw_die_ref type_die = new_die (DW_TAG_structure_type, context_die, type);
10552
10553   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
10554      be incomplete and such types are not marked.  */
10555   add_abstract_origin_attribute (type_die, type);
10556 }
10557
10558 /* Generate a DIE to represent an inlined instance of a union type.  */
10559
10560 static void
10561 gen_inlined_union_type_die (type, context_die)
10562      tree type;
10563      dw_die_ref context_die;
10564 {
10565   dw_die_ref type_die = new_die (DW_TAG_union_type, context_die, type);
10566
10567   /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
10568      be incomplete and such types are not marked.  */
10569   add_abstract_origin_attribute (type_die, type);
10570 }
10571
10572 /* Generate a DIE to represent an enumeration type.  Note that these DIEs
10573    include all of the information about the enumeration values also. Each
10574    enumerated type name/value is listed as a child of the enumerated type
10575    DIE.  */
10576
10577 static void
10578 gen_enumeration_type_die (type, context_die)
10579      tree type;
10580      dw_die_ref context_die;
10581 {
10582   dw_die_ref type_die = lookup_type_die (type);
10583
10584   if (type_die == NULL)
10585     {
10586       type_die = new_die (DW_TAG_enumeration_type,
10587                           scope_die_for (type, context_die), type);
10588       equate_type_number_to_die (type, type_die);
10589       add_name_attribute (type_die, type_tag (type));
10590     }
10591   else if (! TYPE_SIZE (type))
10592     return;
10593   else
10594     remove_AT (type_die, DW_AT_declaration);
10595
10596   /* Handle a GNU C/C++ extension, i.e. incomplete enum types.  If the
10597      given enum type is incomplete, do not generate the DW_AT_byte_size
10598      attribute or the DW_AT_element_list attribute.  */
10599   if (TYPE_SIZE (type))
10600     {
10601       tree link;
10602
10603       TREE_ASM_WRITTEN (type) = 1;
10604       add_byte_size_attribute (type_die, type);
10605       if (TYPE_STUB_DECL (type) != NULL_TREE)
10606         add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
10607
10608       /* If the first reference to this type was as the return type of an
10609          inline function, then it may not have a parent.  Fix this now.  */
10610       if (type_die->die_parent == NULL)
10611         add_child_die (scope_die_for (type, context_die), type_die);
10612
10613       for (link = TYPE_FIELDS (type);
10614            link != NULL; link = TREE_CHAIN (link))
10615         {
10616           dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
10617
10618           add_name_attribute (enum_die,
10619                               IDENTIFIER_POINTER (TREE_PURPOSE (link)));
10620
10621           if (host_integerp (TREE_VALUE (link), 0))
10622             {
10623               if (tree_int_cst_sgn (TREE_VALUE (link)) < 0)
10624                 add_AT_int (enum_die, DW_AT_const_value,
10625                             tree_low_cst (TREE_VALUE (link), 0));
10626               else
10627                 add_AT_unsigned (enum_die, DW_AT_const_value,
10628                                  tree_low_cst (TREE_VALUE (link), 0));
10629             }
10630         }
10631     }
10632   else
10633     add_AT_flag (type_die, DW_AT_declaration, 1);
10634 }
10635
10636 /* Generate a DIE to represent either a real live formal parameter decl or to
10637    represent just the type of some formal parameter position in some function
10638    type.
10639
10640    Note that this routine is a bit unusual because its argument may be a
10641    ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
10642    represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
10643    node.  If it's the former then this function is being called to output a
10644    DIE to represent a formal parameter object (or some inlining thereof).  If
10645    it's the latter, then this function is only being called to output a
10646    DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
10647    argument type of some subprogram type.  */
10648
10649 static dw_die_ref
10650 gen_formal_parameter_die (node, context_die)
10651      tree node;
10652      dw_die_ref context_die;
10653 {
10654   dw_die_ref parm_die
10655     = new_die (DW_TAG_formal_parameter, context_die, node);
10656   tree origin;
10657
10658   switch (TREE_CODE_CLASS (TREE_CODE (node)))
10659     {
10660     case 'd':
10661       origin = decl_ultimate_origin (node);
10662       if (origin != NULL)
10663         add_abstract_origin_attribute (parm_die, origin);
10664       else
10665         {
10666           add_name_and_src_coords_attributes (parm_die, node);
10667           add_type_attribute (parm_die, TREE_TYPE (node),
10668                               TREE_READONLY (node),
10669                               TREE_THIS_VOLATILE (node),
10670                               context_die);
10671           if (DECL_ARTIFICIAL (node))
10672             add_AT_flag (parm_die, DW_AT_artificial, 1);
10673         }
10674
10675       equate_decl_number_to_die (node, parm_die);
10676       if (! DECL_ABSTRACT (node))
10677         add_location_or_const_value_attribute (parm_die, node);
10678
10679       break;
10680
10681     case 't':
10682       /* We were called with some kind of a ..._TYPE node.  */
10683       add_type_attribute (parm_die, node, 0, 0, context_die);
10684       break;
10685
10686     default:
10687       abort ();
10688     }
10689
10690   return parm_die;
10691 }
10692
10693 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
10694    at the end of an (ANSI prototyped) formal parameters list.  */
10695
10696 static void
10697 gen_unspecified_parameters_die (decl_or_type, context_die)
10698      tree decl_or_type;
10699      dw_die_ref context_die;
10700 {
10701   new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
10702 }
10703
10704 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
10705    DW_TAG_unspecified_parameters DIE) to represent the types of the formal
10706    parameters as specified in some function type specification (except for
10707    those which appear as part of a function *definition*).  */
10708
10709 static void
10710 gen_formal_types_die (function_or_method_type, context_die)
10711      tree function_or_method_type;
10712      dw_die_ref context_die;
10713 {
10714   tree link;
10715   tree formal_type = NULL;
10716   tree first_parm_type;
10717   tree arg;
10718
10719   if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
10720     {
10721       arg = DECL_ARGUMENTS (function_or_method_type);
10722       function_or_method_type = TREE_TYPE (function_or_method_type);
10723     }
10724   else
10725     arg = NULL_TREE;
10726
10727   first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
10728
10729   /* Make our first pass over the list of formal parameter types and output a
10730      DW_TAG_formal_parameter DIE for each one.  */
10731   for (link = first_parm_type; link; )
10732     {
10733       dw_die_ref parm_die;
10734
10735       formal_type = TREE_VALUE (link);
10736       if (formal_type == void_type_node)
10737         break;
10738
10739       /* Output a (nameless) DIE to represent the formal parameter itself.  */
10740       parm_die = gen_formal_parameter_die (formal_type, context_die);
10741       if ((TREE_CODE (function_or_method_type) == METHOD_TYPE
10742            && link == first_parm_type)
10743           || (arg && DECL_ARTIFICIAL (arg)))
10744         add_AT_flag (parm_die, DW_AT_artificial, 1);
10745
10746       link = TREE_CHAIN (link);
10747       if (arg)
10748         arg = TREE_CHAIN (arg);
10749     }
10750
10751   /* If this function type has an ellipsis, add a
10752      DW_TAG_unspecified_parameters DIE to the end of the parameter list.  */
10753   if (formal_type != void_type_node)
10754     gen_unspecified_parameters_die (function_or_method_type, context_die);
10755
10756   /* Make our second (and final) pass over the list of formal parameter types
10757      and output DIEs to represent those types (as necessary).  */
10758   for (link = TYPE_ARG_TYPES (function_or_method_type);
10759        link && TREE_VALUE (link);
10760        link = TREE_CHAIN (link))
10761     gen_type_die (TREE_VALUE (link), context_die);
10762 }
10763
10764 /* We want to generate the DIE for TYPE so that we can generate the
10765    die for MEMBER, which has been defined; we will need to refer back
10766    to the member declaration nested within TYPE.  If we're trying to
10767    generate minimal debug info for TYPE, processing TYPE won't do the
10768    trick; we need to attach the member declaration by hand.  */
10769
10770 static void
10771 gen_type_die_for_member (type, member, context_die)
10772      tree type, member;
10773      dw_die_ref context_die;
10774 {
10775   gen_type_die (type, context_die);
10776
10777   /* If we're trying to avoid duplicate debug info, we may not have
10778      emitted the member decl for this function.  Emit it now.  */
10779   if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
10780       && ! lookup_decl_die (member))
10781     {
10782       if (decl_ultimate_origin (member))
10783         abort ();
10784
10785       push_decl_scope (type);
10786       if (TREE_CODE (member) == FUNCTION_DECL)
10787         gen_subprogram_die (member, lookup_type_die (type));
10788       else
10789         gen_variable_die (member, lookup_type_die (type));
10790
10791       pop_decl_scope ();
10792     }
10793 }
10794
10795 /* Generate the DWARF2 info for the "abstract" instance of a function which we
10796    may later generate inlined and/or out-of-line instances of.  */
10797
10798 static void
10799 dwarf2out_abstract_function (decl)
10800      tree decl;
10801 {
10802   dw_die_ref old_die;
10803   tree save_fn;
10804   tree context;
10805   int was_abstract = DECL_ABSTRACT (decl);
10806
10807   /* Make sure we have the actual abstract inline, not a clone.  */
10808   decl = DECL_ORIGIN (decl);
10809
10810   old_die = lookup_decl_die (decl);
10811   if (old_die && get_AT_unsigned (old_die, DW_AT_inline))
10812     /* We've already generated the abstract instance.  */
10813     return;
10814
10815   /* Be sure we've emitted the in-class declaration DIE (if any) first, so
10816      we don't get confused by DECL_ABSTRACT.  */
10817   if (debug_info_level > DINFO_LEVEL_TERSE)
10818     {
10819       context = decl_class_context (decl);
10820       if (context)
10821         gen_type_die_for_member
10822           (context, decl, decl_function_context (decl) ? NULL : comp_unit_die);
10823     }
10824
10825   /* Pretend we've just finished compiling this function.  */
10826   save_fn = current_function_decl;
10827   current_function_decl = decl;
10828
10829   set_decl_abstract_flags (decl, 1);
10830   dwarf2out_decl (decl);
10831   if (! was_abstract)
10832     set_decl_abstract_flags (decl, 0);
10833
10834   current_function_decl = save_fn;
10835 }
10836
10837 /* Generate a DIE to represent a declared function (either file-scope or
10838    block-local).  */
10839
10840 static void
10841 gen_subprogram_die (decl, context_die)
10842      tree decl;
10843      dw_die_ref context_die;
10844 {
10845   char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
10846   tree origin = decl_ultimate_origin (decl);
10847   dw_die_ref subr_die;
10848   rtx fp_reg;
10849   tree fn_arg_types;
10850   tree outer_scope;
10851   dw_die_ref old_die = lookup_decl_die (decl);
10852   int declaration = (current_function_decl != decl
10853                      || class_scope_p (context_die));
10854
10855   /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
10856      started to generate the abstract instance of an inline, decided to output
10857      its containing class, and proceeded to emit the declaration of the inline
10858      from the member list for the class.  If so, DECLARATION takes priority;
10859      we'll get back to the abstract instance when done with the class.  */
10860
10861   /* The class-scope declaration DIE must be the primary DIE.  */
10862   if (origin && declaration && class_scope_p (context_die))
10863     {
10864       origin = NULL;
10865       if (old_die)
10866         abort ();
10867     }
10868
10869   if (origin != NULL)
10870     {
10871       if (declaration && ! local_scope_p (context_die))
10872         abort ();
10873
10874       /* Fixup die_parent for the abstract instance of a nested
10875          inline function.  */
10876       if (old_die && old_die->die_parent == NULL)
10877         add_child_die (context_die, old_die);
10878
10879       subr_die = new_die (DW_TAG_subprogram, context_die, decl);
10880       add_abstract_origin_attribute (subr_die, origin);
10881     }
10882   else if (old_die)
10883     {
10884       unsigned file_index = lookup_filename (DECL_SOURCE_FILE (decl));
10885
10886       if (!get_AT_flag (old_die, DW_AT_declaration)
10887           /* We can have a normal definition following an inline one in the
10888              case of redefinition of GNU C extern inlines.
10889              It seems reasonable to use AT_specification in this case.  */
10890           && !get_AT_unsigned (old_die, DW_AT_inline))
10891         {
10892           /* ??? This can happen if there is a bug in the program, for
10893              instance, if it has duplicate function definitions.  Ideally,
10894              we should detect this case and ignore it.  For now, if we have
10895              already reported an error, any error at all, then assume that
10896              we got here because of an input error, not a dwarf2 bug.  */
10897           if (errorcount)
10898             return;
10899           abort ();
10900         }
10901
10902       /* If the definition comes from the same place as the declaration,
10903          maybe use the old DIE.  We always want the DIE for this function
10904          that has the *_pc attributes to be under comp_unit_die so the
10905          debugger can find it.  We also need to do this for abstract
10906          instances of inlines, since the spec requires the out-of-line copy
10907          to have the same parent.  For local class methods, this doesn't
10908          apply; we just use the old DIE.  */
10909       if ((old_die->die_parent == comp_unit_die || context_die == NULL)
10910           && (DECL_ARTIFICIAL (decl)
10911               || (get_AT_unsigned (old_die, DW_AT_decl_file) == file_index
10912                   && (get_AT_unsigned (old_die, DW_AT_decl_line)
10913                       == (unsigned) DECL_SOURCE_LINE (decl)))))
10914         {
10915           subr_die = old_die;
10916
10917           /* Clear out the declaration attribute and the parm types.  */
10918           remove_AT (subr_die, DW_AT_declaration);
10919           remove_children (subr_die);
10920         }
10921       else
10922         {
10923           subr_die = new_die (DW_TAG_subprogram, context_die, decl);
10924           add_AT_die_ref (subr_die, DW_AT_specification, old_die);
10925           if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
10926             add_AT_unsigned (subr_die, DW_AT_decl_file, file_index);
10927           if (get_AT_unsigned (old_die, DW_AT_decl_line)
10928               != (unsigned) DECL_SOURCE_LINE (decl))
10929             add_AT_unsigned
10930               (subr_die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
10931         }
10932     }
10933   else
10934     {
10935       subr_die = new_die (DW_TAG_subprogram, context_die, decl);
10936
10937       if (TREE_PUBLIC (decl))
10938         add_AT_flag (subr_die, DW_AT_external, 1);
10939
10940       add_name_and_src_coords_attributes (subr_die, decl);
10941       if (debug_info_level > DINFO_LEVEL_TERSE)
10942         {
10943           add_prototyped_attribute (subr_die, TREE_TYPE (decl));
10944           add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
10945                               0, 0, context_die);
10946         }
10947
10948       add_pure_or_virtual_attribute (subr_die, decl);
10949       if (DECL_ARTIFICIAL (decl))
10950         add_AT_flag (subr_die, DW_AT_artificial, 1);
10951
10952       if (TREE_PROTECTED (decl))
10953         add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
10954       else if (TREE_PRIVATE (decl))
10955         add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
10956     }
10957
10958   if (declaration)
10959     {
10960       if (!old_die || !get_AT_unsigned (old_die, DW_AT_inline))
10961         {
10962           add_AT_flag (subr_die, DW_AT_declaration, 1);
10963
10964           /* The first time we see a member function, it is in the context of
10965              the class to which it belongs.  We make sure of this by emitting
10966              the class first.  The next time is the definition, which is
10967              handled above.  The two may come from the same source text.  */
10968           if (DECL_CONTEXT (decl) || DECL_ABSTRACT (decl))
10969             equate_decl_number_to_die (decl, subr_die);
10970         }
10971     }
10972   else if (DECL_ABSTRACT (decl))
10973     {
10974       if (DECL_INLINE (decl) && !flag_no_inline)
10975         {
10976           /* ??? Checking DECL_DEFER_OUTPUT is correct for static
10977              inline functions, but not for extern inline functions.
10978              We can't get this completely correct because information
10979              about whether the function was declared inline is not
10980              saved anywhere.  */
10981           if (DECL_DEFER_OUTPUT (decl))
10982             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
10983           else
10984             add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
10985         }
10986       else
10987         add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
10988
10989       equate_decl_number_to_die (decl, subr_die);
10990     }
10991   else if (!DECL_EXTERNAL (decl))
10992     {
10993       if (!old_die || !get_AT_unsigned (old_die, DW_AT_inline))
10994         equate_decl_number_to_die (decl, subr_die);
10995
10996       ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
10997                                    current_function_funcdef_no);
10998       add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
10999       ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
11000                                    current_function_funcdef_no);
11001       add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
11002
11003       add_pubname (decl, subr_die);
11004       add_arange (decl, subr_die);
11005
11006 #ifdef MIPS_DEBUGGING_INFO
11007       /* Add a reference to the FDE for this routine.  */
11008       add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
11009 #endif
11010
11011       /* Define the "frame base" location for this routine.  We use the
11012          frame pointer or stack pointer registers, since the RTL for local
11013          variables is relative to one of them.  */
11014       fp_reg
11015         = frame_pointer_needed ? hard_frame_pointer_rtx : stack_pointer_rtx;
11016       add_AT_loc (subr_die, DW_AT_frame_base, reg_loc_descriptor (fp_reg));
11017
11018 #if 0
11019       /* ??? This fails for nested inline functions, because context_display
11020          is not part of the state saved/restored for inline functions.  */
11021       if (current_function_needs_context)
11022         add_AT_location_description (subr_die, DW_AT_static_link,
11023                              loc_descriptor (lookup_static_chain (decl)));
11024 #endif
11025     }
11026
11027   /* Now output descriptions of the arguments for this function. This gets
11028      (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
11029      for a FUNCTION_DECL doesn't indicate cases where there was a trailing
11030      `...' at the end of the formal parameter list.  In order to find out if
11031      there was a trailing ellipsis or not, we must instead look at the type
11032      associated with the FUNCTION_DECL.  This will be a node of type
11033      FUNCTION_TYPE. If the chain of type nodes hanging off of this
11034      FUNCTION_TYPE node ends with a void_type_node then there should *not* be
11035      an ellipsis at the end.  */
11036
11037   /* In the case where we are describing a mere function declaration, all we
11038      need to do here (and all we *can* do here) is to describe the *types* of
11039      its formal parameters.  */
11040   if (debug_info_level <= DINFO_LEVEL_TERSE)
11041     ;
11042   else if (declaration)
11043     gen_formal_types_die (decl, subr_die);
11044   else
11045     {
11046       /* Generate DIEs to represent all known formal parameters */
11047       tree arg_decls = DECL_ARGUMENTS (decl);
11048       tree parm;
11049
11050       /* When generating DIEs, generate the unspecified_parameters DIE
11051          instead if we come across the arg "__builtin_va_alist" */
11052       for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
11053         if (TREE_CODE (parm) == PARM_DECL)
11054           {
11055             if (DECL_NAME (parm)
11056                 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
11057                             "__builtin_va_alist"))
11058               gen_unspecified_parameters_die (parm, subr_die);
11059             else
11060               gen_decl_die (parm, subr_die);
11061           }
11062
11063       /* Decide whether we need an unspecified_parameters DIE at the end.
11064          There are 2 more cases to do this for: 1) the ansi ... declaration -
11065          this is detectable when the end of the arg list is not a
11066          void_type_node 2) an unprototyped function declaration (not a
11067          definition).  This just means that we have no info about the
11068          parameters at all.  */
11069       fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
11070       if (fn_arg_types != NULL)
11071         {
11072           /* this is the prototyped case, check for ...  */
11073           if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
11074             gen_unspecified_parameters_die (decl, subr_die);
11075         }
11076       else if (DECL_INITIAL (decl) == NULL_TREE)
11077         gen_unspecified_parameters_die (decl, subr_die);
11078     }
11079
11080   /* Output Dwarf info for all of the stuff within the body of the function
11081      (if it has one - it may be just a declaration).  */
11082   outer_scope = DECL_INITIAL (decl);
11083
11084   /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
11085      a function.  This BLOCK actually represents the outermost binding contour
11086      for the function, i.e. the contour in which the function's formal
11087      parameters and labels get declared. Curiously, it appears that the front
11088      end doesn't actually put the PARM_DECL nodes for the current function onto
11089      the BLOCK_VARS list for this outer scope, but are strung off of the
11090      DECL_ARGUMENTS list for the function instead.
11091
11092      The BLOCK_VARS list for the `outer_scope' does provide us with a list of
11093      the LABEL_DECL nodes for the function however, and we output DWARF info
11094      for those in decls_for_scope.  Just within the `outer_scope' there will be
11095      a BLOCK node representing the function's outermost pair of curly braces,
11096      and any blocks used for the base and member initializers of a C++
11097      constructor function.  */
11098   if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
11099     {
11100       current_function_has_inlines = 0;
11101       decls_for_scope (outer_scope, subr_die, 0);
11102
11103 #if 0 && defined (MIPS_DEBUGGING_INFO)
11104       if (current_function_has_inlines)
11105         {
11106           add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
11107           if (! comp_unit_has_inlines)
11108             {
11109               add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
11110               comp_unit_has_inlines = 1;
11111             }
11112         }
11113 #endif
11114     }
11115 }
11116
11117 /* Generate a DIE to represent a declared data object.  */
11118
11119 static void
11120 gen_variable_die (decl, context_die)
11121      tree decl;
11122      dw_die_ref context_die;
11123 {
11124   tree origin = decl_ultimate_origin (decl);
11125   dw_die_ref var_die = new_die (DW_TAG_variable, context_die, decl);
11126
11127   dw_die_ref old_die = lookup_decl_die (decl);
11128   int declaration = (DECL_EXTERNAL (decl)
11129                      || class_scope_p (context_die));
11130
11131   if (origin != NULL)
11132     add_abstract_origin_attribute (var_die, origin);
11133
11134   /* Loop unrolling can create multiple blocks that refer to the same
11135      static variable, so we must test for the DW_AT_declaration flag.
11136
11137      ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
11138      copy decls and set the DECL_ABSTRACT flag on them instead of
11139      sharing them.
11140
11141      ??? Duplicated blocks have been rewritten to use .debug_ranges.  */
11142   else if (old_die && TREE_STATIC (decl)
11143            && get_AT_flag (old_die, DW_AT_declaration) == 1)
11144     {
11145       /* This is a definition of a C++ class level static.  */
11146       add_AT_die_ref (var_die, DW_AT_specification, old_die);
11147       if (DECL_NAME (decl))
11148         {
11149           unsigned file_index = lookup_filename (DECL_SOURCE_FILE (decl));
11150
11151           if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
11152             add_AT_unsigned (var_die, DW_AT_decl_file, file_index);
11153
11154           if (get_AT_unsigned (old_die, DW_AT_decl_line)
11155               != (unsigned) DECL_SOURCE_LINE (decl))
11156
11157             add_AT_unsigned (var_die, DW_AT_decl_line,
11158                              DECL_SOURCE_LINE (decl));
11159         }
11160     }
11161   else
11162     {
11163       add_name_and_src_coords_attributes (var_die, decl);
11164       add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl),
11165                           TREE_THIS_VOLATILE (decl), context_die);
11166
11167       if (TREE_PUBLIC (decl))
11168         add_AT_flag (var_die, DW_AT_external, 1);
11169
11170       if (DECL_ARTIFICIAL (decl))
11171         add_AT_flag (var_die, DW_AT_artificial, 1);
11172
11173       if (TREE_PROTECTED (decl))
11174         add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
11175       else if (TREE_PRIVATE (decl))
11176         add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
11177     }
11178
11179   if (declaration)
11180     add_AT_flag (var_die, DW_AT_declaration, 1);
11181
11182   if (class_scope_p (context_die) || DECL_ABSTRACT (decl))
11183     equate_decl_number_to_die (decl, var_die);
11184
11185   if (! declaration && ! DECL_ABSTRACT (decl))
11186     {
11187       add_location_or_const_value_attribute (var_die, decl);
11188       add_pubname (decl, var_die);
11189     }
11190   else
11191     tree_add_const_value_attribute (var_die, decl);
11192 }
11193
11194 /* Generate a DIE to represent a label identifier.  */
11195
11196 static void
11197 gen_label_die (decl, context_die)
11198      tree decl;
11199      dw_die_ref context_die;
11200 {
11201   tree origin = decl_ultimate_origin (decl);
11202   dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
11203   rtx insn;
11204   char label[MAX_ARTIFICIAL_LABEL_BYTES];
11205
11206   if (origin != NULL)
11207     add_abstract_origin_attribute (lbl_die, origin);
11208   else
11209     add_name_and_src_coords_attributes (lbl_die, decl);
11210
11211   if (DECL_ABSTRACT (decl))
11212     equate_decl_number_to_die (decl, lbl_die);
11213   else
11214     {
11215       insn = DECL_RTL (decl);
11216
11217       /* Deleted labels are programmer specified labels which have been
11218          eliminated because of various optimisations.  We still emit them
11219          here so that it is possible to put breakpoints on them.  */
11220       if (GET_CODE (insn) == CODE_LABEL
11221           || ((GET_CODE (insn) == NOTE
11222                && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL)))
11223         {
11224           /* When optimization is enabled (via -O) some parts of the compiler
11225              (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
11226              represent source-level labels which were explicitly declared by
11227              the user.  This really shouldn't be happening though, so catch
11228              it if it ever does happen.  */
11229           if (INSN_DELETED_P (insn))
11230             abort ();
11231
11232           ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
11233           add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
11234         }
11235     }
11236 }
11237
11238 /* Generate a DIE for a lexical block.  */
11239
11240 static void
11241 gen_lexical_block_die (stmt, context_die, depth)
11242      tree stmt;
11243      dw_die_ref context_die;
11244      int depth;
11245 {
11246   dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
11247   char label[MAX_ARTIFICIAL_LABEL_BYTES];
11248
11249   if (! BLOCK_ABSTRACT (stmt))
11250     {
11251       if (BLOCK_FRAGMENT_CHAIN (stmt))
11252         {
11253           tree chain;
11254
11255           add_AT_range_list (stmt_die, DW_AT_ranges, add_ranges (stmt));
11256
11257           chain = BLOCK_FRAGMENT_CHAIN (stmt);
11258           do
11259             {
11260               add_ranges (chain);
11261               chain = BLOCK_FRAGMENT_CHAIN (chain);
11262             }
11263           while (chain);
11264           add_ranges (NULL);
11265         }
11266       else
11267         {
11268           ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
11269                                        BLOCK_NUMBER (stmt));
11270           add_AT_lbl_id (stmt_die, DW_AT_low_pc, label);
11271           ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
11272                                        BLOCK_NUMBER (stmt));
11273           add_AT_lbl_id (stmt_die, DW_AT_high_pc, label);
11274         }
11275     }
11276
11277   decls_for_scope (stmt, stmt_die, depth);
11278 }
11279
11280 /* Generate a DIE for an inlined subprogram.  */
11281
11282 static void
11283 gen_inlined_subroutine_die (stmt, context_die, depth)
11284      tree stmt;
11285      dw_die_ref context_die;
11286      int depth;
11287 {
11288   if (! BLOCK_ABSTRACT (stmt))
11289     {
11290       dw_die_ref subr_die
11291         = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
11292       tree decl = block_ultimate_origin (stmt);
11293       char label[MAX_ARTIFICIAL_LABEL_BYTES];
11294
11295       /* Emit info for the abstract instance first, if we haven't yet.  */
11296       dwarf2out_abstract_function (decl);
11297
11298       add_abstract_origin_attribute (subr_die, decl);
11299       ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
11300                                    BLOCK_NUMBER (stmt));
11301       add_AT_lbl_id (subr_die, DW_AT_low_pc, label);
11302       ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
11303                                    BLOCK_NUMBER (stmt));
11304       add_AT_lbl_id (subr_die, DW_AT_high_pc, label);
11305       decls_for_scope (stmt, subr_die, depth);
11306       current_function_has_inlines = 1;
11307     }
11308   else
11309     /* We may get here if we're the outer block of function A that was
11310        inlined into function B that was inlined into function C.  When
11311        generating debugging info for C, dwarf2out_abstract_function(B)
11312        would mark all inlined blocks as abstract, including this one.
11313        So, we wouldn't (and shouldn't) expect labels to be generated
11314        for this one.  Instead, just emit debugging info for
11315        declarations within the block.  This is particularly important
11316        in the case of initializers of arguments passed from B to us:
11317        if they're statement expressions containing declarations, we
11318        wouldn't generate dies for their abstract variables, and then,
11319        when generating dies for the real variables, we'd die (pun
11320        intended :-)  */
11321     gen_lexical_block_die (stmt, context_die, depth);
11322 }
11323
11324 /* Generate a DIE for a field in a record, or structure.  */
11325
11326 static void
11327 gen_field_die (decl, context_die)
11328      tree decl;
11329      dw_die_ref context_die;
11330 {
11331   dw_die_ref decl_die = new_die (DW_TAG_member, context_die, decl);
11332
11333   add_name_and_src_coords_attributes (decl_die, decl);
11334   add_type_attribute (decl_die, member_declared_type (decl),
11335                       TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
11336                       context_die);
11337
11338   if (DECL_BIT_FIELD_TYPE (decl))
11339     {
11340       add_byte_size_attribute (decl_die, decl);
11341       add_bit_size_attribute (decl_die, decl);
11342       add_bit_offset_attribute (decl_die, decl);
11343     }
11344
11345   if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
11346     add_data_member_location_attribute (decl_die, decl);
11347
11348   if (DECL_ARTIFICIAL (decl))
11349     add_AT_flag (decl_die, DW_AT_artificial, 1);
11350
11351   if (TREE_PROTECTED (decl))
11352     add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
11353   else if (TREE_PRIVATE (decl))
11354     add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
11355 }
11356
11357 #if 0
11358 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
11359    Use modified_type_die instead.
11360    We keep this code here just in case these types of DIEs may be needed to
11361    represent certain things in other languages (e.g. Pascal) someday.  */
11362
11363 static void
11364 gen_pointer_type_die (type, context_die)
11365      tree type;
11366      dw_die_ref context_die;
11367 {
11368   dw_die_ref ptr_die
11369     = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
11370
11371   equate_type_number_to_die (type, ptr_die);
11372   add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
11373   add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
11374 }
11375
11376 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
11377    Use modified_type_die instead.
11378    We keep this code here just in case these types of DIEs may be needed to
11379    represent certain things in other languages (e.g. Pascal) someday.  */
11380
11381 static void
11382 gen_reference_type_die (type, context_die)
11383      tree type;
11384      dw_die_ref context_die;
11385 {
11386   dw_die_ref ref_die
11387     = new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type);
11388
11389   equate_type_number_to_die (type, ref_die);
11390   add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
11391   add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
11392 }
11393 #endif
11394
11395 /* Generate a DIE for a pointer to a member type.  */
11396
11397 static void
11398 gen_ptr_to_mbr_type_die (type, context_die)
11399      tree type;
11400      dw_die_ref context_die;
11401 {
11402   dw_die_ref ptr_die
11403     = new_die (DW_TAG_ptr_to_member_type,
11404                scope_die_for (type, context_die), type);
11405
11406   equate_type_number_to_die (type, ptr_die);
11407   add_AT_die_ref (ptr_die, DW_AT_containing_type,
11408                   lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
11409   add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
11410 }
11411
11412 /* Generate the DIE for the compilation unit.  */
11413
11414 static dw_die_ref
11415 gen_compile_unit_die (filename)
11416      const char *filename;
11417 {
11418   dw_die_ref die;
11419   char producer[250];
11420   const char *language_string = lang_hooks.name;
11421   int language;
11422
11423   die = new_die (DW_TAG_compile_unit, NULL, NULL);
11424
11425   if (filename)
11426     {
11427       add_name_attribute (die, filename);
11428       if (filename[0] != DIR_SEPARATOR)
11429         add_comp_dir_attribute (die);
11430     }
11431
11432   sprintf (producer, "%s %s", language_string, version_string);
11433
11434 #ifdef MIPS_DEBUGGING_INFO
11435   /* The MIPS/SGI compilers place the 'cc' command line options in the producer
11436      string.  The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
11437      not appear in the producer string, the debugger reaches the conclusion
11438      that the object file is stripped and has no debugging information.
11439      To get the MIPS/SGI debugger to believe that there is debugging
11440      information in the object file, we add a -g to the producer string.  */
11441   if (debug_info_level > DINFO_LEVEL_TERSE)
11442     strcat (producer, " -g");
11443 #endif
11444
11445   add_AT_string (die, DW_AT_producer, producer);
11446
11447   if (strcmp (language_string, "GNU C++") == 0)
11448     language = DW_LANG_C_plus_plus;
11449   else if (strcmp (language_string, "GNU Ada") == 0)
11450     language = DW_LANG_Ada83;
11451   else if (strcmp (language_string, "GNU F77") == 0)
11452     language = DW_LANG_Fortran77;
11453   else if (strcmp (language_string, "GNU Pascal") == 0)
11454     language = DW_LANG_Pascal83;
11455   else if (strcmp (language_string, "GNU Java") == 0)
11456     language = DW_LANG_Java;
11457   else
11458     language = DW_LANG_C89;
11459
11460   add_AT_unsigned (die, DW_AT_language, language);
11461   return die;
11462 }
11463
11464 /* Generate a DIE for a string type.  */
11465
11466 static void
11467 gen_string_type_die (type, context_die)
11468      tree type;
11469      dw_die_ref context_die;
11470 {
11471   dw_die_ref type_die
11472     = new_die (DW_TAG_string_type, scope_die_for (type, context_die), type);
11473
11474   equate_type_number_to_die (type, type_die);
11475
11476   /* ??? Fudge the string length attribute for now.
11477      TODO: add string length info.  */
11478 #if 0
11479   string_length_attribute (TYPE_MAX_VALUE (TYPE_DOMAIN (type)));
11480   bound_representation (upper_bound, 0, 'u');
11481 #endif
11482 }
11483
11484 /* Generate the DIE for a base class.  */
11485
11486 static void
11487 gen_inheritance_die (binfo, access, context_die)
11488      tree binfo, access;
11489      dw_die_ref context_die;
11490 {
11491   dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
11492
11493   add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
11494   add_data_member_location_attribute (die, binfo);
11495
11496   if (TREE_VIA_VIRTUAL (binfo))
11497     add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
11498
11499   if (access == access_public_node)
11500     add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
11501   else if (access == access_protected_node)
11502     add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
11503 }
11504
11505 /* Generate a DIE for a class member.  */
11506
11507 static void
11508 gen_member_die (type, context_die)
11509      tree type;
11510      dw_die_ref context_die;
11511 {
11512   tree member;
11513   tree binfo = TYPE_BINFO (type);
11514   dw_die_ref child;
11515
11516   /* If this is not an incomplete type, output descriptions of each of its
11517      members. Note that as we output the DIEs necessary to represent the
11518      members of this record or union type, we will also be trying to output
11519      DIEs to represent the *types* of those members. However the `type'
11520      function (above) will specifically avoid generating type DIEs for member
11521      types *within* the list of member DIEs for this (containing) type except
11522      for those types (of members) which are explicitly marked as also being
11523      members of this (containing) type themselves.  The g++ front- end can
11524      force any given type to be treated as a member of some other (containing)
11525      type by setting the TYPE_CONTEXT of the given (member) type to point to
11526      the TREE node representing the appropriate (containing) type.  */
11527
11528   /* First output info about the base classes.  */
11529   if (binfo && BINFO_BASETYPES (binfo))
11530     {
11531       tree bases = BINFO_BASETYPES (binfo);
11532       tree accesses = BINFO_BASEACCESSES (binfo);
11533       int n_bases = TREE_VEC_LENGTH (bases);
11534       int i;
11535
11536       for (i = 0; i < n_bases; i++)
11537         gen_inheritance_die (TREE_VEC_ELT (bases, i),
11538                              (accesses ? TREE_VEC_ELT (accesses, i)
11539                               : access_public_node), context_die);
11540     }
11541
11542   /* Now output info about the data members and type members.  */
11543   for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
11544     {
11545       /* If we thought we were generating minimal debug info for TYPE
11546          and then changed our minds, some of the member declarations
11547          may have already been defined.  Don't define them again, but
11548          do put them in the right order.  */
11549
11550       child = lookup_decl_die (member);
11551       if (child)
11552         splice_child_die (context_die, child);
11553       else
11554         gen_decl_die (member, context_die);
11555     }
11556
11557   /* Now output info about the function members (if any).  */
11558   for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
11559     {
11560       /* Don't include clones in the member list.  */
11561       if (DECL_ABSTRACT_ORIGIN (member))
11562         continue;
11563
11564       child = lookup_decl_die (member);
11565       if (child)
11566         splice_child_die (context_die, child);
11567       else
11568         gen_decl_die (member, context_die);
11569     }
11570 }
11571
11572 /* Generate a DIE for a structure or union type.  If TYPE_DECL_SUPPRESS_DEBUG
11573    is set, we pretend that the type was never defined, so we only get the
11574    member DIEs needed by later specification DIEs.  */
11575
11576 static void
11577 gen_struct_or_union_type_die (type, context_die)
11578      tree type;
11579      dw_die_ref context_die;
11580 {
11581   dw_die_ref type_die = lookup_type_die (type);
11582   dw_die_ref scope_die = 0;
11583   int nested = 0;
11584   int complete = (TYPE_SIZE (type)
11585                   && (! TYPE_STUB_DECL (type)
11586                       || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
11587
11588   if (type_die && ! complete)
11589     return;
11590
11591   if (TYPE_CONTEXT (type) != NULL_TREE
11592       && AGGREGATE_TYPE_P (TYPE_CONTEXT (type)))
11593     nested = 1;
11594
11595   scope_die = scope_die_for (type, context_die);
11596
11597   if (! type_die || (nested && scope_die == comp_unit_die))
11598     /* First occurrence of type or toplevel definition of nested class.  */
11599     {
11600       dw_die_ref old_die = type_die;
11601
11602       type_die = new_die (TREE_CODE (type) == RECORD_TYPE
11603                           ? DW_TAG_structure_type : DW_TAG_union_type,
11604                           scope_die, type);
11605       equate_type_number_to_die (type, type_die);
11606       if (old_die)
11607         add_AT_die_ref (type_die, DW_AT_specification, old_die);
11608       else
11609         add_name_attribute (type_die, type_tag (type));
11610     }
11611   else
11612     remove_AT (type_die, DW_AT_declaration);
11613
11614   /* If this type has been completed, then give it a byte_size attribute and
11615      then give a list of members.  */
11616   if (complete)
11617     {
11618       /* Prevent infinite recursion in cases where the type of some member of
11619          this type is expressed in terms of this type itself.  */
11620       TREE_ASM_WRITTEN (type) = 1;
11621       add_byte_size_attribute (type_die, type);
11622       if (TYPE_STUB_DECL (type) != NULL_TREE)
11623         add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
11624
11625       /* If the first reference to this type was as the return type of an
11626          inline function, then it may not have a parent.  Fix this now.  */
11627       if (type_die->die_parent == NULL)
11628         add_child_die (scope_die, type_die);
11629
11630       push_decl_scope (type);
11631       gen_member_die (type, type_die);
11632       pop_decl_scope ();
11633
11634       /* GNU extension: Record what type our vtable lives in.  */
11635       if (TYPE_VFIELD (type))
11636         {
11637           tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
11638
11639           gen_type_die (vtype, context_die);
11640           add_AT_die_ref (type_die, DW_AT_containing_type,
11641                           lookup_type_die (vtype));
11642         }
11643     }
11644   else
11645     {
11646       add_AT_flag (type_die, DW_AT_declaration, 1);
11647
11648       /* We don't need to do this for function-local types.  */
11649       if (TYPE_STUB_DECL (type)
11650           && ! decl_function_context (TYPE_STUB_DECL (type)))
11651         VARRAY_PUSH_TREE (incomplete_types, type);
11652     }
11653 }
11654
11655 /* Generate a DIE for a subroutine _type_.  */
11656
11657 static void
11658 gen_subroutine_type_die (type, context_die)
11659      tree type;
11660      dw_die_ref context_die;
11661 {
11662   tree return_type = TREE_TYPE (type);
11663   dw_die_ref subr_die
11664     = new_die (DW_TAG_subroutine_type,
11665                scope_die_for (type, context_die), type);
11666
11667   equate_type_number_to_die (type, subr_die);
11668   add_prototyped_attribute (subr_die, type);
11669   add_type_attribute (subr_die, return_type, 0, 0, context_die);
11670   gen_formal_types_die (type, subr_die);
11671 }
11672
11673 /* Generate a DIE for a type definition */
11674
11675 static void
11676 gen_typedef_die (decl, context_die)
11677      tree decl;
11678      dw_die_ref context_die;
11679 {
11680   dw_die_ref type_die;
11681   tree origin;
11682
11683   if (TREE_ASM_WRITTEN (decl))
11684     return;
11685
11686   TREE_ASM_WRITTEN (decl) = 1;
11687   type_die = new_die (DW_TAG_typedef, context_die, decl);
11688   origin = decl_ultimate_origin (decl);
11689   if (origin != NULL)
11690     add_abstract_origin_attribute (type_die, origin);
11691   else
11692     {
11693       tree type;
11694
11695       add_name_and_src_coords_attributes (type_die, decl);
11696       if (DECL_ORIGINAL_TYPE (decl))
11697         {
11698           type = DECL_ORIGINAL_TYPE (decl);
11699
11700           if (type == TREE_TYPE (decl))
11701             abort ();
11702           else
11703             equate_type_number_to_die (TREE_TYPE (decl), type_die);
11704         }
11705       else
11706         type = TREE_TYPE (decl);
11707
11708       add_type_attribute (type_die, type, TREE_READONLY (decl),
11709                           TREE_THIS_VOLATILE (decl), context_die);
11710     }
11711
11712   if (DECL_ABSTRACT (decl))
11713     equate_decl_number_to_die (decl, type_die);
11714 }
11715
11716 /* Generate a type description DIE.  */
11717
11718 static void
11719 gen_type_die (type, context_die)
11720      tree type;
11721      dw_die_ref context_die;
11722 {
11723   int need_pop;
11724
11725   if (type == NULL_TREE || type == error_mark_node)
11726     return;
11727
11728   if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11729       && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
11730     {
11731       if (TREE_ASM_WRITTEN (type))
11732         return;
11733
11734       /* Prevent broken recursion; we can't hand off to the same type.  */
11735       if (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) == type)
11736         abort ();
11737
11738       TREE_ASM_WRITTEN (type) = 1;
11739       gen_decl_die (TYPE_NAME (type), context_die);
11740       return;
11741     }
11742
11743   /* We are going to output a DIE to represent the unqualified version
11744      of this type (i.e. without any const or volatile qualifiers) so
11745      get the main variant (i.e. the unqualified version) of this type
11746      now.  (Vectors are special because the debugging info is in the
11747      cloned type itself).  */
11748   if (TREE_CODE (type) != VECTOR_TYPE)
11749     type = type_main_variant (type);
11750
11751   if (TREE_ASM_WRITTEN (type))
11752     return;
11753
11754   switch (TREE_CODE (type))
11755     {
11756     case ERROR_MARK:
11757       break;
11758
11759     case POINTER_TYPE:
11760     case REFERENCE_TYPE:
11761       /* We must set TREE_ASM_WRITTEN in case this is a recursive type.  This
11762          ensures that the gen_type_die recursion will terminate even if the
11763          type is recursive.  Recursive types are possible in Ada.  */
11764       /* ??? We could perhaps do this for all types before the switch
11765          statement.  */
11766       TREE_ASM_WRITTEN (type) = 1;
11767
11768       /* For these types, all that is required is that we output a DIE (or a
11769          set of DIEs) to represent the "basis" type.  */
11770       gen_type_die (TREE_TYPE (type), context_die);
11771       break;
11772
11773     case OFFSET_TYPE:
11774       /* This code is used for C++ pointer-to-data-member types.
11775          Output a description of the relevant class type.  */
11776       gen_type_die (TYPE_OFFSET_BASETYPE (type), context_die);
11777
11778       /* Output a description of the type of the object pointed to.  */
11779       gen_type_die (TREE_TYPE (type), context_die);
11780
11781       /* Now output a DIE to represent this pointer-to-data-member type
11782          itself.  */
11783       gen_ptr_to_mbr_type_die (type, context_die);
11784       break;
11785
11786     case SET_TYPE:
11787       gen_type_die (TYPE_DOMAIN (type), context_die);
11788       gen_set_type_die (type, context_die);
11789       break;
11790
11791     case FILE_TYPE:
11792       gen_type_die (TREE_TYPE (type), context_die);
11793       abort ();                 /* No way to represent these in Dwarf yet!  */
11794       break;
11795
11796     case FUNCTION_TYPE:
11797       /* Force out return type (in case it wasn't forced out already).  */
11798       gen_type_die (TREE_TYPE (type), context_die);
11799       gen_subroutine_type_die (type, context_die);
11800       break;
11801
11802     case METHOD_TYPE:
11803       /* Force out return type (in case it wasn't forced out already).  */
11804       gen_type_die (TREE_TYPE (type), context_die);
11805       gen_subroutine_type_die (type, context_die);
11806       break;
11807
11808     case ARRAY_TYPE:
11809       if (TYPE_STRING_FLAG (type) && TREE_CODE (TREE_TYPE (type)) == CHAR_TYPE)
11810         {
11811           gen_type_die (TREE_TYPE (type), context_die);
11812           gen_string_type_die (type, context_die);
11813         }
11814       else
11815         gen_array_type_die (type, context_die);
11816       break;
11817
11818     case VECTOR_TYPE:
11819       gen_array_type_die (type, context_die);
11820       break;
11821
11822     case ENUMERAL_TYPE:
11823     case RECORD_TYPE:
11824     case UNION_TYPE:
11825     case QUAL_UNION_TYPE:
11826       /* If this is a nested type whose containing class hasn't been written
11827          out yet, writing it out will cover this one, too.  This does not apply
11828          to instantiations of member class templates; they need to be added to
11829          the containing class as they are generated.  FIXME: This hurts the
11830          idea of combining type decls from multiple TUs, since we can't predict
11831          what set of template instantiations we'll get.  */
11832       if (TYPE_CONTEXT (type)
11833           && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
11834           && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
11835         {
11836           gen_type_die (TYPE_CONTEXT (type), context_die);
11837
11838           if (TREE_ASM_WRITTEN (type))
11839             return;
11840
11841           /* If that failed, attach ourselves to the stub.  */
11842           push_decl_scope (TYPE_CONTEXT (type));
11843           context_die = lookup_type_die (TYPE_CONTEXT (type));
11844           need_pop = 1;
11845         }
11846       else
11847         need_pop = 0;
11848
11849       if (TREE_CODE (type) == ENUMERAL_TYPE)
11850         gen_enumeration_type_die (type, context_die);
11851       else
11852         gen_struct_or_union_type_die (type, context_die);
11853
11854       if (need_pop)
11855         pop_decl_scope ();
11856
11857       /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
11858          it up if it is ever completed.  gen_*_type_die will set it for us
11859          when appropriate.  */
11860       return;
11861
11862     case VOID_TYPE:
11863     case INTEGER_TYPE:
11864     case REAL_TYPE:
11865     case COMPLEX_TYPE:
11866     case BOOLEAN_TYPE:
11867     case CHAR_TYPE:
11868       /* No DIEs needed for fundamental types.  */
11869       break;
11870
11871     case LANG_TYPE:
11872       /* No Dwarf representation currently defined.  */
11873       break;
11874
11875     default:
11876       abort ();
11877     }
11878
11879   TREE_ASM_WRITTEN (type) = 1;
11880 }
11881
11882 /* Generate a DIE for a tagged type instantiation.  */
11883
11884 static void
11885 gen_tagged_type_instantiation_die (type, context_die)
11886      tree type;
11887      dw_die_ref context_die;
11888 {
11889   if (type == NULL_TREE || type == error_mark_node)
11890     return;
11891
11892   /* We are going to output a DIE to represent the unqualified version of
11893      this type (i.e. without any const or volatile qualifiers) so make sure
11894      that we have the main variant (i.e. the unqualified version) of this
11895      type now.  */
11896   if (type != type_main_variant (type))
11897     abort ();
11898
11899   /* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is
11900      an instance of an unresolved type.  */
11901
11902   switch (TREE_CODE (type))
11903     {
11904     case ERROR_MARK:
11905       break;
11906
11907     case ENUMERAL_TYPE:
11908       gen_inlined_enumeration_type_die (type, context_die);
11909       break;
11910
11911     case RECORD_TYPE:
11912       gen_inlined_structure_type_die (type, context_die);
11913       break;
11914
11915     case UNION_TYPE:
11916     case QUAL_UNION_TYPE:
11917       gen_inlined_union_type_die (type, context_die);
11918       break;
11919
11920     default:
11921       abort ();
11922     }
11923 }
11924
11925 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
11926    things which are local to the given block.  */
11927
11928 static void
11929 gen_block_die (stmt, context_die, depth)
11930      tree stmt;
11931      dw_die_ref context_die;
11932      int depth;
11933 {
11934   int must_output_die = 0;
11935   tree origin;
11936   tree decl;
11937   enum tree_code origin_code;
11938
11939   /* Ignore blocks never really used to make RTL.  */
11940   if (stmt == NULL_TREE || !TREE_USED (stmt)
11941       || (!TREE_ASM_WRITTEN (stmt) && !BLOCK_ABSTRACT (stmt)))
11942     return;
11943
11944   /* If the block is one fragment of a non-contiguous block, do not
11945      process the variables, since they will have been done by the
11946      origin block.  Do process subblocks.  */
11947   if (BLOCK_FRAGMENT_ORIGIN (stmt))
11948     {
11949       tree sub;
11950
11951       for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
11952         gen_block_die (sub, context_die, depth + 1);
11953
11954       return;
11955     }
11956
11957   /* Determine the "ultimate origin" of this block.  This block may be an
11958      inlined instance of an inlined instance of inline function, so we have
11959      to trace all of the way back through the origin chain to find out what
11960      sort of node actually served as the original seed for the creation of
11961      the current block.  */
11962   origin = block_ultimate_origin (stmt);
11963   origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;
11964
11965   /* Determine if we need to output any Dwarf DIEs at all to represent this
11966      block.  */
11967   if (origin_code == FUNCTION_DECL)
11968     /* The outer scopes for inlinings *must* always be represented.  We
11969        generate DW_TAG_inlined_subroutine DIEs for them.  (See below.) */
11970     must_output_die = 1;
11971   else
11972     {
11973       /* In the case where the current block represents an inlining of the
11974          "body block" of an inline function, we must *NOT* output any DIE for
11975          this block because we have already output a DIE to represent the whole
11976          inlined function scope and the "body block" of any function doesn't
11977          really represent a different scope according to ANSI C rules.  So we
11978          check here to make sure that this block does not represent a "body
11979          block inlining" before trying to set the MUST_OUTPUT_DIE flag.  */
11980       if (! is_body_block (origin ? origin : stmt))
11981         {
11982           /* Determine if this block directly contains any "significant"
11983              local declarations which we will need to output DIEs for.  */
11984           if (debug_info_level > DINFO_LEVEL_TERSE)
11985             /* We are not in terse mode so *any* local declaration counts
11986                as being a "significant" one.  */
11987             must_output_die = (BLOCK_VARS (stmt) != NULL);
11988           else
11989             /* We are in terse mode, so only local (nested) function
11990                definitions count as "significant" local declarations.  */
11991             for (decl = BLOCK_VARS (stmt);
11992                  decl != NULL; decl = TREE_CHAIN (decl))
11993               if (TREE_CODE (decl) == FUNCTION_DECL
11994                   && DECL_INITIAL (decl))
11995                 {
11996                   must_output_die = 1;
11997                   break;
11998                 }
11999         }
12000     }
12001
12002   /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
12003      DIE for any block which contains no significant local declarations at
12004      all.  Rather, in such cases we just call `decls_for_scope' so that any
12005      needed Dwarf info for any sub-blocks will get properly generated. Note
12006      that in terse mode, our definition of what constitutes a "significant"
12007      local declaration gets restricted to include only inlined function
12008      instances and local (nested) function definitions.  */
12009   if (must_output_die)
12010     {
12011       if (origin_code == FUNCTION_DECL)
12012         gen_inlined_subroutine_die (stmt, context_die, depth);
12013       else
12014         gen_lexical_block_die (stmt, context_die, depth);
12015     }
12016   else
12017     decls_for_scope (stmt, context_die, depth);
12018 }
12019
12020 /* Generate all of the decls declared within a given scope and (recursively)
12021    all of its sub-blocks.  */
12022
12023 static void
12024 decls_for_scope (stmt, context_die, depth)
12025      tree stmt;
12026      dw_die_ref context_die;
12027      int depth;
12028 {
12029   tree decl;
12030   tree subblocks;
12031
12032   /* Ignore blocks never really used to make RTL.  */
12033   if (stmt == NULL_TREE || ! TREE_USED (stmt))
12034     return;
12035
12036   /* Output the DIEs to represent all of the data objects and typedefs
12037      declared directly within this block but not within any nested
12038      sub-blocks.  Also, nested function and tag DIEs have been
12039      generated with a parent of NULL; fix that up now.  */
12040   for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl))
12041     {
12042       dw_die_ref die;
12043
12044       if (TREE_CODE (decl) == FUNCTION_DECL)
12045         die = lookup_decl_die (decl);
12046       else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))
12047         die = lookup_type_die (TREE_TYPE (decl));
12048       else
12049         die = NULL;
12050
12051       if (die != NULL && die->die_parent == NULL)
12052         add_child_die (context_die, die);
12053       else
12054         gen_decl_die (decl, context_die);
12055     }
12056
12057   /* If we're at -g1, we're not interested in subblocks.  */
12058   if (debug_info_level <= DINFO_LEVEL_TERSE)
12059     return;
12060
12061   /* Output the DIEs to represent all sub-blocks (and the items declared
12062      therein) of this block.  */
12063   for (subblocks = BLOCK_SUBBLOCKS (stmt);
12064        subblocks != NULL;
12065        subblocks = BLOCK_CHAIN (subblocks))
12066     gen_block_die (subblocks, context_die, depth + 1);
12067 }
12068
12069 /* Is this a typedef we can avoid emitting?  */
12070
12071 static inline int
12072 is_redundant_typedef (decl)
12073      tree decl;
12074 {
12075   if (TYPE_DECL_IS_STUB (decl))
12076     return 1;
12077
12078   if (DECL_ARTIFICIAL (decl)
12079       && DECL_CONTEXT (decl)
12080       && is_tagged_type (DECL_CONTEXT (decl))
12081       && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
12082       && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
12083     /* Also ignore the artificial member typedef for the class name.  */
12084     return 1;
12085
12086   return 0;
12087 }
12088
12089 /* Generate Dwarf debug information for a decl described by DECL.  */
12090
12091 static void
12092 gen_decl_die (decl, context_die)
12093      tree decl;
12094      dw_die_ref context_die;
12095 {
12096   tree origin;
12097
12098   if (DECL_P (decl) && DECL_IGNORED_P (decl))
12099     return;
12100
12101   switch (TREE_CODE (decl))
12102     {
12103     case ERROR_MARK:
12104       break;
12105
12106     case CONST_DECL:
12107       /* The individual enumerators of an enum type get output when we output
12108          the Dwarf representation of the relevant enum type itself.  */
12109       break;
12110
12111     case FUNCTION_DECL:
12112       /* Don't output any DIEs to represent mere function declarations,
12113          unless they are class members or explicit block externs.  */
12114       if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE
12115           && (current_function_decl == NULL_TREE || DECL_ARTIFICIAL (decl)))
12116         break;
12117
12118       /* If we're emitting a clone, emit info for the abstract instance.  */
12119       if (DECL_ORIGIN (decl) != decl)
12120         dwarf2out_abstract_function (DECL_ABSTRACT_ORIGIN (decl));
12121
12122       /* If we're emitting an out-of-line copy of an inline function,
12123          emit info for the abstract instance and set up to refer to it.  */
12124       else if (DECL_INLINE (decl) && ! DECL_ABSTRACT (decl)
12125                && ! class_scope_p (context_die)
12126                /* dwarf2out_abstract_function won't emit a die if this is just
12127                   a declaration.  We must avoid setting DECL_ABSTRACT_ORIGIN in
12128                   that case, because that works only if we have a die.  */
12129                && DECL_INITIAL (decl) != NULL_TREE)
12130         {
12131           dwarf2out_abstract_function (decl);
12132           set_decl_origin_self (decl);
12133         }
12134
12135       /* Otherwise we're emitting the primary DIE for this decl.  */
12136       else if (debug_info_level > DINFO_LEVEL_TERSE)
12137         {
12138           /* Before we describe the FUNCTION_DECL itself, make sure that we
12139              have described its return type.  */
12140           gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
12141
12142           /* And its virtual context.  */
12143           if (DECL_VINDEX (decl) != NULL_TREE)
12144             gen_type_die (DECL_CONTEXT (decl), context_die);
12145
12146           /* And its containing type.  */
12147           origin = decl_class_context (decl);
12148           if (origin != NULL_TREE)
12149             gen_type_die_for_member (origin, decl, context_die);
12150         }
12151
12152       /* Now output a DIE to represent the function itself.  */
12153       gen_subprogram_die (decl, context_die);
12154       break;
12155
12156     case TYPE_DECL:
12157       /* If we are in terse mode, don't generate any DIEs to represent any
12158          actual typedefs.  */
12159       if (debug_info_level <= DINFO_LEVEL_TERSE)
12160         break;
12161
12162       /* In the special case of a TYPE_DECL node representing the declaration
12163          of some type tag, if the given TYPE_DECL is marked as having been
12164          instantiated from some other (original) TYPE_DECL node (e.g. one which
12165          was generated within the original definition of an inline function) we
12166          have to generate a special (abbreviated) DW_TAG_structure_type,
12167          DW_TAG_union_type, or DW_TAG_enumeration_type DIE here.  */
12168       if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
12169         {
12170           gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
12171           break;
12172         }
12173
12174       if (is_redundant_typedef (decl))
12175         gen_type_die (TREE_TYPE (decl), context_die);
12176       else
12177         /* Output a DIE to represent the typedef itself.  */
12178         gen_typedef_die (decl, context_die);
12179       break;
12180
12181     case LABEL_DECL:
12182       if (debug_info_level >= DINFO_LEVEL_NORMAL)
12183         gen_label_die (decl, context_die);
12184       break;
12185
12186     case VAR_DECL:
12187       /* If we are in terse mode, don't generate any DIEs to represent any
12188          variable declarations or definitions.  */
12189       if (debug_info_level <= DINFO_LEVEL_TERSE)
12190         break;
12191
12192       /* Output any DIEs that are needed to specify the type of this data
12193          object.  */
12194       gen_type_die (TREE_TYPE (decl), context_die);
12195
12196       /* And its containing type.  */
12197       origin = decl_class_context (decl);
12198       if (origin != NULL_TREE)
12199         gen_type_die_for_member (origin, decl, context_die);
12200
12201       /* Now output the DIE to represent the data object itself.  This gets
12202          complicated because of the possibility that the VAR_DECL really
12203          represents an inlined instance of a formal parameter for an inline
12204          function.  */
12205       origin = decl_ultimate_origin (decl);
12206       if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
12207         gen_formal_parameter_die (decl, context_die);
12208       else
12209         gen_variable_die (decl, context_die);
12210       break;
12211
12212     case FIELD_DECL:
12213       /* Ignore the nameless fields that are used to skip bits but handle C++
12214          anonymous unions.  */
12215       if (DECL_NAME (decl) != NULL_TREE
12216           || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE)
12217         {
12218           gen_type_die (member_declared_type (decl), context_die);
12219           gen_field_die (decl, context_die);
12220         }
12221       break;
12222
12223     case PARM_DECL:
12224       gen_type_die (TREE_TYPE (decl), context_die);
12225       gen_formal_parameter_die (decl, context_die);
12226       break;
12227
12228     case NAMESPACE_DECL:
12229       /* Ignore for now.  */
12230       break;
12231
12232     default:
12233       if ((int)TREE_CODE (decl) > NUM_TREE_CODES)
12234         /* Probably some frontend-internal decl.  Assume we don't care.  */
12235         break;
12236       abort ();
12237     }
12238 }
12239 \f
12240 /* Add Ada "use" clause information for SGI Workshop debugger.  */
12241
12242 void
12243 dwarf2out_add_library_unit_info (filename, context_list)
12244      const char *filename;
12245      const char *context_list;
12246 {
12247   unsigned int file_index;
12248
12249   if (filename != NULL)
12250     {
12251       dw_die_ref unit_die = new_die (DW_TAG_module, comp_unit_die, NULL);
12252       tree context_list_decl
12253         = build_decl (LABEL_DECL, get_identifier (context_list),
12254                       void_type_node);
12255
12256       TREE_PUBLIC (context_list_decl) = TRUE;
12257       add_name_attribute (unit_die, context_list);
12258       file_index = lookup_filename (filename);
12259       add_AT_unsigned (unit_die, DW_AT_decl_file, file_index);
12260       add_pubname (context_list_decl, unit_die);
12261     }
12262 }
12263
12264 /* Output debug information for global decl DECL.  Called from toplev.c after
12265    compilation proper has finished.  */
12266
12267 static void
12268 dwarf2out_global_decl (decl)
12269      tree decl;
12270 {
12271   /* Output DWARF2 information for file-scope tentative data object
12272      declarations, file-scope (extern) function declarations (which had no
12273      corresponding body) and file-scope tagged type declarations and
12274      definitions which have not yet been forced out.  */
12275   if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
12276     dwarf2out_decl (decl);
12277 }
12278
12279 /* Write the debugging output for DECL.  */
12280
12281 void
12282 dwarf2out_decl (decl)
12283      tree decl;
12284 {
12285   dw_die_ref context_die = comp_unit_die;
12286
12287   switch (TREE_CODE (decl))
12288     {
12289     case ERROR_MARK:
12290       return;
12291
12292     case FUNCTION_DECL:
12293       /* Ignore this FUNCTION_DECL if it refers to a builtin declaration of a
12294          builtin function.  Explicit programmer-supplied declarations of
12295          these same functions should NOT be ignored however.  */
12296       if (DECL_EXTERNAL (decl) && DECL_BUILT_IN (decl))
12297         return;
12298
12299       /* What we would really like to do here is to filter out all mere
12300          file-scope declarations of file-scope functions which are never
12301          referenced later within this translation unit (and keep all of ones
12302          that *are* referenced later on) but we aren't clairvoyant, so we have
12303          no idea which functions will be referenced in the future (i.e. later
12304          on within the current translation unit). So here we just ignore all
12305          file-scope function declarations which are not also definitions.  If
12306          and when the debugger needs to know something about these functions,
12307          it will have to hunt around and find the DWARF information associated
12308          with the definition of the function.
12309
12310          We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
12311          nodes represent definitions and which ones represent mere
12312          declarations.  We have to check DECL_INITIAL instead. That's because
12313          the C front-end supports some weird semantics for "extern inline"
12314          function definitions.  These can get inlined within the current
12315          translation unit (an thus, we need to generate Dwarf info for their
12316          abstract instances so that the Dwarf info for the concrete inlined
12317          instances can have something to refer to) but the compiler never
12318          generates any out-of-lines instances of such things (despite the fact
12319          that they *are* definitions).
12320
12321          The important point is that the C front-end marks these "extern
12322          inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
12323          them anyway. Note that the C++ front-end also plays some similar games
12324          for inline function definitions appearing within include files which
12325          also contain `#pragma interface' pragmas.  */
12326       if (DECL_INITIAL (decl) == NULL_TREE)
12327         return;
12328
12329       /* If we're a nested function, initially use a parent of NULL; if we're
12330          a plain function, this will be fixed up in decls_for_scope.  If
12331          we're a method, it will be ignored, since we already have a DIE.  */
12332       if (decl_function_context (decl)
12333           /* But if we're in terse mode, we don't care about scope.  */
12334           && debug_info_level > DINFO_LEVEL_TERSE)
12335         context_die = NULL;
12336       break;
12337
12338     case VAR_DECL:
12339       /* Ignore this VAR_DECL if it refers to a file-scope extern data object
12340          declaration and if the declaration was never even referenced from
12341          within this entire compilation unit.  We suppress these DIEs in
12342          order to save space in the .debug section (by eliminating entries
12343          which are probably useless).  Note that we must not suppress
12344          block-local extern declarations (whether used or not) because that
12345          would screw-up the debugger's name lookup mechanism and cause it to
12346          miss things which really ought to be in scope at a given point.  */
12347       if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
12348         return;
12349
12350       /* If we are in terse mode, don't generate any DIEs to represent any
12351          variable declarations or definitions.  */
12352       if (debug_info_level <= DINFO_LEVEL_TERSE)
12353         return;
12354       break;
12355
12356     case TYPE_DECL:
12357       /* Don't emit stubs for types unless they are needed by other DIEs.  */
12358       if (TYPE_DECL_SUPPRESS_DEBUG (decl))
12359         return;
12360
12361       /* Don't bother trying to generate any DIEs to represent any of the
12362          normal built-in types for the language we are compiling.  */
12363       if (DECL_SOURCE_LINE (decl) == 0)
12364         {
12365           /* OK, we need to generate one for `bool' so GDB knows what type
12366              comparisons have.  */
12367           if ((get_AT_unsigned (comp_unit_die, DW_AT_language)
12368                == DW_LANG_C_plus_plus)
12369               && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE
12370               && ! DECL_IGNORED_P (decl))
12371             modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
12372
12373           return;
12374         }
12375
12376       /* If we are in terse mode, don't generate any DIEs for types.  */
12377       if (debug_info_level <= DINFO_LEVEL_TERSE)
12378         return;
12379
12380       /* If we're a function-scope tag, initially use a parent of NULL;
12381          this will be fixed up in decls_for_scope.  */
12382       if (decl_function_context (decl))
12383         context_die = NULL;
12384
12385       break;
12386
12387     default:
12388       return;
12389     }
12390
12391   gen_decl_die (decl, context_die);
12392 }
12393
12394 /* Output a marker (i.e. a label) for the beginning of the generated code for
12395    a lexical block.  */
12396
12397 static void
12398 dwarf2out_begin_block (line, blocknum)
12399      unsigned int line ATTRIBUTE_UNUSED;
12400      unsigned int blocknum;
12401 {
12402   function_section (current_function_decl);
12403   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
12404 }
12405
12406 /* Output a marker (i.e. a label) for the end of the generated code for a
12407    lexical block.  */
12408
12409 static void
12410 dwarf2out_end_block (line, blocknum)
12411      unsigned int line ATTRIBUTE_UNUSED;
12412      unsigned int blocknum;
12413 {
12414   function_section (current_function_decl);
12415   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
12416 }
12417
12418 /* Returns nonzero if it is appropriate not to emit any debugging
12419    information for BLOCK, because it doesn't contain any instructions.
12420
12421    Don't allow this for blocks with nested functions or local classes
12422    as we would end up with orphans, and in the presence of scheduling
12423    we may end up calling them anyway.  */
12424
12425 static bool
12426 dwarf2out_ignore_block (block)
12427      tree block;
12428 {
12429   tree decl;
12430
12431   for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
12432     if (TREE_CODE (decl) == FUNCTION_DECL
12433         || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
12434       return 0;
12435
12436   return 1;
12437 }
12438
12439 /* Lookup FILE_NAME (in the list of filenames that we know about here in
12440    dwarf2out.c) and return its "index".  The index of each (known) filename is
12441    just a unique number which is associated with only that one filename.  We
12442    need such numbers for the sake of generating labels (in the .debug_sfnames
12443    section) and references to those files numbers (in the .debug_srcinfo
12444    and.debug_macinfo sections).  If the filename given as an argument is not
12445    found in our current list, add it to the list and assign it the next
12446    available unique index number.  In order to speed up searches, we remember
12447    the index of the filename was looked up last.  This handles the majority of
12448    all searches.  */
12449
12450 static unsigned
12451 lookup_filename (file_name)
12452      const char *file_name;
12453 {
12454   size_t i, n;
12455   char *save_file_name;
12456
12457   /* Check to see if the file name that was searched on the previous
12458      call matches this file name.  If so, return the index.  */
12459   if (file_table_last_lookup_index != 0)
12460     {
12461       const char *last
12462         = VARRAY_CHAR_PTR (file_table, file_table_last_lookup_index);
12463       if (strcmp (file_name, last) == 0)
12464         return file_table_last_lookup_index;
12465     }
12466
12467   /* Didn't match the previous lookup, search the table */
12468   n = VARRAY_ACTIVE_SIZE (file_table);
12469   for (i = 1; i < n; i++)
12470     if (strcmp (file_name, VARRAY_CHAR_PTR (file_table, i)) == 0)
12471       {
12472         file_table_last_lookup_index = i;
12473         return i;
12474       }
12475
12476   /* Add the new entry to the end of the filename table.  */
12477   file_table_last_lookup_index = n;
12478   save_file_name = (char *) ggc_strdup (file_name);
12479   VARRAY_PUSH_CHAR_PTR (file_table, save_file_name);
12480   VARRAY_PUSH_UINT (file_table_emitted, 0);
12481
12482   return i;
12483 }
12484
12485 static int
12486 maybe_emit_file (fileno)
12487      int fileno;
12488 {
12489   static int emitcount = 0;
12490   if (DWARF2_ASM_LINE_DEBUG_INFO && fileno > 0)
12491     {
12492       if (!VARRAY_UINT (file_table_emitted, fileno))
12493         {
12494           VARRAY_UINT (file_table_emitted, fileno) = ++emitcount;
12495           fprintf (asm_out_file, "\t.file %u ",
12496                    VARRAY_UINT (file_table_emitted, fileno));
12497           output_quoted_string (asm_out_file,
12498                                 VARRAY_CHAR_PTR (file_table, fileno));
12499           fputc ('\n', asm_out_file);
12500         }
12501       return VARRAY_UINT (file_table_emitted, fileno);
12502     }
12503   else
12504     return fileno;
12505 }
12506
12507 static void
12508 init_file_table ()
12509 {
12510   /* Allocate the initial hunk of the file_table.  */
12511   VARRAY_CHAR_PTR_INIT (file_table, 64, "file_table");
12512   VARRAY_UINT_INIT (file_table_emitted, 64, "file_table_emitted");
12513
12514   /* Skip the first entry - file numbers begin at 1.  */
12515   VARRAY_PUSH_CHAR_PTR (file_table, NULL);
12516   VARRAY_PUSH_UINT (file_table_emitted, 0);
12517   file_table_last_lookup_index = 0;
12518 }
12519
12520 /* Output a label to mark the beginning of a source code line entry
12521    and record information relating to this source line, in
12522    'line_info_table' for later output of the .debug_line section.  */
12523
12524 static void
12525 dwarf2out_source_line (line, filename)
12526      unsigned int line;
12527      const char *filename;
12528 {
12529   if (debug_info_level >= DINFO_LEVEL_NORMAL
12530       && line != 0)
12531     {
12532       function_section (current_function_decl);
12533
12534       /* If requested, emit something human-readable.  */
12535       if (flag_debug_asm)
12536         fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START,
12537                  filename, line);
12538
12539       if (DWARF2_ASM_LINE_DEBUG_INFO)
12540         {
12541           unsigned file_num = lookup_filename (filename);
12542
12543           file_num = maybe_emit_file (file_num);
12544
12545           /* Emit the .loc directive understood by GNU as.  */
12546           fprintf (asm_out_file, "\t.loc %d %d 0\n", file_num, line);
12547
12548           /* Indicate that line number info exists.  */
12549           line_info_table_in_use++;
12550
12551           /* Indicate that multiple line number tables exist.  */
12552           if (DECL_SECTION_NAME (current_function_decl))
12553             separate_line_info_table_in_use++;
12554         }
12555       else if (DECL_SECTION_NAME (current_function_decl))
12556         {
12557           dw_separate_line_info_ref line_info;
12558           (*targetm.asm_out.internal_label) (asm_out_file, SEPARATE_LINE_CODE_LABEL,
12559                                      separate_line_info_table_in_use);
12560
12561           /* expand the line info table if necessary */
12562           if (separate_line_info_table_in_use
12563               == separate_line_info_table_allocated)
12564             {
12565               separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
12566               separate_line_info_table
12567                 = (dw_separate_line_info_ref)
12568                   ggc_realloc (separate_line_info_table,
12569                                separate_line_info_table_allocated
12570                                * sizeof (dw_separate_line_info_entry));
12571               memset ((separate_line_info_table
12572                        + separate_line_info_table_in_use),
12573                       0,
12574                       (LINE_INFO_TABLE_INCREMENT
12575                        * sizeof (dw_separate_line_info_entry)));
12576             }
12577
12578           /* Add the new entry at the end of the line_info_table.  */
12579           line_info
12580             = &separate_line_info_table[separate_line_info_table_in_use++];
12581           line_info->dw_file_num = lookup_filename (filename);
12582           line_info->dw_line_num = line;
12583           line_info->function = current_function_funcdef_no;
12584         }
12585       else
12586         {
12587           dw_line_info_ref line_info;
12588
12589           (*targetm.asm_out.internal_label) (asm_out_file, LINE_CODE_LABEL,
12590                                      line_info_table_in_use);
12591
12592           /* Expand the line info table if necessary.  */
12593           if (line_info_table_in_use == line_info_table_allocated)
12594             {
12595               line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
12596               line_info_table
12597                 = ggc_realloc (line_info_table,
12598                                (line_info_table_allocated
12599                                 * sizeof (dw_line_info_entry)));
12600               memset (line_info_table + line_info_table_in_use, 0,
12601                       LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
12602             }
12603
12604           /* Add the new entry at the end of the line_info_table.  */
12605           line_info = &line_info_table[line_info_table_in_use++];
12606           line_info->dw_file_num = lookup_filename (filename);
12607           line_info->dw_line_num = line;
12608         }
12609     }
12610 }
12611
12612 /* Record the beginning of a new source file.  */
12613
12614 static void
12615 dwarf2out_start_source_file (lineno, filename)
12616      unsigned int lineno;
12617      const char *filename;
12618 {
12619   if (flag_eliminate_dwarf2_dups && !is_main_source)
12620     {
12621       /* Record the beginning of the file for break_out_includes.  */
12622       dw_die_ref bincl_die;
12623
12624       bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL);
12625       add_AT_string (bincl_die, DW_AT_name, filename);
12626     }
12627
12628   is_main_source = 0;
12629
12630   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
12631     {
12632       named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
12633       dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
12634       dw2_asm_output_data_uleb128 (lineno, "Included from line number %d",
12635                                    lineno);
12636       maybe_emit_file (lookup_filename (filename));
12637       dw2_asm_output_data_uleb128 (lookup_filename (filename),
12638                                    "Filename we just started");
12639     }
12640 }
12641
12642 /* Record the end of a source file.  */
12643
12644 static void
12645 dwarf2out_end_source_file (lineno)
12646      unsigned int lineno ATTRIBUTE_UNUSED;
12647 {
12648   if (flag_eliminate_dwarf2_dups)
12649     /* Record the end of the file for break_out_includes.  */
12650     new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL);
12651
12652   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
12653     {
12654       named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
12655       dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
12656     }
12657 }
12658
12659 /* Called from debug_define in toplev.c.  The `buffer' parameter contains
12660    the tail part of the directive line, i.e. the part which is past the
12661    initial whitespace, #, whitespace, directive-name, whitespace part.  */
12662
12663 static void
12664 dwarf2out_define (lineno, buffer)
12665      unsigned lineno ATTRIBUTE_UNUSED;
12666      const char *buffer ATTRIBUTE_UNUSED;
12667 {
12668   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
12669     {
12670       named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
12671       dw2_asm_output_data (1, DW_MACINFO_define, "Define macro");
12672       dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
12673       dw2_asm_output_nstring (buffer, -1, "The macro");
12674     }
12675 }
12676
12677 /* Called from debug_undef in toplev.c.  The `buffer' parameter contains
12678    the tail part of the directive line, i.e. the part which is past the
12679    initial whitespace, #, whitespace, directive-name, whitespace part.  */
12680
12681 static void
12682 dwarf2out_undef (lineno, buffer)
12683      unsigned lineno ATTRIBUTE_UNUSED;
12684      const char *buffer ATTRIBUTE_UNUSED;
12685 {
12686   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
12687     {
12688       named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
12689       dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro");
12690       dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
12691       dw2_asm_output_nstring (buffer, -1, "The macro");
12692     }
12693 }
12694
12695 /* Set up for Dwarf output at the start of compilation.  */
12696
12697 static void
12698 dwarf2out_init (input_filename)
12699      const char *input_filename ATTRIBUTE_UNUSED;
12700 {
12701   init_file_table ();
12702
12703   /* Allocate the initial hunk of the decl_die_table.  */
12704   decl_die_table = ggc_alloc_cleared (DECL_DIE_TABLE_INCREMENT
12705                                       * sizeof (dw_die_ref));
12706   decl_die_table_allocated = DECL_DIE_TABLE_INCREMENT;
12707   decl_die_table_in_use = 0;
12708
12709   /* Allocate the initial hunk of the decl_scope_table.  */
12710   VARRAY_TREE_INIT (decl_scope_table, 256, "decl_scope_table");
12711
12712   /* Allocate the initial hunk of the abbrev_die_table.  */
12713   abbrev_die_table = ggc_alloc_cleared (ABBREV_DIE_TABLE_INCREMENT
12714                                         * sizeof (dw_die_ref));
12715   abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
12716   /* Zero-th entry is allocated, but unused */
12717   abbrev_die_table_in_use = 1;
12718
12719   /* Allocate the initial hunk of the line_info_table.  */
12720   line_info_table = ggc_alloc_cleared (LINE_INFO_TABLE_INCREMENT
12721                                        * sizeof (dw_line_info_entry));
12722   line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
12723
12724   /* Zero-th entry is allocated, but unused */
12725   line_info_table_in_use = 1;
12726
12727   /* Generate the initial DIE for the .debug section.  Note that the (string)
12728      value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
12729      will (typically) be a relative pathname and that this pathname should be
12730      taken as being relative to the directory from which the compiler was
12731      invoked when the given (base) source file was compiled.  We will fill
12732      in this value in dwarf2out_finish.  */
12733   comp_unit_die = gen_compile_unit_die (NULL);
12734   is_main_source = 1;
12735
12736   VARRAY_TREE_INIT (incomplete_types, 64, "incomplete_types");
12737
12738   VARRAY_RTX_INIT (used_rtx_varray, 32, "used_rtx_varray");
12739
12740   ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
12741   ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
12742                                DEBUG_ABBREV_SECTION_LABEL, 0);
12743   if (DWARF2_GENERATE_TEXT_SECTION_LABEL)
12744     ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
12745   else
12746     strcpy (text_section_label, stripattributes (TEXT_SECTION_NAME));
12747
12748   ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
12749                                DEBUG_INFO_SECTION_LABEL, 0);
12750   ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
12751                                DEBUG_LINE_SECTION_LABEL, 0);
12752   ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
12753                                DEBUG_RANGES_SECTION_LABEL, 0);
12754   named_section_flags (DEBUG_ABBREV_SECTION, SECTION_DEBUG);
12755   ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
12756   named_section_flags (DEBUG_INFO_SECTION, SECTION_DEBUG);
12757   ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
12758   named_section_flags (DEBUG_LINE_SECTION, SECTION_DEBUG);
12759   ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
12760
12761   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
12762     {
12763       named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
12764       ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
12765                                    DEBUG_MACINFO_SECTION_LABEL, 0);
12766       ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
12767     }
12768
12769   if (DWARF2_GENERATE_TEXT_SECTION_LABEL)
12770     {
12771       text_section ();
12772       ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
12773     }
12774 }
12775
12776 /* A helper function for dwarf2out_finish called through
12777    ht_forall.  Emit one queued .debug_str string.  */
12778
12779 static int
12780 output_indirect_string (h, v)
12781      void **h;
12782      void *v ATTRIBUTE_UNUSED;
12783 {
12784   struct indirect_string_node *node = (struct indirect_string_node *) *h;
12785
12786   if (node->form == DW_FORM_strp)
12787     {
12788       named_section_flags (DEBUG_STR_SECTION, DEBUG_STR_SECTION_FLAGS);
12789       ASM_OUTPUT_LABEL (asm_out_file, node->label);
12790       assemble_string (node->str, strlen (node->str) + 1);
12791     }
12792
12793   return 1;
12794 }
12795
12796
12797
12798 /* Clear the marks for a die and its children.
12799    Be cool if the mark isn't set.  */
12800
12801 static void
12802 prune_unmark_dies (die)
12803      dw_die_ref die;
12804 {
12805   dw_die_ref c;
12806   die->die_mark = 0;
12807   for (c = die->die_child; c; c = c->die_sib)
12808     prune_unmark_dies (c);
12809 }
12810
12811
12812 /* Given DIE that we're marking as used, find any other dies
12813    it references as attributes and mark them as used.  */
12814
12815 static void
12816 prune_unused_types_walk_attribs (die)
12817      dw_die_ref die;
12818 {
12819   dw_attr_ref a;
12820
12821   for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
12822     {
12823       if (a->dw_attr_val.val_class == dw_val_class_die_ref)
12824         {
12825           /* A reference to another DIE.
12826              Make sure that it will get emitted.  */
12827           prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
12828         }
12829       else if (a->dw_attr == DW_AT_decl_file)
12830         {
12831           /* A reference to a file.  Make sure the file name is emitted.  */
12832           a->dw_attr_val.v.val_unsigned =
12833             maybe_emit_file (a->dw_attr_val.v.val_unsigned);
12834         }
12835     }
12836 }
12837
12838
12839 /* Mark DIE as being used.  If DOKIDS is true, then walk down
12840    to DIE's children.  */
12841
12842 static void
12843 prune_unused_types_mark (die, dokids)
12844      dw_die_ref die;
12845      int dokids;
12846 {
12847   dw_die_ref c;
12848
12849   if (die->die_mark == 0)
12850     {
12851       /* We haven't done this node yet.  Mark it as used.  */
12852       die->die_mark = 1;
12853
12854       /* We also have to mark its parents as used.
12855          (But we don't want to mark our parents' kids due to this.)  */
12856       if (die->die_parent)
12857         prune_unused_types_mark (die->die_parent, 0);
12858
12859       /* Mark any referenced nodes.  */
12860       prune_unused_types_walk_attribs (die);
12861     }
12862
12863   if (dokids && die->die_mark != 2)
12864     {
12865       /* We need to walk the children, but haven't done so yet.
12866          Remember that we've walked the kids.  */
12867       die->die_mark = 2;
12868
12869       /* Walk them.  */
12870       for (c = die->die_child; c; c = c->die_sib)
12871         {
12872           /* If this is an array type, we need to make sure our
12873              kids get marked, even if they're types.  */
12874           if (die->die_tag == DW_TAG_array_type)
12875             prune_unused_types_mark (c, 1);
12876           else
12877             prune_unused_types_walk (c);
12878         }
12879     }
12880 }
12881
12882
12883 /* Walk the tree DIE and mark types that we actually use.  */
12884
12885 static void
12886 prune_unused_types_walk (die)
12887      dw_die_ref die;
12888 {
12889   dw_die_ref c;
12890
12891   /* Don't do anything if this node is already marked.  */
12892   if (die->die_mark)
12893     return;
12894
12895   switch (die->die_tag) {
12896   case DW_TAG_const_type:
12897   case DW_TAG_packed_type:
12898   case DW_TAG_pointer_type:
12899   case DW_TAG_reference_type:
12900   case DW_TAG_volatile_type:
12901   case DW_TAG_typedef:
12902   case DW_TAG_array_type:
12903   case DW_TAG_structure_type:
12904   case DW_TAG_union_type:
12905   case DW_TAG_class_type:
12906   case DW_TAG_friend:
12907   case DW_TAG_variant_part:
12908   case DW_TAG_enumeration_type:
12909   case DW_TAG_subroutine_type:
12910   case DW_TAG_string_type:
12911   case DW_TAG_set_type:
12912   case DW_TAG_subrange_type:
12913   case DW_TAG_ptr_to_member_type:
12914   case DW_TAG_file_type:
12915     /* It's a type node --- don't mark it.  */
12916     return;
12917
12918   default:
12919     /* Mark everything else.  */
12920     break;
12921   }
12922
12923   die->die_mark = 1;
12924
12925   /* Now, mark any dies referenced from here.  */
12926   prune_unused_types_walk_attribs (die);
12927
12928   /* Mark children.  */
12929   for (c = die->die_child; c; c = c->die_sib)
12930     prune_unused_types_walk (c);
12931 }
12932
12933
12934 /* Remove from the tree DIE any dies that aren't marked.  */
12935
12936 static void
12937 prune_unused_types_prune (die)
12938      dw_die_ref die;
12939 {
12940   dw_die_ref c, p, n;
12941   if (!die->die_mark)
12942     abort();
12943
12944   p = NULL;
12945   for (c = die->die_child; c; c = n)
12946     {
12947       n = c->die_sib;
12948       if (c->die_mark)
12949         {
12950           prune_unused_types_prune (c);
12951           p = c;
12952         }
12953       else
12954         {
12955           if (p)
12956             p->die_sib = n;
12957           else
12958             die->die_child = n;
12959           free_die (c);
12960         }
12961     }
12962 }
12963
12964
12965 /* Remove dies representing declarations that we never use.  */
12966
12967 static void
12968 prune_unused_types ()
12969 {
12970   unsigned int i;
12971   limbo_die_node *node;
12972
12973   /* Clear all the marks.  */
12974   prune_unmark_dies (comp_unit_die);
12975   for (node = limbo_die_list; node; node = node->next)
12976     prune_unmark_dies (node->die);
12977
12978   /* Set the mark on nodes that are actually used.  */
12979   prune_unused_types_walk (comp_unit_die);
12980   for (node = limbo_die_list; node; node = node->next)
12981     prune_unused_types_walk (node->die);
12982
12983   /* Also set the mark on nodes referenced from the
12984      pubname_table or arange_table.  */
12985   for (i = 0; i < pubname_table_in_use; i++)
12986     prune_unused_types_mark (pubname_table[i].die, 1);
12987   for (i = 0; i < arange_table_in_use; i++)
12988     prune_unused_types_mark (arange_table[i], 1);
12989
12990   /* Get rid of nodes that aren't marked.  */
12991   prune_unused_types_prune (comp_unit_die);
12992   for (node = limbo_die_list; node; node = node->next)
12993     prune_unused_types_prune (node->die);
12994
12995   /* Leave the marks clear.  */
12996   prune_unmark_dies (comp_unit_die);
12997   for (node = limbo_die_list; node; node = node->next)
12998     prune_unmark_dies (node->die);
12999 }
13000
13001 /* Output stuff that dwarf requires at the end of every file,
13002    and generate the DWARF-2 debugging info.  */
13003
13004 static void
13005 dwarf2out_finish (input_filename)
13006      const char *input_filename;
13007 {
13008   limbo_die_node *node, *next_node;
13009   dw_die_ref die = 0;
13010
13011   /* Add the name for the main input file now.  We delayed this from
13012      dwarf2out_init to avoid complications with PCH.  */
13013   add_name_attribute (comp_unit_die, input_filename);
13014   if (input_filename[0] != DIR_SEPARATOR)
13015     add_comp_dir_attribute (comp_unit_die);
13016   else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL)
13017     {
13018       size_t i;
13019       for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
13020         if (VARRAY_CHAR_PTR (file_table, i)[0] != DIR_SEPARATOR)
13021           {
13022             add_comp_dir_attribute (comp_unit_die);
13023             break;
13024           }
13025     }
13026
13027   /* Traverse the limbo die list, and add parent/child links.  The only
13028      dies without parents that should be here are concrete instances of
13029      inline functions, and the comp_unit_die.  We can ignore the comp_unit_die.
13030      For concrete instances, we can get the parent die from the abstract
13031      instance.  */
13032   for (node = limbo_die_list; node; node = next_node)
13033     {
13034       next_node = node->next;
13035       die = node->die;
13036
13037       if (die->die_parent == NULL)
13038         {
13039           dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
13040           tree context;
13041
13042           if (origin)
13043             add_child_die (origin->die_parent, die);
13044           else if (die == comp_unit_die)
13045             ;
13046           /* If this was an expression for a bound involved in a function
13047              return type, it may be a SAVE_EXPR for which we weren't able
13048              to find a DIE previously.  So try now.  */
13049           else if (node->created_for
13050                    && TREE_CODE (node->created_for) == SAVE_EXPR
13051                    && 0 != (origin = (lookup_decl_die
13052                                       (SAVE_EXPR_CONTEXT
13053                                        (node->created_for)))))
13054             add_child_die (origin, die);
13055           else if (errorcount > 0 || sorrycount > 0)
13056             /* It's OK to be confused by errors in the input.  */
13057             add_child_die (comp_unit_die, die);
13058           else if (node->created_for
13059                    && ((DECL_P (node->created_for)
13060                         && (context = DECL_CONTEXT (node->created_for)))
13061                        || (TYPE_P (node->created_for)
13062                            && (context = TYPE_CONTEXT (node->created_for))))
13063                    && TREE_CODE (context) == FUNCTION_DECL)
13064             {
13065               /* In certain situations, the lexical block containing a
13066                  nested function can be optimized away, which results
13067                  in the nested function die being orphaned.  Likewise
13068                  with the return type of that nested function.  Force
13069                  this to be a child of the containing function.  */
13070               origin = lookup_decl_die (context);
13071               if (! origin)
13072                 abort ();
13073               add_child_die (origin, die);
13074             }
13075           else
13076             abort ();
13077         }
13078     }
13079
13080   limbo_die_list = NULL;
13081
13082   /* Walk through the list of incomplete types again, trying once more to
13083      emit full debugging info for them.  */
13084   retry_incomplete_types ();
13085
13086   /* We need to reverse all the dies before break_out_includes, or
13087      we'll see the end of an include file before the beginning.  */
13088   reverse_all_dies (comp_unit_die);
13089
13090   if (flag_eliminate_unused_debug_types)
13091     prune_unused_types ();
13092
13093   /* Generate separate CUs for each of the include files we've seen.
13094      They will go into limbo_die_list.  */
13095   if (flag_eliminate_dwarf2_dups)
13096     break_out_includes (comp_unit_die);
13097
13098   /* Traverse the DIE's and add add sibling attributes to those DIE's
13099      that have children.  */
13100   add_sibling_attributes (comp_unit_die);
13101   for (node = limbo_die_list; node; node = node->next)
13102     add_sibling_attributes (node->die);
13103
13104   /* Output a terminator label for the .text section.  */
13105   text_section ();
13106   (*targetm.asm_out.internal_label) (asm_out_file, TEXT_END_LABEL, 0);
13107
13108   /* Output the source line correspondence table.  We must do this
13109      even if there is no line information.  Otherwise, on an empty
13110      translation unit, we will generate a present, but empty,
13111      .debug_info section.  IRIX 6.5 `nm' will then complain when
13112      examining the file.  */
13113   if (! DWARF2_ASM_LINE_DEBUG_INFO)
13114     {
13115       named_section_flags (DEBUG_LINE_SECTION, SECTION_DEBUG);
13116       output_line_info ();
13117     }
13118
13119   /* Output location list section if necessary.  */
13120   if (have_location_lists)
13121     {
13122       /* Output the location lists info.  */
13123       named_section_flags (DEBUG_LOC_SECTION, SECTION_DEBUG);
13124       ASM_GENERATE_INTERNAL_LABEL (loc_section_label,
13125                                    DEBUG_LOC_SECTION_LABEL, 0);
13126       ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
13127       output_location_lists (die);
13128       have_location_lists = 0;
13129     }
13130
13131   /* We can only use the low/high_pc attributes if all of the code was
13132      in .text.  */
13133   if (separate_line_info_table_in_use == 0)
13134     {
13135       add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
13136       add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
13137     }
13138
13139   /* If it wasn't, we need to give .debug_loc and .debug_ranges an appropriate
13140      "base address".  Use zero so that these addresses become absolute.  */
13141   else if (have_location_lists || ranges_table_in_use)
13142     add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx);
13143
13144   if (debug_info_level >= DINFO_LEVEL_NORMAL)
13145     add_AT_lbl_offset (comp_unit_die, DW_AT_stmt_list,
13146                        debug_line_section_label);
13147
13148   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13149     add_AT_lbl_offset (comp_unit_die, DW_AT_macro_info, macinfo_section_label);
13150
13151   /* Output all of the compilation units.  We put the main one last so that
13152      the offsets are available to output_pubnames.  */
13153   for (node = limbo_die_list; node; node = node->next)
13154     output_comp_unit (node->die, 0);
13155
13156   output_comp_unit (comp_unit_die, 0);
13157
13158   /* Output the abbreviation table.  */
13159   named_section_flags (DEBUG_ABBREV_SECTION, SECTION_DEBUG);
13160   output_abbrev_section ();
13161
13162   /* Output public names table if necessary.  */
13163   if (pubname_table_in_use)
13164     {
13165       named_section_flags (DEBUG_PUBNAMES_SECTION, SECTION_DEBUG);
13166       output_pubnames ();
13167     }
13168
13169   /* Output the address range information.  We only put functions in the arange
13170      table, so don't write it out if we don't have any.  */
13171   if (fde_table_in_use)
13172     {
13173       named_section_flags (DEBUG_ARANGES_SECTION, SECTION_DEBUG);
13174       output_aranges ();
13175     }
13176
13177   /* Output ranges section if necessary.  */
13178   if (ranges_table_in_use)
13179     {
13180       named_section_flags (DEBUG_RANGES_SECTION, SECTION_DEBUG);
13181       ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
13182       output_ranges ();
13183     }
13184
13185   /* Have to end the primary source file.  */
13186   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13187     {
13188       named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
13189       dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
13190       dw2_asm_output_data (1, 0, "End compilation unit");
13191     }
13192
13193   /* If we emitted any DW_FORM_strp form attribute, output the string
13194      table too.  */
13195   if (debug_str_hash)
13196     htab_traverse (debug_str_hash, output_indirect_string, NULL);
13197 }
13198 #else
13199
13200 /* This should never be used, but its address is needed for comparisons.  */
13201 const struct gcc_debug_hooks dwarf2_debug_hooks;
13202
13203 #endif /* DWARF2_DEBUGGING_INFO */
13204
13205 #include "gt-dwarf2out.h"