]> git.ipfire.org Git - thirdparty/gcc.git/blame - gcc/dwarf2asm.c
projects / thirdparty / gcc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
config.gcc, bsd386.h: Do not directly include i386/386bsd.h.
[thirdparty/gcc.git] / gcc / dwarf2asm.c
CommitLineData
2e4b9b8c
RH		 1/* Dwarf2 assembler output helper routines.
2 Copyright (C) 2001 Free Software Foundation, Inc.
3
4This file is part of GNU CC.
5
6GNU CC is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation; either version 2, or (at your option)
9any later version.
10
11GNU CC is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with GNU CC; see the file COPYING. If not, write to
18the Free Software Foundation, 59 Temple Place - Suite 330,
19Boston, MA 02111-1307, USA. */
20
21
22#include "config.h"
23#include "system.h"
24#include "flags.h"
2a1ee410 25#include "tree.h"
2e4b9b8c
RH		 26#include "rtl.h"
27#include "output.h"
28#include "dwarf2asm.h"
2a1ee410
RH		 29#include "dwarf2.h"
30#include "splay-tree.h"
31#include "ggc.h"
2e4b9b8c
RH		 32#include "tm_p.h"
33
34
35/* How to start an assembler comment. */
36#ifndef ASM_COMMENT_START
37#define ASM_COMMENT_START ";#"
38#endif
39
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. */
43
44#ifdef OBJECT_FORMAT_ELF
45#ifndef UNALIGNED_SHORT_ASM_OP
46#define UNALIGNED_SHORT_ASM_OP "\t.2byte\t"
47#endif
48#ifndef UNALIGNED_INT_ASM_OP
49#define UNALIGNED_INT_ASM_OP "\t.4byte\t"
50#endif
51#ifndef UNALIGNED_DOUBLE_INT_ASM_OP
52#define UNALIGNED_DOUBLE_INT_ASM_OP "\t.8byte\t"
53#endif
54#endif /* OBJECT_FORMAT_ELF */
55
56#ifndef ASM_BYTE_OP
57#define ASM_BYTE_OP "\t.byte\t"
58#endif
59
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.
64#endif
65
66\f
67#ifdef UNALIGNED_INT_ASM_OP
68static const char * unaligned_integer_asm_op PARAMS ((int));
69
70static inline const char *
71unaligned_integer_asm_op (size)
72 int size;
73{
74 const char *op;
75 switch (size)
76 {
77 case 1:
78 op = ASM_BYTE_OP;
79 break;
80 case 2:
81 op = UNALIGNED_SHORT_ASM_OP;
82 break;
83 case 4:
84 op = UNALIGNED_INT_ASM_OP;
85 break;
86 case 8:
87#ifdef UNALIGNED_DOUBLE_INT_ASM_OP
88 op = UNALIGNED_DOUBLE_INT_ASM_OP;
89 break;
90#endif
91 default:
92 abort ();
93 }
94 return op;
95}
96#endif /* UNALIGNED_INT_ASM_OP */
97
8e7fa2c8
RH		 98/* Output an immediate constant in a given size. */
99
2e4b9b8c
RH		 100void
101dw2_asm_output_data VPARAMS ((int size, unsigned HOST_WIDE_INT value,
102 const char *comment, ...))
103{
104#ifndef ANSI_PROTOTYPES
105 int size;
106 unsigned HOST_WIDE_INT value;
107 const char *comment;
108#endif
109 va_list ap;
110
111 VA_START (ap, comment);
112
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 *);
117#endif
118
da6af203
RH		 119 if (size * 8 < HOST_BITS_PER_WIDE_INT)
120 value &= ~(~(unsigned HOST_WIDE_INT)0 << (size * 8));
121
2e4b9b8c
RH		 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);
125#else
126 assemble_integer (GEN_INT (value), size, 1);
127#endif
128
129 if (flag_debug_asm && comment)
130 {
131 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
132 vfprintf (asm_out_file, comment, ap);
133 }
134 fputc ('\n', asm_out_file);
135
136 va_end (ap);
137}
138
8e7fa2c8
RH		 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. */
144
2e4b9b8c
RH		 145void
146dw2_asm_output_delta VPARAMS ((int size, const char *lab1, const char *lab2,
147 const char *comment, ...))
148{
149#ifndef ANSI_PROTOTYPES
150 int size;
151 const char *lab1, *lab2;
152 const char *comment;
153#endif
154 va_list ap;
155
156 VA_START (ap, comment);
157
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 *);
163#endif
164
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);
170#else
d2f65b7b 171 assemble_integer (gen_rtx_MINUS (smallest_mode_for_size (size, MODE_INT),
2e4b9b8c
RH		 172 gen_rtx_SYMBOL_REF (Pmode, lab1),
173 gen_rtx_SYMBOL_REF (Pmode, lab2)),
174 size, 1);
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
8e7fa2c8
RH		 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. */
192
2e4b9b8c
RH		 193void
194dw2_asm_output_offset VPARAMS ((int size, const char *label,
195 const char *comment, ...))
196{
197#ifndef ANSI_PROTOTYPES
198 int size;
199 const char *label;
200 const char *comment;
201#endif
202 va_list ap;
203
204 VA_START (ap, comment);
205
206#ifndef ANSI_PROTOTYPES
207 size = va_arg (ap, int);
208 label = va_arg (ap, const char *);
209 comment = va_arg (ap, const char *);
210#endif
211
8e7fa2c8
RH		 212#ifdef ASM_OUTPUT_DWARF_OFFSET
213 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, size, label);
214#else
2e4b9b8c
RH		 215#ifdef UNALIGNED_INT_ASM_OP
216 fputs (unaligned_integer_asm_op (size), asm_out_file);
217 assemble_name (asm_out_file, label);
218#else
219 assemble_integer (gen_rtx_SYMBOL_REF (Pmode, label), size, 1);
8e7fa2c8 220#endif
2e4b9b8c
RH		 221#endif
222
223 if (flag_debug_asm && comment)
224 {
225 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
226 vfprintf (asm_out_file, comment, ap);
227 }
228 fputc ('\n', asm_out_file);
229
230 va_end (ap);
231}
232
8e7fa2c8
RH		 233/* Output a self-relative reference to a label, possibly in a
234 different section or object file. */
235
2e4b9b8c
RH		 236void
237dw2_asm_output_pcrel VPARAMS ((int size, const char *label,
238 const char *comment, ...))
239{
240#ifndef ANSI_PROTOTYPES
241 int size;
242 const char *label;
243 const char *comment;
244#endif
245 va_list ap;
246
247 VA_START (ap, comment);
248
249#ifndef ANSI_PROTOTYPES
250 size = va_arg (ap, int);
251 label = va_arg (ap, const char *);
252 comment = va_arg (ap, const char *);
253#endif
254
8e7fa2c8
RH		 255#ifdef ASM_OUTPUT_DWARF_PCREL
256 ASM_OUTPUT_DWARF_PCREL (asm_out_file, size, label);
257#else
2e4b9b8c
RH		 258#ifdef UNALIGNED_INT_ASM_OP
259 fputs (unaligned_integer_asm_op (size), asm_out_file);
2e4b9b8c
RH		 260 assemble_name (asm_out_file, label);
261 fputc ('-', asm_out_file);
262 fputc ('.', asm_out_file);
263#else
264 abort ();
265#endif
8e7fa2c8
RH		 266#endif
267
268 if (flag_debug_asm && comment)
269 {
270 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
271 vfprintf (asm_out_file, comment, ap);
272 }
273 fputc ('\n', asm_out_file);
274
275 va_end (ap);
276}
277
278/* Output an absolute reference to a label. */
279
280void
281dw2_asm_output_addr VPARAMS ((int size, const char *label,
282 const char *comment, ...))
283{
284#ifndef ANSI_PROTOTYPES
285 int size;
286 const char *label;
287 const char *comment;
288#endif
289 va_list ap;
290
291 VA_START (ap, comment);
292
293#ifndef ANSI_PROTOTYPES
294 size = va_arg (ap, int);
295 label = va_arg (ap, const char *);
296 comment = va_arg (ap, const char *);
297#endif
298
299#ifdef UNALIGNED_INT_ASM_OP
300 fputs (unaligned_integer_asm_op (size), asm_out_file);
301 assemble_name (asm_out_file, label);
302#else
303 assemble_integer (gen_rtx_SYMBOL_REF (Pmode, label), size, 1);
304#endif
2e4b9b8c
RH		 305
306 if (flag_debug_asm && comment)
307 {
308 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
309 vfprintf (asm_out_file, comment, ap);
310 }
311 fputc ('\n', asm_out_file);
312
313 va_end (ap);
314}
315
8e7fa2c8
RH		 316/* Similar, but use an RTX expression instead of a text label. */
317
2e4b9b8c
RH		 318void
319dw2_asm_output_addr_rtx VPARAMS ((int size, rtx addr,
320 const char *comment, ...))
321{
322#ifndef ANSI_PROTOTYPES
323 int size;
324 rtx addr;
325 const char *comment;
326#endif
327 va_list ap;
328
329 VA_START (ap, comment);
330
331#ifndef ANSI_PROTOTYPES
332 size = va_arg (ap, int);
333 addr = va_arg (ap, rtx);
334 comment = va_arg (ap, const char *);
335#endif
336
337#ifdef UNALIGNED_INT_ASM_OP
338 fputs (unaligned_integer_asm_op (size), asm_out_file);
339 output_addr_const (asm_out_file, addr);
340#else
341 assemble_integer (addr, size, 1);
342#endif
343
344 if (flag_debug_asm && comment)
345 {
346 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
347 vfprintf (asm_out_file, comment, ap);
348 }
349 fputc ('\n', asm_out_file);
350
351 va_end (ap);
352}
353
354void
355dw2_asm_output_nstring VPARAMS ((const char *str, size_t orig_len,
356 const char *comment, ...))
357{
358#ifndef ANSI_PROTOTYPES
359 const char *str;
360 size_t orig_len;
361 const char *comment;
362#endif
363 va_list ap;
364 size_t i, len = orig_len;
365
366 VA_START (ap, comment);
367
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 *);
372#endif
373
374 if (len == (size_t) -1)
375 len = strlen (str);
376
377 if (flag_debug_asm && comment)
378 {
379 fputs ("\t.ascii \"", asm_out_file);
380 for (i = 0; i < len; i++)
381 {
382 int c = str[i];
383 if (c == '\"' || c == '\\')
384 fputc ('\\', asm_out_file);
385 if (ISPRINT(c))
386 fputc (c, asm_out_file);
387 else
388 fprintf (asm_out_file, "\\%o", c);
389 }
390 fprintf (asm_out_file, "\\0\"\t%s ", ASM_COMMENT_START);
391 vfprintf (asm_out_file, comment, ap);
392 fputc ('\n', asm_out_file);
393 }
394 else
395 {
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)
399 len += 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);
403 }
404
405 va_end (ap);
406}
407\f
408
409/* Return the size of an unsigned LEB128 quantity. */
410
411int
412size_of_uleb128 (value)
413 unsigned HOST_WIDE_INT value;
414{
415 int size = 0, byte;
416
417 do
418 {
419 byte = (value & 0x7f);
420 value >>= 7;
421 size += 1;
422 }
423 while (value != 0);
424
425 return size;
426}
427
428/* Return the size of a signed LEB128 quantity. */
429
430int
431size_of_sleb128 (value)
432 HOST_WIDE_INT value;
433{
434 int size = 0, byte;
435
436 do
437 {
438 byte = (value & 0x7f);
439 value >>= 7;
440 size += 1;
441 }
442 while (!((value == 0 && (byte & 0x40) == 0)
443 || (value == -1 && (byte & 0x40) != 0)));
444
445 return size;
446}
447
b627d6fe
RH		 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
450 include leb128. */
451
452int
453size_of_encoded_value (encoding)
454 int encoding;
455{
456 if (encoding == DW_EH_PE_omit)
457 return 0;
458
459 switch (encoding & 0x07)
460 {
461 case DW_EH_PE_absptr:
462 return POINTER_SIZE / BITS_PER_UNIT;
463 case DW_EH_PE_udata2:
464 return 2;
465 case DW_EH_PE_udata4:
466 return 4;
467 case DW_EH_PE_udata8:
468 return 8;
469 }
470 abort ();
471}
472
e1f9550a
RH		 473/* Yield a name for a given pointer encoding. */
474
475const char *
476eh_data_format_name (format)
477 int format;
478{
479#if HAVE_DESIGNATED_INITIALIZERS
480#define S(p, v) [p] = v,
481#else
482#define S(p, v) case p: return v;
483#endif
484
485#if HAVE_DESIGNATED_INITIALIZERS
486 __extension__ static const char * const format_names[256] = {
487#else
488 switch (format) {
489#endif
490
491 S(DW_EH_PE_absptr, "absolute")
492 S(DW_EH_PE_omit, "omit")
493
494 S(DW_EH_PE_uleb128, "uleb128")
495 S(DW_EH_PE_udata2, "udata2")
496 S(DW_EH_PE_udata4, "udata4")
497 S(DW_EH_PE_udata8, "udata8")
498 S(DW_EH_PE_sleb128, "sleb128")
499 S(DW_EH_PE_sdata2, "sdata2")
500 S(DW_EH_PE_sdata4, "sdata4")
501 S(DW_EH_PE_sdata8, "sdata8")
502
f90811a2 503 S(DW_EH_PE_absptr | DW_EH_PE_pcrel, "pcrel")
e1f9550a
RH		 504 S(DW_EH_PE_uleb128 | DW_EH_PE_pcrel, "pcrel uleb128")
505 S(DW_EH_PE_udata2 | DW_EH_PE_pcrel, "pcrel udata2")
506 S(DW_EH_PE_udata4 | DW_EH_PE_pcrel, "pcrel udata4")
507 S(DW_EH_PE_udata8 | DW_EH_PE_pcrel, "pcrel udata8")
508 S(DW_EH_PE_sleb128 | DW_EH_PE_pcrel, "pcrel sleb128")
509 S(DW_EH_PE_sdata2 | DW_EH_PE_pcrel, "pcrel sdata2")
510 S(DW_EH_PE_sdata4 | DW_EH_PE_pcrel, "pcrel sdata4")
511 S(DW_EH_PE_sdata8 | DW_EH_PE_pcrel, "pcrel sdata8")
512
f90811a2 513 S(DW_EH_PE_absptr | DW_EH_PE_textrel, "textrel")
e1f9550a
RH		 514 S(DW_EH_PE_uleb128 | DW_EH_PE_textrel, "textrel uleb128")
515 S(DW_EH_PE_udata2 | DW_EH_PE_textrel, "textrel udata2")
516 S(DW_EH_PE_udata4 | DW_EH_PE_textrel, "textrel udata4")
517 S(DW_EH_PE_udata8 | DW_EH_PE_textrel, "textrel udata8")
518 S(DW_EH_PE_sleb128 | DW_EH_PE_textrel, "textrel sleb128")
519 S(DW_EH_PE_sdata2 | DW_EH_PE_textrel, "textrel sdata2")
520 S(DW_EH_PE_sdata4 | DW_EH_PE_textrel, "textrel sdata4")
521 S(DW_EH_PE_sdata8 | DW_EH_PE_textrel, "textrel sdata8")
522
f90811a2 523 S(DW_EH_PE_absptr | DW_EH_PE_datarel, "datarel")
e1f9550a
RH		 524 S(DW_EH_PE_uleb128 | DW_EH_PE_datarel, "datarel uleb128")
525 S(DW_EH_PE_udata2 | DW_EH_PE_datarel, "datarel udata2")
526 S(DW_EH_PE_udata4 | DW_EH_PE_datarel, "datarel udata4")
527 S(DW_EH_PE_udata8 | DW_EH_PE_datarel, "datarel udata8")
528 S(DW_EH_PE_sleb128 | DW_EH_PE_datarel, "datarel sleb128")
529 S(DW_EH_PE_sdata2 | DW_EH_PE_datarel, "datarel sdata2")
530 S(DW_EH_PE_sdata4 | DW_EH_PE_datarel, "datarel sdata4")
531 S(DW_EH_PE_sdata8 | DW_EH_PE_datarel, "datarel sdata8")
532
f90811a2 533 S(DW_EH_PE_absptr | DW_EH_PE_funcrel, "funcrel")
e1f9550a
RH		 534 S(DW_EH_PE_uleb128 | DW_EH_PE_funcrel, "funcrel uleb128")
535 S(DW_EH_PE_udata2 | DW_EH_PE_funcrel, "funcrel udata2")
536 S(DW_EH_PE_udata4 | DW_EH_PE_funcrel, "funcrel udata4")
537 S(DW_EH_PE_udata8 | DW_EH_PE_funcrel, "funcrel udata8")
538 S(DW_EH_PE_sleb128 | DW_EH_PE_funcrel, "funcrel sleb128")
539 S(DW_EH_PE_sdata2 | DW_EH_PE_funcrel, "funcrel sdata2")
540 S(DW_EH_PE_sdata4 | DW_EH_PE_funcrel, "funcrel sdata4")
541 S(DW_EH_PE_sdata8 | DW_EH_PE_funcrel, "funcrel sdata8")
542
f90811a2
RH		 543 S(DW_EH_PE_indirect | DW_EH_PE_absptr | DW_EH_PE_pcrel,
544 "indirect pcrel")
e1f9550a
RH		 545 S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_pcrel,
546 "indirect pcrel uleb128")
547 S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_pcrel,
548 "indirect pcrel udata2")
549 S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_pcrel,
550 "indirect pcrel udata4")
551 S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_pcrel,
552 "indirect pcrel udata8")
553 S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_pcrel,
554 "indirect pcrel sleb128")
555 S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_pcrel,
556 "indirect pcrel sdata2")
557 S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_pcrel,
558 "indirect pcrel sdata4")
559 S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_pcrel,
560 "indirect pcrel sdata8")
561
f90811a2
RH		 562 S(DW_EH_PE_indirect | DW_EH_PE_absptr | DW_EH_PE_textrel,
563 "indirect textrel")
e1f9550a
RH		 564 S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_textrel,
565 "indirect textrel uleb128")
566 S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_textrel,
567 "indirect textrel udata2")
568 S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_textrel,
569 "indirect textrel udata4")
570 S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_textrel,
571 "indirect textrel udata8")
572 S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_textrel,
573 "indirect textrel sleb128")
574 S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_textrel,
575 "indirect textrel sdata2")
576 S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_textrel,
577 "indirect textrel sdata4")
578 S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_textrel,
579 "indirect textrel sdata8")
580
f90811a2
RH		 581 S(DW_EH_PE_indirect | DW_EH_PE_absptr | DW_EH_PE_datarel,
582 "indirect datarel")
e1f9550a
RH		 583 S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_datarel,
584 "indirect datarel uleb128")
585 S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_datarel,
586 "indirect datarel udata2")
587 S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_datarel,
588 "indirect datarel udata4")
589 S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_datarel,
590 "indirect datarel udata8")
591 S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_datarel,
592 "indirect datarel sleb128")
593 S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_datarel,
594 "indirect datarel sdata2")
595 S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_datarel,
596 "indirect datarel sdata4")
597 S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_datarel,
598 "indirect datarel sdata8")
599
f90811a2
RH		 600 S(DW_EH_PE_indirect | DW_EH_PE_absptr | DW_EH_PE_funcrel,
601 "indirect funcrel")
e1f9550a
RH		 602 S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_funcrel,
603 "indirect funcrel uleb128")
604 S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_funcrel,
605 "indirect funcrel udata2")
606 S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_funcrel,
607 "indirect funcrel udata4")
608 S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_funcrel,
609 "indirect funcrel udata8")
610 S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_funcrel,
611 "indirect funcrel sleb128")
612 S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_funcrel,
613 "indirect funcrel sdata2")
614 S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_funcrel,
615 "indirect funcrel sdata4")
616 S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_funcrel,
617 "indirect funcrel sdata8")
618
619#if HAVE_DESIGNATED_INITIALIZERS
620 };
621
622 if (format < 0 || format > 0xff || format_names[format] == NULL)
623 abort ();
624 return format_names[format];
625#else
626 }
627 abort ();
628#endif
629}
630
2e4b9b8c
RH		 631/* Output an unsigned LEB128 quantity. */
632
633void
634dw2_asm_output_data_uleb128 VPARAMS ((unsigned HOST_WIDE_INT value,
635 const char *comment, ...))
636{
637#ifndef ANSI_PROTOTYPES
638 unsigned HOST_WIDE_INT value;
639 const char *comment;
640#endif
641 va_list ap;
642
643 VA_START (ap, comment);
644
645#ifndef ANSI_PROTOTYPES
646 value = va_arg (ap, unsigned HOST_WIDE_INT);
647 comment = va_arg (ap, const char *);
648#endif
649
650#ifdef HAVE_AS_LEB128
da6af203 651 fputs ("\t.uleb128 ", asm_out_file);
2e4b9b8c
RH		 652 fprintf (asm_out_file, HOST_WIDE_INT_PRINT_HEX, 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 unsigned HOST_WIDE_INT work = value;
662
663 fputs (ASM_BYTE_OP, asm_out_file);
664 do
665 {
666 int byte = (work & 0x7f);
667 work >>= 7;
668 if (work != 0)
669 /* More bytes to follow. */
670 byte |= 0x80;
671
672 fprintf (asm_out_file, "0x%x", byte);
673 if (work != 0)
674 fputc (',', asm_out_file);
675 }
676 while (work != 0);
677
678 if (flag_debug_asm)
679 {
680 fprintf (asm_out_file, "\t%s uleb128 ", ASM_COMMENT_START);
681 fprintf (asm_out_file, HOST_WIDE_INT_PRINT_HEX, value);
682 if (comment)
683 {
684 fputs ("; ", asm_out_file);
685 vfprintf (asm_out_file, comment, ap);
686 }
687 }
688 }
689#endif
690 fputc ('\n', asm_out_file);
691
692 va_end (ap);
693}
694
695/* Output an signed LEB128 quantity. */
696
697void
698dw2_asm_output_data_sleb128 VPARAMS ((HOST_WIDE_INT value,
699 const char *comment, ...))
700{
701#ifndef ANSI_PROTOTYPES
702 HOST_WIDE_INT value;
703 const char *comment;
704#endif
705 va_list ap;
706
707 VA_START (ap, comment);
708
709#ifndef ANSI_PROTOTYPES
710 value = va_arg (ap, HOST_WIDE_INT);
711 comment = va_arg (ap, const char *);
712#endif
713
714#ifdef HAVE_AS_LEB128
da6af203
RH		 715 fputs ("\t.sleb128 ", asm_out_file);
716 fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC, value);
2e4b9b8c
RH		 717
718 if (flag_debug_asm && comment)
719 {
720 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
721 vfprintf (asm_out_file, comment, ap);
722 }
723#else
724 {
725 HOST_WIDE_INT work = value;
726 int more, byte;
727
728 fputs (ASM_BYTE_OP, asm_out_file);
729 do
730 {
731 byte = (work & 0x7f);
732 /* arithmetic shift */
733 work >>= 7;
734 more = !((work == 0 && (byte & 0x40) == 0)
735 || (work == -1 && (byte & 0x40) != 0));
736 if (more)
737 byte |= 0x80;
738
739 fprintf (asm_out_file, "0x%x", byte);
740 if (more)
741 fputc (',', asm_out_file);
742 }
743 while (more);
744
745 if (flag_debug_asm)
746 {
747 fprintf (asm_out_file, "\t%s sleb128 ", ASM_COMMENT_START);
748 fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC, value);
749 if (comment)
750 {
751 fputs ("; ", asm_out_file);
752 vfprintf (asm_out_file, comment, ap);
753 }
754 }
755 }
756#endif
757 fputc ('\n', asm_out_file);
758
759 va_end (ap);
760}
761
762void
763dw2_asm_output_delta_uleb128 VPARAMS ((const char *lab1 ATTRIBUTE_UNUSED,
764 const char *lab2 ATTRIBUTE_UNUSED,
765 const char *comment, ...))
766{
767#ifndef ANSI_PROTOTYPES
768 const char *lab1, *lab2;
769 const char *comment;
770#endif
771 va_list ap;
772
773 VA_START (ap, comment);
774
775#ifndef ANSI_PROTOTYPES
776 lab1 = va_arg (ap, const char *);
777 lab2 = va_arg (ap, const char *);
778 comment = va_arg (ap, const char *);
779#endif
780
781#ifdef HAVE_AS_LEB128
da6af203 782 fputs ("\t.uleb128 ", asm_out_file);
2e4b9b8c
RH		 783 assemble_name (asm_out_file, lab1);
784 fputc ('-', asm_out_file);
785 assemble_name (asm_out_file, lab2);
786#else
787 abort ();
788#endif
789
790 if (flag_debug_asm && comment)
791 {
792 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
793 vfprintf (asm_out_file, comment, ap);
794 }
795 fputc ('\n', asm_out_file);
796
797 va_end (ap);
798}
799
800void
801dw2_asm_output_delta_sleb128 VPARAMS ((const char *lab1 ATTRIBUTE_UNUSED,
802 const char *lab2 ATTRIBUTE_UNUSED,
803 const char *comment, ...))
804{
805#ifndef ANSI_PROTOTYPES
806 const char *lab1, *lab2;
807 const char *comment;
808#endif
809 va_list ap;
810
811 VA_START (ap, comment);
812
813#ifndef ANSI_PROTOTYPES
814 lab1 = va_arg (ap, const char *);
815 lab2 = va_arg (ap, const char *);
816 comment = va_arg (ap, const char *);
817#endif
818
819#ifdef HAVE_AS_LEB128
da6af203 820 fputs ("\t.sleb128 ", asm_out_file);
2e4b9b8c
RH		 821 assemble_name (asm_out_file, lab1);
822 fputc ('-', asm_out_file);
823 assemble_name (asm_out_file, lab2);
824#else
825 abort ();
826#endif
827
828 if (flag_debug_asm && comment)
829 {
830 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
831 vfprintf (asm_out_file, comment, ap);
832 }
833 fputc ('\n', asm_out_file);
834
835 va_end (ap);
836}
2a1ee410
RH		 837\f
838static rtx dw2_force_const_mem PARAMS ((rtx));
839static int dw2_output_indirect_constant_1 PARAMS ((splay_tree_node, void *));
840
841static splay_tree indirect_pool;
842
e1f9550a
RH		 843/* Put X, a SYMBOL_REF, in memory. Return a SYMBOL_REF to the allocated
844 memory. Differs from force_const_mem in that a single pool is used for
845 the entire unit of translation, and the memory is not guaranteed to be
846 "near" the function in any interesting sense. */
847
2a1ee410
RH		 848static rtx
849dw2_force_const_mem (x)
850 rtx x;
851{
852 splay_tree_node node;
853 const char *const_sym;
854
855 if (! indirect_pool)
856 indirect_pool = splay_tree_new (splay_tree_compare_pointers, NULL, NULL);
857
858 if (GET_CODE (x) != SYMBOL_REF)
859 abort ();
860 node = splay_tree_lookup (indirect_pool, (splay_tree_key) XSTR (x, 0));
861 if (node)
862 const_sym = (const char *) node->value;
863 else
864 {
865 extern int const_labelno;
866 char label[32];
867 tree id;
868
869 ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
870 ++const_labelno;
871 const_sym = ggc_strdup (label);
872
873 id = maybe_get_identifier (XSTR (x, 0));
874 if (id)
875 TREE_SYMBOL_REFERENCED (id) = 1;
876
877 splay_tree_insert (indirect_pool, (splay_tree_key) XSTR (x, 0),
878 (splay_tree_value) const_sym);
879 }
880
881 return gen_rtx_SYMBOL_REF (Pmode, const_sym);
882}
883
e1f9550a
RH		 884/* A helper function for dw2_output_indirect_constants called through
885 splay_tree_foreach. Emit one queued constant to memory. */
886
2a1ee410
RH		 887static int
888dw2_output_indirect_constant_1 (node, data)
889 splay_tree_node node;
890 void* data ATTRIBUTE_UNUSED;
891{
892 const char *label, *sym;
893 rtx sym_ref;
894
895 label = (const char *) node->value;
896 sym = (const char *) node->key;
897 sym_ref = gen_rtx_SYMBOL_REF (Pmode, sym);
898
899 ASM_OUTPUT_LABEL (asm_out_file, label);
900 assemble_integer (sym_ref, POINTER_SIZE / BITS_PER_UNIT, 1);
901
902 return 0;
903}
904
e1f9550a
RH		 905/* Emit the constants queued through dw2_force_const_mem. */
906
2a1ee410
RH		 907void
908dw2_output_indirect_constants ()
909{
910 if (! indirect_pool)
911 return;
912
913 /* Assume that the whole reason we're emitting these symbol references
914 indirectly is that they contain dynamic relocations, and are thus
915 read-write. If there was no possibility of a dynamic relocation, we
916 might as well have used a direct relocation. */
917 data_section ();
918
919 /* Everything we're emitting is a pointer. Align appropriately. */
920 assemble_align (POINTER_SIZE);
921
922 splay_tree_foreach (indirect_pool, dw2_output_indirect_constant_1, NULL);
923}
924
e1f9550a
RH		 925/* Like dw2_asm_output_addr_rtx, but encode the pointer as directed. */
926
2a1ee410 927void
e1f9550a
RH		 928dw2_asm_output_encoded_addr_rtx VPARAMS ((int encoding,
929 rtx addr,
930 const char *comment, ...))
2a1ee410 931{
e1f9550a
RH		 932#ifndef ANSI_PROTOTYPES
933 int encoding;
934 rtx addr;
935 const char *comment;
936#endif
937 va_list ap;
2a1ee410
RH		 938 int size;
939
e1f9550a
RH		 940 VA_START (ap, comment);
941
942#ifndef ANSI_PROTOTYPES
943 encoding = va_arg (ap, int);
944 addr = va_arg (ap, rtx);
945 comment = va_arg (ap, const char *);
946#endif
947
948 size = size_of_encoded_value (encoding);
2a1ee410
RH		 949
950 /* NULL is _always_ represented as a plain zero. */
951 if (addr == const0_rtx)
e1f9550a
RH		 952 assemble_integer (addr, size, 1);
953 else
2a1ee410 954 {
e1f9550a
RH		 955 restart:
956 /* Allow the target first crack at emitting this. Some of the
957 special relocations require special directives instead of
958 just ".4byte" or whatever. */
2a1ee410 959#ifdef ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX
e1f9550a
RH		 960 ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX (asm_out_file, encoding, size,
961 addr, done);
2a1ee410
RH		 962#endif
963
e1f9550a
RH		 964 /* Indirection is used to get dynamic relocations out of a
965 read-only section. */
966 if (encoding & DW_EH_PE_indirect)
967 {
968 /* It is very tempting to use force_const_mem so that we share data
969 with the normal constant pool. However, we've already emitted
970 the constant pool for this function. Moreover, we'd like to
971 share these constants across the entire unit of translation,
972 or better, across the entire application (or DSO). */
973 addr = dw2_force_const_mem (addr);
974 encoding &= ~DW_EH_PE_indirect;
975 goto restart;
976 }
2a1ee410 977
e1f9550a
RH		 978 switch (encoding & 0xF0)
979 {
980 case DW_EH_PE_absptr:
2a1ee410 981#ifdef UNALIGNED_INT_ASM_OP
e1f9550a
RH		 982 fputs (unaligned_integer_asm_op (size), asm_out_file);
983 output_addr_const (asm_out_file, addr);
2a1ee410 984#else
e1f9550a 985 assemble_integer (addr, size, 1);
2a1ee410 986#endif
e1f9550a 987 break;
2a1ee410 988
e1f9550a
RH		 989 case DW_EH_PE_pcrel:
990 if (GET_CODE (addr) != SYMBOL_REF)
991 abort ();
2a1ee410 992#ifdef ASM_OUTPUT_DWARF_PCREL
e1f9550a 993 ASM_OUTPUT_DWARF_PCREL (asm_out_file, size, XSTR (addr, 0));
2a1ee410
RH		 994#else
995#ifdef UNALIGNED_INT_ASM_OP
e1f9550a
RH		 996 fputs (unaligned_integer_asm_op (size), asm_out_file);
997 assemble_name (asm_out_file, XSTR (addr, 0));
998 fputc ('-', asm_out_file);
999 fputc ('.', asm_out_file);
2a1ee410 1000#else
e1f9550a 1001 abort ();
2a1ee410
RH		 1002#endif
1003#endif
e1f9550a 1004 break;
2a1ee410 1005
e1f9550a
RH		 1006 default:
1007 /* Other encodings should have been handled by
1008 ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX. */
1009 abort ();
1010 }
2a1ee410
RH		 1011
1012#ifdef ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX
e1f9550a 1013 done:;
2a1ee410 1014#endif
e1f9550a
RH		 1015 }
1016
1017 if (flag_debug_asm && comment)
1018 {
1019 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
1020 vfprintf (asm_out_file, comment, ap);
1021 }
2a1ee410 1022 fputc ('\n', asm_out_file);
e1f9550a
RH		 1023
1024 va_end (ap);
2a1ee410 1025}
Mirror of https://gcc.gnu.org/git/gcc.git