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