OSDN Git Service

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