Daily bump.
[official-gcc.git] / gcc / dwarf2asm.c
blob11903fe81a9b0921fcb0237986500484168f475d
1 /* Dwarf2 assembler output helper routines.
2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
4 This file is part of GCC.
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 3, or (at your option) any later
9 version.
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.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "tm.h"
25 #include "flags.h"
26 #include "tree.h"
27 #include "rtl.h"
28 #include "output.h"
29 #include "target.h"
30 #include "dwarf2asm.h"
31 #include "dwarf2.h"
32 #include "splay-tree.h"
33 #include "ggc.h"
34 #include "tm_p.h"
37 /* How to start an assembler comment. */
38 #ifndef ASM_COMMENT_START
39 #define ASM_COMMENT_START ";#"
40 #endif
43 /* Output an unaligned integer with the given value and size. Prefer not
44 to print a newline, since the caller may want to add a comment. */
46 void
47 dw2_assemble_integer (int size, rtx x)
49 const char *op = integer_asm_op (size, FALSE);
51 if (op)
53 fputs (op, asm_out_file);
54 if (GET_CODE (x) == CONST_INT)
55 fprintf (asm_out_file, HOST_WIDE_INT_PRINT_HEX, INTVAL (x));
56 else
57 output_addr_const (asm_out_file, x);
59 else
60 assemble_integer (x, size, BITS_PER_UNIT, 1);
64 /* Output an immediate constant in a given size. */
66 void
67 dw2_asm_output_data (int size, unsigned HOST_WIDE_INT value,
68 const char *comment, ...)
70 va_list ap;
71 const char *op = integer_asm_op (size, FALSE);
73 va_start (ap, comment);
75 if (size * 8 < HOST_BITS_PER_WIDE_INT)
76 value &= ~(~(unsigned HOST_WIDE_INT) 0 << (size * 8));
78 if (op)
79 fprintf (asm_out_file, "%s" HOST_WIDE_INT_PRINT_HEX, op, value);
80 else
81 assemble_integer (GEN_INT (value), size, BITS_PER_UNIT, 1);
83 if (flag_debug_asm && comment)
85 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
86 vfprintf (asm_out_file, comment, ap);
88 fputc ('\n', asm_out_file);
90 va_end (ap);
93 /* Output the difference between two symbols in a given size. */
94 /* ??? There appear to be assemblers that do not like such
95 subtraction, but do support ASM_SET_OP. It's unfortunately
96 impossible to do here, since the ASM_SET_OP for the difference
97 symbol must appear after both symbols are defined. */
99 void
100 dw2_asm_output_delta (int size, const char *lab1, const char *lab2,
101 const char *comment, ...)
103 va_list ap;
105 va_start (ap, comment);
107 #ifdef ASM_OUTPUT_DWARF_DELTA
108 ASM_OUTPUT_DWARF_DELTA (asm_out_file, size, lab1, lab2);
109 #else
110 dw2_assemble_integer (size,
111 gen_rtx_MINUS (Pmode,
112 gen_rtx_SYMBOL_REF (Pmode, lab1),
113 gen_rtx_SYMBOL_REF (Pmode, lab2)));
114 #endif
115 if (flag_debug_asm && comment)
117 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
118 vfprintf (asm_out_file, comment, ap);
120 fputc ('\n', asm_out_file);
122 va_end (ap);
125 /* Output a section-relative reference to a LABEL, which was placed in
126 BASE. In general this can only be done for debugging symbols.
127 E.g. on most targets with the GNU linker, this is accomplished with
128 a direct reference and the knowledge that the debugging section
129 will be placed at VMA 0. Some targets have special relocations for
130 this that we must use. */
132 void
133 dw2_asm_output_offset (int size, const char *label,
134 section *base ATTRIBUTE_UNUSED,
135 const char *comment, ...)
137 va_list ap;
139 va_start (ap, comment);
141 #ifdef ASM_OUTPUT_DWARF_OFFSET
142 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, size, label, base);
143 #else
144 dw2_assemble_integer (size, gen_rtx_SYMBOL_REF (Pmode, label));
145 #endif
147 if (flag_debug_asm && comment)
149 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
150 vfprintf (asm_out_file, comment, ap);
152 fputc ('\n', asm_out_file);
154 va_end (ap);
157 #if 0
159 /* Output a self-relative reference to a label, possibly in a
160 different section or object file. */
162 void
163 dw2_asm_output_pcrel (int size ATTRIBUTE_UNUSED,
164 const char *label ATTRIBUTE_UNUSED,
165 const char *comment, ...)
167 va_list ap;
169 va_start (ap, comment);
171 #ifdef ASM_OUTPUT_DWARF_PCREL
172 ASM_OUTPUT_DWARF_PCREL (asm_out_file, size, label);
173 #else
174 dw2_assemble_integer (size,
175 gen_rtx_MINUS (Pmode,
176 gen_rtx_SYMBOL_REF (Pmode, label),
177 pc_rtx));
178 #endif
180 if (flag_debug_asm && comment)
182 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
183 vfprintf (asm_out_file, comment, ap);
185 fputc ('\n', asm_out_file);
187 va_end (ap);
189 #endif /* 0 */
191 /* Output an absolute reference to a label. */
193 void
194 dw2_asm_output_addr (int size, const char *label,
195 const char *comment, ...)
197 va_list ap;
199 va_start (ap, comment);
201 dw2_assemble_integer (size, gen_rtx_SYMBOL_REF (Pmode, label));
203 if (flag_debug_asm && comment)
205 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
206 vfprintf (asm_out_file, comment, ap);
208 fputc ('\n', asm_out_file);
210 va_end (ap);
213 /* Similar, but use an RTX expression instead of a text label. */
215 void
216 dw2_asm_output_addr_rtx (int size, rtx addr,
217 const char *comment, ...)
219 va_list ap;
221 va_start (ap, comment);
223 dw2_assemble_integer (size, addr);
225 if (flag_debug_asm && comment)
227 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
228 vfprintf (asm_out_file, comment, ap);
230 fputc ('\n', asm_out_file);
232 va_end (ap);
235 /* Output the first ORIG_LEN characters of STR as a string.
236 If ORIG_LEN is equal to -1, ignore this parameter and output
237 the entire STR instead.
238 If COMMENT is not NULL and comments in the debug information
239 have been requested by the user, append the given COMMENT
240 to the generated output. */
242 void
243 dw2_asm_output_nstring (const char *str, size_t orig_len,
244 const char *comment, ...)
246 size_t i, len;
247 va_list ap;
249 va_start (ap, comment);
251 len = orig_len;
253 if (len == (size_t) -1)
254 len = strlen (str);
256 if (flag_debug_asm && comment)
258 fputs ("\t.ascii \"", asm_out_file);
259 for (i = 0; i < len; i++)
261 int c = str[i];
262 if (c == '\"' || c == '\\')
263 fputc ('\\', asm_out_file);
264 if (ISPRINT(c))
265 fputc (c, asm_out_file);
266 else
267 fprintf (asm_out_file, "\\%o", c);
269 fprintf (asm_out_file, "\\0\"\t%s ", ASM_COMMENT_START);
270 vfprintf (asm_out_file, comment, ap);
271 fputc ('\n', asm_out_file);
273 else
275 /* If an explicit length was given, we can't assume there
276 is a null termination in the string buffer. */
277 if (orig_len == (size_t) -1)
278 len += 1;
279 ASM_OUTPUT_ASCII (asm_out_file, str, len);
280 if (orig_len != (size_t) -1)
281 assemble_integer (const0_rtx, 1, BITS_PER_UNIT, 1);
284 va_end (ap);
288 /* Return the size of an unsigned LEB128 quantity. */
291 size_of_uleb128 (unsigned HOST_WIDE_INT value)
293 int size = 0;
297 value >>= 7;
298 size += 1;
300 while (value != 0);
302 return size;
305 /* Return the size of a signed LEB128 quantity. */
308 size_of_sleb128 (HOST_WIDE_INT value)
310 int size = 0, byte;
314 byte = (value & 0x7f);
315 value >>= 7;
316 size += 1;
318 while (!((value == 0 && (byte & 0x40) == 0)
319 || (value == -1 && (byte & 0x40) != 0)));
321 return size;
324 /* Given an encoding, return the number of bytes the format occupies.
325 This is only defined for fixed-size encodings, and so does not
326 include leb128. */
329 size_of_encoded_value (int encoding)
331 if (encoding == DW_EH_PE_omit)
332 return 0;
334 switch (encoding & 0x07)
336 case DW_EH_PE_absptr:
337 return POINTER_SIZE / BITS_PER_UNIT;
338 case DW_EH_PE_udata2:
339 return 2;
340 case DW_EH_PE_udata4:
341 return 4;
342 case DW_EH_PE_udata8:
343 return 8;
344 default:
345 gcc_unreachable ();
349 /* Yield a name for a given pointer encoding. */
351 const char *
352 eh_data_format_name (int format)
354 #if HAVE_DESIGNATED_INITIALIZERS
355 #define S(p, v) [p] = v,
356 #else
357 #define S(p, v) case p: return v;
358 #endif
360 #if HAVE_DESIGNATED_INITIALIZERS
361 __extension__ static const char * const format_names[256] = {
362 #else
363 switch (format) {
364 #endif
366 S(DW_EH_PE_absptr, "absolute")
367 S(DW_EH_PE_omit, "omit")
368 S(DW_EH_PE_aligned, "aligned absolute")
370 S(DW_EH_PE_uleb128, "uleb128")
371 S(DW_EH_PE_udata2, "udata2")
372 S(DW_EH_PE_udata4, "udata4")
373 S(DW_EH_PE_udata8, "udata8")
374 S(DW_EH_PE_sleb128, "sleb128")
375 S(DW_EH_PE_sdata2, "sdata2")
376 S(DW_EH_PE_sdata4, "sdata4")
377 S(DW_EH_PE_sdata8, "sdata8")
379 S(DW_EH_PE_absptr | DW_EH_PE_pcrel, "pcrel")
380 S(DW_EH_PE_uleb128 | DW_EH_PE_pcrel, "pcrel uleb128")
381 S(DW_EH_PE_udata2 | DW_EH_PE_pcrel, "pcrel udata2")
382 S(DW_EH_PE_udata4 | DW_EH_PE_pcrel, "pcrel udata4")
383 S(DW_EH_PE_udata8 | DW_EH_PE_pcrel, "pcrel udata8")
384 S(DW_EH_PE_sleb128 | DW_EH_PE_pcrel, "pcrel sleb128")
385 S(DW_EH_PE_sdata2 | DW_EH_PE_pcrel, "pcrel sdata2")
386 S(DW_EH_PE_sdata4 | DW_EH_PE_pcrel, "pcrel sdata4")
387 S(DW_EH_PE_sdata8 | DW_EH_PE_pcrel, "pcrel sdata8")
389 S(DW_EH_PE_absptr | DW_EH_PE_textrel, "textrel")
390 S(DW_EH_PE_uleb128 | DW_EH_PE_textrel, "textrel uleb128")
391 S(DW_EH_PE_udata2 | DW_EH_PE_textrel, "textrel udata2")
392 S(DW_EH_PE_udata4 | DW_EH_PE_textrel, "textrel udata4")
393 S(DW_EH_PE_udata8 | DW_EH_PE_textrel, "textrel udata8")
394 S(DW_EH_PE_sleb128 | DW_EH_PE_textrel, "textrel sleb128")
395 S(DW_EH_PE_sdata2 | DW_EH_PE_textrel, "textrel sdata2")
396 S(DW_EH_PE_sdata4 | DW_EH_PE_textrel, "textrel sdata4")
397 S(DW_EH_PE_sdata8 | DW_EH_PE_textrel, "textrel sdata8")
399 S(DW_EH_PE_absptr | DW_EH_PE_datarel, "datarel")
400 S(DW_EH_PE_uleb128 | DW_EH_PE_datarel, "datarel uleb128")
401 S(DW_EH_PE_udata2 | DW_EH_PE_datarel, "datarel udata2")
402 S(DW_EH_PE_udata4 | DW_EH_PE_datarel, "datarel udata4")
403 S(DW_EH_PE_udata8 | DW_EH_PE_datarel, "datarel udata8")
404 S(DW_EH_PE_sleb128 | DW_EH_PE_datarel, "datarel sleb128")
405 S(DW_EH_PE_sdata2 | DW_EH_PE_datarel, "datarel sdata2")
406 S(DW_EH_PE_sdata4 | DW_EH_PE_datarel, "datarel sdata4")
407 S(DW_EH_PE_sdata8 | DW_EH_PE_datarel, "datarel sdata8")
409 S(DW_EH_PE_absptr | DW_EH_PE_funcrel, "funcrel")
410 S(DW_EH_PE_uleb128 | DW_EH_PE_funcrel, "funcrel uleb128")
411 S(DW_EH_PE_udata2 | DW_EH_PE_funcrel, "funcrel udata2")
412 S(DW_EH_PE_udata4 | DW_EH_PE_funcrel, "funcrel udata4")
413 S(DW_EH_PE_udata8 | DW_EH_PE_funcrel, "funcrel udata8")
414 S(DW_EH_PE_sleb128 | DW_EH_PE_funcrel, "funcrel sleb128")
415 S(DW_EH_PE_sdata2 | DW_EH_PE_funcrel, "funcrel sdata2")
416 S(DW_EH_PE_sdata4 | DW_EH_PE_funcrel, "funcrel sdata4")
417 S(DW_EH_PE_sdata8 | DW_EH_PE_funcrel, "funcrel sdata8")
419 S(DW_EH_PE_indirect | DW_EH_PE_absptr | DW_EH_PE_pcrel,
420 "indirect pcrel")
421 S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_pcrel,
422 "indirect pcrel uleb128")
423 S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_pcrel,
424 "indirect pcrel udata2")
425 S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_pcrel,
426 "indirect pcrel udata4")
427 S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_pcrel,
428 "indirect pcrel udata8")
429 S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_pcrel,
430 "indirect pcrel sleb128")
431 S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_pcrel,
432 "indirect pcrel sdata2")
433 S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_pcrel,
434 "indirect pcrel sdata4")
435 S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_pcrel,
436 "indirect pcrel sdata8")
438 S(DW_EH_PE_indirect | DW_EH_PE_absptr | DW_EH_PE_textrel,
439 "indirect textrel")
440 S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_textrel,
441 "indirect textrel uleb128")
442 S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_textrel,
443 "indirect textrel udata2")
444 S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_textrel,
445 "indirect textrel udata4")
446 S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_textrel,
447 "indirect textrel udata8")
448 S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_textrel,
449 "indirect textrel sleb128")
450 S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_textrel,
451 "indirect textrel sdata2")
452 S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_textrel,
453 "indirect textrel sdata4")
454 S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_textrel,
455 "indirect textrel sdata8")
457 S(DW_EH_PE_indirect | DW_EH_PE_absptr | DW_EH_PE_datarel,
458 "indirect datarel")
459 S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_datarel,
460 "indirect datarel uleb128")
461 S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_datarel,
462 "indirect datarel udata2")
463 S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_datarel,
464 "indirect datarel udata4")
465 S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_datarel,
466 "indirect datarel udata8")
467 S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_datarel,
468 "indirect datarel sleb128")
469 S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_datarel,
470 "indirect datarel sdata2")
471 S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_datarel,
472 "indirect datarel sdata4")
473 S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_datarel,
474 "indirect datarel sdata8")
476 S(DW_EH_PE_indirect | DW_EH_PE_absptr | DW_EH_PE_funcrel,
477 "indirect funcrel")
478 S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_funcrel,
479 "indirect funcrel uleb128")
480 S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_funcrel,
481 "indirect funcrel udata2")
482 S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_funcrel,
483 "indirect funcrel udata4")
484 S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_funcrel,
485 "indirect funcrel udata8")
486 S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_funcrel,
487 "indirect funcrel sleb128")
488 S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_funcrel,
489 "indirect funcrel sdata2")
490 S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_funcrel,
491 "indirect funcrel sdata4")
492 S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_funcrel,
493 "indirect funcrel sdata8")
495 #if HAVE_DESIGNATED_INITIALIZERS
498 gcc_assert (format >= 0 && format < 0x100 && format_names[format]);
500 return format_names[format];
501 #else
503 gcc_unreachable ();
504 #endif
507 /* Output an unsigned LEB128 quantity. */
509 void
510 dw2_asm_output_data_uleb128 (unsigned HOST_WIDE_INT value,
511 const char *comment, ...)
513 va_list ap;
515 va_start (ap, comment);
517 #ifdef HAVE_AS_LEB128
518 fprintf (asm_out_file, "\t.uleb128 " HOST_WIDE_INT_PRINT_HEX , value);
520 if (flag_debug_asm && comment)
522 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
523 vfprintf (asm_out_file, comment, ap);
525 #else
527 unsigned HOST_WIDE_INT work = value;
528 const char *byte_op = targetm.asm_out.byte_op;
530 if (byte_op)
531 fputs (byte_op, asm_out_file);
534 int byte = (work & 0x7f);
535 work >>= 7;
536 if (work != 0)
537 /* More bytes to follow. */
538 byte |= 0x80;
540 if (byte_op)
542 fprintf (asm_out_file, "0x%x", byte);
543 if (work != 0)
544 fputc (',', asm_out_file);
546 else
547 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
549 while (work != 0);
551 if (flag_debug_asm)
553 fprintf (asm_out_file, "\t%s uleb128 " HOST_WIDE_INT_PRINT_HEX,
554 ASM_COMMENT_START, value);
555 if (comment)
557 fputs ("; ", asm_out_file);
558 vfprintf (asm_out_file, comment, ap);
562 #endif
563 fputc ('\n', asm_out_file);
565 va_end (ap);
568 /* Output a signed LEB128 quantity. */
570 void
571 dw2_asm_output_data_sleb128 (HOST_WIDE_INT value,
572 const char *comment, ...)
574 va_list ap;
576 va_start (ap, comment);
578 #ifdef HAVE_AS_LEB128
579 fprintf (asm_out_file, "\t.sleb128 " HOST_WIDE_INT_PRINT_DEC, value);
581 if (flag_debug_asm && comment)
583 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
584 vfprintf (asm_out_file, comment, ap);
586 #else
588 HOST_WIDE_INT work = value;
589 int more, byte;
590 const char *byte_op = targetm.asm_out.byte_op;
592 if (byte_op)
593 fputs (byte_op, asm_out_file);
596 byte = (work & 0x7f);
597 /* arithmetic shift */
598 work >>= 7;
599 more = !((work == 0 && (byte & 0x40) == 0)
600 || (work == -1 && (byte & 0x40) != 0));
601 if (more)
602 byte |= 0x80;
604 if (byte_op)
606 fprintf (asm_out_file, "0x%x", byte);
607 if (more)
608 fputc (',', asm_out_file);
610 else
611 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
613 while (more);
615 if (flag_debug_asm)
617 fprintf (asm_out_file, "\t%s sleb128 " HOST_WIDE_INT_PRINT_DEC,
618 ASM_COMMENT_START, value);
619 if (comment)
621 fputs ("; ", asm_out_file);
622 vfprintf (asm_out_file, comment, ap);
626 #endif
627 fputc ('\n', asm_out_file);
629 va_end (ap);
632 void
633 dw2_asm_output_delta_uleb128 (const char *lab1 ATTRIBUTE_UNUSED,
634 const char *lab2 ATTRIBUTE_UNUSED,
635 const char *comment, ...)
637 va_list ap;
639 va_start (ap, comment);
641 #ifdef HAVE_AS_LEB128
642 fputs ("\t.uleb128 ", asm_out_file);
643 assemble_name (asm_out_file, lab1);
644 fputc ('-', asm_out_file);
645 assemble_name (asm_out_file, lab2);
646 #else
647 gcc_unreachable ();
648 #endif
650 if (flag_debug_asm && comment)
652 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
653 vfprintf (asm_out_file, comment, ap);
655 fputc ('\n', asm_out_file);
657 va_end (ap);
660 #if 0
662 void
663 dw2_asm_output_delta_sleb128 (const char *lab1 ATTRIBUTE_UNUSED,
664 const char *lab2 ATTRIBUTE_UNUSED,
665 const char *comment, ...)
667 va_list ap;
669 va_start (ap, comment);
671 #ifdef HAVE_AS_LEB128
672 fputs ("\t.sleb128 ", asm_out_file);
673 assemble_name (asm_out_file, lab1);
674 fputc ('-', asm_out_file);
675 assemble_name (asm_out_file, lab2);
676 #else
677 gcc_unreachable ();
678 #endif
680 if (flag_debug_asm && comment)
682 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
683 vfprintf (asm_out_file, comment, ap);
685 fputc ('\n', asm_out_file);
687 va_end (ap);
689 #endif /* 0 */
691 static rtx dw2_force_const_mem (rtx, bool);
692 static int dw2_output_indirect_constant_1 (splay_tree_node, void *);
694 static GTY((param1_is (char *), param2_is (tree))) splay_tree indirect_pool;
696 static GTY(()) int dw2_const_labelno;
698 #if defined(HAVE_GAS_HIDDEN) && defined(SUPPORTS_ONE_ONLY)
699 # define USE_LINKONCE_INDIRECT 1
700 #else
701 # define USE_LINKONCE_INDIRECT 0
702 #endif
704 /* Comparison function for a splay tree in which the keys are strings.
705 K1 and K2 have the dynamic type "const char *". Returns <0, 0, or
706 >0 to indicate whether K1 is less than, equal to, or greater than
707 K2, respectively. */
709 static int
710 splay_tree_compare_strings (splay_tree_key k1, splay_tree_key k2)
712 const char *s1 = (const char *)k1;
713 const char *s2 = (const char *)k2;
714 int ret;
716 if (s1 == s2)
717 return 0;
719 ret = strcmp (s1, s2);
721 /* The strings are always those from IDENTIFIER_NODEs, and,
722 therefore, we should never have two copies of the same
723 string. */
724 gcc_assert (ret);
726 return ret;
729 /* Put X, a SYMBOL_REF, in memory. Return a SYMBOL_REF to the allocated
730 memory. Differs from force_const_mem in that a single pool is used for
731 the entire unit of translation, and the memory is not guaranteed to be
732 "near" the function in any interesting sense. PUBLIC controls whether
733 the symbol can be shared across the entire application (or DSO). */
735 static rtx
736 dw2_force_const_mem (rtx x, bool public)
738 splay_tree_node node;
739 const char *str;
740 tree decl;
742 if (! indirect_pool)
743 /* We use strcmp, rather than just comparing pointers, so that the
744 sort order will not depend on the host system. */
745 indirect_pool = splay_tree_new_ggc (splay_tree_compare_strings);
747 gcc_assert (GET_CODE (x) == SYMBOL_REF);
749 str = targetm.strip_name_encoding (XSTR (x, 0));
750 node = splay_tree_lookup (indirect_pool, (splay_tree_key) str);
751 if (node)
752 decl = (tree) node->value;
753 else
755 tree id;
757 if (public && USE_LINKONCE_INDIRECT)
759 char *ref_name = alloca (strlen (str) + sizeof "DW.ref.");
761 sprintf (ref_name, "DW.ref.%s", str);
762 id = get_identifier (ref_name);
763 decl = build_decl (VAR_DECL, id, ptr_type_node);
764 DECL_ARTIFICIAL (decl) = 1;
765 DECL_IGNORED_P (decl) = 1;
766 TREE_PUBLIC (decl) = 1;
767 DECL_INITIAL (decl) = decl;
768 make_decl_one_only (decl);
770 else
772 char label[32];
774 ASM_GENERATE_INTERNAL_LABEL (label, "LDFCM", dw2_const_labelno);
775 ++dw2_const_labelno;
776 id = get_identifier (label);
777 decl = build_decl (VAR_DECL, id, ptr_type_node);
778 DECL_ARTIFICIAL (decl) = 1;
779 DECL_IGNORED_P (decl) = 1;
780 TREE_STATIC (decl) = 1;
781 DECL_INITIAL (decl) = decl;
784 id = maybe_get_identifier (str);
785 if (id)
786 TREE_SYMBOL_REFERENCED (id) = 1;
788 splay_tree_insert (indirect_pool, (splay_tree_key) str,
789 (splay_tree_value) decl);
792 return XEXP (DECL_RTL (decl), 0);
795 /* A helper function for dw2_output_indirect_constants called through
796 splay_tree_foreach. Emit one queued constant to memory. */
798 static int
799 dw2_output_indirect_constant_1 (splay_tree_node node,
800 void *data ATTRIBUTE_UNUSED)
802 const char *sym;
803 rtx sym_ref;
804 tree decl;
806 sym = (const char *) node->key;
807 decl = (tree) node->value;
808 sym_ref = gen_rtx_SYMBOL_REF (Pmode, sym);
809 if (TREE_PUBLIC (decl) && USE_LINKONCE_INDIRECT)
810 fprintf (asm_out_file, "\t.hidden %sDW.ref.%s\n", user_label_prefix, sym);
811 assemble_variable (decl, 1, 1, 1);
812 assemble_integer (sym_ref, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
814 return 0;
817 /* Emit the constants queued through dw2_force_const_mem. */
819 void
820 dw2_output_indirect_constants (void)
822 if (indirect_pool)
823 splay_tree_foreach (indirect_pool, dw2_output_indirect_constant_1, NULL);
826 /* Like dw2_asm_output_addr_rtx, but encode the pointer as directed.
827 If PUBLIC is set and the encoding is DW_EH_PE_indirect, the indirect
828 reference is shared across the entire application (or DSO). */
830 void
831 dw2_asm_output_encoded_addr_rtx (int encoding, rtx addr, bool public,
832 const char *comment, ...)
834 int size;
835 va_list ap;
837 va_start (ap, comment);
839 size = size_of_encoded_value (encoding);
841 if (encoding == DW_EH_PE_aligned)
843 assemble_align (POINTER_SIZE);
844 assemble_integer (addr, size, POINTER_SIZE, 1);
845 return;
848 /* NULL is _always_ represented as a plain zero, as is 1 for Ada's
849 "all others". */
850 if (addr == const0_rtx || addr == const1_rtx)
851 assemble_integer (addr, size, BITS_PER_UNIT, 1);
852 else
854 restart:
855 /* Allow the target first crack at emitting this. Some of the
856 special relocations require special directives instead of
857 just ".4byte" or whatever. */
858 #ifdef ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX
859 ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX (asm_out_file, encoding, size,
860 addr, done);
861 #endif
863 /* Indirection is used to get dynamic relocations out of a
864 read-only section. */
865 if (encoding & DW_EH_PE_indirect)
867 /* It is very tempting to use force_const_mem so that we share data
868 with the normal constant pool. However, we've already emitted
869 the constant pool for this function. Moreover, we'd like to
870 share these constants across the entire unit of translation and
871 even, if possible, across the entire application (or DSO). */
872 addr = dw2_force_const_mem (addr, public);
873 encoding &= ~DW_EH_PE_indirect;
874 goto restart;
877 switch (encoding & 0xF0)
879 case DW_EH_PE_absptr:
880 dw2_assemble_integer (size, addr);
881 break;
883 case DW_EH_PE_pcrel:
884 gcc_assert (GET_CODE (addr) == SYMBOL_REF);
885 #ifdef ASM_OUTPUT_DWARF_PCREL
886 ASM_OUTPUT_DWARF_PCREL (asm_out_file, size, XSTR (addr, 0));
887 #else
888 dw2_assemble_integer (size, gen_rtx_MINUS (Pmode, addr, pc_rtx));
889 #endif
890 break;
892 default:
893 /* Other encodings should have been handled by
894 ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX. */
895 gcc_unreachable ();
898 #ifdef ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX
899 done:;
900 #endif
903 if (flag_debug_asm && comment)
905 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
906 vfprintf (asm_out_file, comment, ap);
908 fputc ('\n', asm_out_file);
910 va_end (ap);
913 #include "gt-dwarf2asm.h"