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