OSDN Git Service

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