OSDN Git Service

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