OSDN Git Service

cfced5edf8efbc2f3ce41427552d6267931a1048
[pf3gnuchains/gcc-fork.git] / gcc / dwarf2out.c
1 /* Output Dwarf2 format symbol table information from GCC.
2    Copyright (C) 1992, 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3    2003 Free Software Foundation, Inc.
4    Contributed by Gary Funck (gary@intrepid.com).
5    Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
6    Extensively modified by Jason Merrill (jason@cygnus.com).
7
8 This file is part of GCC.
9
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 2, or (at your option) any later
13 version.
14
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
18 for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING.  If not, write to the Free
22 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
23 02111-1307, USA.  */
24
25 /* TODO: Emit .debug_line header even when there are no functions, since
26            the file numbers are used by .debug_info.  Alternately, leave
27            out locations for types and decls.
28          Avoid talking about ctors and op= for PODs.
29          Factor out common prologue sequences into multiple CIEs.  */
30
31 /* The first part of this file deals with the DWARF 2 frame unwind
32    information, which is also used by the GCC efficient exception handling
33    mechanism.  The second part, controlled only by an #ifdef
34    DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
35    information.  */
36
37 #include "config.h"
38 #include "system.h"
39 #include "coretypes.h"
40 #include "tm.h"
41 #include "tree.h"
42 #include "flags.h"
43 #include "real.h"
44 #include "rtl.h"
45 #include "hard-reg-set.h"
46 #include "regs.h"
47 #include "insn-config.h"
48 #include "reload.h"
49 #include "function.h"
50 #include "output.h"
51 #include "expr.h"
52 #include "libfuncs.h"
53 #include "except.h"
54 #include "dwarf2.h"
55 #include "dwarf2out.h"
56 #include "dwarf2asm.h"
57 #include "toplev.h"
58 #include "varray.h"
59 #include "ggc.h"
60 #include "md5.h"
61 #include "tm_p.h"
62 #include "diagnostic.h"
63 #include "debug.h"
64 #include "target.h"
65 #include "langhooks.h"
66 #include "hashtab.h"
67 #include "cgraph.h"
68
69 #ifdef DWARF2_DEBUGGING_INFO
70 static void dwarf2out_source_line (unsigned int, const char *);
71 #endif
72
73 /* DWARF2 Abbreviation Glossary:
74    CFA = Canonical Frame Address
75            a fixed address on the stack which identifies a call frame.
76            We define it to be the value of SP just before the call insn.
77            The CFA register and offset, which may change during the course
78            of the function, are used to calculate its value at runtime.
79    CFI = Call Frame Instruction
80            an instruction for the DWARF2 abstract machine
81    CIE = Common Information Entry
82            information describing information common to one or more FDEs
83    DIE = Debugging Information Entry
84    FDE = Frame Description Entry
85            information describing the stack call frame, in particular,
86            how to restore registers
87
88    DW_CFA_... = DWARF2 CFA call frame instruction
89    DW_TAG_... = DWARF2 DIE tag */
90
91 /* Decide whether we want to emit frame unwind information for the current
92    translation unit.  */
93
94 int
95 dwarf2out_do_frame (void)
96 {
97   return (write_symbols == DWARF2_DEBUG
98           || write_symbols == VMS_AND_DWARF2_DEBUG
99 #ifdef DWARF2_FRAME_INFO
100           || DWARF2_FRAME_INFO
101 #endif
102 #ifdef DWARF2_UNWIND_INFO
103           || flag_unwind_tables
104           || (flag_exceptions && ! USING_SJLJ_EXCEPTIONS)
105 #endif
106           );
107 }
108
109 /* The size of the target's pointer type.  */
110 #ifndef PTR_SIZE
111 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
112 #endif
113
114 /* Various versions of targetm.eh_frame_section.  Note these must appear
115    outside the DWARF2_DEBUGGING_INFO || DWARF2_UNWIND_INFO macro guards.  */
116
117 /* Version of targetm.eh_frame_section for systems with named sections.  */ 
118 void
119 named_section_eh_frame_section (void)
120 {
121 #ifdef EH_FRAME_SECTION_NAME
122 #ifdef HAVE_LD_RO_RW_SECTION_MIXING
123   int fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
124   int per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
125   int lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
126   int flags;
127
128   flags = (! flag_pic
129            || ((fde_encoding & 0x70) != DW_EH_PE_absptr
130                && (fde_encoding & 0x70) != DW_EH_PE_aligned
131                && (per_encoding & 0x70) != DW_EH_PE_absptr
132                && (per_encoding & 0x70) != DW_EH_PE_aligned
133                && (lsda_encoding & 0x70) != DW_EH_PE_absptr
134                && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
135           ? 0 : SECTION_WRITE;
136   named_section_flags (EH_FRAME_SECTION_NAME, flags);
137 #else
138   named_section_flags (EH_FRAME_SECTION_NAME, SECTION_WRITE);
139 #endif
140 #endif
141 }
142
143 /* Version of targetm.eh_frame_section for systems using collect2.  */ 
144 void
145 collect2_eh_frame_section (void)
146 {
147   tree label = get_file_function_name ('F');
148
149   data_section ();
150   ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
151   (*targetm.asm_out.globalize_label) (asm_out_file, IDENTIFIER_POINTER (label));
152   ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
153 }
154
155 /* Default version of targetm.eh_frame_section.  */
156 void
157 default_eh_frame_section (void)
158 {
159 #ifdef EH_FRAME_SECTION_NAME
160   named_section_eh_frame_section ();
161 #else
162   collect2_eh_frame_section ();
163 #endif
164 }
165
166 /* Array of RTXes referenced by the debugging information, which therefore
167    must be kept around forever.  */
168 static GTY(()) varray_type used_rtx_varray;
169
170 /* A pointer to the base of a list of incomplete types which might be
171    completed at some later time.  incomplete_types_list needs to be a VARRAY
172    because we want to tell the garbage collector about it.  */
173 static GTY(()) varray_type incomplete_types;
174
175 /* A pointer to the base of a table of references to declaration
176    scopes.  This table is a display which tracks the nesting
177    of declaration scopes at the current scope and containing
178    scopes.  This table is used to find the proper place to
179    define type declaration DIE's.  */
180 static GTY(()) varray_type decl_scope_table;
181
182 /* How to start an assembler comment.  */
183 #ifndef ASM_COMMENT_START
184 #define ASM_COMMENT_START ";#"
185 #endif
186
187 typedef struct dw_cfi_struct *dw_cfi_ref;
188 typedef struct dw_fde_struct *dw_fde_ref;
189 typedef union  dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
190
191 /* Call frames are described using a sequence of Call Frame
192    Information instructions.  The register number, offset
193    and address fields are provided as possible operands;
194    their use is selected by the opcode field.  */
195
196 enum dw_cfi_oprnd_type {
197   dw_cfi_oprnd_unused,
198   dw_cfi_oprnd_reg_num,
199   dw_cfi_oprnd_offset,
200   dw_cfi_oprnd_addr,
201   dw_cfi_oprnd_loc
202 };
203
204 typedef union dw_cfi_oprnd_struct GTY(())
205 {
206   unsigned long GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
207   HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
208   const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;
209   struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
210 }
211 dw_cfi_oprnd;
212
213 typedef struct dw_cfi_struct GTY(())
214 {
215   dw_cfi_ref dw_cfi_next;
216   enum dwarf_call_frame_info dw_cfi_opc;
217   dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
218     dw_cfi_oprnd1;
219   dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
220     dw_cfi_oprnd2;
221 }
222 dw_cfi_node;
223
224 /* This is how we define the location of the CFA. We use to handle it
225    as REG + OFFSET all the time,  but now it can be more complex.
226    It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
227    Instead of passing around REG and OFFSET, we pass a copy
228    of this structure.  */
229 typedef struct cfa_loc GTY(())
230 {
231   unsigned long reg;
232   HOST_WIDE_INT offset;
233   HOST_WIDE_INT base_offset;
234   int indirect;            /* 1 if CFA is accessed via a dereference.  */
235 } dw_cfa_location;
236
237 /* All call frame descriptions (FDE's) in the GCC generated DWARF
238    refer to a single Common Information Entry (CIE), defined at
239    the beginning of the .debug_frame section.  This use of a single
240    CIE obviates the need to keep track of multiple CIE's
241    in the DWARF generation routines below.  */
242
243 typedef struct dw_fde_struct GTY(())
244 {
245   const char *dw_fde_begin;
246   const char *dw_fde_current_label;
247   const char *dw_fde_end;
248   dw_cfi_ref dw_fde_cfi;
249   unsigned funcdef_number;
250   unsigned all_throwers_are_sibcalls : 1;
251   unsigned nothrow : 1;
252   unsigned uses_eh_lsda : 1;
253 }
254 dw_fde_node;
255
256 /* Maximum size (in bytes) of an artificially generated label.  */
257 #define MAX_ARTIFICIAL_LABEL_BYTES      30
258
259 /* The size of addresses as they appear in the Dwarf 2 data.
260    Some architectures use word addresses to refer to code locations,
261    but Dwarf 2 info always uses byte addresses.  On such machines,
262    Dwarf 2 addresses need to be larger than the architecture's
263    pointers.  */
264 #ifndef DWARF2_ADDR_SIZE
265 #define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
266 #endif
267
268 /* The size in bytes of a DWARF field indicating an offset or length
269    relative to a debug info section, specified to be 4 bytes in the
270    DWARF-2 specification.  The SGI/MIPS ABI defines it to be the same
271    as PTR_SIZE.  */
272
273 #ifndef DWARF_OFFSET_SIZE
274 #define DWARF_OFFSET_SIZE 4
275 #endif
276
277 /* According to the (draft) DWARF 3 specification, the initial length
278    should either be 4 or 12 bytes.  When it's 12 bytes, the first 4
279    bytes are 0xffffffff, followed by the length stored in the next 8
280    bytes.
281
282    However, the SGI/MIPS ABI uses an initial length which is equal to
283    DWARF_OFFSET_SIZE.  It is defined (elsewhere) accordingly.  */
284
285 #ifndef DWARF_INITIAL_LENGTH_SIZE
286 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
287 #endif
288
289 #define DWARF_VERSION 2
290
291 /* Round SIZE up to the nearest BOUNDARY.  */
292 #define DWARF_ROUND(SIZE,BOUNDARY) \
293   ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
294
295 /* Offsets recorded in opcodes are a multiple of this alignment factor.  */
296 #ifndef DWARF_CIE_DATA_ALIGNMENT
297 #ifdef STACK_GROWS_DOWNWARD
298 #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
299 #else
300 #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
301 #endif
302 #endif
303
304 /* A pointer to the base of a table that contains frame description
305    information for each routine.  */
306 static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table;
307
308 /* Number of elements currently allocated for fde_table.  */
309 static GTY(()) unsigned fde_table_allocated;
310
311 /* Number of elements in fde_table currently in use.  */
312 static GTY(()) unsigned fde_table_in_use;
313
314 /* Size (in elements) of increments by which we may expand the
315    fde_table.  */
316 #define FDE_TABLE_INCREMENT 256
317
318 /* A list of call frame insns for the CIE.  */
319 static GTY(()) dw_cfi_ref cie_cfi_head;
320
321 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
322 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
323    attribute that accelerates the lookup of the FDE associated
324    with the subprogram.  This variable holds the table index of the FDE
325    associated with the current function (body) definition.  */
326 static unsigned current_funcdef_fde;
327 #endif
328
329 struct indirect_string_node GTY(())
330 {
331   const char *str;
332   unsigned int refcount;
333   unsigned int form;
334   char *label;
335 };
336
337 static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;
338
339 static GTY(()) int dw2_string_counter;
340 static GTY(()) unsigned long dwarf2out_cfi_label_num;
341
342 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
343
344 /* Forward declarations for functions defined in this file.  */
345
346 static char *stripattributes (const char *);
347 static const char *dwarf_cfi_name (unsigned);
348 static dw_cfi_ref new_cfi (void);
349 static void add_cfi (dw_cfi_ref *, dw_cfi_ref);
350 static void add_fde_cfi (const char *, dw_cfi_ref);
351 static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *);
352 static void lookup_cfa (dw_cfa_location *);
353 static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT);
354 static void initial_return_save (rtx);
355 static HOST_WIDE_INT stack_adjust_offset (rtx);
356 static void output_cfi (dw_cfi_ref, dw_fde_ref, int);
357 static void output_call_frame_info (int);
358 static void dwarf2out_stack_adjust (rtx);
359 static void queue_reg_save (const char *, rtx, HOST_WIDE_INT);
360 static void flush_queued_reg_saves (void);
361 static bool clobbers_queued_reg_save (rtx);
362 static void dwarf2out_frame_debug_expr (rtx, const char *);
363
364 /* Support for complex CFA locations.  */
365 static void output_cfa_loc (dw_cfi_ref);
366 static void get_cfa_from_loc_descr (dw_cfa_location *,
367                                     struct dw_loc_descr_struct *);
368 static struct dw_loc_descr_struct *build_cfa_loc
369  (dw_cfa_location *);
370 static void def_cfa_1 (const char *, dw_cfa_location *);
371
372 /* How to start an assembler comment.  */
373 #ifndef ASM_COMMENT_START
374 #define ASM_COMMENT_START ";#"
375 #endif
376
377 /* Data and reference forms for relocatable data.  */
378 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
379 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
380
381 #ifndef DEBUG_FRAME_SECTION
382 #define DEBUG_FRAME_SECTION     ".debug_frame"
383 #endif
384
385 #ifndef FUNC_BEGIN_LABEL
386 #define FUNC_BEGIN_LABEL        "LFB"
387 #endif
388
389 #ifndef FUNC_END_LABEL
390 #define FUNC_END_LABEL          "LFE"
391 #endif
392
393 #define FRAME_BEGIN_LABEL       "Lframe"
394 #define CIE_AFTER_SIZE_LABEL    "LSCIE"
395 #define CIE_END_LABEL           "LECIE"
396 #define FDE_LABEL               "LSFDE"
397 #define FDE_AFTER_SIZE_LABEL    "LASFDE"
398 #define FDE_END_LABEL           "LEFDE"
399 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
400 #define LINE_NUMBER_END_LABEL   "LELT"
401 #define LN_PROLOG_AS_LABEL      "LASLTP"
402 #define LN_PROLOG_END_LABEL     "LELTP"
403 #define DIE_LABEL_PREFIX        "DW"
404
405 /* The DWARF 2 CFA column which tracks the return address.  Normally this
406    is the column for PC, or the first column after all of the hard
407    registers.  */
408 #ifndef DWARF_FRAME_RETURN_COLUMN
409 #ifdef PC_REGNUM
410 #define DWARF_FRAME_RETURN_COLUMN       DWARF_FRAME_REGNUM (PC_REGNUM)
411 #else
412 #define DWARF_FRAME_RETURN_COLUMN       DWARF_FRAME_REGISTERS
413 #endif
414 #endif
415
416 /* The mapping from gcc register number to DWARF 2 CFA column number.  By
417    default, we just provide columns for all registers.  */
418 #ifndef DWARF_FRAME_REGNUM
419 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
420 #endif
421
422 /* The offset from the incoming value of %sp to the top of the stack frame
423    for the current function.  */
424 #ifndef INCOMING_FRAME_SP_OFFSET
425 #define INCOMING_FRAME_SP_OFFSET 0
426 #endif
427 \f
428 /* Hook used by __throw.  */
429
430 rtx
431 expand_builtin_dwarf_sp_column (void)
432 {
433   return GEN_INT (DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
434 }
435
436 /* Return a pointer to a copy of the section string name S with all
437    attributes stripped off, and an asterisk prepended (for assemble_name).  */
438
439 static inline char *
440 stripattributes (const char *s)
441 {
442   char *stripped = xmalloc (strlen (s) + 2);
443   char *p = stripped;
444
445   *p++ = '*';
446
447   while (*s && *s != ',')
448     *p++ = *s++;
449
450   *p = '\0';
451   return stripped;
452 }
453
454 /* Generate code to initialize the register size table.  */
455
456 void
457 expand_builtin_init_dwarf_reg_sizes (tree address)
458 {
459   int i;
460   enum machine_mode mode = TYPE_MODE (char_type_node);
461   rtx addr = expand_expr (address, NULL_RTX, VOIDmode, 0);
462   rtx mem = gen_rtx_MEM (BLKmode, addr);
463   bool wrote_return_column = false;
464
465   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
466     if (DWARF_FRAME_REGNUM (i) < DWARF_FRAME_REGISTERS)
467       {
468         HOST_WIDE_INT offset = DWARF_FRAME_REGNUM (i) * GET_MODE_SIZE (mode);
469         enum machine_mode save_mode = reg_raw_mode[i];
470         HOST_WIDE_INT size;
471
472         if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode))
473           save_mode = choose_hard_reg_mode (i, 1, true);
474         if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
475           {
476             if (save_mode == VOIDmode)
477               continue;
478             wrote_return_column = true;
479           }
480         size = GET_MODE_SIZE (save_mode);
481         if (offset < 0)
482           continue;
483
484         emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size));
485       }
486
487 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
488   if (! wrote_return_column)
489     abort ();
490   i = DWARF_ALT_FRAME_RETURN_COLUMN;
491   wrote_return_column = false;
492 #else
493   i = DWARF_FRAME_RETURN_COLUMN;
494 #endif
495
496   if (! wrote_return_column)
497     {
498       enum machine_mode save_mode = Pmode;
499       HOST_WIDE_INT offset = i * GET_MODE_SIZE (mode);
500       HOST_WIDE_INT size = GET_MODE_SIZE (save_mode);
501       emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size));
502     }
503 }
504
505 /* Convert a DWARF call frame info. operation to its string name */
506
507 static const char *
508 dwarf_cfi_name (unsigned int cfi_opc)
509 {
510   switch (cfi_opc)
511     {
512     case DW_CFA_advance_loc:
513       return "DW_CFA_advance_loc";
514     case DW_CFA_offset:
515       return "DW_CFA_offset";
516     case DW_CFA_restore:
517       return "DW_CFA_restore";
518     case DW_CFA_nop:
519       return "DW_CFA_nop";
520     case DW_CFA_set_loc:
521       return "DW_CFA_set_loc";
522     case DW_CFA_advance_loc1:
523       return "DW_CFA_advance_loc1";
524     case DW_CFA_advance_loc2:
525       return "DW_CFA_advance_loc2";
526     case DW_CFA_advance_loc4:
527       return "DW_CFA_advance_loc4";
528     case DW_CFA_offset_extended:
529       return "DW_CFA_offset_extended";
530     case DW_CFA_restore_extended:
531       return "DW_CFA_restore_extended";
532     case DW_CFA_undefined:
533       return "DW_CFA_undefined";
534     case DW_CFA_same_value:
535       return "DW_CFA_same_value";
536     case DW_CFA_register:
537       return "DW_CFA_register";
538     case DW_CFA_remember_state:
539       return "DW_CFA_remember_state";
540     case DW_CFA_restore_state:
541       return "DW_CFA_restore_state";
542     case DW_CFA_def_cfa:
543       return "DW_CFA_def_cfa";
544     case DW_CFA_def_cfa_register:
545       return "DW_CFA_def_cfa_register";
546     case DW_CFA_def_cfa_offset:
547       return "DW_CFA_def_cfa_offset";
548
549     /* DWARF 3 */
550     case DW_CFA_def_cfa_expression:
551       return "DW_CFA_def_cfa_expression";
552     case DW_CFA_expression:
553       return "DW_CFA_expression";
554     case DW_CFA_offset_extended_sf:
555       return "DW_CFA_offset_extended_sf";
556     case DW_CFA_def_cfa_sf:
557       return "DW_CFA_def_cfa_sf";
558     case DW_CFA_def_cfa_offset_sf:
559       return "DW_CFA_def_cfa_offset_sf";
560
561     /* SGI/MIPS specific */
562     case DW_CFA_MIPS_advance_loc8:
563       return "DW_CFA_MIPS_advance_loc8";
564
565     /* GNU extensions */
566     case DW_CFA_GNU_window_save:
567       return "DW_CFA_GNU_window_save";
568     case DW_CFA_GNU_args_size:
569       return "DW_CFA_GNU_args_size";
570     case DW_CFA_GNU_negative_offset_extended:
571       return "DW_CFA_GNU_negative_offset_extended";
572
573     default:
574       return "DW_CFA_<unknown>";
575     }
576 }
577
578 /* Return a pointer to a newly allocated Call Frame Instruction.  */
579
580 static inline dw_cfi_ref
581 new_cfi (void)
582 {
583   dw_cfi_ref cfi = ggc_alloc (sizeof (dw_cfi_node));
584
585   cfi->dw_cfi_next = NULL;
586   cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
587   cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
588
589   return cfi;
590 }
591
592 /* Add a Call Frame Instruction to list of instructions.  */
593
594 static inline void
595 add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi)
596 {
597   dw_cfi_ref *p;
598
599   /* Find the end of the chain.  */
600   for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
601     ;
602
603   *p = cfi;
604 }
605
606 /* Generate a new label for the CFI info to refer to.  */
607
608 char *
609 dwarf2out_cfi_label (void)
610 {
611   static char label[20];
612
613   ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", dwarf2out_cfi_label_num++);
614   ASM_OUTPUT_LABEL (asm_out_file, label);
615   return label;
616 }
617
618 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
619    or to the CIE if LABEL is NULL.  */
620
621 static void
622 add_fde_cfi (const char *label, dw_cfi_ref cfi)
623 {
624   if (label)
625     {
626       dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
627
628       if (*label == 0)
629         label = dwarf2out_cfi_label ();
630
631       if (fde->dw_fde_current_label == NULL
632           || strcmp (label, fde->dw_fde_current_label) != 0)
633         {
634           dw_cfi_ref xcfi;
635
636           fde->dw_fde_current_label = label = xstrdup (label);
637
638           /* Set the location counter to the new label.  */
639           xcfi = new_cfi ();
640           xcfi->dw_cfi_opc = DW_CFA_advance_loc4;
641           xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
642           add_cfi (&fde->dw_fde_cfi, xcfi);
643         }
644
645       add_cfi (&fde->dw_fde_cfi, cfi);
646     }
647
648   else
649     add_cfi (&cie_cfi_head, cfi);
650 }
651
652 /* Subroutine of lookup_cfa.  */
653
654 static inline void
655 lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc)
656 {
657   switch (cfi->dw_cfi_opc)
658     {
659     case DW_CFA_def_cfa_offset:
660       loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset;
661       break;
662     case DW_CFA_def_cfa_register:
663       loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
664       break;
665     case DW_CFA_def_cfa:
666       loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
667       loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset;
668       break;
669     case DW_CFA_def_cfa_expression:
670       get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc);
671       break;
672     default:
673       break;
674     }
675 }
676
677 /* Find the previous value for the CFA.  */
678
679 static void
680 lookup_cfa (dw_cfa_location *loc)
681 {
682   dw_cfi_ref cfi;
683
684   loc->reg = (unsigned long) -1;
685   loc->offset = 0;
686   loc->indirect = 0;
687   loc->base_offset = 0;
688
689   for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
690     lookup_cfa_1 (cfi, loc);
691
692   if (fde_table_in_use)
693     {
694       dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
695       for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
696         lookup_cfa_1 (cfi, loc);
697     }
698 }
699
700 /* The current rule for calculating the DWARF2 canonical frame address.  */
701 static dw_cfa_location cfa;
702
703 /* The register used for saving registers to the stack, and its offset
704    from the CFA.  */
705 static dw_cfa_location cfa_store;
706
707 /* The running total of the size of arguments pushed onto the stack.  */
708 static HOST_WIDE_INT args_size;
709
710 /* The last args_size we actually output.  */
711 static HOST_WIDE_INT old_args_size;
712
713 /* Entry point to update the canonical frame address (CFA).
714    LABEL is passed to add_fde_cfi.  The value of CFA is now to be
715    calculated from REG+OFFSET.  */
716
717 void
718 dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset)
719 {
720   dw_cfa_location loc;
721   loc.indirect = 0;
722   loc.base_offset = 0;
723   loc.reg = reg;
724   loc.offset = offset;
725   def_cfa_1 (label, &loc);
726 }
727
728 /* This routine does the actual work.  The CFA is now calculated from
729    the dw_cfa_location structure.  */
730
731 static void
732 def_cfa_1 (const char *label, dw_cfa_location *loc_p)
733 {
734   dw_cfi_ref cfi;
735   dw_cfa_location old_cfa, loc;
736
737   cfa = *loc_p;
738   loc = *loc_p;
739
740   if (cfa_store.reg == loc.reg && loc.indirect == 0)
741     cfa_store.offset = loc.offset;
742
743   loc.reg = DWARF_FRAME_REGNUM (loc.reg);
744   lookup_cfa (&old_cfa);
745
746   /* If nothing changed, no need to issue any call frame instructions.  */
747   if (loc.reg == old_cfa.reg && loc.offset == old_cfa.offset
748       && loc.indirect == old_cfa.indirect
749       && (loc.indirect == 0 || loc.base_offset == old_cfa.base_offset))
750     return;
751
752   cfi = new_cfi ();
753
754   if (loc.reg == old_cfa.reg && !loc.indirect)
755     {
756       /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction,
757          indicating the CFA register did not change but the offset
758          did.  */
759       cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
760       cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset;
761     }
762
763 #ifndef MIPS_DEBUGGING_INFO  /* SGI dbx thinks this means no offset.  */
764   else if (loc.offset == old_cfa.offset && old_cfa.reg != (unsigned long) -1
765            && !loc.indirect)
766     {
767       /* Construct a "DW_CFA_def_cfa_register <register>" instruction,
768          indicating the CFA register has changed to <register> but the
769          offset has not changed.  */
770       cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
771       cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
772     }
773 #endif
774
775   else if (loc.indirect == 0)
776     {
777       /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
778          indicating the CFA register has changed to <register> with
779          the specified offset.  */
780       cfi->dw_cfi_opc = DW_CFA_def_cfa;
781       cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
782       cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset;
783     }
784   else
785     {
786       /* Construct a DW_CFA_def_cfa_expression instruction to
787          calculate the CFA using a full location expression since no
788          register-offset pair is available.  */
789       struct dw_loc_descr_struct *loc_list;
790
791       cfi->dw_cfi_opc = DW_CFA_def_cfa_expression;
792       loc_list = build_cfa_loc (&loc);
793       cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list;
794     }
795
796   add_fde_cfi (label, cfi);
797 }
798
799 /* Add the CFI for saving a register.  REG is the CFA column number.
800    LABEL is passed to add_fde_cfi.
801    If SREG is -1, the register is saved at OFFSET from the CFA;
802    otherwise it is saved in SREG.  */
803
804 static void
805 reg_save (const char *label, unsigned int reg, unsigned int sreg, HOST_WIDE_INT offset)
806 {
807   dw_cfi_ref cfi = new_cfi ();
808
809   cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
810
811   /* The following comparison is correct. -1 is used to indicate that
812      the value isn't a register number.  */
813   if (sreg == (unsigned int) -1)
814     {
815       if (reg & ~0x3f)
816         /* The register number won't fit in 6 bits, so we have to use
817            the long form.  */
818         cfi->dw_cfi_opc = DW_CFA_offset_extended;
819       else
820         cfi->dw_cfi_opc = DW_CFA_offset;
821
822 #ifdef ENABLE_CHECKING
823       {
824         /* If we get an offset that is not a multiple of
825            DWARF_CIE_DATA_ALIGNMENT, there is either a bug in the
826            definition of DWARF_CIE_DATA_ALIGNMENT, or a bug in the machine
827            description.  */
828         HOST_WIDE_INT check_offset = offset / DWARF_CIE_DATA_ALIGNMENT;
829
830         if (check_offset * DWARF_CIE_DATA_ALIGNMENT != offset)
831           abort ();
832       }
833 #endif
834       offset /= DWARF_CIE_DATA_ALIGNMENT;
835       if (offset < 0)
836         cfi->dw_cfi_opc = DW_CFA_offset_extended_sf;
837
838       cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
839     }
840   else if (sreg == reg)
841     /* We could emit a DW_CFA_same_value in this case, but don't bother.  */
842     return;
843   else
844     {
845       cfi->dw_cfi_opc = DW_CFA_register;
846       cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
847     }
848
849   add_fde_cfi (label, cfi);
850 }
851
852 /* Add the CFI for saving a register window.  LABEL is passed to reg_save.
853    This CFI tells the unwinder that it needs to restore the window registers
854    from the previous frame's window save area.
855
856    ??? Perhaps we should note in the CIE where windows are saved (instead of
857    assuming 0(cfa)) and what registers are in the window.  */
858
859 void
860 dwarf2out_window_save (const char *label)
861 {
862   dw_cfi_ref cfi = new_cfi ();
863
864   cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
865   add_fde_cfi (label, cfi);
866 }
867
868 /* Add a CFI to update the running total of the size of arguments
869    pushed onto the stack.  */
870
871 void
872 dwarf2out_args_size (const char *label, HOST_WIDE_INT size)
873 {
874   dw_cfi_ref cfi;
875
876   if (size == old_args_size)
877     return;
878
879   old_args_size = size;
880
881   cfi = new_cfi ();
882   cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
883   cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
884   add_fde_cfi (label, cfi);
885 }
886
887 /* Entry point for saving a register to the stack.  REG is the GCC register
888    number.  LABEL and OFFSET are passed to reg_save.  */
889
890 void
891 dwarf2out_reg_save (const char *label, unsigned int reg, HOST_WIDE_INT offset)
892 {
893   reg_save (label, DWARF_FRAME_REGNUM (reg), -1, offset);
894 }
895
896 /* Entry point for saving the return address in the stack.
897    LABEL and OFFSET are passed to reg_save.  */
898
899 void
900 dwarf2out_return_save (const char *label, HOST_WIDE_INT offset)
901 {
902   reg_save (label, DWARF_FRAME_RETURN_COLUMN, -1, offset);
903 }
904
905 /* Entry point for saving the return address in a register.
906    LABEL and SREG are passed to reg_save.  */
907
908 void
909 dwarf2out_return_reg (const char *label, unsigned int sreg)
910 {
911   reg_save (label, DWARF_FRAME_RETURN_COLUMN, sreg, 0);
912 }
913
914 /* Record the initial position of the return address.  RTL is
915    INCOMING_RETURN_ADDR_RTX.  */
916
917 static void
918 initial_return_save (rtx rtl)
919 {
920   unsigned int reg = (unsigned int) -1;
921   HOST_WIDE_INT offset = 0;
922
923   switch (GET_CODE (rtl))
924     {
925     case REG:
926       /* RA is in a register.  */
927       reg = DWARF_FRAME_REGNUM (REGNO (rtl));
928       break;
929
930     case MEM:
931       /* RA is on the stack.  */
932       rtl = XEXP (rtl, 0);
933       switch (GET_CODE (rtl))
934         {
935         case REG:
936           if (REGNO (rtl) != STACK_POINTER_REGNUM)
937             abort ();
938           offset = 0;
939           break;
940
941         case PLUS:
942           if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM)
943             abort ();
944           offset = INTVAL (XEXP (rtl, 1));
945           break;
946
947         case MINUS:
948           if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM)
949             abort ();
950           offset = -INTVAL (XEXP (rtl, 1));
951           break;
952
953         default:
954           abort ();
955         }
956
957       break;
958
959     case PLUS:
960       /* The return address is at some offset from any value we can
961          actually load.  For instance, on the SPARC it is in %i7+8. Just
962          ignore the offset for now; it doesn't matter for unwinding frames.  */
963       if (GET_CODE (XEXP (rtl, 1)) != CONST_INT)
964         abort ();
965       initial_return_save (XEXP (rtl, 0));
966       return;
967
968     default:
969       abort ();
970     }
971
972   reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset);
973 }
974
975 /* Given a SET, calculate the amount of stack adjustment it
976    contains.  */
977
978 static HOST_WIDE_INT
979 stack_adjust_offset (rtx pattern)
980 {
981   rtx src = SET_SRC (pattern);
982   rtx dest = SET_DEST (pattern);
983   HOST_WIDE_INT offset = 0;
984   enum rtx_code code;
985
986   if (dest == stack_pointer_rtx)
987     {
988       /* (set (reg sp) (plus (reg sp) (const_int))) */
989       code = GET_CODE (src);
990       if (! (code == PLUS || code == MINUS)
991           || XEXP (src, 0) != stack_pointer_rtx
992           || GET_CODE (XEXP (src, 1)) != CONST_INT)
993         return 0;
994
995       offset = INTVAL (XEXP (src, 1));
996       if (code == PLUS)
997         offset = -offset;
998     }
999   else if (GET_CODE (dest) == MEM)
1000     {
1001       /* (set (mem (pre_dec (reg sp))) (foo)) */
1002       src = XEXP (dest, 0);
1003       code = GET_CODE (src);
1004
1005       switch (code)
1006         {
1007         case PRE_MODIFY:
1008         case POST_MODIFY:
1009           if (XEXP (src, 0) == stack_pointer_rtx)
1010             {
1011               rtx val = XEXP (XEXP (src, 1), 1);
1012               /* We handle only adjustments by constant amount.  */
1013               if (GET_CODE (XEXP (src, 1)) != PLUS ||
1014                   GET_CODE (val) != CONST_INT)
1015                 abort ();
1016               offset = -INTVAL (val);
1017               break;
1018             }
1019           return 0;
1020
1021         case PRE_DEC:
1022         case POST_DEC:
1023           if (XEXP (src, 0) == stack_pointer_rtx)
1024             {
1025               offset = GET_MODE_SIZE (GET_MODE (dest));
1026               break;
1027             }
1028           return 0;
1029
1030         case PRE_INC:
1031         case POST_INC:
1032           if (XEXP (src, 0) == stack_pointer_rtx)
1033             {
1034               offset = -GET_MODE_SIZE (GET_MODE (dest));
1035               break;
1036             }
1037           return 0;
1038
1039         default:
1040           return 0;
1041         }
1042     }
1043   else
1044     return 0;
1045
1046   return offset;
1047 }
1048
1049 /* Check INSN to see if it looks like a push or a stack adjustment, and
1050    make a note of it if it does.  EH uses this information to find out how
1051    much extra space it needs to pop off the stack.  */
1052
1053 static void
1054 dwarf2out_stack_adjust (rtx insn)
1055 {
1056   HOST_WIDE_INT offset;
1057   const char *label;
1058   int i;
1059
1060   if (!flag_asynchronous_unwind_tables && GET_CODE (insn) == CALL_INSN)
1061     {
1062       /* Extract the size of the args from the CALL rtx itself.  */
1063       insn = PATTERN (insn);
1064       if (GET_CODE (insn) == PARALLEL)
1065         insn = XVECEXP (insn, 0, 0);
1066       if (GET_CODE (insn) == SET)
1067         insn = SET_SRC (insn);
1068       if (GET_CODE (insn) != CALL)
1069         abort ();
1070
1071       dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1072       return;
1073     }
1074
1075   /* If only calls can throw, and we have a frame pointer,
1076      save up adjustments until we see the CALL_INSN.  */
1077   else if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM)
1078     return;
1079
1080   if (GET_CODE (insn) == BARRIER)
1081     {
1082       /* When we see a BARRIER, we know to reset args_size to 0.  Usually
1083          the compiler will have already emitted a stack adjustment, but
1084          doesn't bother for calls to noreturn functions.  */
1085 #ifdef STACK_GROWS_DOWNWARD
1086       offset = -args_size;
1087 #else
1088       offset = args_size;
1089 #endif
1090     }
1091   else if (GET_CODE (PATTERN (insn)) == SET)
1092     offset = stack_adjust_offset (PATTERN (insn));
1093   else if (GET_CODE (PATTERN (insn)) == PARALLEL
1094            || GET_CODE (PATTERN (insn)) == SEQUENCE)
1095     {
1096       /* There may be stack adjustments inside compound insns.  Search
1097          for them.  */
1098       for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1099         if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1100           offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i));
1101     }
1102   else
1103     return;
1104
1105   if (offset == 0)
1106     return;
1107
1108   if (cfa.reg == STACK_POINTER_REGNUM)
1109     cfa.offset += offset;
1110
1111 #ifndef STACK_GROWS_DOWNWARD
1112   offset = -offset;
1113 #endif
1114
1115   args_size += offset;
1116   if (args_size < 0)
1117     args_size = 0;
1118
1119   label = dwarf2out_cfi_label ();
1120   def_cfa_1 (label, &cfa);
1121   dwarf2out_args_size (label, args_size);
1122 }
1123
1124 #endif
1125
1126 /* We delay emitting a register save until either (a) we reach the end
1127    of the prologue or (b) the register is clobbered.  This clusters
1128    register saves so that there are fewer pc advances.  */
1129
1130 struct queued_reg_save GTY(())
1131 {
1132   struct queued_reg_save *next;
1133   rtx reg;
1134   HOST_WIDE_INT cfa_offset;
1135 };
1136
1137 static GTY(()) struct queued_reg_save *queued_reg_saves;
1138
1139 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1140 static const char *last_reg_save_label;
1141
1142 static void
1143 queue_reg_save (const char *label, rtx reg, HOST_WIDE_INT offset)
1144 {
1145   struct queued_reg_save *q = ggc_alloc (sizeof (*q));
1146
1147   q->next = queued_reg_saves;
1148   q->reg = reg;
1149   q->cfa_offset = offset;
1150   queued_reg_saves = q;
1151
1152   last_reg_save_label = label;
1153 }
1154
1155 static void
1156 flush_queued_reg_saves (void)
1157 {
1158   struct queued_reg_save *q, *next;
1159
1160   for (q = queued_reg_saves; q; q = next)
1161     {
1162       dwarf2out_reg_save (last_reg_save_label, REGNO (q->reg), q->cfa_offset);
1163       next = q->next;
1164     }
1165
1166   queued_reg_saves = NULL;
1167   last_reg_save_label = NULL;
1168 }
1169
1170 static bool
1171 clobbers_queued_reg_save (rtx insn)
1172 {
1173   struct queued_reg_save *q;
1174
1175   for (q = queued_reg_saves; q; q = q->next)
1176     if (modified_in_p (q->reg, insn))
1177       return true;
1178
1179   return false;
1180 }
1181
1182
1183 /* A temporary register holding an integral value used in adjusting SP
1184    or setting up the store_reg.  The "offset" field holds the integer
1185    value, not an offset.  */
1186 static dw_cfa_location cfa_temp;
1187
1188 /* Record call frame debugging information for an expression EXPR,
1189    which either sets SP or FP (adjusting how we calculate the frame
1190    address) or saves a register to the stack.  LABEL indicates the
1191    address of EXPR.
1192
1193    This function encodes a state machine mapping rtxes to actions on
1194    cfa, cfa_store, and cfa_temp.reg.  We describe these rules so
1195    users need not read the source code.
1196
1197   The High-Level Picture
1198
1199   Changes in the register we use to calculate the CFA: Currently we
1200   assume that if you copy the CFA register into another register, we
1201   should take the other one as the new CFA register; this seems to
1202   work pretty well.  If it's wrong for some target, it's simple
1203   enough not to set RTX_FRAME_RELATED_P on the insn in question.
1204
1205   Changes in the register we use for saving registers to the stack:
1206   This is usually SP, but not always.  Again, we deduce that if you
1207   copy SP into another register (and SP is not the CFA register),
1208   then the new register is the one we will be using for register
1209   saves.  This also seems to work.
1210
1211   Register saves: There's not much guesswork about this one; if
1212   RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
1213   register save, and the register used to calculate the destination
1214   had better be the one we think we're using for this purpose.
1215
1216   Except: If the register being saved is the CFA register, and the
1217   offset is nonzero, we are saving the CFA, so we assume we have to
1218   use DW_CFA_def_cfa_expression.  If the offset is 0, we assume that
1219   the intent is to save the value of SP from the previous frame.
1220
1221   Invariants / Summaries of Rules
1222
1223   cfa          current rule for calculating the CFA.  It usually
1224                consists of a register and an offset.
1225   cfa_store    register used by prologue code to save things to the stack
1226                cfa_store.offset is the offset from the value of
1227                cfa_store.reg to the actual CFA
1228   cfa_temp     register holding an integral value.  cfa_temp.offset
1229                stores the value, which will be used to adjust the
1230                stack pointer.  cfa_temp is also used like cfa_store,
1231                to track stores to the stack via fp or a temp reg.
1232
1233   Rules  1- 4: Setting a register's value to cfa.reg or an expression
1234                with cfa.reg as the first operand changes the cfa.reg and its
1235                cfa.offset.  Rule 1 and 4 also set cfa_temp.reg and
1236                cfa_temp.offset.
1237
1238   Rules  6- 9: Set a non-cfa.reg register value to a constant or an
1239                expression yielding a constant.  This sets cfa_temp.reg
1240                and cfa_temp.offset.
1241
1242   Rule 5:      Create a new register cfa_store used to save items to the
1243                stack.
1244
1245   Rules 10-14: Save a register to the stack.  Define offset as the
1246                difference of the original location and cfa_store's
1247                location (or cfa_temp's location if cfa_temp is used).
1248
1249   The Rules
1250
1251   "{a,b}" indicates a choice of a xor b.
1252   "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.
1253
1254   Rule 1:
1255   (set <reg1> <reg2>:cfa.reg)
1256   effects: cfa.reg = <reg1>
1257            cfa.offset unchanged
1258            cfa_temp.reg = <reg1>
1259            cfa_temp.offset = cfa.offset
1260
1261   Rule 2:
1262   (set sp ({minus,plus,losum} {sp,fp}:cfa.reg
1263                               {<const_int>,<reg>:cfa_temp.reg}))
1264   effects: cfa.reg = sp if fp used
1265            cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
1266            cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
1267              if cfa_store.reg==sp
1268
1269   Rule 3:
1270   (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
1271   effects: cfa.reg = fp
1272            cfa_offset += +/- <const_int>
1273
1274   Rule 4:
1275   (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
1276   constraints: <reg1> != fp
1277                <reg1> != sp
1278   effects: cfa.reg = <reg1>
1279            cfa_temp.reg = <reg1>
1280            cfa_temp.offset = cfa.offset
1281
1282   Rule 5:
1283   (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
1284   constraints: <reg1> != fp
1285                <reg1> != sp
1286   effects: cfa_store.reg = <reg1>
1287            cfa_store.offset = cfa.offset - cfa_temp.offset
1288
1289   Rule 6:
1290   (set <reg> <const_int>)
1291   effects: cfa_temp.reg = <reg>
1292            cfa_temp.offset = <const_int>
1293
1294   Rule 7:
1295   (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
1296   effects: cfa_temp.reg = <reg1>
1297            cfa_temp.offset |= <const_int>
1298
1299   Rule 8:
1300   (set <reg> (high <exp>))
1301   effects: none
1302
1303   Rule 9:
1304   (set <reg> (lo_sum <exp> <const_int>))
1305   effects: cfa_temp.reg = <reg>
1306            cfa_temp.offset = <const_int>
1307
1308   Rule 10:
1309   (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
1310   effects: cfa_store.offset -= <const_int>
1311            cfa.offset = cfa_store.offset if cfa.reg == sp
1312            cfa.reg = sp
1313            cfa.base_offset = -cfa_store.offset
1314
1315   Rule 11:
1316   (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>)
1317   effects: cfa_store.offset += -/+ mode_size(mem)
1318            cfa.offset = cfa_store.offset if cfa.reg == sp
1319            cfa.reg = sp
1320            cfa.base_offset = -cfa_store.offset
1321
1322   Rule 12:
1323   (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))
1324
1325        <reg2>)
1326   effects: cfa.reg = <reg1>
1327            cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
1328
1329   Rule 13:
1330   (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
1331   effects: cfa.reg = <reg1>
1332            cfa.base_offset = -{cfa_store,cfa_temp}.offset
1333
1334   Rule 14:
1335   (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>)
1336   effects: cfa.reg = <reg1>
1337            cfa.base_offset = -cfa_temp.offset
1338            cfa_temp.offset -= mode_size(mem)  */
1339
1340 static void
1341 dwarf2out_frame_debug_expr (rtx expr, const char *label)
1342 {
1343   rtx src, dest;
1344   HOST_WIDE_INT offset;
1345
1346   /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
1347      the PARALLEL independently. The first element is always processed if
1348      it is a SET. This is for backward compatibility.   Other elements
1349      are processed only if they are SETs and the RTX_FRAME_RELATED_P
1350      flag is set in them.  */
1351   if (GET_CODE (expr) == PARALLEL || GET_CODE (expr) == SEQUENCE)
1352     {
1353       int par_index;
1354       int limit = XVECLEN (expr, 0);
1355
1356       for (par_index = 0; par_index < limit; par_index++)
1357         if (GET_CODE (XVECEXP (expr, 0, par_index)) == SET
1358             && (RTX_FRAME_RELATED_P (XVECEXP (expr, 0, par_index))
1359                 || par_index == 0))
1360           dwarf2out_frame_debug_expr (XVECEXP (expr, 0, par_index), label);
1361
1362       return;
1363     }
1364
1365   if (GET_CODE (expr) != SET)
1366     abort ();
1367
1368   src = SET_SRC (expr);
1369   dest = SET_DEST (expr);
1370
1371   switch (GET_CODE (dest))
1372     {
1373     case REG:
1374       /* Rule 1 */
1375       /* Update the CFA rule wrt SP or FP.  Make sure src is
1376          relative to the current CFA register.  */
1377       switch (GET_CODE (src))
1378         {
1379           /* Setting FP from SP.  */
1380         case REG:
1381           if (cfa.reg == (unsigned) REGNO (src))
1382             /* OK.  */
1383             ;
1384           else
1385             abort ();
1386
1387           /* We used to require that dest be either SP or FP, but the
1388              ARM copies SP to a temporary register, and from there to
1389              FP.  So we just rely on the backends to only set
1390              RTX_FRAME_RELATED_P on appropriate insns.  */
1391           cfa.reg = REGNO (dest);
1392           cfa_temp.reg = cfa.reg;
1393           cfa_temp.offset = cfa.offset;
1394           break;
1395
1396         case PLUS:
1397         case MINUS:
1398         case LO_SUM:
1399           if (dest == stack_pointer_rtx)
1400             {
1401               /* Rule 2 */
1402               /* Adjusting SP.  */
1403               switch (GET_CODE (XEXP (src, 1)))
1404                 {
1405                 case CONST_INT:
1406                   offset = INTVAL (XEXP (src, 1));
1407                   break;
1408                 case REG:
1409                   if ((unsigned) REGNO (XEXP (src, 1)) != cfa_temp.reg)
1410                     abort ();
1411                   offset = cfa_temp.offset;
1412                   break;
1413                 default:
1414                   abort ();
1415                 }
1416
1417               if (XEXP (src, 0) == hard_frame_pointer_rtx)
1418                 {
1419                   /* Restoring SP from FP in the epilogue.  */
1420                   if (cfa.reg != (unsigned) HARD_FRAME_POINTER_REGNUM)
1421                     abort ();
1422                   cfa.reg = STACK_POINTER_REGNUM;
1423                 }
1424               else if (GET_CODE (src) == LO_SUM)
1425                 /* Assume we've set the source reg of the LO_SUM from sp.  */
1426                 ;
1427               else if (XEXP (src, 0) != stack_pointer_rtx)
1428                 abort ();
1429
1430               if (GET_CODE (src) != MINUS)
1431                 offset = -offset;
1432               if (cfa.reg == STACK_POINTER_REGNUM)
1433                 cfa.offset += offset;
1434               if (cfa_store.reg == STACK_POINTER_REGNUM)
1435                 cfa_store.offset += offset;
1436             }
1437           else if (dest == hard_frame_pointer_rtx)
1438             {
1439               /* Rule 3 */
1440               /* Either setting the FP from an offset of the SP,
1441                  or adjusting the FP */
1442               if (! frame_pointer_needed)
1443                 abort ();
1444
1445               if (GET_CODE (XEXP (src, 0)) == REG
1446                   && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg
1447                   && GET_CODE (XEXP (src, 1)) == CONST_INT)
1448                 {
1449                   offset = INTVAL (XEXP (src, 1));
1450                   if (GET_CODE (src) != MINUS)
1451                     offset = -offset;
1452                   cfa.offset += offset;
1453                   cfa.reg = HARD_FRAME_POINTER_REGNUM;
1454                 }
1455               else
1456                 abort ();
1457             }
1458           else
1459             {
1460               if (GET_CODE (src) == MINUS)
1461                 abort ();
1462
1463               /* Rule 4 */
1464               if (GET_CODE (XEXP (src, 0)) == REG
1465                   && REGNO (XEXP (src, 0)) == cfa.reg
1466                   && GET_CODE (XEXP (src, 1)) == CONST_INT)
1467                 {
1468                   /* Setting a temporary CFA register that will be copied
1469                      into the FP later on.  */
1470                   offset = - INTVAL (XEXP (src, 1));
1471                   cfa.offset += offset;
1472                   cfa.reg = REGNO (dest);
1473                   /* Or used to save regs to the stack.  */
1474                   cfa_temp.reg = cfa.reg;
1475                   cfa_temp.offset = cfa.offset;
1476                 }
1477
1478               /* Rule 5 */
1479               else if (GET_CODE (XEXP (src, 0)) == REG
1480                        && REGNO (XEXP (src, 0)) == cfa_temp.reg
1481                        && XEXP (src, 1) == stack_pointer_rtx)
1482                 {
1483                   /* Setting a scratch register that we will use instead
1484                      of SP for saving registers to the stack.  */
1485                   if (cfa.reg != STACK_POINTER_REGNUM)
1486                     abort ();
1487                   cfa_store.reg = REGNO (dest);
1488                   cfa_store.offset = cfa.offset - cfa_temp.offset;
1489                 }
1490
1491               /* Rule 9 */
1492               else if (GET_CODE (src) == LO_SUM
1493                        && GET_CODE (XEXP (src, 1)) == CONST_INT)
1494                 {
1495                   cfa_temp.reg = REGNO (dest);
1496                   cfa_temp.offset = INTVAL (XEXP (src, 1));
1497                 }
1498               else
1499                 abort ();
1500             }
1501           break;
1502
1503           /* Rule 6 */
1504         case CONST_INT:
1505           cfa_temp.reg = REGNO (dest);
1506           cfa_temp.offset = INTVAL (src);
1507           break;
1508
1509           /* Rule 7 */
1510         case IOR:
1511           if (GET_CODE (XEXP (src, 0)) != REG
1512               || (unsigned) REGNO (XEXP (src, 0)) != cfa_temp.reg
1513               || GET_CODE (XEXP (src, 1)) != CONST_INT)
1514             abort ();
1515
1516           if ((unsigned) REGNO (dest) != cfa_temp.reg)
1517             cfa_temp.reg = REGNO (dest);
1518           cfa_temp.offset |= INTVAL (XEXP (src, 1));
1519           break;
1520
1521           /* Skip over HIGH, assuming it will be followed by a LO_SUM,
1522              which will fill in all of the bits.  */
1523           /* Rule 8 */
1524         case HIGH:
1525           break;
1526
1527         default:
1528           abort ();
1529         }
1530
1531       def_cfa_1 (label, &cfa);
1532       break;
1533
1534     case MEM:
1535       if (GET_CODE (src) != REG)
1536         abort ();
1537
1538       /* Saving a register to the stack.  Make sure dest is relative to the
1539          CFA register.  */
1540       switch (GET_CODE (XEXP (dest, 0)))
1541         {
1542           /* Rule 10 */
1543           /* With a push.  */
1544         case PRE_MODIFY:
1545           /* We can't handle variable size modifications.  */
1546           if (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1)) != CONST_INT)
1547             abort ();
1548           offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1));
1549
1550           if (REGNO (XEXP (XEXP (dest, 0), 0)) != STACK_POINTER_REGNUM
1551               || cfa_store.reg != STACK_POINTER_REGNUM)
1552             abort ();
1553
1554           cfa_store.offset += offset;
1555           if (cfa.reg == STACK_POINTER_REGNUM)
1556             cfa.offset = cfa_store.offset;
1557
1558           offset = -cfa_store.offset;
1559           break;
1560
1561           /* Rule 11 */
1562         case PRE_INC:
1563         case PRE_DEC:
1564           offset = GET_MODE_SIZE (GET_MODE (dest));
1565           if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
1566             offset = -offset;
1567
1568           if (REGNO (XEXP (XEXP (dest, 0), 0)) != STACK_POINTER_REGNUM
1569               || cfa_store.reg != STACK_POINTER_REGNUM)
1570             abort ();
1571
1572           cfa_store.offset += offset;
1573           if (cfa.reg == STACK_POINTER_REGNUM)
1574             cfa.offset = cfa_store.offset;
1575
1576           offset = -cfa_store.offset;
1577           break;
1578
1579           /* Rule 12 */
1580           /* With an offset.  */
1581         case PLUS:
1582         case MINUS:
1583         case LO_SUM:
1584           if (GET_CODE (XEXP (XEXP (dest, 0), 1)) != CONST_INT)
1585             abort ();
1586           offset = INTVAL (XEXP (XEXP (dest, 0), 1));
1587           if (GET_CODE (XEXP (dest, 0)) == MINUS)
1588             offset = -offset;
1589
1590           if (cfa_store.reg == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)))
1591             offset -= cfa_store.offset;
1592           else if (cfa_temp.reg == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)))
1593             offset -= cfa_temp.offset;
1594           else
1595             abort ();
1596           break;
1597
1598           /* Rule 13 */
1599           /* Without an offset.  */
1600         case REG:
1601           if (cfa_store.reg == (unsigned) REGNO (XEXP (dest, 0)))
1602             offset = -cfa_store.offset;
1603           else if (cfa_temp.reg == (unsigned) REGNO (XEXP (dest, 0)))
1604             offset = -cfa_temp.offset;
1605           else
1606             abort ();
1607           break;
1608
1609           /* Rule 14 */
1610         case POST_INC:
1611           if (cfa_temp.reg != (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)))
1612             abort ();
1613           offset = -cfa_temp.offset;
1614           cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest));
1615           break;
1616
1617         default:
1618           abort ();
1619         }
1620
1621       if (REGNO (src) != STACK_POINTER_REGNUM
1622           && REGNO (src) != HARD_FRAME_POINTER_REGNUM
1623           && (unsigned) REGNO (src) == cfa.reg)
1624         {
1625           /* We're storing the current CFA reg into the stack.  */
1626
1627           if (cfa.offset == 0)
1628             {
1629               /* If the source register is exactly the CFA, assume
1630                  we're saving SP like any other register; this happens
1631                  on the ARM.  */
1632               def_cfa_1 (label, &cfa);
1633               queue_reg_save (label, stack_pointer_rtx, offset);
1634               break;
1635             }
1636           else
1637             {
1638               /* Otherwise, we'll need to look in the stack to
1639                  calculate the CFA.  */
1640               rtx x = XEXP (dest, 0);
1641
1642               if (GET_CODE (x) != REG)
1643                 x = XEXP (x, 0);
1644               if (GET_CODE (x) != REG)
1645                 abort ();
1646
1647               cfa.reg = REGNO (x);
1648               cfa.base_offset = offset;
1649               cfa.indirect = 1;
1650               def_cfa_1 (label, &cfa);
1651               break;
1652             }
1653         }
1654
1655       def_cfa_1 (label, &cfa);
1656       queue_reg_save (label, src, offset);
1657       break;
1658
1659     default:
1660       abort ();
1661     }
1662 }
1663
1664 /* Record call frame debugging information for INSN, which either
1665    sets SP or FP (adjusting how we calculate the frame address) or saves a
1666    register to the stack.  If INSN is NULL_RTX, initialize our state.  */
1667
1668 void
1669 dwarf2out_frame_debug (rtx insn)
1670 {
1671   const char *label;
1672   rtx src;
1673
1674   if (insn == NULL_RTX)
1675     {
1676       /* Flush any queued register saves.  */
1677       flush_queued_reg_saves ();
1678
1679       /* Set up state for generating call frame debug info.  */
1680       lookup_cfa (&cfa);
1681       if (cfa.reg != (unsigned long) DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM))
1682         abort ();
1683
1684       cfa.reg = STACK_POINTER_REGNUM;
1685       cfa_store = cfa;
1686       cfa_temp.reg = -1;
1687       cfa_temp.offset = 0;
1688       return;
1689     }
1690
1691   if (GET_CODE (insn) != INSN || clobbers_queued_reg_save (insn))
1692     flush_queued_reg_saves ();
1693
1694   if (! RTX_FRAME_RELATED_P (insn))
1695     {
1696       if (!ACCUMULATE_OUTGOING_ARGS)
1697         dwarf2out_stack_adjust (insn);
1698
1699       return;
1700     }
1701
1702   label = dwarf2out_cfi_label ();
1703   src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1704   if (src)
1705     insn = XEXP (src, 0);
1706   else
1707     insn = PATTERN (insn);
1708
1709   dwarf2out_frame_debug_expr (insn, label);
1710 }
1711
1712 #endif
1713
1714 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used.  */
1715 static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
1716  (enum dwarf_call_frame_info cfi);
1717
1718 static enum dw_cfi_oprnd_type
1719 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
1720 {
1721   switch (cfi)
1722     {
1723     case DW_CFA_nop:
1724     case DW_CFA_GNU_window_save:
1725       return dw_cfi_oprnd_unused;
1726
1727     case DW_CFA_set_loc:
1728     case DW_CFA_advance_loc1:
1729     case DW_CFA_advance_loc2:
1730     case DW_CFA_advance_loc4:
1731     case DW_CFA_MIPS_advance_loc8:
1732       return dw_cfi_oprnd_addr;
1733
1734     case DW_CFA_offset:
1735     case DW_CFA_offset_extended:
1736     case DW_CFA_def_cfa:
1737     case DW_CFA_offset_extended_sf:
1738     case DW_CFA_def_cfa_sf:
1739     case DW_CFA_restore_extended:
1740     case DW_CFA_undefined:
1741     case DW_CFA_same_value:
1742     case DW_CFA_def_cfa_register:
1743     case DW_CFA_register:
1744       return dw_cfi_oprnd_reg_num;
1745
1746     case DW_CFA_def_cfa_offset:
1747     case DW_CFA_GNU_args_size:
1748     case DW_CFA_def_cfa_offset_sf:
1749       return dw_cfi_oprnd_offset;
1750
1751     case DW_CFA_def_cfa_expression:
1752     case DW_CFA_expression:
1753       return dw_cfi_oprnd_loc;
1754
1755     default:
1756       abort ();
1757     }
1758 }
1759
1760 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used.  */
1761 static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
1762  (enum dwarf_call_frame_info cfi);
1763
1764 static enum dw_cfi_oprnd_type
1765 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
1766 {
1767   switch (cfi)
1768     {
1769     case DW_CFA_def_cfa:
1770     case DW_CFA_def_cfa_sf:
1771     case DW_CFA_offset:
1772     case DW_CFA_offset_extended_sf:
1773     case DW_CFA_offset_extended:
1774       return dw_cfi_oprnd_offset;
1775
1776     case DW_CFA_register:
1777       return dw_cfi_oprnd_reg_num;
1778
1779     default:
1780       return dw_cfi_oprnd_unused;
1781     }
1782 }
1783
1784 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1785
1786 /* Output a Call Frame Information opcode and its operand(s).  */
1787
1788 static void
1789 output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int for_eh)
1790 {
1791   if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
1792     dw2_asm_output_data (1, (cfi->dw_cfi_opc
1793                              | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)),
1794                          "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX,
1795                          cfi->dw_cfi_oprnd1.dw_cfi_offset);
1796   else if (cfi->dw_cfi_opc == DW_CFA_offset)
1797     {
1798       dw2_asm_output_data (1, (cfi->dw_cfi_opc
1799                                | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f)),
1800                            "DW_CFA_offset, column 0x%lx",
1801                            cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1802       dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
1803     }
1804   else if (cfi->dw_cfi_opc == DW_CFA_restore)
1805     dw2_asm_output_data (1, (cfi->dw_cfi_opc
1806                              | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f)),
1807                          "DW_CFA_restore, column 0x%lx",
1808                          cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1809   else
1810     {
1811       dw2_asm_output_data (1, cfi->dw_cfi_opc,
1812                            "%s", dwarf_cfi_name (cfi->dw_cfi_opc));
1813
1814       switch (cfi->dw_cfi_opc)
1815         {
1816         case DW_CFA_set_loc:
1817           if (for_eh)
1818             dw2_asm_output_encoded_addr_rtx (
1819                 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0),
1820                 gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr),
1821                 NULL);
1822           else
1823             dw2_asm_output_addr (DWARF2_ADDR_SIZE,
1824                                  cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL);
1825           break;
1826
1827         case DW_CFA_advance_loc1:
1828           dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr,
1829                                 fde->dw_fde_current_label, NULL);
1830           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1831           break;
1832
1833         case DW_CFA_advance_loc2:
1834           dw2_asm_output_delta (2, cfi->dw_cfi_oprnd1.dw_cfi_addr,
1835                                 fde->dw_fde_current_label, NULL);
1836           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1837           break;
1838
1839         case DW_CFA_advance_loc4:
1840           dw2_asm_output_delta (4, cfi->dw_cfi_oprnd1.dw_cfi_addr,
1841                                 fde->dw_fde_current_label, NULL);
1842           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1843           break;
1844
1845         case DW_CFA_MIPS_advance_loc8:
1846           dw2_asm_output_delta (8, cfi->dw_cfi_oprnd1.dw_cfi_addr,
1847                                 fde->dw_fde_current_label, NULL);
1848           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1849           break;
1850
1851         case DW_CFA_offset_extended:
1852         case DW_CFA_def_cfa:
1853           dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num,
1854                                        NULL);
1855           dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
1856           break;
1857
1858         case DW_CFA_offset_extended_sf:
1859         case DW_CFA_def_cfa_sf:
1860           dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num,
1861                                        NULL);
1862           dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
1863           break;
1864
1865         case DW_CFA_restore_extended:
1866         case DW_CFA_undefined:
1867         case DW_CFA_same_value:
1868         case DW_CFA_def_cfa_register:
1869           dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num,
1870                                        NULL);
1871           break;
1872
1873         case DW_CFA_register:
1874           dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num,
1875                                        NULL);
1876           dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_reg_num,
1877                                        NULL);
1878           break;
1879
1880         case DW_CFA_def_cfa_offset:
1881         case DW_CFA_GNU_args_size:
1882           dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
1883           break;
1884
1885         case DW_CFA_def_cfa_offset_sf:
1886           dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
1887           break;
1888
1889         case DW_CFA_GNU_window_save:
1890           break;
1891
1892         case DW_CFA_def_cfa_expression:
1893         case DW_CFA_expression:
1894           output_cfa_loc (cfi);
1895           break;
1896
1897         case DW_CFA_GNU_negative_offset_extended:
1898           /* Obsoleted by DW_CFA_offset_extended_sf.  */
1899           abort ();
1900
1901         default:
1902           break;
1903         }
1904     }
1905 }
1906
1907 /* Output the call frame information used to used to record information
1908    that relates to calculating the frame pointer, and records the
1909    location of saved registers.  */
1910
1911 static void
1912 output_call_frame_info (int for_eh)
1913 {
1914   unsigned int i;
1915   dw_fde_ref fde;
1916   dw_cfi_ref cfi;
1917   char l1[20], l2[20], section_start_label[20];
1918   bool any_lsda_needed = false;
1919   char augmentation[6];
1920   int augmentation_size;
1921   int fde_encoding = DW_EH_PE_absptr;
1922   int per_encoding = DW_EH_PE_absptr;
1923   int lsda_encoding = DW_EH_PE_absptr;
1924
1925   /* Don't emit a CIE if there won't be any FDEs.  */
1926   if (fde_table_in_use == 0)
1927     return;
1928
1929   /* If we don't have any functions we'll want to unwind out of, don't
1930      emit any EH unwind information.  Note that if exceptions aren't
1931      enabled, we won't have collected nothrow information, and if we
1932      asked for asynchronous tables, we always want this info.  */
1933   if (for_eh)
1934     {
1935       bool any_eh_needed = !flag_exceptions || flag_asynchronous_unwind_tables;
1936
1937       for (i = 0; i < fde_table_in_use; i++)
1938         if (fde_table[i].uses_eh_lsda)
1939           any_eh_needed = any_lsda_needed = true;
1940         else if (! fde_table[i].nothrow
1941                  && ! fde_table[i].all_throwers_are_sibcalls)
1942           any_eh_needed = true;
1943
1944       if (! any_eh_needed)
1945         return;
1946     }
1947
1948   /* We're going to be generating comments, so turn on app.  */
1949   if (flag_debug_asm)
1950     app_enable ();
1951
1952   if (for_eh)
1953     (*targetm.asm_out.eh_frame_section) ();
1954   else
1955     named_section_flags (DEBUG_FRAME_SECTION, SECTION_DEBUG);
1956
1957   ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
1958   ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
1959
1960   /* Output the CIE.  */
1961   ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
1962   ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
1963   dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
1964                         "Length of Common Information Entry");
1965   ASM_OUTPUT_LABEL (asm_out_file, l1);
1966
1967   /* Now that the CIE pointer is PC-relative for EH,
1968      use 0 to identify the CIE.  */
1969   dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
1970                        (for_eh ? 0 : DW_CIE_ID),
1971                        "CIE Identifier Tag");
1972
1973   dw2_asm_output_data (1, DW_CIE_VERSION, "CIE Version");
1974
1975   augmentation[0] = 0;
1976   augmentation_size = 0;
1977   if (for_eh)
1978     {
1979       char *p;
1980
1981       /* Augmentation:
1982          z      Indicates that a uleb128 is present to size the
1983                 augmentation section.
1984          L      Indicates the encoding (and thus presence) of
1985                 an LSDA pointer in the FDE augmentation.
1986          R      Indicates a non-default pointer encoding for
1987                 FDE code pointers.
1988          P      Indicates the presence of an encoding + language
1989                 personality routine in the CIE augmentation.  */
1990
1991       fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
1992       per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
1993       lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
1994
1995       p = augmentation + 1;
1996       if (eh_personality_libfunc)
1997         {
1998           *p++ = 'P';
1999           augmentation_size += 1 + size_of_encoded_value (per_encoding);
2000         }
2001       if (any_lsda_needed)
2002         {
2003           *p++ = 'L';
2004           augmentation_size += 1;
2005         }
2006       if (fde_encoding != DW_EH_PE_absptr)
2007         {
2008           *p++ = 'R';
2009           augmentation_size += 1;
2010         }
2011       if (p > augmentation + 1)
2012         {
2013           augmentation[0] = 'z';
2014           *p = '\0';
2015         }
2016
2017       /* Ug.  Some platforms can't do unaligned dynamic relocations at all.  */
2018       if (eh_personality_libfunc && per_encoding == DW_EH_PE_aligned)
2019         {
2020           int offset = (  4             /* Length */
2021                         + 4             /* CIE Id */
2022                         + 1             /* CIE version */
2023                         + strlen (augmentation) + 1     /* Augmentation */
2024                         + size_of_uleb128 (1)           /* Code alignment */
2025                         + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
2026                         + 1             /* RA column */
2027                         + 1             /* Augmentation size */
2028                         + 1             /* Personality encoding */ );
2029           int pad = -offset & (PTR_SIZE - 1);
2030
2031           augmentation_size += pad;
2032
2033           /* Augmentations should be small, so there's scarce need to
2034              iterate for a solution.  Die if we exceed one uleb128 byte.  */
2035           if (size_of_uleb128 (augmentation_size) != 1)
2036             abort ();
2037         }
2038     }
2039
2040   dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
2041   dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
2042   dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
2043                                "CIE Data Alignment Factor");
2044   dw2_asm_output_data (1, DWARF_FRAME_RETURN_COLUMN, "CIE RA Column");
2045
2046   if (augmentation[0])
2047     {
2048       dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
2049       if (eh_personality_libfunc)
2050         {
2051           dw2_asm_output_data (1, per_encoding, "Personality (%s)",
2052                                eh_data_format_name (per_encoding));
2053           dw2_asm_output_encoded_addr_rtx (per_encoding,
2054                                            eh_personality_libfunc, NULL);
2055         }
2056
2057       if (any_lsda_needed)
2058         dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
2059                              eh_data_format_name (lsda_encoding));
2060
2061       if (fde_encoding != DW_EH_PE_absptr)
2062         dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
2063                              eh_data_format_name (fde_encoding));
2064     }
2065
2066   for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
2067     output_cfi (cfi, NULL, for_eh);
2068
2069   /* Pad the CIE out to an address sized boundary.  */
2070   ASM_OUTPUT_ALIGN (asm_out_file,
2071                     floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
2072   ASM_OUTPUT_LABEL (asm_out_file, l2);
2073
2074   /* Loop through all of the FDE's.  */
2075   for (i = 0; i < fde_table_in_use; i++)
2076     {
2077       fde = &fde_table[i];
2078
2079       /* Don't emit EH unwind info for leaf functions that don't need it.  */
2080       if (for_eh && !flag_asynchronous_unwind_tables && flag_exceptions
2081           && (fde->nothrow || fde->all_throwers_are_sibcalls)
2082           && !fde->uses_eh_lsda)
2083         continue;
2084
2085       (*targetm.asm_out.internal_label) (asm_out_file, FDE_LABEL, for_eh + i * 2);
2086       ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i * 2);
2087       ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i * 2);
2088       dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
2089                             "FDE Length");
2090       ASM_OUTPUT_LABEL (asm_out_file, l1);
2091
2092       if (for_eh)
2093         dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
2094       else
2095         dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
2096                                "FDE CIE offset");
2097
2098       if (for_eh)
2099         {
2100           dw2_asm_output_encoded_addr_rtx (fde_encoding,
2101                    gen_rtx_SYMBOL_REF (Pmode, fde->dw_fde_begin),
2102                    "FDE initial location");
2103           dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2104                                 fde->dw_fde_end, fde->dw_fde_begin,
2105                                 "FDE address range");
2106         }
2107       else
2108         {
2109           dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin,
2110                                "FDE initial location");
2111           dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2112                                 fde->dw_fde_end, fde->dw_fde_begin,
2113                                 "FDE address range");
2114         }
2115
2116       if (augmentation[0])
2117         {
2118           if (any_lsda_needed)
2119             {
2120               int size = size_of_encoded_value (lsda_encoding);
2121
2122               if (lsda_encoding == DW_EH_PE_aligned)
2123                 {
2124                   int offset = (  4             /* Length */
2125                                 + 4             /* CIE offset */
2126                                 + 2 * size_of_encoded_value (fde_encoding)
2127                                 + 1             /* Augmentation size */ );
2128                   int pad = -offset & (PTR_SIZE - 1);
2129
2130                   size += pad;
2131                   if (size_of_uleb128 (size) != 1)
2132                     abort ();
2133                 }
2134
2135               dw2_asm_output_data_uleb128 (size, "Augmentation size");
2136
2137               if (fde->uses_eh_lsda)
2138                 {
2139                   ASM_GENERATE_INTERNAL_LABEL (l1, "LLSDA",
2140                                                fde->funcdef_number);
2141                   dw2_asm_output_encoded_addr_rtx (
2142                         lsda_encoding, gen_rtx_SYMBOL_REF (Pmode, l1),
2143                         "Language Specific Data Area");
2144                 }
2145               else
2146                 {
2147                   if (lsda_encoding == DW_EH_PE_aligned)
2148                     ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
2149                   dw2_asm_output_data
2150                     (size_of_encoded_value (lsda_encoding), 0,
2151                      "Language Specific Data Area (none)");
2152                 }
2153             }
2154           else
2155             dw2_asm_output_data_uleb128 (0, "Augmentation size");
2156         }
2157
2158       /* Loop through the Call Frame Instructions associated with
2159          this FDE.  */
2160       fde->dw_fde_current_label = fde->dw_fde_begin;
2161       for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
2162         output_cfi (cfi, fde, for_eh);
2163
2164       /* Pad the FDE out to an address sized boundary.  */
2165       ASM_OUTPUT_ALIGN (asm_out_file,
2166                         floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
2167       ASM_OUTPUT_LABEL (asm_out_file, l2);
2168     }
2169
2170   if (for_eh && targetm.terminate_dw2_eh_frame_info)
2171     dw2_asm_output_data (4, 0, "End of Table");
2172 #ifdef MIPS_DEBUGGING_INFO
2173   /* Work around Irix 6 assembler bug whereby labels at the end of a section
2174      get a value of 0.  Putting .align 0 after the label fixes it.  */
2175   ASM_OUTPUT_ALIGN (asm_out_file, 0);
2176 #endif
2177
2178   /* Turn off app to make assembly quicker.  */
2179   if (flag_debug_asm)
2180     app_disable ();
2181 }
2182
2183 /* Output a marker (i.e. a label) for the beginning of a function, before
2184    the prologue.  */
2185
2186 void
2187 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
2188                           const char *file ATTRIBUTE_UNUSED)
2189 {
2190   char label[MAX_ARTIFICIAL_LABEL_BYTES];
2191   dw_fde_ref fde;
2192
2193   current_function_func_begin_label = 0;
2194
2195 #ifdef IA64_UNWIND_INFO
2196   /* ??? current_function_func_begin_label is also used by except.c
2197      for call-site information.  We must emit this label if it might
2198      be used.  */
2199   if ((! flag_exceptions || USING_SJLJ_EXCEPTIONS)
2200       && ! dwarf2out_do_frame ())
2201     return;
2202 #else
2203   if (! dwarf2out_do_frame ())
2204     return;
2205 #endif
2206
2207   function_section (current_function_decl);
2208   ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
2209                                current_function_funcdef_no);
2210   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
2211                           current_function_funcdef_no);
2212   current_function_func_begin_label = get_identifier (label);
2213
2214 #ifdef IA64_UNWIND_INFO
2215   /* We can elide the fde allocation if we're not emitting debug info.  */
2216   if (! dwarf2out_do_frame ())
2217     return;
2218 #endif
2219
2220   /* Expand the fde table if necessary.  */
2221   if (fde_table_in_use == fde_table_allocated)
2222     {
2223       fde_table_allocated += FDE_TABLE_INCREMENT;
2224       fde_table = ggc_realloc (fde_table,
2225                                fde_table_allocated * sizeof (dw_fde_node));
2226       memset (fde_table + fde_table_in_use, 0,
2227               FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
2228     }
2229
2230   /* Record the FDE associated with this function.  */
2231   current_funcdef_fde = fde_table_in_use;
2232
2233   /* Add the new FDE at the end of the fde_table.  */
2234   fde = &fde_table[fde_table_in_use++];
2235   fde->dw_fde_begin = xstrdup (label);
2236   fde->dw_fde_current_label = NULL;
2237   fde->dw_fde_end = NULL;
2238   fde->dw_fde_cfi = NULL;
2239   fde->funcdef_number = current_function_funcdef_no;
2240   fde->nothrow = current_function_nothrow;
2241   fde->uses_eh_lsda = cfun->uses_eh_lsda;
2242   fde->all_throwers_are_sibcalls = cfun->all_throwers_are_sibcalls;
2243
2244   args_size = old_args_size = 0;
2245
2246   /* We only want to output line number information for the genuine dwarf2
2247      prologue case, not the eh frame case.  */
2248 #ifdef DWARF2_DEBUGGING_INFO
2249   if (file)
2250     dwarf2out_source_line (line, file);
2251 #endif
2252 }
2253
2254 /* Output a marker (i.e. a label) for the absolute end of the generated code
2255    for a function definition.  This gets called *after* the epilogue code has
2256    been generated.  */
2257
2258 void
2259 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
2260                         const char *file ATTRIBUTE_UNUSED)
2261 {
2262   dw_fde_ref fde;
2263   char label[MAX_ARTIFICIAL_LABEL_BYTES];
2264
2265   /* Output a label to mark the endpoint of the code generated for this
2266      function.  */
2267   ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
2268                                current_function_funcdef_no);
2269   ASM_OUTPUT_LABEL (asm_out_file, label);
2270   fde = &fde_table[fde_table_in_use - 1];
2271   fde->dw_fde_end = xstrdup (label);
2272 }
2273
2274 void
2275 dwarf2out_frame_init (void)
2276 {
2277   /* Allocate the initial hunk of the fde_table.  */
2278   fde_table = ggc_alloc_cleared (FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
2279   fde_table_allocated = FDE_TABLE_INCREMENT;
2280   fde_table_in_use = 0;
2281
2282   /* Generate the CFA instructions common to all FDE's.  Do it now for the
2283      sake of lookup_cfa.  */
2284
2285 #ifdef DWARF2_UNWIND_INFO
2286   /* On entry, the Canonical Frame Address is at SP.  */
2287   dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
2288   initial_return_save (INCOMING_RETURN_ADDR_RTX);
2289 #endif
2290 }
2291
2292 void
2293 dwarf2out_frame_finish (void)
2294 {
2295   /* Output call frame information.  */
2296   if (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
2297     output_call_frame_info (0);
2298
2299   if (! USING_SJLJ_EXCEPTIONS && (flag_unwind_tables || flag_exceptions))
2300     output_call_frame_info (1);
2301 }
2302 #endif
2303 \f
2304 /* And now, the subset of the debugging information support code necessary
2305    for emitting location expressions.  */
2306
2307 /* We need some way to distinguish DW_OP_addr with a direct symbol
2308    relocation from DW_OP_addr with a dtp-relative symbol relocation.  */
2309 #define INTERNAL_DW_OP_tls_addr         (0x100 + DW_OP_addr)
2310
2311
2312 typedef struct dw_val_struct *dw_val_ref;
2313 typedef struct die_struct *dw_die_ref;
2314 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
2315 typedef struct dw_loc_list_struct *dw_loc_list_ref;
2316
2317 /* Each DIE may have a series of attribute/value pairs.  Values
2318    can take on several forms.  The forms that are used in this
2319    implementation are listed below.  */
2320
2321 enum dw_val_class
2322 {
2323   dw_val_class_addr,
2324   dw_val_class_offset,
2325   dw_val_class_loc,
2326   dw_val_class_loc_list,
2327   dw_val_class_range_list,
2328   dw_val_class_const,
2329   dw_val_class_unsigned_const,
2330   dw_val_class_long_long,
2331   dw_val_class_float,
2332   dw_val_class_flag,
2333   dw_val_class_die_ref,
2334   dw_val_class_fde_ref,
2335   dw_val_class_lbl_id,
2336   dw_val_class_lbl_offset,
2337   dw_val_class_str
2338 };
2339
2340 /* Describe a double word constant value.  */
2341 /* ??? Every instance of long_long in the code really means CONST_DOUBLE.  */
2342
2343 typedef struct dw_long_long_struct GTY(())
2344 {
2345   unsigned long hi;
2346   unsigned long low;
2347 }
2348 dw_long_long_const;
2349
2350 /* Describe a floating point constant value.  */
2351
2352 typedef struct dw_fp_struct GTY(())
2353 {
2354   long * GTY((length ("%h.length"))) array;
2355   unsigned length;
2356 }
2357 dw_float_const;
2358
2359 /* The dw_val_node describes an attribute's value, as it is
2360    represented internally.  */
2361
2362 typedef struct dw_val_struct GTY(())
2363 {
2364   enum dw_val_class val_class;
2365   union dw_val_struct_union
2366     {
2367       rtx GTY ((tag ("dw_val_class_addr"))) val_addr;
2368       unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset;
2369       dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list;
2370       dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc;
2371       HOST_WIDE_INT GTY ((default (""))) val_int;
2372       unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned;
2373       dw_long_long_const GTY ((tag ("dw_val_class_long_long"))) val_long_long;
2374       dw_float_const GTY ((tag ("dw_val_class_float"))) val_float;
2375       struct dw_val_die_union
2376         {
2377           dw_die_ref die;
2378           int external;
2379         } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref;
2380       unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index;
2381       struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str;
2382       char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id;
2383       unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag;
2384     }
2385   GTY ((desc ("%1.val_class"))) v;
2386 }
2387 dw_val_node;
2388
2389 /* Locations in memory are described using a sequence of stack machine
2390    operations.  */
2391
2392 typedef struct dw_loc_descr_struct GTY(())
2393 {
2394   dw_loc_descr_ref dw_loc_next;
2395   enum dwarf_location_atom dw_loc_opc;
2396   dw_val_node dw_loc_oprnd1;
2397   dw_val_node dw_loc_oprnd2;
2398   int dw_loc_addr;
2399 }
2400 dw_loc_descr_node;
2401
2402 /* Location lists are ranges + location descriptions for that range,
2403    so you can track variables that are in different places over
2404    their entire life.  */
2405 typedef struct dw_loc_list_struct GTY(())
2406 {
2407   dw_loc_list_ref dw_loc_next;
2408   const char *begin; /* Label for begin address of range */
2409   const char *end;  /* Label for end address of range */
2410   char *ll_symbol; /* Label for beginning of location list.
2411                       Only on head of list */
2412   const char *section; /* Section this loclist is relative to */
2413   dw_loc_descr_ref expr;
2414 } dw_loc_list_node;
2415
2416 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
2417
2418 static const char *dwarf_stack_op_name (unsigned);
2419 static dw_loc_descr_ref new_loc_descr (enum dwarf_location_atom,
2420                                        unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT);
2421 static void add_loc_descr (dw_loc_descr_ref *, dw_loc_descr_ref);
2422 static unsigned long size_of_loc_descr (dw_loc_descr_ref);
2423 static unsigned long size_of_locs (dw_loc_descr_ref);
2424 static void output_loc_operands (dw_loc_descr_ref);
2425 static void output_loc_sequence (dw_loc_descr_ref);
2426
2427 /* Convert a DWARF stack opcode into its string name.  */
2428
2429 static const char *
2430 dwarf_stack_op_name (unsigned int op)
2431 {
2432   switch (op)
2433     {
2434     case DW_OP_addr:
2435     case INTERNAL_DW_OP_tls_addr:
2436       return "DW_OP_addr";
2437     case DW_OP_deref:
2438       return "DW_OP_deref";
2439     case DW_OP_const1u:
2440       return "DW_OP_const1u";
2441     case DW_OP_const1s:
2442       return "DW_OP_const1s";
2443     case DW_OP_const2u:
2444       return "DW_OP_const2u";
2445     case DW_OP_const2s:
2446       return "DW_OP_const2s";
2447     case DW_OP_const4u:
2448       return "DW_OP_const4u";
2449     case DW_OP_const4s:
2450       return "DW_OP_const4s";
2451     case DW_OP_const8u:
2452       return "DW_OP_const8u";
2453     case DW_OP_const8s:
2454       return "DW_OP_const8s";
2455     case DW_OP_constu:
2456       return "DW_OP_constu";
2457     case DW_OP_consts:
2458       return "DW_OP_consts";
2459     case DW_OP_dup:
2460       return "DW_OP_dup";
2461     case DW_OP_drop:
2462       return "DW_OP_drop";
2463     case DW_OP_over:
2464       return "DW_OP_over";
2465     case DW_OP_pick:
2466       return "DW_OP_pick";
2467     case DW_OP_swap:
2468       return "DW_OP_swap";
2469     case DW_OP_rot:
2470       return "DW_OP_rot";
2471     case DW_OP_xderef:
2472       return "DW_OP_xderef";
2473     case DW_OP_abs:
2474       return "DW_OP_abs";
2475     case DW_OP_and:
2476       return "DW_OP_and";
2477     case DW_OP_div:
2478       return "DW_OP_div";
2479     case DW_OP_minus:
2480       return "DW_OP_minus";
2481     case DW_OP_mod:
2482       return "DW_OP_mod";
2483     case DW_OP_mul:
2484       return "DW_OP_mul";
2485     case DW_OP_neg:
2486       return "DW_OP_neg";
2487     case DW_OP_not:
2488       return "DW_OP_not";
2489     case DW_OP_or:
2490       return "DW_OP_or";
2491     case DW_OP_plus:
2492       return "DW_OP_plus";
2493     case DW_OP_plus_uconst:
2494       return "DW_OP_plus_uconst";
2495     case DW_OP_shl:
2496       return "DW_OP_shl";
2497     case DW_OP_shr:
2498       return "DW_OP_shr";
2499     case DW_OP_shra:
2500       return "DW_OP_shra";
2501     case DW_OP_xor:
2502       return "DW_OP_xor";
2503     case DW_OP_bra:
2504       return "DW_OP_bra";
2505     case DW_OP_eq:
2506       return "DW_OP_eq";
2507     case DW_OP_ge:
2508       return "DW_OP_ge";
2509     case DW_OP_gt:
2510       return "DW_OP_gt";
2511     case DW_OP_le:
2512       return "DW_OP_le";
2513     case DW_OP_lt:
2514       return "DW_OP_lt";
2515     case DW_OP_ne:
2516       return "DW_OP_ne";
2517     case DW_OP_skip:
2518       return "DW_OP_skip";
2519     case DW_OP_lit0:
2520       return "DW_OP_lit0";
2521     case DW_OP_lit1:
2522       return "DW_OP_lit1";
2523     case DW_OP_lit2:
2524       return "DW_OP_lit2";
2525     case DW_OP_lit3:
2526       return "DW_OP_lit3";
2527     case DW_OP_lit4:
2528       return "DW_OP_lit4";
2529     case DW_OP_lit5:
2530       return "DW_OP_lit5";
2531     case DW_OP_lit6:
2532       return "DW_OP_lit6";
2533     case DW_OP_lit7:
2534       return "DW_OP_lit7";
2535     case DW_OP_lit8:
2536       return "DW_OP_lit8";
2537     case DW_OP_lit9:
2538       return "DW_OP_lit9";
2539     case DW_OP_lit10:
2540       return "DW_OP_lit10";
2541     case DW_OP_lit11:
2542       return "DW_OP_lit11";
2543     case DW_OP_lit12:
2544       return "DW_OP_lit12";
2545     case DW_OP_lit13:
2546       return "DW_OP_lit13";
2547     case DW_OP_lit14:
2548       return "DW_OP_lit14";
2549     case DW_OP_lit15:
2550       return "DW_OP_lit15";
2551     case DW_OP_lit16:
2552       return "DW_OP_lit16";
2553     case DW_OP_lit17:
2554       return "DW_OP_lit17";
2555     case DW_OP_lit18:
2556       return "DW_OP_lit18";
2557     case DW_OP_lit19:
2558       return "DW_OP_lit19";
2559     case DW_OP_lit20:
2560       return "DW_OP_lit20";
2561     case DW_OP_lit21:
2562       return "DW_OP_lit21";
2563     case DW_OP_lit22:
2564       return "DW_OP_lit22";
2565     case DW_OP_lit23:
2566       return "DW_OP_lit23";
2567     case DW_OP_lit24:
2568       return "DW_OP_lit24";
2569     case DW_OP_lit25:
2570       return "DW_OP_lit25";
2571     case DW_OP_lit26:
2572       return "DW_OP_lit26";
2573     case DW_OP_lit27:
2574       return "DW_OP_lit27";
2575     case DW_OP_lit28:
2576       return "DW_OP_lit28";
2577     case DW_OP_lit29:
2578       return "DW_OP_lit29";
2579     case DW_OP_lit30:
2580       return "DW_OP_lit30";
2581     case DW_OP_lit31:
2582       return "DW_OP_lit31";
2583     case DW_OP_reg0:
2584       return "DW_OP_reg0";
2585     case DW_OP_reg1:
2586       return "DW_OP_reg1";
2587     case DW_OP_reg2:
2588       return "DW_OP_reg2";
2589     case DW_OP_reg3:
2590       return "DW_OP_reg3";
2591     case DW_OP_reg4:
2592       return "DW_OP_reg4";
2593     case DW_OP_reg5:
2594       return "DW_OP_reg5";
2595     case DW_OP_reg6:
2596       return "DW_OP_reg6";
2597     case DW_OP_reg7:
2598       return "DW_OP_reg7";
2599     case DW_OP_reg8:
2600       return "DW_OP_reg8";
2601     case DW_OP_reg9:
2602       return "DW_OP_reg9";
2603     case DW_OP_reg10:
2604       return "DW_OP_reg10";
2605     case DW_OP_reg11:
2606       return "DW_OP_reg11";
2607     case DW_OP_reg12:
2608       return "DW_OP_reg12";
2609     case DW_OP_reg13:
2610       return "DW_OP_reg13";
2611     case DW_OP_reg14:
2612       return "DW_OP_reg14";
2613     case DW_OP_reg15:
2614       return "DW_OP_reg15";
2615     case DW_OP_reg16:
2616       return "DW_OP_reg16";
2617     case DW_OP_reg17:
2618       return "DW_OP_reg17";
2619     case DW_OP_reg18:
2620       return "DW_OP_reg18";
2621     case DW_OP_reg19:
2622       return "DW_OP_reg19";
2623     case DW_OP_reg20:
2624       return "DW_OP_reg20";
2625     case DW_OP_reg21:
2626       return "DW_OP_reg21";
2627     case DW_OP_reg22:
2628       return "DW_OP_reg22";
2629     case DW_OP_reg23:
2630       return "DW_OP_reg23";
2631     case DW_OP_reg24:
2632       return "DW_OP_reg24";
2633     case DW_OP_reg25:
2634       return "DW_OP_reg25";
2635     case DW_OP_reg26:
2636       return "DW_OP_reg26";
2637     case DW_OP_reg27:
2638       return "DW_OP_reg27";
2639     case DW_OP_reg28:
2640       return "DW_OP_reg28";
2641     case DW_OP_reg29:
2642       return "DW_OP_reg29";
2643     case DW_OP_reg30:
2644       return "DW_OP_reg30";
2645     case DW_OP_reg31:
2646       return "DW_OP_reg31";
2647     case DW_OP_breg0:
2648       return "DW_OP_breg0";
2649     case DW_OP_breg1:
2650       return "DW_OP_breg1";
2651     case DW_OP_breg2:
2652       return "DW_OP_breg2";
2653     case DW_OP_breg3:
2654       return "DW_OP_breg3";
2655     case DW_OP_breg4:
2656       return "DW_OP_breg4";
2657     case DW_OP_breg5:
2658       return "DW_OP_breg5";
2659     case DW_OP_breg6:
2660       return "DW_OP_breg6";
2661     case DW_OP_breg7:
2662       return "DW_OP_breg7";
2663     case DW_OP_breg8:
2664       return "DW_OP_breg8";
2665     case DW_OP_breg9:
2666       return "DW_OP_breg9";
2667     case DW_OP_breg10:
2668       return "DW_OP_breg10";
2669     case DW_OP_breg11:
2670       return "DW_OP_breg11";
2671     case DW_OP_breg12:
2672       return "DW_OP_breg12";
2673     case DW_OP_breg13:
2674       return "DW_OP_breg13";
2675     case DW_OP_breg14:
2676       return "DW_OP_breg14";
2677     case DW_OP_breg15:
2678       return "DW_OP_breg15";
2679     case DW_OP_breg16:
2680       return "DW_OP_breg16";
2681     case DW_OP_breg17:
2682       return "DW_OP_breg17";
2683     case DW_OP_breg18:
2684       return "DW_OP_breg18";
2685     case DW_OP_breg19:
2686       return "DW_OP_breg19";
2687     case DW_OP_breg20:
2688       return "DW_OP_breg20";
2689     case DW_OP_breg21:
2690       return "DW_OP_breg21";
2691     case DW_OP_breg22:
2692       return "DW_OP_breg22";
2693     case DW_OP_breg23:
2694       return "DW_OP_breg23";
2695     case DW_OP_breg24:
2696       return "DW_OP_breg24";
2697     case DW_OP_breg25:
2698       return "DW_OP_breg25";
2699     case DW_OP_breg26:
2700       return "DW_OP_breg26";
2701     case DW_OP_breg27:
2702       return "DW_OP_breg27";
2703     case DW_OP_breg28:
2704       return "DW_OP_breg28";
2705     case DW_OP_breg29:
2706       return "DW_OP_breg29";
2707     case DW_OP_breg30:
2708       return "DW_OP_breg30";
2709     case DW_OP_breg31:
2710       return "DW_OP_breg31";
2711     case DW_OP_regx:
2712       return "DW_OP_regx";
2713     case DW_OP_fbreg:
2714       return "DW_OP_fbreg";
2715     case DW_OP_bregx:
2716       return "DW_OP_bregx";
2717     case DW_OP_piece:
2718       return "DW_OP_piece";
2719     case DW_OP_deref_size:
2720       return "DW_OP_deref_size";
2721     case DW_OP_xderef_size:
2722       return "DW_OP_xderef_size";
2723     case DW_OP_nop:
2724       return "DW_OP_nop";
2725     case DW_OP_push_object_address:
2726       return "DW_OP_push_object_address";
2727     case DW_OP_call2:
2728       return "DW_OP_call2";
2729     case DW_OP_call4:
2730       return "DW_OP_call4";
2731     case DW_OP_call_ref:
2732       return "DW_OP_call_ref";
2733     case DW_OP_GNU_push_tls_address:
2734       return "DW_OP_GNU_push_tls_address";
2735     default:
2736       return "OP_<unknown>";
2737     }
2738 }
2739
2740 /* Return a pointer to a newly allocated location description.  Location
2741    descriptions are simple expression terms that can be strung
2742    together to form more complicated location (address) descriptions.  */
2743
2744 static inline dw_loc_descr_ref
2745 new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
2746                unsigned HOST_WIDE_INT oprnd2)
2747 {
2748   dw_loc_descr_ref descr = ggc_alloc_cleared (sizeof (dw_loc_descr_node));
2749
2750   descr->dw_loc_opc = op;
2751   descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
2752   descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
2753   descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
2754   descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
2755
2756   return descr;
2757 }
2758
2759
2760 /* Add a location description term to a location description expression.  */
2761
2762 static inline void
2763 add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
2764 {
2765   dw_loc_descr_ref *d;
2766
2767   /* Find the end of the chain.  */
2768   for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
2769     ;
2770
2771   *d = descr;
2772 }
2773
2774 /* Return the size of a location descriptor.  */
2775
2776 static unsigned long
2777 size_of_loc_descr (dw_loc_descr_ref loc)
2778 {
2779   unsigned long size = 1;
2780
2781   switch (loc->dw_loc_opc)
2782     {
2783     case DW_OP_addr:
2784     case INTERNAL_DW_OP_tls_addr:
2785       size += DWARF2_ADDR_SIZE;
2786       break;
2787     case DW_OP_const1u:
2788     case DW_OP_const1s:
2789       size += 1;
2790       break;
2791     case DW_OP_const2u:
2792     case DW_OP_const2s:
2793       size += 2;
2794       break;
2795     case DW_OP_const4u:
2796     case DW_OP_const4s:
2797       size += 4;
2798       break;
2799     case DW_OP_const8u:
2800     case DW_OP_const8s:
2801       size += 8;
2802       break;
2803     case DW_OP_constu:
2804       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
2805       break;
2806     case DW_OP_consts:
2807       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
2808       break;
2809     case DW_OP_pick:
2810       size += 1;
2811       break;
2812     case DW_OP_plus_uconst:
2813       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
2814       break;
2815     case DW_OP_skip:
2816     case DW_OP_bra:
2817       size += 2;
2818       break;
2819     case DW_OP_breg0:
2820     case DW_OP_breg1:
2821     case DW_OP_breg2:
2822     case DW_OP_breg3:
2823     case DW_OP_breg4:
2824     case DW_OP_breg5:
2825     case DW_OP_breg6:
2826     case DW_OP_breg7:
2827     case DW_OP_breg8:
2828     case DW_OP_breg9:
2829     case DW_OP_breg10:
2830     case DW_OP_breg11:
2831     case DW_OP_breg12:
2832     case DW_OP_breg13:
2833     case DW_OP_breg14:
2834     case DW_OP_breg15:
2835     case DW_OP_breg16:
2836     case DW_OP_breg17:
2837     case DW_OP_breg18:
2838     case DW_OP_breg19:
2839     case DW_OP_breg20:
2840     case DW_OP_breg21:
2841     case DW_OP_breg22:
2842     case DW_OP_breg23:
2843     case DW_OP_breg24:
2844     case DW_OP_breg25:
2845     case DW_OP_breg26:
2846     case DW_OP_breg27:
2847     case DW_OP_breg28:
2848     case DW_OP_breg29:
2849     case DW_OP_breg30:
2850     case DW_OP_breg31:
2851       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
2852       break;
2853     case DW_OP_regx:
2854       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
2855       break;
2856     case DW_OP_fbreg:
2857       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
2858       break;
2859     case DW_OP_bregx:
2860       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
2861       size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
2862       break;
2863     case DW_OP_piece:
2864       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
2865       break;
2866     case DW_OP_deref_size:
2867     case DW_OP_xderef_size:
2868       size += 1;
2869       break;
2870     case DW_OP_call2:
2871       size += 2;
2872       break;
2873     case DW_OP_call4:
2874       size += 4;
2875       break;
2876     case DW_OP_call_ref:
2877       size += DWARF2_ADDR_SIZE;
2878       break;
2879     default:
2880       break;
2881     }
2882
2883   return size;
2884 }
2885
2886 /* Return the size of a series of location descriptors.  */
2887
2888 static unsigned long
2889 size_of_locs (dw_loc_descr_ref loc)
2890 {
2891   unsigned long size;
2892
2893   for (size = 0; loc != NULL; loc = loc->dw_loc_next)
2894     {
2895       loc->dw_loc_addr = size;
2896       size += size_of_loc_descr (loc);
2897     }
2898
2899   return size;
2900 }
2901
2902 /* Output location description stack opcode's operands (if any).  */
2903
2904 static void
2905 output_loc_operands (dw_loc_descr_ref loc)
2906 {
2907   dw_val_ref val1 = &loc->dw_loc_oprnd1;
2908   dw_val_ref val2 = &loc->dw_loc_oprnd2;
2909
2910   switch (loc->dw_loc_opc)
2911     {
2912 #ifdef DWARF2_DEBUGGING_INFO
2913     case DW_OP_addr:
2914       dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
2915       break;
2916     case DW_OP_const2u:
2917     case DW_OP_const2s:
2918       dw2_asm_output_data (2, val1->v.val_int, NULL);
2919       break;
2920     case DW_OP_const4u:
2921     case DW_OP_const4s:
2922       dw2_asm_output_data (4, val1->v.val_int, NULL);
2923       break;
2924     case DW_OP_const8u:
2925     case DW_OP_const8s:
2926       if (HOST_BITS_PER_LONG < 64)
2927         abort ();
2928       dw2_asm_output_data (8, val1->v.val_int, NULL);
2929       break;
2930     case DW_OP_skip:
2931     case DW_OP_bra:
2932       {
2933         int offset;
2934
2935         if (val1->val_class == dw_val_class_loc)
2936           offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
2937         else
2938           abort ();
2939
2940         dw2_asm_output_data (2, offset, NULL);
2941       }
2942       break;
2943 #else
2944     case DW_OP_addr:
2945     case DW_OP_const2u:
2946     case DW_OP_const2s:
2947     case DW_OP_const4u:
2948     case DW_OP_const4s:
2949     case DW_OP_const8u:
2950     case DW_OP_const8s:
2951     case DW_OP_skip:
2952     case DW_OP_bra:
2953       /* We currently don't make any attempt to make sure these are
2954          aligned properly like we do for the main unwind info, so
2955          don't support emitting things larger than a byte if we're
2956          only doing unwinding.  */
2957       abort ();
2958 #endif
2959     case DW_OP_const1u:
2960     case DW_OP_const1s:
2961       dw2_asm_output_data (1, val1->v.val_int, NULL);
2962       break;
2963     case DW_OP_constu:
2964       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2965       break;
2966     case DW_OP_consts:
2967       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
2968       break;
2969     case DW_OP_pick:
2970       dw2_asm_output_data (1, val1->v.val_int, NULL);
2971       break;
2972     case DW_OP_plus_uconst:
2973       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2974       break;
2975     case DW_OP_breg0:
2976     case DW_OP_breg1:
2977     case DW_OP_breg2:
2978     case DW_OP_breg3:
2979     case DW_OP_breg4:
2980     case DW_OP_breg5:
2981     case DW_OP_breg6:
2982     case DW_OP_breg7:
2983     case DW_OP_breg8:
2984     case DW_OP_breg9:
2985     case DW_OP_breg10:
2986     case DW_OP_breg11:
2987     case DW_OP_breg12:
2988     case DW_OP_breg13:
2989     case DW_OP_breg14:
2990     case DW_OP_breg15:
2991     case DW_OP_breg16:
2992     case DW_OP_breg17:
2993     case DW_OP_breg18:
2994     case DW_OP_breg19:
2995     case DW_OP_breg20:
2996     case DW_OP_breg21:
2997     case DW_OP_breg22:
2998     case DW_OP_breg23:
2999     case DW_OP_breg24:
3000     case DW_OP_breg25:
3001     case DW_OP_breg26:
3002     case DW_OP_breg27:
3003     case DW_OP_breg28:
3004     case DW_OP_breg29:
3005     case DW_OP_breg30:
3006     case DW_OP_breg31:
3007       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3008       break;
3009     case DW_OP_regx:
3010       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3011       break;
3012     case DW_OP_fbreg:
3013       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3014       break;
3015     case DW_OP_bregx:
3016       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3017       dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
3018       break;
3019     case DW_OP_piece:
3020       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3021       break;
3022     case DW_OP_deref_size:
3023     case DW_OP_xderef_size:
3024       dw2_asm_output_data (1, val1->v.val_int, NULL);
3025       break;
3026
3027     case INTERNAL_DW_OP_tls_addr:
3028 #ifdef ASM_OUTPUT_DWARF_DTPREL
3029       ASM_OUTPUT_DWARF_DTPREL (asm_out_file, DWARF2_ADDR_SIZE,
3030                                val1->v.val_addr);
3031       fputc ('\n', asm_out_file);
3032 #else
3033       abort ();
3034 #endif
3035       break;
3036
3037     default:
3038       /* Other codes have no operands.  */
3039       break;
3040     }
3041 }
3042
3043 /* Output a sequence of location operations.  */
3044
3045 static void
3046 output_loc_sequence (dw_loc_descr_ref loc)
3047 {
3048   for (; loc != NULL; loc = loc->dw_loc_next)
3049     {
3050       /* Output the opcode.  */
3051       dw2_asm_output_data (1, loc->dw_loc_opc,
3052                            "%s", dwarf_stack_op_name (loc->dw_loc_opc));
3053
3054       /* Output the operand(s) (if any).  */
3055       output_loc_operands (loc);
3056     }
3057 }
3058
3059 /* This routine will generate the correct assembly data for a location
3060    description based on a cfi entry with a complex address.  */
3061
3062 static void
3063 output_cfa_loc (dw_cfi_ref cfi)
3064 {
3065   dw_loc_descr_ref loc;
3066   unsigned long size;
3067
3068   /* Output the size of the block.  */
3069   loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
3070   size = size_of_locs (loc);
3071   dw2_asm_output_data_uleb128 (size, NULL);
3072
3073   /* Now output the operations themselves.  */
3074   output_loc_sequence (loc);
3075 }
3076
3077 /* This function builds a dwarf location descriptor sequence from
3078    a dw_cfa_location.  */
3079
3080 static struct dw_loc_descr_struct *
3081 build_cfa_loc (dw_cfa_location *cfa)
3082 {
3083   struct dw_loc_descr_struct *head, *tmp;
3084
3085   if (cfa->indirect == 0)
3086     abort ();
3087
3088   if (cfa->base_offset)
3089     {
3090       if (cfa->reg <= 31)
3091         head = new_loc_descr (DW_OP_breg0 + cfa->reg, cfa->base_offset, 0);
3092       else
3093         head = new_loc_descr (DW_OP_bregx, cfa->reg, cfa->base_offset);
3094     }
3095   else if (cfa->reg <= 31)
3096     head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0);
3097   else
3098     head = new_loc_descr (DW_OP_regx, cfa->reg, 0);
3099
3100   head->dw_loc_oprnd1.val_class = dw_val_class_const;
3101   tmp = new_loc_descr (DW_OP_deref, 0, 0);
3102   add_loc_descr (&head, tmp);
3103   if (cfa->offset != 0)
3104     {
3105       tmp = new_loc_descr (DW_OP_plus_uconst, cfa->offset, 0);
3106       add_loc_descr (&head, tmp);
3107     }
3108
3109   return head;
3110 }
3111
3112 /* This function fills in aa dw_cfa_location structure from a dwarf location
3113    descriptor sequence.  */
3114
3115 static void
3116 get_cfa_from_loc_descr (dw_cfa_location *cfa, struct dw_loc_descr_struct *loc)
3117 {
3118   struct dw_loc_descr_struct *ptr;
3119   cfa->offset = 0;
3120   cfa->base_offset = 0;
3121   cfa->indirect = 0;
3122   cfa->reg = -1;
3123
3124   for (ptr = loc; ptr != NULL; ptr = ptr->dw_loc_next)
3125     {
3126       enum dwarf_location_atom op = ptr->dw_loc_opc;
3127
3128       switch (op)
3129         {
3130         case DW_OP_reg0:
3131         case DW_OP_reg1:
3132         case DW_OP_reg2:
3133         case DW_OP_reg3:
3134         case DW_OP_reg4:
3135         case DW_OP_reg5:
3136         case DW_OP_reg6:
3137         case DW_OP_reg7:
3138         case DW_OP_reg8:
3139         case DW_OP_reg9:
3140         case DW_OP_reg10:
3141         case DW_OP_reg11:
3142         case DW_OP_reg12:
3143         case DW_OP_reg13:
3144         case DW_OP_reg14:
3145         case DW_OP_reg15:
3146         case DW_OP_reg16:
3147         case DW_OP_reg17:
3148         case DW_OP_reg18:
3149         case DW_OP_reg19:
3150         case DW_OP_reg20:
3151         case DW_OP_reg21:
3152         case DW_OP_reg22:
3153         case DW_OP_reg23:
3154         case DW_OP_reg24:
3155         case DW_OP_reg25:
3156         case DW_OP_reg26:
3157         case DW_OP_reg27:
3158         case DW_OP_reg28:
3159         case DW_OP_reg29:
3160         case DW_OP_reg30:
3161         case DW_OP_reg31:
3162           cfa->reg = op - DW_OP_reg0;
3163           break;
3164         case DW_OP_regx:
3165           cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
3166           break;
3167         case DW_OP_breg0:
3168         case DW_OP_breg1:
3169         case DW_OP_breg2:
3170         case DW_OP_breg3:
3171         case DW_OP_breg4:
3172         case DW_OP_breg5:
3173         case DW_OP_breg6:
3174         case DW_OP_breg7:
3175         case DW_OP_breg8:
3176         case DW_OP_breg9:
3177         case DW_OP_breg10:
3178         case DW_OP_breg11:
3179         case DW_OP_breg12:
3180         case DW_OP_breg13:
3181         case DW_OP_breg14:
3182         case DW_OP_breg15:
3183         case DW_OP_breg16:
3184         case DW_OP_breg17:
3185         case DW_OP_breg18:
3186         case DW_OP_breg19:
3187         case DW_OP_breg20:
3188         case DW_OP_breg21:
3189         case DW_OP_breg22:
3190         case DW_OP_breg23:
3191         case DW_OP_breg24:
3192         case DW_OP_breg25:
3193         case DW_OP_breg26:
3194         case DW_OP_breg27:
3195         case DW_OP_breg28:
3196         case DW_OP_breg29:
3197         case DW_OP_breg30:
3198         case DW_OP_breg31:
3199           cfa->reg = op - DW_OP_breg0;
3200           cfa->base_offset = ptr->dw_loc_oprnd1.v.val_int;
3201           break;
3202         case DW_OP_bregx:
3203           cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
3204           cfa->base_offset = ptr->dw_loc_oprnd2.v.val_int;
3205           break;
3206         case DW_OP_deref:
3207           cfa->indirect = 1;
3208           break;
3209         case DW_OP_plus_uconst:
3210           cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned;
3211           break;
3212         default:
3213           internal_error ("DW_LOC_OP %s not implemented\n",
3214                           dwarf_stack_op_name (ptr->dw_loc_opc));
3215         }
3216     }
3217 }
3218 #endif /* .debug_frame support */
3219 \f
3220 /* And now, the support for symbolic debugging information.  */
3221 #ifdef DWARF2_DEBUGGING_INFO
3222
3223 /* .debug_str support.  */
3224 static int output_indirect_string (void **, void *);
3225
3226 static void dwarf2out_init (const char *);
3227 static void dwarf2out_finish (const char *);
3228 static void dwarf2out_define (unsigned int, const char *);
3229 static void dwarf2out_undef (unsigned int, const char *);
3230 static void dwarf2out_start_source_file (unsigned, const char *);
3231 static void dwarf2out_end_source_file (unsigned);
3232 static void dwarf2out_begin_block (unsigned, unsigned);
3233 static void dwarf2out_end_block (unsigned, unsigned);
3234 static bool dwarf2out_ignore_block (tree);
3235 static void dwarf2out_global_decl (tree);
3236 static void dwarf2out_abstract_function (tree);
3237
3238 /* The debug hooks structure.  */
3239
3240 const struct gcc_debug_hooks dwarf2_debug_hooks =
3241 {
3242   dwarf2out_init,
3243   dwarf2out_finish,
3244   dwarf2out_define,
3245   dwarf2out_undef,
3246   dwarf2out_start_source_file,
3247   dwarf2out_end_source_file,
3248   dwarf2out_begin_block,
3249   dwarf2out_end_block,
3250   dwarf2out_ignore_block,
3251   dwarf2out_source_line,
3252   dwarf2out_begin_prologue,
3253   debug_nothing_int_charstar,   /* end_prologue */
3254   dwarf2out_end_epilogue,
3255   debug_nothing_tree,           /* begin_function */
3256   debug_nothing_int,            /* end_function */
3257   dwarf2out_decl,               /* function_decl */
3258   dwarf2out_global_decl,
3259   debug_nothing_tree,           /* deferred_inline_function */
3260   /* The DWARF 2 backend tries to reduce debugging bloat by not
3261      emitting the abstract description of inline functions until
3262      something tries to reference them.  */
3263   dwarf2out_abstract_function,  /* outlining_inline_function */
3264   debug_nothing_rtx,            /* label */
3265   debug_nothing_int             /* handle_pch */
3266 };
3267 #endif
3268 \f
3269 /* NOTE: In the comments in this file, many references are made to
3270    "Debugging Information Entries".  This term is abbreviated as `DIE'
3271    throughout the remainder of this file.  */
3272
3273 /* An internal representation of the DWARF output is built, and then
3274    walked to generate the DWARF debugging info.  The walk of the internal
3275    representation is done after the entire program has been compiled.
3276    The types below are used to describe the internal representation.  */
3277
3278 /* Various DIE's use offsets relative to the beginning of the
3279    .debug_info section to refer to each other.  */
3280
3281 typedef long int dw_offset;
3282
3283 /* Define typedefs here to avoid circular dependencies.  */
3284
3285 typedef struct dw_attr_struct *dw_attr_ref;
3286 typedef struct dw_line_info_struct *dw_line_info_ref;
3287 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
3288 typedef struct pubname_struct *pubname_ref;
3289 typedef struct dw_ranges_struct *dw_ranges_ref;
3290
3291 /* Each entry in the line_info_table maintains the file and
3292    line number associated with the label generated for that
3293    entry.  The label gives the PC value associated with
3294    the line number entry.  */
3295
3296 typedef struct dw_line_info_struct GTY(())
3297 {
3298   unsigned long dw_file_num;
3299   unsigned long dw_line_num;
3300 }
3301 dw_line_info_entry;
3302
3303 /* Line information for functions in separate sections; each one gets its
3304    own sequence.  */
3305 typedef struct dw_separate_line_info_struct GTY(())
3306 {
3307   unsigned long dw_file_num;
3308   unsigned long dw_line_num;
3309   unsigned long function;
3310 }
3311 dw_separate_line_info_entry;
3312
3313 /* Each DIE attribute has a field specifying the attribute kind,
3314    a link to the next attribute in the chain, and an attribute value.
3315    Attributes are typically linked below the DIE they modify.  */
3316
3317 typedef struct dw_attr_struct GTY(())
3318 {
3319   enum dwarf_attribute dw_attr;
3320   dw_attr_ref dw_attr_next;
3321   dw_val_node dw_attr_val;
3322 }
3323 dw_attr_node;
3324
3325 /* The Debugging Information Entry (DIE) structure */
3326
3327 typedef struct die_struct GTY(())
3328 {
3329   enum dwarf_tag die_tag;
3330   char *die_symbol;
3331   dw_attr_ref die_attr;
3332   dw_die_ref die_parent;
3333   dw_die_ref die_child;
3334   dw_die_ref die_sib;
3335   dw_die_ref die_definition; /* ref from a specification to its definition */
3336   dw_offset die_offset;
3337   unsigned long die_abbrev;
3338   int die_mark;
3339 }
3340 die_node;
3341
3342 /* The pubname structure */
3343
3344 typedef struct pubname_struct GTY(())
3345 {
3346   dw_die_ref die;
3347   char *name;
3348 }
3349 pubname_entry;
3350
3351 struct dw_ranges_struct GTY(())
3352 {
3353   int block_num;
3354 };
3355
3356 /* The limbo die list structure.  */
3357 typedef struct limbo_die_struct GTY(())
3358 {
3359   dw_die_ref die;
3360   tree created_for;
3361   struct limbo_die_struct *next;
3362 }
3363 limbo_die_node;
3364
3365 /* How to start an assembler comment.  */
3366 #ifndef ASM_COMMENT_START
3367 #define ASM_COMMENT_START ";#"
3368 #endif
3369
3370 /* Define a macro which returns nonzero for a TYPE_DECL which was
3371    implicitly generated for a tagged type.
3372
3373    Note that unlike the gcc front end (which generates a NULL named
3374    TYPE_DECL node for each complete tagged type, each array type, and
3375    each function type node created) the g++ front end generates a
3376    _named_ TYPE_DECL node for each tagged type node created.
3377    These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
3378    generate a DW_TAG_typedef DIE for them.  */
3379
3380 #define TYPE_DECL_IS_STUB(decl)                         \
3381   (DECL_NAME (decl) == NULL_TREE                        \
3382    || (DECL_ARTIFICIAL (decl)                           \
3383        && is_tagged_type (TREE_TYPE (decl))             \
3384        && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl)))  \
3385            /* This is necessary for stub decls that     \
3386               appear in nested inline functions.  */    \
3387            || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
3388                && (decl_ultimate_origin (decl)          \
3389                    == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
3390
3391 /* Information concerning the compilation unit's programming
3392    language, and compiler version.  */
3393
3394 /* Fixed size portion of the DWARF compilation unit header.  */
3395 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
3396   (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
3397
3398 /* Fixed size portion of public names info.  */
3399 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
3400
3401 /* Fixed size portion of the address range info.  */
3402 #define DWARF_ARANGES_HEADER_SIZE                                       \
3403   (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4,      \
3404                 DWARF2_ADDR_SIZE * 2)                                   \
3405    - DWARF_INITIAL_LENGTH_SIZE)
3406
3407 /* Size of padding portion in the address range info.  It must be
3408    aligned to twice the pointer size.  */
3409 #define DWARF_ARANGES_PAD_SIZE \
3410   (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3411                 DWARF2_ADDR_SIZE * 2) \
3412    - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
3413
3414 /* Use assembler line directives if available.  */
3415 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
3416 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
3417 #define DWARF2_ASM_LINE_DEBUG_INFO 1
3418 #else
3419 #define DWARF2_ASM_LINE_DEBUG_INFO 0
3420 #endif
3421 #endif
3422
3423 /* Minimum line offset in a special line info. opcode.
3424    This value was chosen to give a reasonable range of values.  */
3425 #define DWARF_LINE_BASE  -10
3426
3427 /* First special line opcode - leave room for the standard opcodes.  */
3428 #define DWARF_LINE_OPCODE_BASE  10
3429
3430 /* Range of line offsets in a special line info. opcode.  */
3431 #define DWARF_LINE_RANGE  (254-DWARF_LINE_OPCODE_BASE+1)
3432
3433 /* Flag that indicates the initial value of the is_stmt_start flag.
3434    In the present implementation, we do not mark any lines as
3435    the beginning of a source statement, because that information
3436    is not made available by the GCC front-end.  */
3437 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
3438
3439 #ifdef DWARF2_DEBUGGING_INFO
3440 /* This location is used by calc_die_sizes() to keep track
3441    the offset of each DIE within the .debug_info section.  */
3442 static unsigned long next_die_offset;
3443 #endif
3444
3445 /* Record the root of the DIE's built for the current compilation unit.  */
3446 static GTY(()) dw_die_ref comp_unit_die;
3447
3448 /* A list of DIEs with a NULL parent waiting to be relocated.  */
3449 static GTY(()) limbo_die_node *limbo_die_list;
3450
3451 /* Filenames referenced by this compilation unit.  */
3452 static GTY(()) varray_type file_table;
3453 static GTY(()) varray_type file_table_emitted;
3454 static GTY(()) size_t file_table_last_lookup_index;
3455
3456 /* A pointer to the base of a table of references to DIE's that describe
3457    declarations.  The table is indexed by DECL_UID() which is a unique
3458    number identifying each decl.  */
3459 static GTY((length ("decl_die_table_allocated"))) dw_die_ref *decl_die_table;
3460
3461 /* Number of elements currently allocated for the decl_die_table.  */
3462 static GTY(()) unsigned decl_die_table_allocated;
3463
3464 /* Number of elements in decl_die_table currently in use.  */
3465 static GTY(()) unsigned decl_die_table_in_use;
3466
3467 /* Size (in elements) of increments by which we may expand the
3468    decl_die_table.  */
3469 #define DECL_DIE_TABLE_INCREMENT 256
3470
3471 /* A pointer to the base of a list of references to DIE's that
3472    are uniquely identified by their tag, presence/absence of
3473    children DIE's, and list of attribute/value pairs.  */
3474 static GTY((length ("abbrev_die_table_allocated")))
3475   dw_die_ref *abbrev_die_table;
3476
3477 /* Number of elements currently allocated for abbrev_die_table.  */
3478 static GTY(()) unsigned abbrev_die_table_allocated;
3479
3480 /* Number of elements in type_die_table currently in use.  */
3481 static GTY(()) unsigned abbrev_die_table_in_use;
3482
3483 /* Size (in elements) of increments by which we may expand the
3484    abbrev_die_table.  */
3485 #define ABBREV_DIE_TABLE_INCREMENT 256
3486
3487 /* A pointer to the base of a table that contains line information
3488    for each source code line in .text in the compilation unit.  */
3489 static GTY((length ("line_info_table_allocated")))
3490      dw_line_info_ref line_info_table;
3491
3492 /* Number of elements currently allocated for line_info_table.  */
3493 static GTY(()) unsigned line_info_table_allocated;
3494
3495 /* Number of elements in line_info_table currently in use.  */
3496 static GTY(()) unsigned line_info_table_in_use;
3497
3498 /* A pointer to the base of a table that contains line information
3499    for each source code line outside of .text in the compilation unit.  */
3500 static GTY ((length ("separate_line_info_table_allocated")))
3501      dw_separate_line_info_ref separate_line_info_table;
3502
3503 /* Number of elements currently allocated for separate_line_info_table.  */
3504 static GTY(()) unsigned separate_line_info_table_allocated;
3505
3506 /* Number of elements in separate_line_info_table currently in use.  */
3507 static GTY(()) unsigned separate_line_info_table_in_use;
3508
3509 /* Size (in elements) of increments by which we may expand the
3510    line_info_table.  */
3511 #define LINE_INFO_TABLE_INCREMENT 1024
3512
3513 /* A pointer to the base of a table that contains a list of publicly
3514    accessible names.  */
3515 static GTY ((length ("pubname_table_allocated"))) pubname_ref pubname_table;
3516
3517 /* Number of elements currently allocated for pubname_table.  */
3518 static GTY(()) unsigned pubname_table_allocated;
3519
3520 /* Number of elements in pubname_table currently in use.  */
3521 static GTY(()) unsigned pubname_table_in_use;
3522
3523 /* Size (in elements) of increments by which we may expand the
3524    pubname_table.  */
3525 #define PUBNAME_TABLE_INCREMENT 64
3526
3527 /* Array of dies for which we should generate .debug_arange info.  */
3528 static GTY((length ("arange_table_allocated"))) dw_die_ref *arange_table;
3529
3530 /* Number of elements currently allocated for arange_table.  */
3531 static GTY(()) unsigned arange_table_allocated;
3532
3533 /* Number of elements in arange_table currently in use.  */
3534 static GTY(()) unsigned arange_table_in_use;
3535
3536 /* Size (in elements) of increments by which we may expand the
3537    arange_table.  */
3538 #define ARANGE_TABLE_INCREMENT 64
3539
3540 /* Array of dies for which we should generate .debug_ranges info.  */
3541 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;
3542
3543 /* Number of elements currently allocated for ranges_table.  */
3544 static GTY(()) unsigned ranges_table_allocated;
3545
3546 /* Number of elements in ranges_table currently in use.  */
3547 static GTY(()) unsigned ranges_table_in_use;
3548
3549 /* Size (in elements) of increments by which we may expand the
3550    ranges_table.  */
3551 #define RANGES_TABLE_INCREMENT 64
3552
3553 /* Whether we have location lists that need outputting */
3554 static GTY(()) unsigned have_location_lists;
3555
3556 #ifdef DWARF2_DEBUGGING_INFO
3557 /* Record whether the function being analyzed contains inlined functions.  */
3558 static int current_function_has_inlines;
3559 #endif
3560 #if 0 && defined (MIPS_DEBUGGING_INFO)
3561 static int comp_unit_has_inlines;
3562 #endif
3563
3564 /* Number of file tables emitted in maybe_emit_file().  */
3565 static GTY(()) int emitcount = 0;
3566
3567 /* Number of internal labels generated by gen_internal_sym().  */
3568 static GTY(()) int label_num;
3569
3570 #ifdef DWARF2_DEBUGGING_INFO
3571
3572 /* Forward declarations for functions defined in this file.  */
3573
3574 static int is_pseudo_reg (rtx);
3575 static tree type_main_variant (tree);
3576 static int is_tagged_type (tree);
3577 static const char *dwarf_tag_name (unsigned);
3578 static const char *dwarf_attr_name (unsigned);
3579 static const char *dwarf_form_name (unsigned);
3580 #if 0
3581 static const char *dwarf_type_encoding_name (unsigned);
3582 #endif
3583 static tree decl_ultimate_origin (tree);
3584 static tree block_ultimate_origin (tree);
3585 static tree decl_class_context (tree);
3586 static void add_dwarf_attr (dw_die_ref, dw_attr_ref);
3587 static inline enum dw_val_class AT_class (dw_attr_ref);
3588 static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
3589 static inline unsigned AT_flag (dw_attr_ref);
3590 static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
3591 static inline HOST_WIDE_INT AT_int (dw_attr_ref);
3592 static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
3593 static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref);
3594 static void add_AT_long_long (dw_die_ref, enum dwarf_attribute, unsigned long,
3595                               unsigned long);
3596 static void add_AT_float (dw_die_ref, enum dwarf_attribute, unsigned, long *);
3597 static hashval_t debug_str_do_hash (const void *);
3598 static int debug_str_eq (const void *, const void *);
3599 static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
3600 static inline const char *AT_string (dw_attr_ref);
3601 static int AT_string_form (dw_attr_ref);
3602 static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
3603 static void add_AT_specification (dw_die_ref, dw_die_ref);
3604 static inline dw_die_ref AT_ref (dw_attr_ref);
3605 static inline int AT_ref_external (dw_attr_ref);
3606 static inline void set_AT_ref_external (dw_attr_ref, int);
3607 static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned);
3608 static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
3609 static inline dw_loc_descr_ref AT_loc (dw_attr_ref);
3610 static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
3611                              dw_loc_list_ref);
3612 static inline dw_loc_list_ref AT_loc_list (dw_attr_ref);
3613 static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx);
3614 static inline rtx AT_addr (dw_attr_ref);
3615 static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
3616 static void add_AT_lbl_offset (dw_die_ref, enum dwarf_attribute, const char *);
3617 static void add_AT_offset (dw_die_ref, enum dwarf_attribute,
3618                            unsigned HOST_WIDE_INT);
3619 static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
3620                                unsigned long);
3621 static inline const char *AT_lbl (dw_attr_ref);
3622 static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
3623 static const char *get_AT_low_pc (dw_die_ref);
3624 static const char *get_AT_hi_pc (dw_die_ref);
3625 static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
3626 static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
3627 static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
3628 static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
3629 static bool is_c_family (void);
3630 static bool is_cxx (void);
3631 static bool is_java (void);
3632 static bool is_fortran (void);
3633 static bool is_ada (void);
3634 static void remove_AT (dw_die_ref, enum dwarf_attribute);
3635 static inline void free_die (dw_die_ref);
3636 static void remove_children (dw_die_ref);
3637 static void add_child_die (dw_die_ref, dw_die_ref);
3638 static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
3639 static dw_die_ref lookup_type_die (tree);
3640 static void equate_type_number_to_die (tree, dw_die_ref);
3641 static dw_die_ref lookup_decl_die (tree);
3642 static void equate_decl_number_to_die (tree, dw_die_ref);
3643 static void print_spaces (FILE *);
3644 static void print_die (dw_die_ref, FILE *);
3645 static void print_dwarf_line_table (FILE *);
3646 static void reverse_die_lists (dw_die_ref);
3647 static void reverse_all_dies (dw_die_ref);
3648 static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
3649 static dw_die_ref pop_compile_unit (dw_die_ref);
3650 static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
3651 static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *);
3652 static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
3653 static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
3654 static int same_dw_val_p (dw_val_node *, dw_val_node *, int *);
3655 static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
3656 static int same_die_p (dw_die_ref, dw_die_ref, int *);
3657 static int same_die_p_wrap (dw_die_ref, dw_die_ref);
3658 static void compute_section_prefix (dw_die_ref);
3659 static int is_type_die (dw_die_ref);
3660 static int is_comdat_die (dw_die_ref);
3661 static int is_symbol_die (dw_die_ref);
3662 static void assign_symbol_names (dw_die_ref);
3663 static void break_out_includes (dw_die_ref);
3664 static hashval_t htab_cu_hash (const void *);
3665 static int htab_cu_eq (const void *, const void *);
3666 static void htab_cu_del (void *);
3667 static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *);
3668 static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned);
3669 static void add_sibling_attributes (dw_die_ref);
3670 static void build_abbrev_table (dw_die_ref);
3671 static void output_location_lists (dw_die_ref);
3672 static int constant_size (long unsigned);
3673 static unsigned long size_of_die (dw_die_ref);
3674 static void calc_die_sizes (dw_die_ref);
3675 static void mark_dies (dw_die_ref);
3676 static void unmark_dies (dw_die_ref);
3677 static void unmark_all_dies (dw_die_ref);
3678 static unsigned long size_of_pubnames (void);
3679 static unsigned long size_of_aranges (void);
3680 static enum dwarf_form value_format (dw_attr_ref);
3681 static void output_value_format (dw_attr_ref);
3682 static void output_abbrev_section (void);
3683 static void output_die_symbol (dw_die_ref);
3684 static void output_die (dw_die_ref);
3685 static void output_compilation_unit_header (void);
3686 static void output_comp_unit (dw_die_ref, int);
3687 static const char *dwarf2_name (tree, int);
3688 static void add_pubname (tree, dw_die_ref);
3689 static void output_pubnames (void);
3690 static void add_arange (tree, dw_die_ref);
3691 static void output_aranges (void);
3692 static unsigned int add_ranges (tree);
3693 static void output_ranges (void);
3694 static void output_line_info (void);
3695 static void output_file_names (void);
3696 static dw_die_ref base_type_die (tree);
3697 static tree root_type (tree);
3698 static int is_base_type (tree);
3699 static bool is_ada_subrange_type (tree);
3700 static dw_die_ref subrange_type_die (tree);
3701 static dw_die_ref modified_type_die (tree, int, int, dw_die_ref);
3702 static int type_is_enum (tree);
3703 static unsigned int reg_number (rtx);
3704 static dw_loc_descr_ref reg_loc_descriptor (rtx);
3705 static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int);
3706 static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx);
3707 static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
3708 static dw_loc_descr_ref based_loc_descr (unsigned, HOST_WIDE_INT);
3709 static int is_based_loc (rtx);
3710 static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode);
3711 static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx);
3712 static dw_loc_descr_ref loc_descriptor (rtx);
3713 static dw_loc_descr_ref loc_descriptor_from_tree (tree, int);
3714 static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
3715 static tree field_type (tree);
3716 static unsigned int simple_type_align_in_bits (tree);
3717 static unsigned int simple_decl_align_in_bits (tree);
3718 static unsigned HOST_WIDE_INT simple_type_size_in_bits (tree);
3719 static HOST_WIDE_INT field_byte_offset (tree);
3720 static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
3721                                          dw_loc_descr_ref);
3722 static void add_data_member_location_attribute (dw_die_ref, tree);
3723 static void add_const_value_attribute (dw_die_ref, rtx);
3724 static rtx rtl_for_decl_location (tree);
3725 static void add_location_or_const_value_attribute (dw_die_ref, tree);
3726 static void tree_add_const_value_attribute (dw_die_ref, tree);
3727 static void add_name_attribute (dw_die_ref, const char *);
3728 static void add_comp_dir_attribute (dw_die_ref);
3729 static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree);
3730 static void add_subscript_info (dw_die_ref, tree);
3731 static void add_byte_size_attribute (dw_die_ref, tree);
3732 static void add_bit_offset_attribute (dw_die_ref, tree);
3733 static void add_bit_size_attribute (dw_die_ref, tree);
3734 static void add_prototyped_attribute (dw_die_ref, tree);
3735 static void add_abstract_origin_attribute (dw_die_ref, tree);
3736 static void add_pure_or_virtual_attribute (dw_die_ref, tree);
3737 static void add_src_coords_attributes (dw_die_ref, tree);
3738 static void add_name_and_src_coords_attributes (dw_die_ref, tree);
3739 static void push_decl_scope (tree);
3740 static void pop_decl_scope (void);
3741 static dw_die_ref scope_die_for (tree, dw_die_ref);
3742 static inline int local_scope_p (dw_die_ref);
3743 static inline int class_or_namespace_scope_p (dw_die_ref);
3744 static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref);
3745 static const char *type_tag (tree);
3746 static tree member_declared_type (tree);
3747 #if 0
3748 static const char *decl_start_label (tree);
3749 #endif
3750 static void gen_array_type_die (tree, dw_die_ref);
3751 static void gen_set_type_die (tree, dw_die_ref);
3752 #if 0
3753 static void gen_entry_point_die (tree, dw_die_ref);
3754 #endif
3755 static void gen_inlined_enumeration_type_die (tree, dw_die_ref);
3756 static void gen_inlined_structure_type_die (tree, dw_die_ref);
3757 static void gen_inlined_union_type_die (tree, dw_die_ref);
3758 static void gen_enumeration_type_die (tree, dw_die_ref);
3759 static dw_die_ref gen_formal_parameter_die (tree, dw_die_ref);
3760 static void gen_unspecified_parameters_die (tree, dw_die_ref);
3761 static void gen_formal_types_die (tree, dw_die_ref);
3762 static void gen_subprogram_die (tree, dw_die_ref);
3763 static void gen_variable_die (tree, dw_die_ref);
3764 static void gen_label_die (tree, dw_die_ref);
3765 static void gen_lexical_block_die (tree, dw_die_ref, int);
3766 static void gen_inlined_subroutine_die (tree, dw_die_ref, int);
3767 static void gen_field_die (tree, dw_die_ref);
3768 static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
3769 static dw_die_ref gen_compile_unit_die (const char *);
3770 static void gen_string_type_die (tree, dw_die_ref);
3771 static void gen_inheritance_die (tree, tree, dw_die_ref);
3772 static void gen_member_die (tree, dw_die_ref);
3773 static void gen_struct_or_union_type_die (tree, dw_die_ref);
3774 static void gen_subroutine_type_die (tree, dw_die_ref);
3775 static void gen_typedef_die (tree, dw_die_ref);
3776 static void gen_type_die (tree, dw_die_ref);
3777 static void gen_tagged_type_instantiation_die (tree, dw_die_ref);
3778 static void gen_block_die (tree, dw_die_ref, int);
3779 static void decls_for_scope (tree, dw_die_ref, int);
3780 static int is_redundant_typedef (tree);
3781 static void gen_namespace_die (tree);
3782 static void gen_decl_die (tree, dw_die_ref);
3783 static dw_die_ref force_namespace_die (tree);
3784 static dw_die_ref setup_namespace_context (tree, dw_die_ref);
3785 static void declare_in_namespace (tree, dw_die_ref);
3786 static unsigned lookup_filename (const char *);
3787 static void init_file_table (void);
3788 static void retry_incomplete_types (void);
3789 static void gen_type_die_for_member (tree, tree, dw_die_ref);
3790 static void splice_child_die (dw_die_ref, dw_die_ref);
3791 static int file_info_cmp (const void *, const void *);
3792 static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
3793                                      const char *, const char *, unsigned);
3794 static void add_loc_descr_to_loc_list (dw_loc_list_ref *, dw_loc_descr_ref,
3795                                        const char *, const char *,
3796                                        const char *);
3797 static void output_loc_list (dw_loc_list_ref);
3798 static char *gen_internal_sym (const char *);
3799
3800 static void prune_unmark_dies (dw_die_ref);
3801 static void prune_unused_types_mark (dw_die_ref, int);
3802 static void prune_unused_types_walk (dw_die_ref);
3803 static void prune_unused_types_walk_attribs (dw_die_ref);
3804 static void prune_unused_types_prune (dw_die_ref);
3805 static void prune_unused_types (void);
3806 static int maybe_emit_file (int);
3807
3808 /* Section names used to hold DWARF debugging information.  */
3809 #ifndef DEBUG_INFO_SECTION
3810 #define DEBUG_INFO_SECTION      ".debug_info"
3811 #endif
3812 #ifndef DEBUG_ABBREV_SECTION
3813 #define DEBUG_ABBREV_SECTION    ".debug_abbrev"
3814 #endif
3815 #ifndef DEBUG_ARANGES_SECTION
3816 #define DEBUG_ARANGES_SECTION   ".debug_aranges"
3817 #endif
3818 #ifndef DEBUG_MACINFO_SECTION
3819 #define DEBUG_MACINFO_SECTION   ".debug_macinfo"
3820 #endif
3821 #ifndef DEBUG_LINE_SECTION
3822 #define DEBUG_LINE_SECTION      ".debug_line"
3823 #endif
3824 #ifndef DEBUG_LOC_SECTION
3825 #define DEBUG_LOC_SECTION       ".debug_loc"
3826 #endif
3827 #ifndef DEBUG_PUBNAMES_SECTION
3828 #define DEBUG_PUBNAMES_SECTION  ".debug_pubnames"
3829 #endif
3830 #ifndef DEBUG_STR_SECTION
3831 #define DEBUG_STR_SECTION       ".debug_str"
3832 #endif
3833 #ifndef DEBUG_RANGES_SECTION
3834 #define DEBUG_RANGES_SECTION    ".debug_ranges"
3835 #endif
3836
3837 /* Standard ELF section names for compiled code and data.  */
3838 #ifndef TEXT_SECTION_NAME
3839 #define TEXT_SECTION_NAME       ".text"
3840 #endif
3841
3842 /* Section flags for .debug_str section.  */
3843 #define DEBUG_STR_SECTION_FLAGS \
3844   (HAVE_GAS_SHF_MERGE && flag_merge_constants                   \
3845    ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1        \
3846    : SECTION_DEBUG)
3847
3848 /* Labels we insert at beginning sections we can reference instead of
3849    the section names themselves.  */
3850
3851 #ifndef TEXT_SECTION_LABEL
3852 #define TEXT_SECTION_LABEL              "Ltext"
3853 #endif
3854 #ifndef DEBUG_LINE_SECTION_LABEL
3855 #define DEBUG_LINE_SECTION_LABEL        "Ldebug_line"
3856 #endif
3857 #ifndef DEBUG_INFO_SECTION_LABEL
3858 #define DEBUG_INFO_SECTION_LABEL        "Ldebug_info"
3859 #endif
3860 #ifndef DEBUG_ABBREV_SECTION_LABEL
3861 #define DEBUG_ABBREV_SECTION_LABEL      "Ldebug_abbrev"
3862 #endif
3863 #ifndef DEBUG_LOC_SECTION_LABEL
3864 #define DEBUG_LOC_SECTION_LABEL         "Ldebug_loc"
3865 #endif
3866 #ifndef DEBUG_RANGES_SECTION_LABEL
3867 #define DEBUG_RANGES_SECTION_LABEL      "Ldebug_ranges"
3868 #endif
3869 #ifndef DEBUG_MACINFO_SECTION_LABEL
3870 #define DEBUG_MACINFO_SECTION_LABEL     "Ldebug_macinfo"
3871 #endif
3872
3873 /* Definitions of defaults for formats and names of various special
3874    (artificial) labels which may be generated within this file (when the -g
3875    options is used and DWARF2_DEBUGGING_INFO is in effect.
3876    If necessary, these may be overridden from within the tm.h file, but
3877    typically, overriding these defaults is unnecessary.  */
3878
3879 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
3880 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3881 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3882 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3883 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3884 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3885 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3886 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
3887
3888 #ifndef TEXT_END_LABEL
3889 #define TEXT_END_LABEL          "Letext"
3890 #endif
3891 #ifndef BLOCK_BEGIN_LABEL
3892 #define BLOCK_BEGIN_LABEL       "LBB"
3893 #endif
3894 #ifndef BLOCK_END_LABEL
3895 #define BLOCK_END_LABEL         "LBE"
3896 #endif
3897 #ifndef LINE_CODE_LABEL
3898 #define LINE_CODE_LABEL         "LM"
3899 #endif
3900 #ifndef SEPARATE_LINE_CODE_LABEL
3901 #define SEPARATE_LINE_CODE_LABEL        "LSM"
3902 #endif
3903 \f
3904 /* We allow a language front-end to designate a function that is to be
3905    called to "demangle" any name before it it put into a DIE.  */
3906
3907 static const char *(*demangle_name_func) (const char *);
3908
3909 void
3910 dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
3911 {
3912   demangle_name_func = func;
3913 }
3914
3915 /* Test if rtl node points to a pseudo register.  */
3916
3917 static inline int
3918 is_pseudo_reg (rtx rtl)
3919 {
3920   return ((GET_CODE (rtl) == REG && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
3921           || (GET_CODE (rtl) == SUBREG
3922               && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
3923 }
3924
3925 /* Return a reference to a type, with its const and volatile qualifiers
3926    removed.  */
3927
3928 static inline tree
3929 type_main_variant (tree type)
3930 {
3931   type = TYPE_MAIN_VARIANT (type);
3932
3933   /* ??? There really should be only one main variant among any group of
3934      variants of a given type (and all of the MAIN_VARIANT values for all
3935      members of the group should point to that one type) but sometimes the C
3936      front-end messes this up for array types, so we work around that bug
3937      here.  */
3938   if (TREE_CODE (type) == ARRAY_TYPE)
3939     while (type != TYPE_MAIN_VARIANT (type))
3940       type = TYPE_MAIN_VARIANT (type);
3941
3942   return type;
3943 }
3944
3945 /* Return nonzero if the given type node represents a tagged type.  */
3946
3947 static inline int
3948 is_tagged_type (tree type)
3949 {
3950   enum tree_code code = TREE_CODE (type);
3951
3952   return (code == RECORD_TYPE || code == UNION_TYPE
3953           || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
3954 }
3955
3956 /* Convert a DIE tag into its string name.  */
3957
3958 static const char *
3959 dwarf_tag_name (unsigned int tag)
3960 {
3961   switch (tag)
3962     {
3963     case DW_TAG_padding:
3964       return "DW_TAG_padding";
3965     case DW_TAG_array_type:
3966       return "DW_TAG_array_type";
3967     case DW_TAG_class_type:
3968       return "DW_TAG_class_type";
3969     case DW_TAG_entry_point:
3970       return "DW_TAG_entry_point";
3971     case DW_TAG_enumeration_type:
3972       return "DW_TAG_enumeration_type";
3973     case DW_TAG_formal_parameter:
3974       return "DW_TAG_formal_parameter";
3975     case DW_TAG_imported_declaration:
3976       return "DW_TAG_imported_declaration";
3977     case DW_TAG_label:
3978       return "DW_TAG_label";
3979     case DW_TAG_lexical_block:
3980       return "DW_TAG_lexical_block";
3981     case DW_TAG_member:
3982       return "DW_TAG_member";
3983     case DW_TAG_pointer_type:
3984       return "DW_TAG_pointer_type";
3985     case DW_TAG_reference_type:
3986       return "DW_TAG_reference_type";
3987     case DW_TAG_compile_unit:
3988       return "DW_TAG_compile_unit";
3989     case DW_TAG_string_type:
3990       return "DW_TAG_string_type";
3991     case DW_TAG_structure_type:
3992       return "DW_TAG_structure_type";
3993     case DW_TAG_subroutine_type:
3994       return "DW_TAG_subroutine_type";
3995     case DW_TAG_typedef:
3996       return "DW_TAG_typedef";
3997     case DW_TAG_union_type:
3998       return "DW_TAG_union_type";
3999     case DW_TAG_unspecified_parameters:
4000       return "DW_TAG_unspecified_parameters";
4001     case DW_TAG_variant:
4002       return "DW_TAG_variant";
4003     case DW_TAG_common_block:
4004       return "DW_TAG_common_block";
4005     case DW_TAG_common_inclusion:
4006       return "DW_TAG_common_inclusion";
4007     case DW_TAG_inheritance:
4008       return "DW_TAG_inheritance";
4009     case DW_TAG_inlined_subroutine:
4010       return "DW_TAG_inlined_subroutine";
4011     case DW_TAG_module:
4012       return "DW_TAG_module";
4013     case DW_TAG_ptr_to_member_type:
4014       return "DW_TAG_ptr_to_member_type";
4015     case DW_TAG_set_type:
4016       return "DW_TAG_set_type";
4017     case DW_TAG_subrange_type:
4018       return "DW_TAG_subrange_type";
4019     case DW_TAG_with_stmt:
4020       return "DW_TAG_with_stmt";
4021     case DW_TAG_access_declaration:
4022       return "DW_TAG_access_declaration";
4023     case DW_TAG_base_type:
4024       return "DW_TAG_base_type";
4025     case DW_TAG_catch_block:
4026       return "DW_TAG_catch_block";
4027     case DW_TAG_const_type:
4028       return "DW_TAG_const_type";
4029     case DW_TAG_constant:
4030       return "DW_TAG_constant";
4031     case DW_TAG_enumerator:
4032       return "DW_TAG_enumerator";
4033     case DW_TAG_file_type:
4034       return "DW_TAG_file_type";
4035     case DW_TAG_friend:
4036       return "DW_TAG_friend";
4037     case DW_TAG_namelist:
4038       return "DW_TAG_namelist";
4039     case DW_TAG_namelist_item:
4040       return "DW_TAG_namelist_item";
4041     case DW_TAG_namespace:
4042       return "DW_TAG_namespace";
4043     case DW_TAG_packed_type:
4044       return "DW_TAG_packed_type";
4045     case DW_TAG_subprogram:
4046       return "DW_TAG_subprogram";
4047     case DW_TAG_template_type_param:
4048       return "DW_TAG_template_type_param";
4049     case DW_TAG_template_value_param:
4050       return "DW_TAG_template_value_param";
4051     case DW_TAG_thrown_type:
4052       return "DW_TAG_thrown_type";
4053     case DW_TAG_try_block:
4054       return "DW_TAG_try_block";
4055     case DW_TAG_variant_part:
4056       return "DW_TAG_variant_part";
4057     case DW_TAG_variable:
4058       return "DW_TAG_variable";
4059     case DW_TAG_volatile_type:
4060       return "DW_TAG_volatile_type";
4061     case DW_TAG_MIPS_loop:
4062       return "DW_TAG_MIPS_loop";
4063     case DW_TAG_format_label:
4064       return "DW_TAG_format_label";
4065     case DW_TAG_function_template:
4066       return "DW_TAG_function_template";
4067     case DW_TAG_class_template:
4068       return "DW_TAG_class_template";
4069     case DW_TAG_GNU_BINCL:
4070       return "DW_TAG_GNU_BINCL";
4071     case DW_TAG_GNU_EINCL:
4072       return "DW_TAG_GNU_EINCL";
4073     default:
4074       return "DW_TAG_<unknown>";
4075     }
4076 }
4077
4078 /* Convert a DWARF attribute code into its string name.  */
4079
4080 static const char *
4081 dwarf_attr_name (unsigned int attr)
4082 {
4083   switch (attr)
4084     {
4085     case DW_AT_sibling:
4086       return "DW_AT_sibling";
4087     case DW_AT_location:
4088       return "DW_AT_location";
4089     case DW_AT_name:
4090       return "DW_AT_name";
4091     case DW_AT_ordering:
4092       return "DW_AT_ordering";
4093     case DW_AT_subscr_data:
4094       return "DW_AT_subscr_data";
4095     case DW_AT_byte_size:
4096       return "DW_AT_byte_size";
4097     case DW_AT_bit_offset:
4098       return "DW_AT_bit_offset";
4099     case DW_AT_bit_size:
4100       return "DW_AT_bit_size";
4101     case DW_AT_element_list:
4102       return "DW_AT_element_list";
4103     case DW_AT_stmt_list:
4104       return "DW_AT_stmt_list";
4105     case DW_AT_low_pc:
4106       return "DW_AT_low_pc";
4107     case DW_AT_high_pc:
4108       return "DW_AT_high_pc";
4109     case DW_AT_language:
4110       return "DW_AT_language";
4111     case DW_AT_member:
4112       return "DW_AT_member";
4113     case DW_AT_discr:
4114       return "DW_AT_discr";
4115     case DW_AT_discr_value:
4116       return "DW_AT_discr_value";
4117     case DW_AT_visibility:
4118       return "DW_AT_visibility";
4119     case DW_AT_import:
4120       return "DW_AT_import";
4121     case DW_AT_string_length:
4122       return "DW_AT_string_length";
4123     case DW_AT_common_reference:
4124       return "DW_AT_common_reference";
4125     case DW_AT_comp_dir:
4126       return "DW_AT_comp_dir";
4127     case DW_AT_const_value:
4128       return "DW_AT_const_value";
4129     case DW_AT_containing_type:
4130       return "DW_AT_containing_type";
4131     case DW_AT_default_value:
4132       return "DW_AT_default_value";
4133     case DW_AT_inline:
4134       return "DW_AT_inline";
4135     case DW_AT_is_optional:
4136       return "DW_AT_is_optional";
4137     case DW_AT_lower_bound:
4138       return "DW_AT_lower_bound";
4139     case DW_AT_producer:
4140       return "DW_AT_producer";
4141     case DW_AT_prototyped:
4142       return "DW_AT_prototyped";
4143     case DW_AT_return_addr:
4144       return "DW_AT_return_addr";
4145     case DW_AT_start_scope:
4146       return "DW_AT_start_scope";
4147     case DW_AT_stride_size:
4148       return "DW_AT_stride_size";
4149     case DW_AT_upper_bound:
4150       return "DW_AT_upper_bound";
4151     case DW_AT_abstract_origin:
4152       return "DW_AT_abstract_origin";
4153     case DW_AT_accessibility:
4154       return "DW_AT_accessibility";
4155     case DW_AT_address_class:
4156       return "DW_AT_address_class";
4157     case DW_AT_artificial:
4158       return "DW_AT_artificial";
4159     case DW_AT_base_types:
4160       return "DW_AT_base_types";
4161     case DW_AT_calling_convention:
4162       return "DW_AT_calling_convention";
4163     case DW_AT_count:
4164       return "DW_AT_count";
4165     case DW_AT_data_member_location:
4166       return "DW_AT_data_member_location";
4167     case DW_AT_decl_column:
4168       return "DW_AT_decl_column";
4169     case DW_AT_decl_file:
4170       return "DW_AT_decl_file";
4171     case DW_AT_decl_line:
4172       return "DW_AT_decl_line";
4173     case DW_AT_declaration:
4174       return "DW_AT_declaration";
4175     case DW_AT_discr_list:
4176       return "DW_AT_discr_list";
4177     case DW_AT_encoding:
4178       return "DW_AT_encoding";
4179     case DW_AT_external:
4180       return "DW_AT_external";
4181     case DW_AT_frame_base:
4182       return "DW_AT_frame_base";
4183     case DW_AT_friend:
4184       return "DW_AT_friend";
4185     case DW_AT_identifier_case:
4186       return "DW_AT_identifier_case";
4187     case DW_AT_macro_info:
4188       return "DW_AT_macro_info";
4189     case DW_AT_namelist_items:
4190       return "DW_AT_namelist_items";
4191     case DW_AT_priority:
4192       return "DW_AT_priority";
4193     case DW_AT_segment:
4194       return "DW_AT_segment";
4195     case DW_AT_specification:
4196       return "DW_AT_specification";
4197     case DW_AT_static_link:
4198       return "DW_AT_static_link";
4199     case DW_AT_type:
4200       return "DW_AT_type";
4201     case DW_AT_use_location:
4202       return "DW_AT_use_location";
4203     case DW_AT_variable_parameter:
4204       return "DW_AT_variable_parameter";
4205     case DW_AT_virtuality:
4206       return "DW_AT_virtuality";
4207     case DW_AT_vtable_elem_location:
4208       return "DW_AT_vtable_elem_location";
4209
4210     case DW_AT_allocated:
4211       return "DW_AT_allocated";
4212     case DW_AT_associated:
4213       return "DW_AT_associated";
4214     case DW_AT_data_location:
4215       return "DW_AT_data_location";
4216     case DW_AT_stride:
4217       return "DW_AT_stride";
4218     case DW_AT_entry_pc:
4219       return "DW_AT_entry_pc";
4220     case DW_AT_use_UTF8:
4221       return "DW_AT_use_UTF8";
4222     case DW_AT_extension:
4223       return "DW_AT_extension";
4224     case DW_AT_ranges:
4225       return "DW_AT_ranges";
4226     case DW_AT_trampoline:
4227       return "DW_AT_trampoline";
4228     case DW_AT_call_column:
4229       return "DW_AT_call_column";
4230     case DW_AT_call_file:
4231       return "DW_AT_call_file";
4232     case DW_AT_call_line:
4233       return "DW_AT_call_line";
4234
4235     case DW_AT_MIPS_fde:
4236       return "DW_AT_MIPS_fde";
4237     case DW_AT_MIPS_loop_begin:
4238       return "DW_AT_MIPS_loop_begin";
4239     case DW_AT_MIPS_tail_loop_begin:
4240       return "DW_AT_MIPS_tail_loop_begin";
4241     case DW_AT_MIPS_epilog_begin:
4242       return "DW_AT_MIPS_epilog_begin";
4243     case DW_AT_MIPS_loop_unroll_factor:
4244       return "DW_AT_MIPS_loop_unroll_factor";
4245     case DW_AT_MIPS_software_pipeline_depth:
4246       return "DW_AT_MIPS_software_pipeline_depth";
4247     case DW_AT_MIPS_linkage_name:
4248       return "DW_AT_MIPS_linkage_name";
4249     case DW_AT_MIPS_stride:
4250       return "DW_AT_MIPS_stride";
4251     case DW_AT_MIPS_abstract_name:
4252       return "DW_AT_MIPS_abstract_name";
4253     case DW_AT_MIPS_clone_origin:
4254       return "DW_AT_MIPS_clone_origin";
4255     case DW_AT_MIPS_has_inlines:
4256       return "DW_AT_MIPS_has_inlines";
4257
4258     case DW_AT_sf_names:
4259       return "DW_AT_sf_names";
4260     case DW_AT_src_info:
4261       return "DW_AT_src_info";
4262     case DW_AT_mac_info:
4263       return "DW_AT_mac_info";
4264     case DW_AT_src_coords:
4265       return "DW_AT_src_coords";
4266     case DW_AT_body_begin:
4267       return "DW_AT_body_begin";
4268     case DW_AT_body_end:
4269       return "DW_AT_body_end";
4270     case DW_AT_GNU_vector:
4271       return "DW_AT_GNU_vector";
4272
4273     case DW_AT_VMS_rtnbeg_pd_address:
4274       return "DW_AT_VMS_rtnbeg_pd_address";
4275
4276     default:
4277       return "DW_AT_<unknown>";
4278     }
4279 }
4280
4281 /* Convert a DWARF value form code into its string name.  */
4282
4283 static const char *
4284 dwarf_form_name (unsigned int form)
4285 {
4286   switch (form)
4287     {
4288     case DW_FORM_addr:
4289       return "DW_FORM_addr";
4290     case DW_FORM_block2:
4291       return "DW_FORM_block2";
4292     case DW_FORM_block4:
4293       return "DW_FORM_block4";
4294     case DW_FORM_data2:
4295       return "DW_FORM_data2";
4296     case DW_FORM_data4:
4297       return "DW_FORM_data4";
4298     case DW_FORM_data8:
4299       return "DW_FORM_data8";
4300     case DW_FORM_string:
4301       return "DW_FORM_string";
4302     case DW_FORM_block:
4303       return "DW_FORM_block";
4304     case DW_FORM_block1:
4305       return "DW_FORM_block1";
4306     case DW_FORM_data1:
4307       return "DW_FORM_data1";
4308     case DW_FORM_flag:
4309     &nb