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