1 /* Dwarf2 assembler output helper routines.
2 Copyright (C) 2001 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
28 #include "dwarf2asm.h"
30 #include "splay-tree.h"
35 /* How to start an assembler comment. */
36 #ifndef ASM_COMMENT_START
37 #define ASM_COMMENT_START ";#"
40 /* Definitions of defaults for assembler-dependent names of various
41 pseudo-ops and section names. These may be overridden in the tm.h
42 file (if necessary) for a particular assembler. */
44 #ifdef OBJECT_FORMAT_ELF
45 #ifndef UNALIGNED_SHORT_ASM_OP
46 #define UNALIGNED_SHORT_ASM_OP "\t.2byte\t"
48 #ifndef UNALIGNED_INT_ASM_OP
49 #define UNALIGNED_INT_ASM_OP "\t.4byte\t"
51 #ifndef UNALIGNED_DOUBLE_INT_ASM_OP
52 #define UNALIGNED_DOUBLE_INT_ASM_OP "\t.8byte\t"
54 #endif /* OBJECT_FORMAT_ELF */
57 #define ASM_BYTE_OP "\t.byte\t"
60 /* We don't have unaligned support, let's hope the normal output works for
61 .debug_frame. But we know it won't work for .debug_info. */
62 #if !defined(UNALIGNED_INT_ASM_OP) && defined(DWARF2_DEBUGGING_INFO)
63 #error DWARF2_DEBUGGING_INFO requires UNALIGNED_INT_ASM_OP.
67 #ifdef UNALIGNED_INT_ASM_OP
68 static const char * unaligned_integer_asm_op
PARAMS ((int));
70 static inline const char *
71 unaligned_integer_asm_op (size
)
81 op
= UNALIGNED_SHORT_ASM_OP
;
84 op
= UNALIGNED_INT_ASM_OP
;
87 #ifdef UNALIGNED_DOUBLE_INT_ASM_OP
88 op
= UNALIGNED_DOUBLE_INT_ASM_OP
;
96 #endif /* UNALIGNED_INT_ASM_OP */
98 /* Output an immediate constant in a given size. */
101 dw2_asm_output_data
VPARAMS ((int size
, unsigned HOST_WIDE_INT value
,
102 const char *comment
, ...))
104 #ifndef ANSI_PROTOTYPES
106 unsigned HOST_WIDE_INT value
;
111 VA_START (ap
, comment
);
113 #ifndef ANSI_PROTOTYPES
114 size
= va_arg (ap
, int);
115 value
= va_arg (ap
, unsigned HOST_WIDE_INT
);
116 comment
= va_arg (ap
, const char *);
119 if (size
* 8 < HOST_BITS_PER_WIDE_INT
)
120 value
&= ~(~(unsigned HOST_WIDE_INT
)0 << (size
* 8));
122 #ifdef UNALIGNED_INT_ASM_OP
123 fputs (unaligned_integer_asm_op (size
), asm_out_file
);
124 fprintf (asm_out_file
, HOST_WIDE_INT_PRINT_HEX
, value
);
126 assemble_integer (GEN_INT (value
), size
, 1);
129 if (flag_debug_asm
&& comment
)
131 fprintf (asm_out_file
, "\t%s ", ASM_COMMENT_START
);
132 vfprintf (asm_out_file
, comment
, ap
);
134 fputc ('\n', asm_out_file
);
139 /* Output the difference between two symbols in a given size. */
140 /* ??? There appear to be assemblers that do not like such
141 subtraction, but do support ASM_SET_OP. It's unfortunately
142 impossible to do here, since the ASM_SET_OP for the difference
143 symbol must appear after both symbols are defined. */
146 dw2_asm_output_delta
VPARAMS ((int size
, const char *lab1
, const char *lab2
,
147 const char *comment
, ...))
149 #ifndef ANSI_PROTOTYPES
151 const char *lab1
, *lab2
;
156 VA_START (ap
, comment
);
158 #ifndef ANSI_PROTOTYPES
159 size
= va_arg (ap
, int);
160 lab1
= va_arg (ap
, const char *);
161 lab2
= va_arg (ap
, const char *);
162 comment
= va_arg (ap
, const char *);
165 #ifdef UNALIGNED_INT_ASM_OP
166 fputs (unaligned_integer_asm_op (size
), asm_out_file
);
167 assemble_name (asm_out_file
, lab1
);
168 fputc ('-', asm_out_file
);
169 assemble_name (asm_out_file
, lab2
);
171 assemble_integer (gen_rtx_MINUS (smallest_mode_for_size (size
, MODE_INT
),
172 gen_rtx_SYMBOL_REF (Pmode
, lab1
),
173 gen_rtx_SYMBOL_REF (Pmode
, lab2
)),
177 if (flag_debug_asm
&& comment
)
179 fprintf (asm_out_file
, "\t%s ", ASM_COMMENT_START
);
180 vfprintf (asm_out_file
, comment
, ap
);
182 fputc ('\n', asm_out_file
);
187 /* Output a section-relative reference to a label. In general this
188 can only be done for debugging symbols. E.g. on most targets with
189 the GNU linker, this is accomplished with a direct reference and
190 the knowledge that the debugging section will be placed at VMA 0.
191 Some targets have special relocations for this that we must use. */
194 dw2_asm_output_offset
VPARAMS ((int size
, const char *label
,
195 const char *comment
, ...))
197 #ifndef ANSI_PROTOTYPES
204 VA_START (ap
, comment
);
206 #ifndef ANSI_PROTOTYPES
207 size
= va_arg (ap
, int);
208 label
= va_arg (ap
, const char *);
209 comment
= va_arg (ap
, const char *);
212 #ifdef ASM_OUTPUT_DWARF_OFFSET
213 ASM_OUTPUT_DWARF_OFFSET (asm_out_file
, size
, label
);
215 #ifdef UNALIGNED_INT_ASM_OP
216 fputs (unaligned_integer_asm_op (size
), asm_out_file
);
217 assemble_name (asm_out_file
, label
);
219 assemble_integer (gen_rtx_SYMBOL_REF (Pmode
, label
), size
, 1);
223 if (flag_debug_asm
&& comment
)
225 fprintf (asm_out_file
, "\t%s ", ASM_COMMENT_START
);
226 vfprintf (asm_out_file
, comment
, ap
);
228 fputc ('\n', asm_out_file
);
233 /* Output a self-relative reference to a label, possibly in a
234 different section or object file. */
237 dw2_asm_output_pcrel
VPARAMS ((int size
, const char *label
,
238 const char *comment
, ...))
240 #ifndef ANSI_PROTOTYPES
247 VA_START (ap
, comment
);
249 #ifndef ANSI_PROTOTYPES
250 size
= va_arg (ap
, int);
251 label
= va_arg (ap
, const char *);
252 comment
= va_arg (ap
, const char *);
255 #ifdef ASM_OUTPUT_DWARF_PCREL
256 ASM_OUTPUT_DWARF_PCREL (asm_out_file
, size
, label
);
258 #ifdef UNALIGNED_INT_ASM_OP
259 fputs (unaligned_integer_asm_op (size
), asm_out_file
);
260 assemble_name (asm_out_file
, label
);
261 fputc ('-', asm_out_file
);
262 fputc ('.', asm_out_file
);
268 if (flag_debug_asm
&& comment
)
270 fprintf (asm_out_file
, "\t%s ", ASM_COMMENT_START
);
271 vfprintf (asm_out_file
, comment
, ap
);
273 fputc ('\n', asm_out_file
);
278 /* Output an absolute reference to a label. */
281 dw2_asm_output_addr
VPARAMS ((int size
, const char *label
,
282 const char *comment
, ...))
284 #ifndef ANSI_PROTOTYPES
291 VA_START (ap
, comment
);
293 #ifndef ANSI_PROTOTYPES
294 size
= va_arg (ap
, int);
295 label
= va_arg (ap
, const char *);
296 comment
= va_arg (ap
, const char *);
299 #ifdef UNALIGNED_INT_ASM_OP
300 fputs (unaligned_integer_asm_op (size
), asm_out_file
);
301 assemble_name (asm_out_file
, label
);
303 assemble_integer (gen_rtx_SYMBOL_REF (Pmode
, label
), size
, 1);
306 if (flag_debug_asm
&& comment
)
308 fprintf (asm_out_file
, "\t%s ", ASM_COMMENT_START
);
309 vfprintf (asm_out_file
, comment
, ap
);
311 fputc ('\n', asm_out_file
);
316 /* Similar, but use an RTX expression instead of a text label. */
319 dw2_asm_output_addr_rtx
VPARAMS ((int size
, rtx addr
,
320 const char *comment
, ...))
322 #ifndef ANSI_PROTOTYPES
329 VA_START (ap
, comment
);
331 #ifndef ANSI_PROTOTYPES
332 size
= va_arg (ap
, int);
333 addr
= va_arg (ap
, rtx
);
334 comment
= va_arg (ap
, const char *);
337 #ifdef UNALIGNED_INT_ASM_OP
338 fputs (unaligned_integer_asm_op (size
), asm_out_file
);
339 output_addr_const (asm_out_file
, addr
);
341 assemble_integer (addr
, size
, 1);
344 if (flag_debug_asm
&& comment
)
346 fprintf (asm_out_file
, "\t%s ", ASM_COMMENT_START
);
347 vfprintf (asm_out_file
, comment
, ap
);
349 fputc ('\n', asm_out_file
);
355 dw2_asm_output_nstring
VPARAMS ((const char *str
, size_t orig_len
,
356 const char *comment
, ...))
358 #ifndef ANSI_PROTOTYPES
364 size_t i
, len
= orig_len
;
366 VA_START (ap
, comment
);
368 #ifndef ANSI_PROTOTYPES
369 str
= va_arg (ap
, const char *);
370 len
= va_arg (ap
, size_t);
371 comment
= va_arg (ap
, const char *);
374 if (len
== (size_t) -1)
377 if (flag_debug_asm
&& comment
)
379 fputs ("\t.ascii \"", asm_out_file
);
380 for (i
= 0; i
< len
; i
++)
383 if (c
== '\"' || c
== '\\')
384 fputc ('\\', asm_out_file
);
386 fputc (c
, asm_out_file
);
388 fprintf (asm_out_file
, "\\%o", c
);
390 fprintf (asm_out_file
, "\\0\"\t%s ", ASM_COMMENT_START
);
391 vfprintf (asm_out_file
, comment
, ap
);
392 fputc ('\n', asm_out_file
);
396 /* If an explicit length was given, we can't assume there
397 is a null termination in the string buffer. */
398 if (orig_len
== (size_t) -1)
400 ASM_OUTPUT_ASCII (asm_out_file
, str
, len
);
401 if (orig_len
!= (size_t) -1)
402 fprintf (asm_out_file
, "%s0\n", ASM_BYTE_OP
);
409 /* Return the size of an unsigned LEB128 quantity. */
412 size_of_uleb128 (value
)
413 unsigned HOST_WIDE_INT value
;
419 byte
= (value
& 0x7f);
428 /* Return the size of a signed LEB128 quantity. */
431 size_of_sleb128 (value
)
438 byte
= (value
& 0x7f);
442 while (!((value
== 0 && (byte
& 0x40) == 0)
443 || (value
== -1 && (byte
& 0x40) != 0)));
448 /* Given an encoding, return the number of bytes the format occupies.
449 This is only defined for fixed-size encodings, and so does not
453 size_of_encoded_value (encoding
)
456 if (encoding
== DW_EH_PE_omit
)
459 switch (encoding
& 0x07)
461 case DW_EH_PE_absptr
:
462 return POINTER_SIZE
/ BITS_PER_UNIT
;
463 case DW_EH_PE_udata2
:
465 case DW_EH_PE_udata4
:
467 case DW_EH_PE_udata8
:
473 /* Yield a name for a given pointer encoding. */
476 eh_data_format_name (format
)
479 #if HAVE_DESIGNATED_INITIALIZERS
480 #define S(p, v) [p] = v,
482 #define S(p, v) case p: return v;
485 #if HAVE_DESIGNATED_INITIALIZERS
486 __extension__
static const char * const format_names
[256] = {
491 S(DW_EH_PE_absptr
, "absolute")
492 S(DW_EH_PE_omit
, "omit")
493 S(DW_EH_PE_aligned
, "aligned absolute")
495 S(DW_EH_PE_uleb128
, "uleb128")
496 S(DW_EH_PE_udata2
, "udata2")
497 S(DW_EH_PE_udata4
, "udata4")
498 S(DW_EH_PE_udata8
, "udata8")
499 S(DW_EH_PE_sleb128
, "sleb128")
500 S(DW_EH_PE_sdata2
, "sdata2")
501 S(DW_EH_PE_sdata4
, "sdata4")
502 S(DW_EH_PE_sdata8
, "sdata8")
504 S(DW_EH_PE_absptr
| DW_EH_PE_pcrel
, "pcrel")
505 S(DW_EH_PE_uleb128
| DW_EH_PE_pcrel
, "pcrel uleb128")
506 S(DW_EH_PE_udata2
| DW_EH_PE_pcrel
, "pcrel udata2")
507 S(DW_EH_PE_udata4
| DW_EH_PE_pcrel
, "pcrel udata4")
508 S(DW_EH_PE_udata8
| DW_EH_PE_pcrel
, "pcrel udata8")
509 S(DW_EH_PE_sleb128
| DW_EH_PE_pcrel
, "pcrel sleb128")
510 S(DW_EH_PE_sdata2
| DW_EH_PE_pcrel
, "pcrel sdata2")
511 S(DW_EH_PE_sdata4
| DW_EH_PE_pcrel
, "pcrel sdata4")
512 S(DW_EH_PE_sdata8
| DW_EH_PE_pcrel
, "pcrel sdata8")
514 S(DW_EH_PE_absptr
| DW_EH_PE_textrel
, "textrel")
515 S(DW_EH_PE_uleb128
| DW_EH_PE_textrel
, "textrel uleb128")
516 S(DW_EH_PE_udata2
| DW_EH_PE_textrel
, "textrel udata2")
517 S(DW_EH_PE_udata4
| DW_EH_PE_textrel
, "textrel udata4")
518 S(DW_EH_PE_udata8
| DW_EH_PE_textrel
, "textrel udata8")
519 S(DW_EH_PE_sleb128
| DW_EH_PE_textrel
, "textrel sleb128")
520 S(DW_EH_PE_sdata2
| DW_EH_PE_textrel
, "textrel sdata2")
521 S(DW_EH_PE_sdata4
| DW_EH_PE_textrel
, "textrel sdata4")
522 S(DW_EH_PE_sdata8
| DW_EH_PE_textrel
, "textrel sdata8")
524 S(DW_EH_PE_absptr
| DW_EH_PE_datarel
, "datarel")
525 S(DW_EH_PE_uleb128
| DW_EH_PE_datarel
, "datarel uleb128")
526 S(DW_EH_PE_udata2
| DW_EH_PE_datarel
, "datarel udata2")
527 S(DW_EH_PE_udata4
| DW_EH_PE_datarel
, "datarel udata4")
528 S(DW_EH_PE_udata8
| DW_EH_PE_datarel
, "datarel udata8")
529 S(DW_EH_PE_sleb128
| DW_EH_PE_datarel
, "datarel sleb128")
530 S(DW_EH_PE_sdata2
| DW_EH_PE_datarel
, "datarel sdata2")
531 S(DW_EH_PE_sdata4
| DW_EH_PE_datarel
, "datarel sdata4")
532 S(DW_EH_PE_sdata8
| DW_EH_PE_datarel
, "datarel sdata8")
534 S(DW_EH_PE_absptr
| DW_EH_PE_funcrel
, "funcrel")
535 S(DW_EH_PE_uleb128
| DW_EH_PE_funcrel
, "funcrel uleb128")
536 S(DW_EH_PE_udata2
| DW_EH_PE_funcrel
, "funcrel udata2")
537 S(DW_EH_PE_udata4
| DW_EH_PE_funcrel
, "funcrel udata4")
538 S(DW_EH_PE_udata8
| DW_EH_PE_funcrel
, "funcrel udata8")
539 S(DW_EH_PE_sleb128
| DW_EH_PE_funcrel
, "funcrel sleb128")
540 S(DW_EH_PE_sdata2
| DW_EH_PE_funcrel
, "funcrel sdata2")
541 S(DW_EH_PE_sdata4
| DW_EH_PE_funcrel
, "funcrel sdata4")
542 S(DW_EH_PE_sdata8
| DW_EH_PE_funcrel
, "funcrel sdata8")
544 S(DW_EH_PE_indirect
| DW_EH_PE_absptr
| DW_EH_PE_pcrel
,
546 S(DW_EH_PE_indirect
| DW_EH_PE_uleb128
| DW_EH_PE_pcrel
,
547 "indirect pcrel uleb128")
548 S(DW_EH_PE_indirect
| DW_EH_PE_udata2
| DW_EH_PE_pcrel
,
549 "indirect pcrel udata2")
550 S(DW_EH_PE_indirect
| DW_EH_PE_udata4
| DW_EH_PE_pcrel
,
551 "indirect pcrel udata4")
552 S(DW_EH_PE_indirect
| DW_EH_PE_udata8
| DW_EH_PE_pcrel
,
553 "indirect pcrel udata8")
554 S(DW_EH_PE_indirect
| DW_EH_PE_sleb128
| DW_EH_PE_pcrel
,
555 "indirect pcrel sleb128")
556 S(DW_EH_PE_indirect
| DW_EH_PE_sdata2
| DW_EH_PE_pcrel
,
557 "indirect pcrel sdata2")
558 S(DW_EH_PE_indirect
| DW_EH_PE_sdata4
| DW_EH_PE_pcrel
,
559 "indirect pcrel sdata4")
560 S(DW_EH_PE_indirect
| DW_EH_PE_sdata8
| DW_EH_PE_pcrel
,
561 "indirect pcrel sdata8")
563 S(DW_EH_PE_indirect
| DW_EH_PE_absptr
| DW_EH_PE_textrel
,
565 S(DW_EH_PE_indirect
| DW_EH_PE_uleb128
| DW_EH_PE_textrel
,
566 "indirect textrel uleb128")
567 S(DW_EH_PE_indirect
| DW_EH_PE_udata2
| DW_EH_PE_textrel
,
568 "indirect textrel udata2")
569 S(DW_EH_PE_indirect
| DW_EH_PE_udata4
| DW_EH_PE_textrel
,
570 "indirect textrel udata4")
571 S(DW_EH_PE_indirect
| DW_EH_PE_udata8
| DW_EH_PE_textrel
,
572 "indirect textrel udata8")
573 S(DW_EH_PE_indirect
| DW_EH_PE_sleb128
| DW_EH_PE_textrel
,
574 "indirect textrel sleb128")
575 S(DW_EH_PE_indirect
| DW_EH_PE_sdata2
| DW_EH_PE_textrel
,
576 "indirect textrel sdata2")
577 S(DW_EH_PE_indirect
| DW_EH_PE_sdata4
| DW_EH_PE_textrel
,
578 "indirect textrel sdata4")
579 S(DW_EH_PE_indirect
| DW_EH_PE_sdata8
| DW_EH_PE_textrel
,
580 "indirect textrel sdata8")
582 S(DW_EH_PE_indirect
| DW_EH_PE_absptr
| DW_EH_PE_datarel
,
584 S(DW_EH_PE_indirect
| DW_EH_PE_uleb128
| DW_EH_PE_datarel
,
585 "indirect datarel uleb128")
586 S(DW_EH_PE_indirect
| DW_EH_PE_udata2
| DW_EH_PE_datarel
,
587 "indirect datarel udata2")
588 S(DW_EH_PE_indirect
| DW_EH_PE_udata4
| DW_EH_PE_datarel
,
589 "indirect datarel udata4")
590 S(DW_EH_PE_indirect
| DW_EH_PE_udata8
| DW_EH_PE_datarel
,
591 "indirect datarel udata8")
592 S(DW_EH_PE_indirect
| DW_EH_PE_sleb128
| DW_EH_PE_datarel
,
593 "indirect datarel sleb128")
594 S(DW_EH_PE_indirect
| DW_EH_PE_sdata2
| DW_EH_PE_datarel
,
595 "indirect datarel sdata2")
596 S(DW_EH_PE_indirect
| DW_EH_PE_sdata4
| DW_EH_PE_datarel
,
597 "indirect datarel sdata4")
598 S(DW_EH_PE_indirect
| DW_EH_PE_sdata8
| DW_EH_PE_datarel
,
599 "indirect datarel sdata8")
601 S(DW_EH_PE_indirect
| DW_EH_PE_absptr
| DW_EH_PE_funcrel
,
603 S(DW_EH_PE_indirect
| DW_EH_PE_uleb128
| DW_EH_PE_funcrel
,
604 "indirect funcrel uleb128")
605 S(DW_EH_PE_indirect
| DW_EH_PE_udata2
| DW_EH_PE_funcrel
,
606 "indirect funcrel udata2")
607 S(DW_EH_PE_indirect
| DW_EH_PE_udata4
| DW_EH_PE_funcrel
,
608 "indirect funcrel udata4")
609 S(DW_EH_PE_indirect
| DW_EH_PE_udata8
| DW_EH_PE_funcrel
,
610 "indirect funcrel udata8")
611 S(DW_EH_PE_indirect
| DW_EH_PE_sleb128
| DW_EH_PE_funcrel
,
612 "indirect funcrel sleb128")
613 S(DW_EH_PE_indirect
| DW_EH_PE_sdata2
| DW_EH_PE_funcrel
,
614 "indirect funcrel sdata2")
615 S(DW_EH_PE_indirect
| DW_EH_PE_sdata4
| DW_EH_PE_funcrel
,
616 "indirect funcrel sdata4")
617 S(DW_EH_PE_indirect
| DW_EH_PE_sdata8
| DW_EH_PE_funcrel
,
618 "indirect funcrel sdata8")
620 #if HAVE_DESIGNATED_INITIALIZERS
623 if (format
< 0 || format
> 0xff || format_names
[format
] == NULL
)
625 return format_names
[format
];
632 /* Output an unsigned LEB128 quantity. */
635 dw2_asm_output_data_uleb128
VPARAMS ((unsigned HOST_WIDE_INT value
,
636 const char *comment
, ...))
638 #ifndef ANSI_PROTOTYPES
639 unsigned HOST_WIDE_INT value
;
644 VA_START (ap
, comment
);
646 #ifndef ANSI_PROTOTYPES
647 value
= va_arg (ap
, unsigned HOST_WIDE_INT
);
648 comment
= va_arg (ap
, const char *);
651 #ifdef HAVE_AS_LEB128
652 fputs ("\t.uleb128 ", asm_out_file
);
653 fprintf (asm_out_file
, HOST_WIDE_INT_PRINT_HEX
, value
);
655 if (flag_debug_asm
&& comment
)
657 fprintf (asm_out_file
, "\t%s ", ASM_COMMENT_START
);
658 vfprintf (asm_out_file
, comment
, ap
);
662 unsigned HOST_WIDE_INT work
= value
;
664 fputs (ASM_BYTE_OP
, asm_out_file
);
667 int byte
= (work
& 0x7f);
670 /* More bytes to follow. */
673 fprintf (asm_out_file
, "0x%x", byte
);
675 fputc (',', asm_out_file
);
681 fprintf (asm_out_file
, "\t%s uleb128 ", ASM_COMMENT_START
);
682 fprintf (asm_out_file
, HOST_WIDE_INT_PRINT_HEX
, value
);
685 fputs ("; ", asm_out_file
);
686 vfprintf (asm_out_file
, comment
, ap
);
691 fputc ('\n', asm_out_file
);
696 /* Output an signed LEB128 quantity. */
699 dw2_asm_output_data_sleb128
VPARAMS ((HOST_WIDE_INT value
,
700 const char *comment
, ...))
702 #ifndef ANSI_PROTOTYPES
708 VA_START (ap
, comment
);
710 #ifndef ANSI_PROTOTYPES
711 value
= va_arg (ap
, HOST_WIDE_INT
);
712 comment
= va_arg (ap
, const char *);
715 #ifdef HAVE_AS_LEB128
716 fputs ("\t.sleb128 ", asm_out_file
);
717 fprintf (asm_out_file
, HOST_WIDE_INT_PRINT_DEC
, value
);
719 if (flag_debug_asm
&& comment
)
721 fprintf (asm_out_file
, "\t%s ", ASM_COMMENT_START
);
722 vfprintf (asm_out_file
, comment
, ap
);
726 HOST_WIDE_INT work
= value
;
729 fputs (ASM_BYTE_OP
, asm_out_file
);
732 byte
= (work
& 0x7f);
733 /* arithmetic shift */
735 more
= !((work
== 0 && (byte
& 0x40) == 0)
736 || (work
== -1 && (byte
& 0x40) != 0));
740 fprintf (asm_out_file
, "0x%x", byte
);
742 fputc (',', asm_out_file
);
748 fprintf (asm_out_file
, "\t%s sleb128 ", ASM_COMMENT_START
);
749 fprintf (asm_out_file
, HOST_WIDE_INT_PRINT_DEC
, value
);
752 fputs ("; ", asm_out_file
);
753 vfprintf (asm_out_file
, comment
, ap
);
758 fputc ('\n', asm_out_file
);
764 dw2_asm_output_delta_uleb128
VPARAMS ((const char *lab1 ATTRIBUTE_UNUSED
,
765 const char *lab2 ATTRIBUTE_UNUSED
,
766 const char *comment
, ...))
768 #ifndef ANSI_PROTOTYPES
769 const char *lab1
, *lab2
;
774 VA_START (ap
, comment
);
776 #ifndef ANSI_PROTOTYPES
777 lab1
= va_arg (ap
, const char *);
778 lab2
= va_arg (ap
, const char *);
779 comment
= va_arg (ap
, const char *);
782 #ifdef HAVE_AS_LEB128
783 fputs ("\t.uleb128 ", asm_out_file
);
784 assemble_name (asm_out_file
, lab1
);
785 fputc ('-', asm_out_file
);
786 assemble_name (asm_out_file
, lab2
);
791 if (flag_debug_asm
&& comment
)
793 fprintf (asm_out_file
, "\t%s ", ASM_COMMENT_START
);
794 vfprintf (asm_out_file
, comment
, ap
);
796 fputc ('\n', asm_out_file
);
802 dw2_asm_output_delta_sleb128
VPARAMS ((const char *lab1 ATTRIBUTE_UNUSED
,
803 const char *lab2 ATTRIBUTE_UNUSED
,
804 const char *comment
, ...))
806 #ifndef ANSI_PROTOTYPES
807 const char *lab1
, *lab2
;
812 VA_START (ap
, comment
);
814 #ifndef ANSI_PROTOTYPES
815 lab1
= va_arg (ap
, const char *);
816 lab2
= va_arg (ap
, const char *);
817 comment
= va_arg (ap
, const char *);
820 #ifdef HAVE_AS_LEB128
821 fputs ("\t.sleb128 ", asm_out_file
);
822 assemble_name (asm_out_file
, lab1
);
823 fputc ('-', asm_out_file
);
824 assemble_name (asm_out_file
, lab2
);
829 if (flag_debug_asm
&& comment
)
831 fprintf (asm_out_file
, "\t%s ", ASM_COMMENT_START
);
832 vfprintf (asm_out_file
, comment
, ap
);
834 fputc ('\n', asm_out_file
);
839 static rtx dw2_force_const_mem
PARAMS ((rtx
));
840 static int dw2_output_indirect_constant_1
PARAMS ((splay_tree_node
, void *));
842 static splay_tree indirect_pool
;
844 /* Put X, a SYMBOL_REF, in memory. Return a SYMBOL_REF to the allocated
845 memory. Differs from force_const_mem in that a single pool is used for
846 the entire unit of translation, and the memory is not guaranteed to be
847 "near" the function in any interesting sense. */
850 dw2_force_const_mem (x
)
853 splay_tree_node node
;
854 const char *const_sym
;
857 indirect_pool
= splay_tree_new (splay_tree_compare_pointers
, NULL
, NULL
);
859 if (GET_CODE (x
) != SYMBOL_REF
)
861 node
= splay_tree_lookup (indirect_pool
, (splay_tree_key
) XSTR (x
, 0));
863 const_sym
= (const char *) node
->value
;
866 extern int const_labelno
;
870 ASM_GENERATE_INTERNAL_LABEL (label
, "LC", const_labelno
);
872 const_sym
= ggc_strdup (label
);
874 id
= maybe_get_identifier (XSTR (x
, 0));
876 TREE_SYMBOL_REFERENCED (id
) = 1;
878 splay_tree_insert (indirect_pool
, (splay_tree_key
) XSTR (x
, 0),
879 (splay_tree_value
) const_sym
);
882 return gen_rtx_SYMBOL_REF (Pmode
, const_sym
);
885 /* A helper function for dw2_output_indirect_constants called through
886 splay_tree_foreach. Emit one queued constant to memory. */
889 dw2_output_indirect_constant_1 (node
, data
)
890 splay_tree_node node
;
891 void* data ATTRIBUTE_UNUSED
;
893 const char *label
, *sym
;
896 label
= (const char *) node
->value
;
897 sym
= (const char *) node
->key
;
898 sym_ref
= gen_rtx_SYMBOL_REF (Pmode
, sym
);
900 ASM_OUTPUT_LABEL (asm_out_file
, label
);
901 assemble_integer (sym_ref
, POINTER_SIZE
/ BITS_PER_UNIT
, 1);
906 /* Emit the constants queued through dw2_force_const_mem. */
909 dw2_output_indirect_constants ()
914 /* Assume that the whole reason we're emitting these symbol references
915 indirectly is that they contain dynamic relocations, and are thus
916 read-write. If there was no possibility of a dynamic relocation, we
917 might as well have used a direct relocation. */
920 /* Everything we're emitting is a pointer. Align appropriately. */
921 assemble_align (POINTER_SIZE
);
923 splay_tree_foreach (indirect_pool
, dw2_output_indirect_constant_1
, NULL
);
926 /* Like dw2_asm_output_addr_rtx, but encode the pointer as directed. */
929 dw2_asm_output_encoded_addr_rtx
VPARAMS ((int encoding
,
931 const char *comment
, ...))
933 #ifndef ANSI_PROTOTYPES
941 VA_START (ap
, comment
);
943 #ifndef ANSI_PROTOTYPES
944 encoding
= va_arg (ap
, int);
945 addr
= va_arg (ap
, rtx
);
946 comment
= va_arg (ap
, const char *);
949 size
= size_of_encoded_value (encoding
);
951 if (encoding
== DW_EH_PE_aligned
)
953 assemble_align (POINTER_SIZE
);
954 encoding
= DW_EH_PE_absptr
;
957 /* NULL is _always_ represented as a plain zero. */
958 if (addr
== const0_rtx
)
959 assemble_integer (addr
, size
, 1);
963 /* Allow the target first crack at emitting this. Some of the
964 special relocations require special directives instead of
965 just ".4byte" or whatever. */
966 #ifdef ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX
967 ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX (asm_out_file
, encoding
, size
,
971 /* Indirection is used to get dynamic relocations out of a
972 read-only section. */
973 if (encoding
& DW_EH_PE_indirect
)
975 /* It is very tempting to use force_const_mem so that we share data
976 with the normal constant pool. However, we've already emitted
977 the constant pool for this function. Moreover, we'd like to
978 share these constants across the entire unit of translation,
979 or better, across the entire application (or DSO). */
980 addr
= dw2_force_const_mem (addr
);
981 encoding
&= ~DW_EH_PE_indirect
;
985 switch (encoding
& 0xF0)
987 case DW_EH_PE_absptr
:
988 #ifdef UNALIGNED_INT_ASM_OP
989 fputs (unaligned_integer_asm_op (size
), asm_out_file
);
990 output_addr_const (asm_out_file
, addr
);
992 assemble_integer (addr
, size
, 1);
997 if (GET_CODE (addr
) != SYMBOL_REF
)
999 #ifdef ASM_OUTPUT_DWARF_PCREL
1000 ASM_OUTPUT_DWARF_PCREL (asm_out_file
, size
, XSTR (addr
, 0));
1002 #ifdef UNALIGNED_INT_ASM_OP
1003 fputs (unaligned_integer_asm_op (size
), asm_out_file
);
1004 assemble_name (asm_out_file
, XSTR (addr
, 0));
1005 fputc ('-', asm_out_file
);
1006 fputc ('.', asm_out_file
);
1014 /* Other encodings should have been handled by
1015 ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX. */
1019 #ifdef ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX
1024 if (flag_debug_asm
&& comment
)
1026 fprintf (asm_out_file
, "\t%s ", ASM_COMMENT_START
);
1027 vfprintf (asm_out_file
, comment
, ap
);
1029 fputc ('\n', asm_out_file
);