OSDN Git Service

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