OSDN Git Service

* dwarf2asm.c (dw2_asm_output_offset): Mark 'base' argument
[pf3gnuchains/gcc-fork.git] / gcc / dwarf2asm.c
1 /* Dwarf2 assembler output helper routines.
2    Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 2, or (at your option) any later
9 version.
10
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING.  If not, write to the Free
18 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
19 02110-1301, USA.  */
20
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "flags.h"
27 #include "tree.h"
28 #include "rtl.h"
29 #include "output.h"
30 #include "target.h"
31 #include "dwarf2asm.h"
32 #include "dwarf2.h"
33 #include "splay-tree.h"
34 #include "ggc.h"
35 #include "tm_p.h"
36
37
38 /* How to start an assembler comment.  */
39 #ifndef ASM_COMMENT_START
40 #define ASM_COMMENT_START ";#"
41 #endif
42
43 \f
44 /* Output an unaligned integer with the given value and size.  Prefer not
45    to print a newline, since the caller may want to add a comment.  */
46
47 void
48 dw2_assemble_integer (int size, rtx x)
49 {
50   const char *op = integer_asm_op (size, FALSE);
51
52   if (op)
53     {
54       fputs (op, asm_out_file);
55       if (GET_CODE (x) == CONST_INT)
56         fprintf (asm_out_file, HOST_WIDE_INT_PRINT_HEX, INTVAL (x));
57       else
58         output_addr_const (asm_out_file, x);
59     }
60   else
61     assemble_integer (x, size, BITS_PER_UNIT, 1);
62 }
63
64
65 /* Output an immediate constant in a given size.  */
66
67 void
68 dw2_asm_output_data (int size, unsigned HOST_WIDE_INT value,
69                      const char *comment, ...)
70 {
71   va_list ap;
72
73   va_start (ap, comment);
74
75   if (size * 8 < HOST_BITS_PER_WIDE_INT)
76     value &= ~(~(unsigned HOST_WIDE_INT) 0 << (size * 8));
77
78   dw2_assemble_integer (size, GEN_INT (value));
79
80   if (flag_debug_asm && comment)
81     {
82       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
83       vfprintf (asm_out_file, comment, ap);
84     }
85   fputc ('\n', asm_out_file);
86
87   va_end (ap);
88 }
89
90 /* Output the difference between two symbols in a given size.  */
91 /* ??? There appear to be assemblers that do not like such
92    subtraction, but do support ASM_SET_OP.  It's unfortunately
93    impossible to do here, since the ASM_SET_OP for the difference
94    symbol must appear after both symbols are defined.  */
95
96 void
97 dw2_asm_output_delta (int size, const char *lab1, const char *lab2,
98                       const char *comment, ...)
99 {
100   va_list ap;
101
102   va_start (ap, comment);
103
104 #ifdef ASM_OUTPUT_DWARF_DELTA
105   ASM_OUTPUT_DWARF_DELTA (asm_out_file, size, lab1, lab2);
106 #else
107   dw2_assemble_integer (size,
108                         gen_rtx_MINUS (Pmode,
109                                        gen_rtx_SYMBOL_REF (Pmode, lab1),
110                                        gen_rtx_SYMBOL_REF (Pmode, lab2)));
111 #endif
112   if (flag_debug_asm && comment)
113     {
114       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
115       vfprintf (asm_out_file, comment, ap);
116     }
117   fputc ('\n', asm_out_file);
118
119   va_end (ap);
120 }
121
122 /* Output a section-relative reference to a LABEL, which was placed in
123    BASE.  In general this can only be done for debugging symbols.
124    E.g. on most targets with the GNU linker, this is accomplished with
125    a direct reference and the knowledge that the debugging section
126    will be placed at VMA 0.  Some targets have special relocations for
127    this that we must use.  */
128
129 void
130 dw2_asm_output_offset (int size, const char *label,
131                        section *base ATTRIBUTE_UNUSED,
132                        const char *comment, ...)
133 {
134   va_list ap;
135
136   va_start (ap, comment);
137
138 #ifdef ASM_OUTPUT_DWARF_OFFSET
139   ASM_OUTPUT_DWARF_OFFSET (asm_out_file, size, label, base);
140 #else
141   dw2_assemble_integer (size, gen_rtx_SYMBOL_REF (Pmode, label));
142 #endif
143
144   if (flag_debug_asm && comment)
145     {
146       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
147       vfprintf (asm_out_file, comment, ap);
148     }
149   fputc ('\n', asm_out_file);
150
151   va_end (ap);
152 }
153
154 #if 0
155
156 /* Output a self-relative reference to a label, possibly in a
157    different section or object file.  */
158
159 void
160 dw2_asm_output_pcrel (int size ATTRIBUTE_UNUSED,
161                       const char *label ATTRIBUTE_UNUSED,
162                       const char *comment, ...)
163 {
164   va_list ap;
165
166   va_start (ap, comment);
167
168 #ifdef ASM_OUTPUT_DWARF_PCREL
169   ASM_OUTPUT_DWARF_PCREL (asm_out_file, size, label);
170 #else
171   dw2_assemble_integer (size,
172                         gen_rtx_MINUS (Pmode,
173                                        gen_rtx_SYMBOL_REF (Pmode, label),
174                                        pc_rtx));
175 #endif
176
177   if (flag_debug_asm && comment)
178     {
179       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
180       vfprintf (asm_out_file, comment, ap);
181     }
182   fputc ('\n', asm_out_file);
183
184   va_end (ap);
185 }
186 #endif /* 0 */
187
188 /* Output an absolute reference to a label.  */
189
190 void
191 dw2_asm_output_addr (int size, const char *label,
192                      const char *comment, ...)
193 {
194   va_list ap;
195
196   va_start (ap, comment);
197
198   dw2_assemble_integer (size, gen_rtx_SYMBOL_REF (Pmode, label));
199
200   if (flag_debug_asm && comment)
201     {
202       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
203       vfprintf (asm_out_file, comment, ap);
204     }
205   fputc ('\n', asm_out_file);
206
207   va_end (ap);
208 }
209
210 /* Similar, but use an RTX expression instead of a text label.  */
211
212 void
213 dw2_asm_output_addr_rtx (int size, rtx addr,
214                          const char *comment, ...)
215 {
216   va_list ap;
217
218   va_start (ap, comment);
219
220   dw2_assemble_integer (size, addr);
221
222   if (flag_debug_asm && comment)
223     {
224       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
225       vfprintf (asm_out_file, comment, ap);
226     }
227   fputc ('\n', asm_out_file);
228
229   va_end (ap);
230 }
231
232 /* Output the first ORIG_LEN characters of STR as a string.
233    If ORIG_LEN is equal to -1, ignore this parameter and output
234    the entire STR instead.
235    If COMMENT is not NULL and comments in the debug information
236    have been requested by the user, append the given COMMENT
237    to the generated output.  */
238    
239 void
240 dw2_asm_output_nstring (const char *str, size_t orig_len,
241                         const char *comment, ...)
242 {
243   size_t i, len;
244   va_list ap;
245
246   va_start (ap, comment);
247
248   len = orig_len;
249
250   if (len == (size_t) -1)
251     len = strlen (str);
252
253   if (flag_debug_asm && comment)
254     {
255       fputs ("\t.ascii \"", asm_out_file);
256       for (i = 0; i < len; i++)
257         {
258           int c = str[i];
259           if (c == '\"' || c == '\\')
260             fputc ('\\', asm_out_file);
261           if (ISPRINT(c))
262             fputc (c, asm_out_file);
263           else
264             fprintf (asm_out_file, "\\%o", c);
265         }
266       fprintf (asm_out_file, "\\0\"\t%s ", ASM_COMMENT_START);
267       vfprintf (asm_out_file, comment, ap);
268       fputc ('\n', asm_out_file);
269     }
270   else
271     {
272       /* If an explicit length was given, we can't assume there
273          is a null termination in the string buffer.  */
274       if (orig_len == (size_t) -1)
275         len += 1;
276       ASM_OUTPUT_ASCII (asm_out_file, str, len);
277       if (orig_len != (size_t) -1)
278         assemble_integer (const0_rtx, 1, BITS_PER_UNIT, 1);
279     }
280
281   va_end (ap);
282 }
283 \f
284
285 /* Return the size of an unsigned LEB128 quantity.  */
286
287 int
288 size_of_uleb128 (unsigned HOST_WIDE_INT value)
289 {
290   int size = 0;
291
292   do
293     {
294       value >>= 7;
295       size += 1;
296     }
297   while (value != 0);
298
299   return size;
300 }
301
302 /* Return the size of a signed LEB128 quantity.  */
303
304 int
305 size_of_sleb128 (HOST_WIDE_INT value)
306 {
307   int size = 0, byte;
308
309   do
310     {
311       byte = (value & 0x7f);
312       value >>= 7;
313       size += 1;
314     }
315   while (!((value == 0 && (byte & 0x40) == 0)
316            || (value == -1 && (byte & 0x40) != 0)));
317
318   return size;
319 }
320
321 /* Given an encoding, return the number of bytes the format occupies.
322    This is only defined for fixed-size encodings, and so does not
323    include leb128.  */
324
325 int
326 size_of_encoded_value (int encoding)
327 {
328   if (encoding == DW_EH_PE_omit)
329     return 0;
330
331   switch (encoding & 0x07)
332     {
333     case DW_EH_PE_absptr:
334       return POINTER_SIZE / BITS_PER_UNIT;
335     case DW_EH_PE_udata2:
336       return 2;
337     case DW_EH_PE_udata4:
338       return 4;
339     case DW_EH_PE_udata8:
340       return 8;
341     default:
342       gcc_unreachable ();
343     }
344 }
345
346 /* Yield a name for a given pointer encoding.  */
347
348 const char *
349 eh_data_format_name (int format)
350 {
351 #if HAVE_DESIGNATED_INITIALIZERS
352 #define S(p, v)         [p] = v,
353 #else
354 #define S(p, v)         case p: return v;
355 #endif
356
357 #if HAVE_DESIGNATED_INITIALIZERS
358   __extension__ static const char * const format_names[256] = {
359 #else
360   switch (format) {
361 #endif
362
363   S(DW_EH_PE_absptr, "absolute")
364   S(DW_EH_PE_omit, "omit")
365   S(DW_EH_PE_aligned, "aligned absolute")
366
367   S(DW_EH_PE_uleb128, "uleb128")
368   S(DW_EH_PE_udata2, "udata2")
369   S(DW_EH_PE_udata4, "udata4")
370   S(DW_EH_PE_udata8, "udata8")
371   S(DW_EH_PE_sleb128, "sleb128")
372   S(DW_EH_PE_sdata2, "sdata2")
373   S(DW_EH_PE_sdata4, "sdata4")
374   S(DW_EH_PE_sdata8, "sdata8")
375
376   S(DW_EH_PE_absptr | DW_EH_PE_pcrel, "pcrel")
377   S(DW_EH_PE_uleb128 | DW_EH_PE_pcrel, "pcrel uleb128")
378   S(DW_EH_PE_udata2 | DW_EH_PE_pcrel, "pcrel udata2")
379   S(DW_EH_PE_udata4 | DW_EH_PE_pcrel, "pcrel udata4")
380   S(DW_EH_PE_udata8 | DW_EH_PE_pcrel, "pcrel udata8")
381   S(DW_EH_PE_sleb128 | DW_EH_PE_pcrel, "pcrel sleb128")
382   S(DW_EH_PE_sdata2 | DW_EH_PE_pcrel, "pcrel sdata2")
383   S(DW_EH_PE_sdata4 | DW_EH_PE_pcrel, "pcrel sdata4")
384   S(DW_EH_PE_sdata8 | DW_EH_PE_pcrel, "pcrel sdata8")
385
386   S(DW_EH_PE_absptr | DW_EH_PE_textrel, "textrel")
387   S(DW_EH_PE_uleb128 | DW_EH_PE_textrel, "textrel uleb128")
388   S(DW_EH_PE_udata2 | DW_EH_PE_textrel, "textrel udata2")
389   S(DW_EH_PE_udata4 | DW_EH_PE_textrel, "textrel udata4")
390   S(DW_EH_PE_udata8 | DW_EH_PE_textrel, "textrel udata8")
391   S(DW_EH_PE_sleb128 | DW_EH_PE_textrel, "textrel sleb128")
392   S(DW_EH_PE_sdata2 | DW_EH_PE_textrel, "textrel sdata2")
393   S(DW_EH_PE_sdata4 | DW_EH_PE_textrel, "textrel sdata4")
394   S(DW_EH_PE_sdata8 | DW_EH_PE_textrel, "textrel sdata8")
395
396   S(DW_EH_PE_absptr | DW_EH_PE_datarel, "datarel")
397   S(DW_EH_PE_uleb128 | DW_EH_PE_datarel, "datarel uleb128")
398   S(DW_EH_PE_udata2 | DW_EH_PE_datarel, "datarel udata2")
399   S(DW_EH_PE_udata4 | DW_EH_PE_datarel, "datarel udata4")
400   S(DW_EH_PE_udata8 | DW_EH_PE_datarel, "datarel udata8")
401   S(DW_EH_PE_sleb128 | DW_EH_PE_datarel, "datarel sleb128")
402   S(DW_EH_PE_sdata2 | DW_EH_PE_datarel, "datarel sdata2")
403   S(DW_EH_PE_sdata4 | DW_EH_PE_datarel, "datarel sdata4")
404   S(DW_EH_PE_sdata8 | DW_EH_PE_datarel, "datarel sdata8")
405
406   S(DW_EH_PE_absptr | DW_EH_PE_funcrel, "funcrel")
407   S(DW_EH_PE_uleb128 | DW_EH_PE_funcrel, "funcrel uleb128")
408   S(DW_EH_PE_udata2 | DW_EH_PE_funcrel, "funcrel udata2")
409   S(DW_EH_PE_udata4 | DW_EH_PE_funcrel, "funcrel udata4")
410   S(DW_EH_PE_udata8 | DW_EH_PE_funcrel, "funcrel udata8")
411   S(DW_EH_PE_sleb128 | DW_EH_PE_funcrel, "funcrel sleb128")
412   S(DW_EH_PE_sdata2 | DW_EH_PE_funcrel, "funcrel sdata2")
413   S(DW_EH_PE_sdata4 | DW_EH_PE_funcrel, "funcrel sdata4")
414   S(DW_EH_PE_sdata8 | DW_EH_PE_funcrel, "funcrel sdata8")
415
416   S(DW_EH_PE_indirect | DW_EH_PE_absptr | DW_EH_PE_pcrel,
417     "indirect pcrel")
418   S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_pcrel,
419     "indirect pcrel uleb128")
420   S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_pcrel,
421     "indirect pcrel udata2")
422   S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_pcrel,
423     "indirect pcrel udata4")
424   S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_pcrel,
425     "indirect pcrel udata8")
426   S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_pcrel,
427     "indirect pcrel sleb128")
428   S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_pcrel,
429     "indirect pcrel sdata2")
430   S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_pcrel,
431     "indirect pcrel sdata4")
432   S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_pcrel,
433     "indirect pcrel sdata8")
434
435   S(DW_EH_PE_indirect | DW_EH_PE_absptr | DW_EH_PE_textrel,
436     "indirect textrel")
437   S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_textrel,
438     "indirect textrel uleb128")
439   S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_textrel,
440     "indirect textrel udata2")
441   S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_textrel,
442     "indirect textrel udata4")
443   S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_textrel,
444     "indirect textrel udata8")
445   S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_textrel,
446     "indirect textrel sleb128")
447   S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_textrel,
448     "indirect textrel sdata2")
449   S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_textrel,
450     "indirect textrel sdata4")
451   S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_textrel,
452     "indirect textrel sdata8")
453
454   S(DW_EH_PE_indirect | DW_EH_PE_absptr | DW_EH_PE_datarel,
455     "indirect datarel")
456   S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_datarel,
457     "indirect datarel uleb128")
458   S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_datarel,
459     "indirect datarel udata2")
460   S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_datarel,
461     "indirect datarel udata4")
462   S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_datarel,
463     "indirect datarel udata8")
464   S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_datarel,
465     "indirect datarel sleb128")
466   S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_datarel,
467     "indirect datarel sdata2")
468   S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_datarel,
469     "indirect datarel sdata4")
470   S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_datarel,
471     "indirect datarel sdata8")
472
473   S(DW_EH_PE_indirect | DW_EH_PE_absptr | DW_EH_PE_funcrel,
474     "indirect funcrel")
475   S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_funcrel,
476     "indirect funcrel uleb128")
477   S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_funcrel,
478     "indirect funcrel udata2")
479   S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_funcrel,
480     "indirect funcrel udata4")
481   S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_funcrel,
482     "indirect funcrel udata8")
483   S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_funcrel,
484     "indirect funcrel sleb128")
485   S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_funcrel,
486     "indirect funcrel sdata2")
487   S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_funcrel,
488     "indirect funcrel sdata4")
489   S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_funcrel,
490     "indirect funcrel sdata8")
491
492 #if HAVE_DESIGNATED_INITIALIZERS
493   };
494
495   gcc_assert (format >= 0 && format < 0x100 && format_names[format]);
496   
497   return format_names[format];
498 #else
499   }
500   gcc_unreachable ();
501 #endif
502 }
503
504 /* Output an unsigned LEB128 quantity.  */
505
506 void
507 dw2_asm_output_data_uleb128 (unsigned HOST_WIDE_INT value,
508                              const char *comment, ...)
509 {
510   va_list ap;
511
512   va_start (ap, comment);
513
514 #ifdef HAVE_AS_LEB128
515   fprintf (asm_out_file, "\t.uleb128 " HOST_WIDE_INT_PRINT_HEX , value);
516
517   if (flag_debug_asm && comment)
518     {
519       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
520       vfprintf (asm_out_file, comment, ap);
521     }
522 #else
523   {
524     unsigned HOST_WIDE_INT work = value;
525     const char *byte_op = targetm.asm_out.byte_op;
526
527     if (byte_op)
528       fputs (byte_op, asm_out_file);
529     do
530       {
531         int byte = (work & 0x7f);
532         work >>= 7;
533         if (work != 0)
534           /* More bytes to follow.  */
535           byte |= 0x80;
536
537         if (byte_op)
538           {
539             fprintf (asm_out_file, "0x%x", byte);
540             if (work != 0)
541               fputc (',', asm_out_file);
542           }
543         else
544           assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
545       }
546     while (work != 0);
547
548   if (flag_debug_asm)
549     {
550       fprintf (asm_out_file, "\t%s uleb128 " HOST_WIDE_INT_PRINT_HEX,
551                ASM_COMMENT_START, value);
552       if (comment)
553         {
554           fputs ("; ", asm_out_file);
555           vfprintf (asm_out_file, comment, ap);
556         }
557     }
558   }
559 #endif
560   fputc ('\n', asm_out_file);
561
562   va_end (ap);
563 }
564
565 /* Output a signed LEB128 quantity.  */
566
567 void
568 dw2_asm_output_data_sleb128 (HOST_WIDE_INT value,
569                              const char *comment, ...)
570 {
571   va_list ap;
572
573   va_start (ap, comment);
574
575 #ifdef HAVE_AS_LEB128
576   fprintf (asm_out_file, "\t.sleb128 " HOST_WIDE_INT_PRINT_DEC, value);
577
578   if (flag_debug_asm && comment)
579     {
580       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
581       vfprintf (asm_out_file, comment, ap);
582     }
583 #else
584   {
585     HOST_WIDE_INT work = value;
586     int more, byte;
587     const char *byte_op = targetm.asm_out.byte_op;
588
589     if (byte_op)
590       fputs (byte_op, asm_out_file);
591     do
592       {
593         byte = (work & 0x7f);
594         /* arithmetic shift */
595         work >>= 7;
596         more = !((work == 0 && (byte & 0x40) == 0)
597                  || (work == -1 && (byte & 0x40) != 0));
598         if (more)
599           byte |= 0x80;
600
601         if (byte_op)
602           {
603             fprintf (asm_out_file, "0x%x", byte);
604             if (more)
605               fputc (',', asm_out_file);
606           }
607         else
608           assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
609       }
610     while (more);
611
612   if (flag_debug_asm)
613     {
614       fprintf (asm_out_file, "\t%s sleb128 " HOST_WIDE_INT_PRINT_DEC,
615                ASM_COMMENT_START, value);
616       if (comment)
617         {
618           fputs ("; ", asm_out_file);
619           vfprintf (asm_out_file, comment, ap);
620         }
621     }
622   }
623 #endif
624   fputc ('\n', asm_out_file);
625
626   va_end (ap);
627 }
628
629 void
630 dw2_asm_output_delta_uleb128 (const char *lab1 ATTRIBUTE_UNUSED,
631                               const char *lab2 ATTRIBUTE_UNUSED,
632                               const char *comment, ...)
633 {
634   va_list ap;
635
636   va_start (ap, comment);
637
638 #ifdef HAVE_AS_LEB128
639   fputs ("\t.uleb128 ", asm_out_file);
640   assemble_name (asm_out_file, lab1);
641   fputc ('-', asm_out_file);
642   assemble_name (asm_out_file, lab2);
643 #else
644   gcc_unreachable ();
645 #endif
646
647   if (flag_debug_asm && comment)
648     {
649       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
650       vfprintf (asm_out_file, comment, ap);
651     }
652   fputc ('\n', asm_out_file);
653
654   va_end (ap);
655 }
656
657 #if 0
658
659 void
660 dw2_asm_output_delta_sleb128 (const char *lab1 ATTRIBUTE_UNUSED,
661                               const char *lab2 ATTRIBUTE_UNUSED,
662                               const char *comment, ...)
663 {
664   va_list ap;
665
666   va_start (ap, comment);
667
668 #ifdef HAVE_AS_LEB128
669   fputs ("\t.sleb128 ", asm_out_file);
670   assemble_name (asm_out_file, lab1);
671   fputc ('-', asm_out_file);
672   assemble_name (asm_out_file, lab2);
673 #else
674   gcc_unreachable ();
675 #endif
676
677   if (flag_debug_asm && comment)
678     {
679       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
680       vfprintf (asm_out_file, comment, ap);
681     }
682   fputc ('\n', asm_out_file);
683
684   va_end (ap);
685 }
686 #endif /* 0 */
687 \f
688 static rtx dw2_force_const_mem (rtx, bool);
689 static int dw2_output_indirect_constant_1 (splay_tree_node, void *);
690
691 static GTY((param1_is (char *), param2_is (tree))) splay_tree indirect_pool;
692
693 static GTY(()) int dw2_const_labelno;
694
695 #if defined(HAVE_GAS_HIDDEN) && defined(SUPPORTS_ONE_ONLY)
696 # define USE_LINKONCE_INDIRECT 1
697 #else
698 # define USE_LINKONCE_INDIRECT 0
699 #endif
700
701 /* Put X, a SYMBOL_REF, in memory.  Return a SYMBOL_REF to the allocated
702    memory.  Differs from force_const_mem in that a single pool is used for
703    the entire unit of translation, and the memory is not guaranteed to be
704    "near" the function in any interesting sense.  PUBLIC controls whether
705    the symbol can be shared across the entire application (or DSO).  */
706
707 static rtx
708 dw2_force_const_mem (rtx x, bool public)
709 {
710   splay_tree_node node;
711   const char *str;
712   tree decl;
713
714   if (! indirect_pool)
715     indirect_pool = splay_tree_new_ggc (splay_tree_compare_pointers);
716
717   gcc_assert (GET_CODE (x) == SYMBOL_REF);
718
719   str = targetm.strip_name_encoding (XSTR (x, 0));
720   node = splay_tree_lookup (indirect_pool, (splay_tree_key) str);
721   if (node)
722     decl = (tree) node->value;
723   else
724     {
725       tree id;
726
727       if (public && USE_LINKONCE_INDIRECT)
728         {
729           char *ref_name = alloca (strlen (str) + sizeof "DW.ref.");
730
731           sprintf (ref_name, "DW.ref.%s", str);
732           id = get_identifier (ref_name);
733           decl = build_decl (VAR_DECL, id, ptr_type_node);
734           DECL_ARTIFICIAL (decl) = 1;
735           DECL_IGNORED_P (decl) = 1;
736           TREE_PUBLIC (decl) = 1;
737           DECL_INITIAL (decl) = decl;
738           make_decl_one_only (decl);
739         }
740       else
741         {
742           char label[32];
743
744           ASM_GENERATE_INTERNAL_LABEL (label, "LDFCM", dw2_const_labelno);
745           ++dw2_const_labelno;
746           id = get_identifier (label);
747           decl = build_decl (VAR_DECL, id, ptr_type_node);
748           DECL_ARTIFICIAL (decl) = 1;
749           DECL_IGNORED_P (decl) = 1;
750           TREE_STATIC (decl) = 1;
751           DECL_INITIAL (decl) = decl;
752         }
753
754       id = maybe_get_identifier (str);
755       if (id)
756         TREE_SYMBOL_REFERENCED (id) = 1;
757
758       splay_tree_insert (indirect_pool, (splay_tree_key) str,
759                          (splay_tree_value) decl);
760     }
761
762   return XEXP (DECL_RTL (decl), 0);
763 }
764
765 /* A helper function for dw2_output_indirect_constants called through
766    splay_tree_foreach.  Emit one queued constant to memory.  */
767
768 static int
769 dw2_output_indirect_constant_1 (splay_tree_node node,
770                                 void *data ATTRIBUTE_UNUSED)
771 {
772   const char *sym;
773   rtx sym_ref;
774   tree decl;
775
776   sym = (const char *) node->key;
777   decl = (tree) node->value;
778   sym_ref = gen_rtx_SYMBOL_REF (Pmode, sym);
779   if (TREE_PUBLIC (decl) && USE_LINKONCE_INDIRECT)
780     fprintf (asm_out_file, "\t.hidden %sDW.ref.%s\n", user_label_prefix, sym);
781   assemble_variable (decl, 1, 1, 1);
782   assemble_integer (sym_ref, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
783
784   return 0;
785 }
786
787 /* Emit the constants queued through dw2_force_const_mem.  */
788
789 void
790 dw2_output_indirect_constants (void)
791 {
792   if (indirect_pool)
793     splay_tree_foreach (indirect_pool, dw2_output_indirect_constant_1, NULL);
794 }
795
796 /* Like dw2_asm_output_addr_rtx, but encode the pointer as directed.
797    If PUBLIC is set and the encoding is DW_EH_PE_indirect, the indirect
798    reference is shared across the entire application (or DSO).  */
799
800 void
801 dw2_asm_output_encoded_addr_rtx (int encoding, rtx addr, bool public,
802                                  const char *comment, ...)
803 {
804   int size;
805   va_list ap;
806
807   va_start (ap, comment);
808
809   size = size_of_encoded_value (encoding);
810
811   if (encoding == DW_EH_PE_aligned)
812     {
813       assemble_align (POINTER_SIZE);
814       assemble_integer (addr, size, POINTER_SIZE, 1);
815       return;
816     }
817
818   /* NULL is _always_ represented as a plain zero, as is 1 for Ada's
819      "all others".  */
820   if (addr == const0_rtx || addr == const1_rtx)
821     assemble_integer (addr, size, BITS_PER_UNIT, 1);
822   else
823     {
824     restart:
825       /* Allow the target first crack at emitting this.  Some of the
826          special relocations require special directives instead of
827          just ".4byte" or whatever.  */
828 #ifdef ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX
829       ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX (asm_out_file, encoding, size,
830                                          addr, done);
831 #endif
832
833       /* Indirection is used to get dynamic relocations out of a
834          read-only section.  */
835       if (encoding & DW_EH_PE_indirect)
836         {
837           /* It is very tempting to use force_const_mem so that we share data
838              with the normal constant pool.  However, we've already emitted
839              the constant pool for this function.  Moreover, we'd like to
840              share these constants across the entire unit of translation and
841              even, if possible, across the entire application (or DSO).  */
842           addr = dw2_force_const_mem (addr, public);
843           encoding &= ~DW_EH_PE_indirect;
844           goto restart;
845         }
846
847       switch (encoding & 0xF0)
848         {
849         case DW_EH_PE_absptr:
850           dw2_assemble_integer (size, addr);
851           break;
852
853         case DW_EH_PE_pcrel:
854           gcc_assert (GET_CODE (addr) == SYMBOL_REF);
855 #ifdef ASM_OUTPUT_DWARF_PCREL
856           ASM_OUTPUT_DWARF_PCREL (asm_out_file, size, XSTR (addr, 0));
857 #else
858           dw2_assemble_integer (size, gen_rtx_MINUS (Pmode, addr, pc_rtx));
859 #endif
860           break;
861
862         default:
863           /* Other encodings should have been handled by
864              ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX.  */
865           gcc_unreachable ();
866         }
867
868 #ifdef ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX
869     done:;
870 #endif
871     }
872
873   if (flag_debug_asm && comment)
874     {
875       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
876       vfprintf (asm_out_file, comment, ap);
877     }
878   fputc ('\n', asm_out_file);
879
880   va_end (ap);
881 }
882
883 #include "gt-dwarf2asm.h"