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