OSDN Git Service

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