2018-02-23 Paul Thomas <pault@gcc.gnu.org>
[official-gcc.git] / gcc / dwarf2asm.c
blobe9b18b8b78520131116ced6d0431db568af1b307
1 /* Dwarf2 assembler output helper routines.
2 Copyright (C) 2001-2018 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 "target.h"
25 #include "rtl.h"
26 #include "tree.h"
27 #include "memmodel.h"
28 #include "tm_p.h"
29 #include "stringpool.h"
30 #include "varasm.h"
31 #include "output.h"
32 #include "dwarf2asm.h"
33 #include "dwarf2.h"
34 #include "function.h"
35 #include "emit-rtl.h"
37 #ifndef XCOFF_DEBUGGING_INFO
38 #define XCOFF_DEBUGGING_INFO 0
39 #endif
42 /* Output an unaligned integer with the given value and size. Prefer not
43 to print a newline, since the caller may want to add a comment. */
45 void
46 dw2_assemble_integer (int size, rtx x)
48 const char *op = integer_asm_op (size, FALSE);
50 if (op)
52 fputs (op, asm_out_file);
53 if (CONST_INT_P (x))
54 fprint_whex (asm_out_file, (unsigned HOST_WIDE_INT) INTVAL (x));
55 else
56 output_addr_const (asm_out_file, x);
58 else
59 assemble_integer (x, size, BITS_PER_UNIT, 1);
63 /* Output a value of a given size in target byte order. */
65 void
66 dw2_asm_output_data_raw (int size, unsigned HOST_WIDE_INT value)
68 unsigned char bytes[8];
69 int i;
71 for (i = 0; i < 8; ++i)
73 bytes[i] = value & 0xff;
74 value >>= 8;
77 if (BYTES_BIG_ENDIAN)
79 for (i = size - 1; i > 0; --i)
80 fprintf (asm_out_file, "%#x,", bytes[i]);
81 fprintf (asm_out_file, "%#x", bytes[0]);
83 else
85 for (i = 0; i < size - 1; ++i)
86 fprintf (asm_out_file, "%#x,", bytes[i]);
87 fprintf (asm_out_file, "%#x", bytes[i]);
91 /* Output an immediate constant in a given SIZE in bytes. */
93 void
94 dw2_asm_output_data (int size, unsigned HOST_WIDE_INT value,
95 const char *comment, ...)
97 va_list ap;
98 const char *op = integer_asm_op (size, FALSE);
100 va_start (ap, comment);
102 if (size * 8 < HOST_BITS_PER_WIDE_INT)
103 value &= ~(HOST_WIDE_INT_M1U << (size * 8));
105 if (op)
107 fputs (op, asm_out_file);
108 fprint_whex (asm_out_file, value);
110 else
111 assemble_integer (GEN_INT (value), size, BITS_PER_UNIT, 1);
113 if (flag_debug_asm && comment)
115 fputs ("\t" ASM_COMMENT_START " ", asm_out_file);
116 vfprintf (asm_out_file, comment, ap);
118 putc ('\n', asm_out_file);
120 va_end (ap);
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. */
129 void
130 dw2_asm_output_delta (int size, const char *lab1, const char *lab2,
131 const char *comment, ...)
133 va_list ap;
135 va_start (ap, comment);
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)
147 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
148 vfprintf (asm_out_file, comment, ap);
150 fputc ('\n', asm_out_file);
152 va_end (ap);
155 #ifdef ASM_OUTPUT_DWARF_VMS_DELTA
156 /* Output the difference between two symbols in instruction units
157 in a given size. */
159 void
160 dw2_asm_output_vms_delta (int size ATTRIBUTE_UNUSED,
161 const char *lab1, const char *lab2,
162 const char *comment, ...)
164 va_list ap;
166 va_start (ap, comment);
168 ASM_OUTPUT_DWARF_VMS_DELTA (asm_out_file, size, lab1, lab2);
169 if (flag_debug_asm && comment)
171 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
172 vfprintf (asm_out_file, comment, ap);
174 fputc ('\n', asm_out_file);
176 va_end (ap);
178 #endif
180 /* Output a section-relative reference to a LABEL, which was placed in
181 BASE. In general this can only be done for debugging symbols.
182 E.g. on most targets with the GNU linker, this is accomplished with
183 a direct reference and the knowledge that the debugging section
184 will be placed at VMA 0. Some targets have special relocations for
185 this that we must use. */
187 void
188 dw2_asm_output_offset (int size, const char *label,
189 section *base ATTRIBUTE_UNUSED,
190 const char *comment, ...)
192 va_list ap;
194 va_start (ap, comment);
196 #ifdef ASM_OUTPUT_DWARF_OFFSET
197 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, size, label, 0, base);
198 #else
199 dw2_assemble_integer (size, gen_rtx_SYMBOL_REF (Pmode, label));
200 #endif
202 if (flag_debug_asm && comment)
204 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
205 vfprintf (asm_out_file, comment, ap);
207 fputc ('\n', asm_out_file);
209 va_end (ap);
212 void
213 dw2_asm_output_offset (int size, const char *label, HOST_WIDE_INT offset,
214 section *base ATTRIBUTE_UNUSED,
215 const char *comment, ...)
217 va_list ap;
219 va_start (ap, comment);
221 #ifdef ASM_OUTPUT_DWARF_OFFSET
222 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, size, label, offset, base);
223 #else
224 dw2_assemble_integer (size, gen_rtx_PLUS (Pmode,
225 gen_rtx_SYMBOL_REF (Pmode, label),
226 gen_int_mode (offset, Pmode)));
227 #endif
229 if (flag_debug_asm && comment)
231 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
232 vfprintf (asm_out_file, comment, ap);
234 fputc ('\n', asm_out_file);
236 va_end (ap);
239 #if 0
241 /* Output a self-relative reference to a label, possibly in a
242 different section or object file. */
244 void
245 dw2_asm_output_pcrel (int size ATTRIBUTE_UNUSED,
246 const char *label ATTRIBUTE_UNUSED,
247 const char *comment, ...)
249 va_list ap;
251 va_start (ap, comment);
253 #ifdef ASM_OUTPUT_DWARF_PCREL
254 ASM_OUTPUT_DWARF_PCREL (asm_out_file, size, label);
255 #else
256 dw2_assemble_integer (size,
257 gen_rtx_MINUS (Pmode,
258 gen_rtx_SYMBOL_REF (Pmode, label),
259 pc_rtx));
260 #endif
262 if (flag_debug_asm && comment)
264 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
265 vfprintf (asm_out_file, comment, ap);
267 fputc ('\n', asm_out_file);
269 va_end (ap);
271 #endif /* 0 */
273 /* Output an absolute reference to a label. */
275 void
276 dw2_asm_output_addr (int size, const char *label,
277 const char *comment, ...)
279 va_list ap;
281 va_start (ap, comment);
283 dw2_assemble_integer (size, gen_rtx_SYMBOL_REF (Pmode, label));
285 if (flag_debug_asm && comment)
287 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
288 vfprintf (asm_out_file, comment, ap);
290 fputc ('\n', asm_out_file);
292 va_end (ap);
295 /* Similar, but use an RTX expression instead of a text label. */
297 void
298 dw2_asm_output_addr_rtx (int size, rtx addr,
299 const char *comment, ...)
301 va_list ap;
303 va_start (ap, comment);
305 dw2_assemble_integer (size, addr);
307 if (flag_debug_asm && comment)
309 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
310 vfprintf (asm_out_file, comment, ap);
312 fputc ('\n', asm_out_file);
314 va_end (ap);
317 /* Output the first ORIG_LEN characters of STR as a string.
318 If ORIG_LEN is equal to -1, ignore this parameter and output
319 the entire STR instead.
320 If COMMENT is not NULL and comments in the debug information
321 have been requested by the user, append the given COMMENT
322 to the generated output. */
324 void
325 dw2_asm_output_nstring (const char *str, size_t orig_len,
326 const char *comment, ...)
328 size_t i, len;
329 va_list ap;
331 va_start (ap, comment);
333 len = orig_len;
335 if (len == (size_t) -1)
336 len = strlen (str);
338 if (flag_debug_asm && comment)
340 if (XCOFF_DEBUGGING_INFO)
341 fputs ("\t.byte \"", asm_out_file);
342 else
343 fputs ("\t.ascii \"", asm_out_file);
345 for (i = 0; i < len; i++)
347 int c = str[i];
348 if (c == '\"')
349 fputc (XCOFF_DEBUGGING_INFO ? '\"' : '\\', asm_out_file);
350 else if (c == '\\')
351 fputc ('\\', asm_out_file);
352 if (ISPRINT (c))
353 fputc (c, asm_out_file);
354 else
355 fprintf (asm_out_file, "\\%o", c);
357 fprintf (asm_out_file, "\\0\"\t%s ", ASM_COMMENT_START);
358 vfprintf (asm_out_file, comment, ap);
359 fputc ('\n', asm_out_file);
361 else
363 /* If an explicit length was given, we can't assume there
364 is a null termination in the string buffer. */
365 if (orig_len == (size_t) -1)
366 len += 1;
367 ASM_OUTPUT_ASCII (asm_out_file, str, len);
368 if (orig_len != (size_t) -1)
369 assemble_integer (const0_rtx, 1, BITS_PER_UNIT, 1);
372 va_end (ap);
376 /* Return the size of an unsigned LEB128 quantity. */
379 size_of_uleb128 (unsigned HOST_WIDE_INT value)
381 int size = 0;
385 value >>= 7;
386 size += 1;
388 while (value != 0);
390 return size;
393 /* Return the size of a signed LEB128 quantity. */
396 size_of_sleb128 (HOST_WIDE_INT value)
398 int size = 0, byte;
402 byte = (value & 0x7f);
403 value >>= 7;
404 size += 1;
406 while (!((value == 0 && (byte & 0x40) == 0)
407 || (value == -1 && (byte & 0x40) != 0)));
409 return size;
412 /* Given an encoding, return the number of bytes the format occupies.
413 This is only defined for fixed-size encodings, and so does not
414 include leb128. */
417 size_of_encoded_value (int encoding)
419 if (encoding == DW_EH_PE_omit)
420 return 0;
422 switch (encoding & 0x07)
424 case DW_EH_PE_absptr:
425 return POINTER_SIZE_UNITS;
426 case DW_EH_PE_udata2:
427 return 2;
428 case DW_EH_PE_udata4:
429 return 4;
430 case DW_EH_PE_udata8:
431 return 8;
432 default:
433 gcc_unreachable ();
437 /* Yield a name for a given pointer encoding. */
439 const char *
440 eh_data_format_name (int format)
442 #if HAVE_DESIGNATED_INITIALIZERS
443 #define S(p, v) [p] = v,
444 #else
445 #define S(p, v) case p: return v;
446 #endif
448 #if HAVE_DESIGNATED_INITIALIZERS
449 __extension__ static const char * const format_names[256] = {
450 #else
451 switch (format) {
452 #endif
454 S(DW_EH_PE_absptr, "absolute")
455 S(DW_EH_PE_omit, "omit")
456 S(DW_EH_PE_aligned, "aligned absolute")
458 S(DW_EH_PE_uleb128, "uleb128")
459 S(DW_EH_PE_udata2, "udata2")
460 S(DW_EH_PE_udata4, "udata4")
461 S(DW_EH_PE_udata8, "udata8")
462 S(DW_EH_PE_sleb128, "sleb128")
463 S(DW_EH_PE_sdata2, "sdata2")
464 S(DW_EH_PE_sdata4, "sdata4")
465 S(DW_EH_PE_sdata8, "sdata8")
467 S(DW_EH_PE_absptr | DW_EH_PE_pcrel, "pcrel")
468 S(DW_EH_PE_uleb128 | DW_EH_PE_pcrel, "pcrel uleb128")
469 S(DW_EH_PE_udata2 | DW_EH_PE_pcrel, "pcrel udata2")
470 S(DW_EH_PE_udata4 | DW_EH_PE_pcrel, "pcrel udata4")
471 S(DW_EH_PE_udata8 | DW_EH_PE_pcrel, "pcrel udata8")
472 S(DW_EH_PE_sleb128 | DW_EH_PE_pcrel, "pcrel sleb128")
473 S(DW_EH_PE_sdata2 | DW_EH_PE_pcrel, "pcrel sdata2")
474 S(DW_EH_PE_sdata4 | DW_EH_PE_pcrel, "pcrel sdata4")
475 S(DW_EH_PE_sdata8 | DW_EH_PE_pcrel, "pcrel sdata8")
477 S(DW_EH_PE_absptr | DW_EH_PE_textrel, "textrel")
478 S(DW_EH_PE_uleb128 | DW_EH_PE_textrel, "textrel uleb128")
479 S(DW_EH_PE_udata2 | DW_EH_PE_textrel, "textrel udata2")
480 S(DW_EH_PE_udata4 | DW_EH_PE_textrel, "textrel udata4")
481 S(DW_EH_PE_udata8 | DW_EH_PE_textrel, "textrel udata8")
482 S(DW_EH_PE_sleb128 | DW_EH_PE_textrel, "textrel sleb128")
483 S(DW_EH_PE_sdata2 | DW_EH_PE_textrel, "textrel sdata2")
484 S(DW_EH_PE_sdata4 | DW_EH_PE_textrel, "textrel sdata4")
485 S(DW_EH_PE_sdata8 | DW_EH_PE_textrel, "textrel sdata8")
487 S(DW_EH_PE_absptr | DW_EH_PE_datarel, "datarel")
488 S(DW_EH_PE_uleb128 | DW_EH_PE_datarel, "datarel uleb128")
489 S(DW_EH_PE_udata2 | DW_EH_PE_datarel, "datarel udata2")
490 S(DW_EH_PE_udata4 | DW_EH_PE_datarel, "datarel udata4")
491 S(DW_EH_PE_udata8 | DW_EH_PE_datarel, "datarel udata8")
492 S(DW_EH_PE_sleb128 | DW_EH_PE_datarel, "datarel sleb128")
493 S(DW_EH_PE_sdata2 | DW_EH_PE_datarel, "datarel sdata2")
494 S(DW_EH_PE_sdata4 | DW_EH_PE_datarel, "datarel sdata4")
495 S(DW_EH_PE_sdata8 | DW_EH_PE_datarel, "datarel sdata8")
497 S(DW_EH_PE_absptr | DW_EH_PE_funcrel, "funcrel")
498 S(DW_EH_PE_uleb128 | DW_EH_PE_funcrel, "funcrel uleb128")
499 S(DW_EH_PE_udata2 | DW_EH_PE_funcrel, "funcrel udata2")
500 S(DW_EH_PE_udata4 | DW_EH_PE_funcrel, "funcrel udata4")
501 S(DW_EH_PE_udata8 | DW_EH_PE_funcrel, "funcrel udata8")
502 S(DW_EH_PE_sleb128 | DW_EH_PE_funcrel, "funcrel sleb128")
503 S(DW_EH_PE_sdata2 | DW_EH_PE_funcrel, "funcrel sdata2")
504 S(DW_EH_PE_sdata4 | DW_EH_PE_funcrel, "funcrel sdata4")
505 S(DW_EH_PE_sdata8 | DW_EH_PE_funcrel, "funcrel sdata8")
507 S(DW_EH_PE_indirect | DW_EH_PE_absptr, "indirect absolute")
509 S(DW_EH_PE_indirect | DW_EH_PE_absptr | DW_EH_PE_pcrel,
510 "indirect pcrel")
511 S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_pcrel,
512 "indirect pcrel uleb128")
513 S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_pcrel,
514 "indirect pcrel udata2")
515 S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_pcrel,
516 "indirect pcrel udata4")
517 S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_pcrel,
518 "indirect pcrel udata8")
519 S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_pcrel,
520 "indirect pcrel sleb128")
521 S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_pcrel,
522 "indirect pcrel sdata2")
523 S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_pcrel,
524 "indirect pcrel sdata4")
525 S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_pcrel,
526 "indirect pcrel sdata8")
528 S(DW_EH_PE_indirect | DW_EH_PE_absptr | DW_EH_PE_textrel,
529 "indirect textrel")
530 S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_textrel,
531 "indirect textrel uleb128")
532 S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_textrel,
533 "indirect textrel udata2")
534 S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_textrel,
535 "indirect textrel udata4")
536 S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_textrel,
537 "indirect textrel udata8")
538 S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_textrel,
539 "indirect textrel sleb128")
540 S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_textrel,
541 "indirect textrel sdata2")
542 S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_textrel,
543 "indirect textrel sdata4")
544 S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_textrel,
545 "indirect textrel sdata8")
547 S(DW_EH_PE_indirect | DW_EH_PE_absptr | DW_EH_PE_datarel,
548 "indirect datarel")
549 S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_datarel,
550 "indirect datarel uleb128")
551 S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_datarel,
552 "indirect datarel udata2")
553 S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_datarel,
554 "indirect datarel udata4")
555 S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_datarel,
556 "indirect datarel udata8")
557 S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_datarel,
558 "indirect datarel sleb128")
559 S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_datarel,
560 "indirect datarel sdata2")
561 S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_datarel,
562 "indirect datarel sdata4")
563 S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_datarel,
564 "indirect datarel sdata8")
566 S(DW_EH_PE_indirect | DW_EH_PE_absptr | DW_EH_PE_funcrel,
567 "indirect funcrel")
568 S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_funcrel,
569 "indirect funcrel uleb128")
570 S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_funcrel,
571 "indirect funcrel udata2")
572 S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_funcrel,
573 "indirect funcrel udata4")
574 S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_funcrel,
575 "indirect funcrel udata8")
576 S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_funcrel,
577 "indirect funcrel sleb128")
578 S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_funcrel,
579 "indirect funcrel sdata2")
580 S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_funcrel,
581 "indirect funcrel sdata4")
582 S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_funcrel,
583 "indirect funcrel sdata8")
585 #if HAVE_DESIGNATED_INITIALIZERS
588 gcc_assert (format >= 0 && format < 0x100 && format_names[format]);
590 return format_names[format];
591 #else
593 gcc_unreachable ();
594 #endif
597 /* Output an unsigned LEB128 quantity, but only the byte values. */
599 void
600 dw2_asm_output_data_uleb128_raw (unsigned HOST_WIDE_INT value)
602 while (1)
604 int byte = (value & 0x7f);
605 value >>= 7;
606 if (value != 0)
607 /* More bytes to follow. */
608 byte |= 0x80;
610 fprintf (asm_out_file, "%#x", byte);
611 if (value == 0)
612 break;
613 fputc (',', asm_out_file);
617 /* Output an unsigned LEB128 quantity. */
619 void
620 dw2_asm_output_data_uleb128 (unsigned HOST_WIDE_INT value,
621 const char *comment, ...)
623 va_list ap;
625 va_start (ap, comment);
627 if (HAVE_AS_LEB128)
629 fputs ("\t.uleb128 ", asm_out_file);
630 fprint_whex (asm_out_file, value);
632 if (flag_debug_asm && comment)
634 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
635 vfprintf (asm_out_file, comment, ap);
638 else
640 unsigned HOST_WIDE_INT work = value;
641 const char *byte_op = targetm.asm_out.byte_op;
643 if (byte_op)
644 fputs (byte_op, asm_out_file);
647 int byte = (work & 0x7f);
648 work >>= 7;
649 if (work != 0)
650 /* More bytes to follow. */
651 byte |= 0x80;
653 if (byte_op)
655 fprintf (asm_out_file, "%#x", byte);
656 if (work != 0)
657 fputc (',', asm_out_file);
659 else
660 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
662 while (work != 0);
664 if (flag_debug_asm)
666 fprintf (asm_out_file, "\t%s uleb128 " HOST_WIDE_INT_PRINT_HEX,
667 ASM_COMMENT_START, value);
668 if (comment)
670 fputs ("; ", asm_out_file);
671 vfprintf (asm_out_file, comment, ap);
676 putc ('\n', asm_out_file);
678 va_end (ap);
681 /* Output an signed LEB128 quantity, but only the byte values. */
683 void
684 dw2_asm_output_data_sleb128_raw (HOST_WIDE_INT value)
686 int byte, more;
688 while (1)
690 byte = (value & 0x7f);
691 value >>= 7;
692 more = !((value == 0 && (byte & 0x40) == 0)
693 || (value == -1 && (byte & 0x40) != 0));
694 if (more)
695 byte |= 0x80;
697 fprintf (asm_out_file, "%#x", byte);
698 if (!more)
699 break;
700 fputc (',', asm_out_file);
704 /* Output a signed LEB128 quantity. */
706 void
707 dw2_asm_output_data_sleb128 (HOST_WIDE_INT value,
708 const char *comment, ...)
710 va_list ap;
712 va_start (ap, comment);
714 if (HAVE_AS_LEB128)
716 fprintf (asm_out_file, "\t.sleb128 " HOST_WIDE_INT_PRINT_DEC, value);
718 if (flag_debug_asm && comment)
720 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
721 vfprintf (asm_out_file, comment, ap);
724 else
726 HOST_WIDE_INT work = value;
727 int more, byte;
728 const char *byte_op = targetm.asm_out.byte_op;
730 if (byte_op)
731 fputs (byte_op, asm_out_file);
734 byte = (work & 0x7f);
735 /* arithmetic shift */
736 work >>= 7;
737 more = !((work == 0 && (byte & 0x40) == 0)
738 || (work == -1 && (byte & 0x40) != 0));
739 if (more)
740 byte |= 0x80;
742 if (byte_op)
744 fprintf (asm_out_file, "%#x", byte);
745 if (more)
746 fputc (',', asm_out_file);
748 else
749 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
751 while (more);
753 if (flag_debug_asm)
755 fprintf (asm_out_file, "\t%s sleb128 " HOST_WIDE_INT_PRINT_DEC,
756 ASM_COMMENT_START, value);
757 if (comment)
759 fputs ("; ", asm_out_file);
760 vfprintf (asm_out_file, comment, ap);
765 fputc ('\n', asm_out_file);
767 va_end (ap);
770 /* Output symbol LAB1 as an unsigned LEB128 quantity. LAB1 should be
771 an assembler-computed constant, e.g. a view number, because we
772 can't have relocations in LEB128 quantities. */
774 void
775 dw2_asm_output_symname_uleb128 (const char *lab1 ATTRIBUTE_UNUSED,
776 const char *comment, ...)
778 va_list ap;
780 va_start (ap, comment);
782 #ifdef HAVE_AS_LEB128
783 fputs ("\t.uleb128 ", asm_out_file);
784 assemble_name (asm_out_file, lab1);
785 #else
786 gcc_unreachable ();
787 #endif
789 if (flag_debug_asm && comment)
791 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
792 vfprintf (asm_out_file, comment, ap);
794 fputc ('\n', asm_out_file);
796 va_end (ap);
799 void
800 dw2_asm_output_delta_uleb128 (const char *lab1 ATTRIBUTE_UNUSED,
801 const char *lab2 ATTRIBUTE_UNUSED,
802 const char *comment, ...)
804 va_list ap;
806 va_start (ap, comment);
808 gcc_assert (HAVE_AS_LEB128);
810 fputs ("\t.uleb128 ", asm_out_file);
811 assemble_name (asm_out_file, lab1);
812 putc ('-', asm_out_file);
813 assemble_name (asm_out_file, lab2);
815 if (flag_debug_asm && comment)
817 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
818 vfprintf (asm_out_file, comment, ap);
820 fputc ('\n', asm_out_file);
822 va_end (ap);
825 #if 0
827 void
828 dw2_asm_output_delta_sleb128 (const char *lab1 ATTRIBUTE_UNUSED,
829 const char *lab2 ATTRIBUTE_UNUSED,
830 const char *comment, ...)
832 va_list ap;
834 va_start (ap, comment);
836 gcc_assert (HAVE_AS_LEB128);
838 fputs ("\t.sleb128 ", asm_out_file);
839 assemble_name (asm_out_file, lab1);
840 putc ('-', asm_out_file);
841 assemble_name (asm_out_file, lab2);
843 if (flag_debug_asm && comment)
845 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
846 vfprintf (asm_out_file, comment, ap);
848 fputc ('\n', asm_out_file);
850 va_end (ap);
852 #endif /* 0 */
854 static GTY(()) hash_map<const char *, tree> *indirect_pool;
856 static GTY(()) int dw2_const_labelno;
858 #if defined(HAVE_GAS_HIDDEN)
859 # define USE_LINKONCE_INDIRECT (SUPPORTS_ONE_ONLY && !XCOFF_DEBUGGING_INFO)
860 #else
861 # define USE_LINKONCE_INDIRECT 0
862 #endif
864 /* Compare two std::pair<const char *, tree> by their first element.
865 Returns <0, 0, or
866 >0 to indicate whether K1 is less than, equal to, or greater than
867 K2, respectively. */
869 static int
870 compare_strings (const void *a, const void *b)
872 const char *s1 = ((const std::pair<const char *, tree> *) a)->first;
873 const char *s2 = ((const std::pair<const char *, tree> *) b)->first;
874 int ret;
876 if (s1 == s2)
877 return 0;
879 ret = strcmp (s1, s2);
881 /* The strings are always those from IDENTIFIER_NODEs, and,
882 therefore, we should never have two copies of the same
883 string. */
884 gcc_assert (ret);
886 return ret;
889 /* Put X, a SYMBOL_REF, in memory. Return a SYMBOL_REF to the allocated
890 memory. Differs from force_const_mem in that a single pool is used for
891 the entire unit of translation, and the memory is not guaranteed to be
892 "near" the function in any interesting sense. IS_PUBLIC controls whether
893 the symbol can be shared across the entire application (or DSO). */
896 dw2_force_const_mem (rtx x, bool is_public)
898 const char *key;
899 tree decl_id;
901 if (! indirect_pool)
902 indirect_pool = hash_map<const char *, tree>::create_ggc (64);
904 gcc_assert (GET_CODE (x) == SYMBOL_REF);
906 key = XSTR (x, 0);
907 tree *slot = indirect_pool->get (key);
908 if (slot)
909 decl_id = *slot;
910 else
912 tree id;
913 const char *str = targetm.strip_name_encoding (key);
915 if (is_public && USE_LINKONCE_INDIRECT)
917 char *ref_name = XALLOCAVEC (char, strlen (str) + sizeof "DW.ref.");
919 sprintf (ref_name, "DW.ref.%s", str);
920 gcc_assert (!maybe_get_identifier (ref_name));
921 decl_id = get_identifier (ref_name);
922 TREE_PUBLIC (decl_id) = 1;
924 else
926 char label[32];
928 ASM_GENERATE_INTERNAL_LABEL (label, "LDFCM", dw2_const_labelno);
929 ++dw2_const_labelno;
930 gcc_assert (!maybe_get_identifier (label));
931 decl_id = get_identifier (label);
934 id = maybe_get_identifier (str);
935 if (id)
936 TREE_SYMBOL_REFERENCED (id) = 1;
938 indirect_pool->put (key, decl_id);
941 return gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (decl_id));
944 /* A helper function for dw2_output_indirect_constants. Emit one queued
945 constant to memory. */
947 static int
948 dw2_output_indirect_constant_1 (const char *sym, tree id)
950 rtx sym_ref;
951 tree decl;
953 decl = build_decl (UNKNOWN_LOCATION, VAR_DECL, id, ptr_type_node);
954 SET_DECL_ASSEMBLER_NAME (decl, id);
955 DECL_ARTIFICIAL (decl) = 1;
956 DECL_IGNORED_P (decl) = 1;
957 DECL_INITIAL (decl) = decl;
958 TREE_READONLY (decl) = 1;
959 TREE_STATIC (decl) = 1;
961 if (TREE_PUBLIC (id))
963 TREE_PUBLIC (decl) = 1;
964 make_decl_one_only (decl, DECL_ASSEMBLER_NAME (decl));
965 if (USE_LINKONCE_INDIRECT)
966 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
969 sym_ref = gen_rtx_SYMBOL_REF (Pmode, sym);
970 assemble_variable (decl, 1, 1, 1);
971 assemble_integer (sym_ref, POINTER_SIZE_UNITS, POINTER_SIZE, 1);
973 return 0;
976 /* Emit the constants queued through dw2_force_const_mem. */
978 void
979 dw2_output_indirect_constants (void)
981 if (!indirect_pool)
982 return;
984 auto_vec<std::pair<const char *, tree> > temp (indirect_pool->elements ());
985 for (hash_map<const char *, tree>::iterator iter = indirect_pool->begin ();
986 iter != indirect_pool->end (); ++iter)
987 temp.quick_push (*iter);
989 temp.qsort (compare_strings);
991 for (unsigned int i = 0; i < temp.length (); i++)
992 dw2_output_indirect_constant_1 (temp[i].first, temp[i].second);
995 /* Like dw2_asm_output_addr_rtx, but encode the pointer as directed.
996 If PUBLIC is set and the encoding is DW_EH_PE_indirect, the indirect
997 reference is shared across the entire application (or DSO). */
999 void
1000 dw2_asm_output_encoded_addr_rtx (int encoding, rtx addr, bool is_public,
1001 const char *comment, ...)
1003 int size;
1004 va_list ap;
1006 va_start (ap, comment);
1008 size = size_of_encoded_value (encoding);
1010 if (encoding == DW_EH_PE_aligned)
1012 assemble_align (POINTER_SIZE);
1013 assemble_integer (addr, size, POINTER_SIZE, 1);
1014 va_end (ap);
1015 return;
1018 /* NULL is _always_ represented as a plain zero, as is 1 for Ada's
1019 "all others". */
1020 if (addr == const0_rtx || addr == const1_rtx)
1021 assemble_integer (addr, size, BITS_PER_UNIT, 1);
1022 else
1024 restart:
1025 /* Allow the target first crack at emitting this. Some of the
1026 special relocations require special directives instead of
1027 just ".4byte" or whatever. */
1028 #ifdef ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX
1029 ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX (asm_out_file, encoding, size,
1030 addr, done);
1031 #endif
1033 /* Indirection is used to get dynamic relocations out of a
1034 read-only section. */
1035 if (encoding & DW_EH_PE_indirect)
1037 /* It is very tempting to use force_const_mem so that we share data
1038 with the normal constant pool. However, we've already emitted
1039 the constant pool for this function. Moreover, we'd like to
1040 share these constants across the entire unit of translation and
1041 even, if possible, across the entire application (or DSO). */
1042 addr = dw2_force_const_mem (addr, is_public);
1043 encoding &= ~DW_EH_PE_indirect;
1044 goto restart;
1047 switch (encoding & 0xF0)
1049 case DW_EH_PE_absptr:
1050 dw2_assemble_integer (size, addr);
1051 break;
1053 #ifdef ASM_OUTPUT_DWARF_DATAREL
1054 case DW_EH_PE_datarel:
1055 gcc_assert (GET_CODE (addr) == SYMBOL_REF);
1056 ASM_OUTPUT_DWARF_DATAREL (asm_out_file, size, XSTR (addr, 0));
1057 break;
1058 #endif
1060 case DW_EH_PE_pcrel:
1061 gcc_assert (GET_CODE (addr) == SYMBOL_REF);
1062 #ifdef ASM_OUTPUT_DWARF_PCREL
1063 ASM_OUTPUT_DWARF_PCREL (asm_out_file, size, XSTR (addr, 0));
1064 #else
1065 dw2_assemble_integer (size, gen_rtx_MINUS (Pmode, addr, pc_rtx));
1066 #endif
1067 break;
1069 default:
1070 /* Other encodings should have been handled by
1071 ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX. */
1072 gcc_unreachable ();
1075 #ifdef ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX
1076 done:;
1077 #endif
1080 if (flag_debug_asm && comment)
1082 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
1083 vfprintf (asm_out_file, comment, ap);
1085 fputc ('\n', asm_out_file);
1087 va_end (ap);
1090 #include "gt-dwarf2asm.h"