1 /* Dwarf2 assembler output helper routines.
2 Copyright (C) 2001-2020 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
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.
10
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.
15
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/>. */
19
20
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"
36 #include "fold-const.h"
37
38 #ifndef XCOFF_DEBUGGING_INFO
39 #define XCOFF_DEBUGGING_INFO 0
40 #endif
41
42
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. */
45
46 void
dw2_assemble_integer(int size,rtx x)47 dw2_assemble_integer (int size, rtx x)
48 {
49 const char *op = integer_asm_op (size, FALSE);
50
51 if (op)
52 {
53 fputs (op, asm_out_file);
54 if (CONST_INT_P (x))
55 fprint_whex (asm_out_file, (unsigned HOST_WIDE_INT) INTVAL (x));
56 else
57 output_addr_const (asm_out_file, x);
58 }
59 else
60 assemble_integer (x, size, BITS_PER_UNIT, 1);
61 }
62
63
64 /* Output a value of a given size in target byte order. */
65
66 void
dw2_asm_output_data_raw(int size,unsigned HOST_WIDE_INT value)67 dw2_asm_output_data_raw (int size, unsigned HOST_WIDE_INT value)
68 {
69 unsigned char bytes[8];
70 int i;
71
72 for (i = 0; i < 8; ++i)
73 {
74 bytes[i] = value & 0xff;
75 value >>= 8;
76 }
77
78 if (BYTES_BIG_ENDIAN)
79 {
80 for (i = size - 1; i > 0; --i)
81 fprintf (asm_out_file, "%#x,", bytes[i]);
82 fprintf (asm_out_file, "%#x", bytes[0]);
83 }
84 else
85 {
86 for (i = 0; i < size - 1; ++i)
87 fprintf (asm_out_file, "%#x,", bytes[i]);
88 fprintf (asm_out_file, "%#x", bytes[i]);
89 }
90 }
91
92 /* Output an immediate constant in a given SIZE in bytes. */
93
94 void
dw2_asm_output_data(int size,unsigned HOST_WIDE_INT value,const char * comment,...)95 dw2_asm_output_data (int size, unsigned HOST_WIDE_INT value,
96 const char *comment, ...)
97 {
98 va_list ap;
99 const char *op = integer_asm_op (size, FALSE);
100
101 va_start (ap, comment);
102
103 if (size * 8 < HOST_BITS_PER_WIDE_INT)
104 value &= ~(HOST_WIDE_INT_M1U << (size * 8));
105
106 if (op)
107 {
108 fputs (op, asm_out_file);
109 fprint_whex (asm_out_file, value);
110 }
111 else
112 assemble_integer (GEN_INT (value), size, BITS_PER_UNIT, 1);
113
114 if (flag_debug_asm && comment)
115 {
116 fputs ("\t" ASM_COMMENT_START " ", asm_out_file);
117 vfprintf (asm_out_file, comment, ap);
118 }
119 putc ('\n', asm_out_file);
120
121 va_end (ap);
122 }
123
124 /* Output the difference between two symbols in a given size. */
125 /* ??? There appear to be assemblers that do not like such
126 subtraction, but do support ASM_SET_OP. It's unfortunately
127 impossible to do here, since the ASM_SET_OP for the difference
128 symbol must appear after both symbols are defined. */
129
130 void
dw2_asm_output_delta(int size,const char * lab1,const char * lab2,const char * comment,...)131 dw2_asm_output_delta (int size, const char *lab1, const char *lab2,
132 const char *comment, ...)
133 {
134 va_list ap;
135
136 va_start (ap, comment);
137
138 #ifdef ASM_OUTPUT_DWARF_DELTA
139 ASM_OUTPUT_DWARF_DELTA (asm_out_file, size, lab1, lab2);
140 #else
141 dw2_assemble_integer (size,
142 gen_rtx_MINUS (Pmode,
143 gen_rtx_SYMBOL_REF (Pmode, lab1),
144 gen_rtx_SYMBOL_REF (Pmode, lab2)));
145 #endif
146 if (flag_debug_asm && comment)
147 {
148 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
149 vfprintf (asm_out_file, comment, ap);
150 }
151 fputc ('\n', asm_out_file);
152
153 va_end (ap);
154 }
155
156 #ifdef ASM_OUTPUT_DWARF_VMS_DELTA
157 /* Output the difference between two symbols in instruction units
158 in a given size. */
159
160 void
dw2_asm_output_vms_delta(int size ATTRIBUTE_UNUSED,const char * lab1,const char * lab2,const char * comment,...)161 dw2_asm_output_vms_delta (int size ATTRIBUTE_UNUSED,
162 const char *lab1, const char *lab2,
163 const char *comment, ...)
164 {
165 va_list ap;
166
167 va_start (ap, comment);
168
169 ASM_OUTPUT_DWARF_VMS_DELTA (asm_out_file, size, lab1, lab2);
170 if (flag_debug_asm && comment)
171 {
172 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
173 vfprintf (asm_out_file, comment, ap);
174 }
175 fputc ('\n', asm_out_file);
176
177 va_end (ap);
178 }
179 #endif
180
181 /* Output a section-relative reference to a LABEL, which was placed in
182 BASE. In general this can only be done for debugging symbols.
183 E.g. on most targets with the GNU linker, this is accomplished with
184 a direct reference and the knowledge that the debugging section
185 will be placed at VMA 0. Some targets have special relocations for
186 this that we must use. */
187
188 void
dw2_asm_output_offset(int size,const char * label,section * base ATTRIBUTE_UNUSED,const char * comment,...)189 dw2_asm_output_offset (int size, const char *label,
190 section *base ATTRIBUTE_UNUSED,
191 const char *comment, ...)
192 {
193 va_list ap;
194
195 va_start (ap, comment);
196
197 #ifdef ASM_OUTPUT_DWARF_OFFSET
198 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, size, label, 0, base);
199 #else
200 dw2_assemble_integer (size, gen_rtx_SYMBOL_REF (Pmode, label));
201 #endif
202
203 if (flag_debug_asm && comment)
204 {
205 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
206 vfprintf (asm_out_file, comment, ap);
207 }
208 fputc ('\n', asm_out_file);
209
210 va_end (ap);
211 }
212
213 void
dw2_asm_output_offset(int size,const char * label,HOST_WIDE_INT offset,section * base ATTRIBUTE_UNUSED,const char * comment,...)214 dw2_asm_output_offset (int size, const char *label, HOST_WIDE_INT offset,
215 section *base ATTRIBUTE_UNUSED,
216 const char *comment, ...)
217 {
218 va_list ap;
219
220 va_start (ap, comment);
221
222 #ifdef ASM_OUTPUT_DWARF_OFFSET
223 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, size, label, offset, base);
224 #else
225 dw2_assemble_integer (size, gen_rtx_PLUS (Pmode,
226 gen_rtx_SYMBOL_REF (Pmode, label),
227 gen_int_mode (offset, Pmode)));
228 #endif
229
230 if (flag_debug_asm && comment)
231 {
232 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
233 vfprintf (asm_out_file, comment, ap);
234 }
235 fputc ('\n', asm_out_file);
236
237 va_end (ap);
238 }
239
240 #if 0
241
242 /* Output a self-relative reference to a label, possibly in a
243 different section or object file. */
244
245 void
246 dw2_asm_output_pcrel (int size ATTRIBUTE_UNUSED,
247 const char *label ATTRIBUTE_UNUSED,
248 const char *comment, ...)
249 {
250 va_list ap;
251
252 va_start (ap, comment);
253
254 #ifdef ASM_OUTPUT_DWARF_PCREL
255 ASM_OUTPUT_DWARF_PCREL (asm_out_file, size, label);
256 #else
257 dw2_assemble_integer (size,
258 gen_rtx_MINUS (Pmode,
259 gen_rtx_SYMBOL_REF (Pmode, label),
260 pc_rtx));
261 #endif
262
263 if (flag_debug_asm && comment)
264 {
265 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
266 vfprintf (asm_out_file, comment, ap);
267 }
268 fputc ('\n', asm_out_file);
269
270 va_end (ap);
271 }
272 #endif /* 0 */
273
274 /* Output an absolute reference to a label. */
275
276 void
dw2_asm_output_addr(int size,const char * label,const char * comment,...)277 dw2_asm_output_addr (int size, const char *label,
278 const char *comment, ...)
279 {
280 va_list ap;
281
282 va_start (ap, comment);
283
284 dw2_assemble_integer (size, gen_rtx_SYMBOL_REF (Pmode, label));
285
286 if (flag_debug_asm && comment)
287 {
288 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
289 vfprintf (asm_out_file, comment, ap);
290 }
291 fputc ('\n', asm_out_file);
292
293 va_end (ap);
294 }
295
296 /* Similar, but use an RTX expression instead of a text label. */
297
298 void
dw2_asm_output_addr_rtx(int size,rtx addr,const char * comment,...)299 dw2_asm_output_addr_rtx (int size, rtx addr,
300 const char *comment, ...)
301 {
302 va_list ap;
303
304 va_start (ap, comment);
305
306 dw2_assemble_integer (size, addr);
307
308 if (flag_debug_asm && comment)
309 {
310 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
311 vfprintf (asm_out_file, comment, ap);
312 }
313 fputc ('\n', asm_out_file);
314
315 va_end (ap);
316 }
317
318 /* Output the first ORIG_LEN characters of STR as a string.
319 If ORIG_LEN is equal to -1, ignore this parameter and output
320 the entire STR instead.
321 If COMMENT is not NULL and comments in the debug information
322 have been requested by the user, append the given COMMENT
323 to the generated output. */
324
325 void
dw2_asm_output_nstring(const char * str,size_t orig_len,const char * comment,...)326 dw2_asm_output_nstring (const char *str, size_t orig_len,
327 const char *comment, ...)
328 {
329 size_t i, len;
330 va_list ap;
331
332 va_start (ap, comment);
333
334 len = orig_len;
335
336 if (len == (size_t) -1)
337 len = strlen (str);
338
339 if (flag_debug_asm && comment)
340 {
341 if (XCOFF_DEBUGGING_INFO)
342 fputs ("\t.byte \"", asm_out_file);
343 else
344 fputs ("\t.ascii \"", asm_out_file);
345
346 for (i = 0; i < len; i++)
347 {
348 int c = str[i];
349 if (c == '\"')
350 fputc (XCOFF_DEBUGGING_INFO ? '\"' : '\\', asm_out_file);
351 else if (c == '\\')
352 fputc ('\\', asm_out_file);
353 if (ISPRINT (c))
354 fputc (c, asm_out_file);
355 else
356 fprintf (asm_out_file, "\\%o", c);
357 }
358 fprintf (asm_out_file, "\\0\"\t%s ", ASM_COMMENT_START);
359 vfprintf (asm_out_file, comment, ap);
360 fputc ('\n', asm_out_file);
361 }
362 else
363 {
364 /* If an explicit length was given, we can't assume there
365 is a null termination in the string buffer. */
366 if (orig_len == (size_t) -1)
367 len += 1;
368 ASM_OUTPUT_ASCII (asm_out_file, str, len);
369 if (orig_len != (size_t) -1)
370 assemble_integer (const0_rtx, 1, BITS_PER_UNIT, 1);
371 }
372
373 va_end (ap);
374 }
375
376
377 /* Return the size of an unsigned LEB128 quantity. */
378
379 int
size_of_uleb128(unsigned HOST_WIDE_INT value)380 size_of_uleb128 (unsigned HOST_WIDE_INT value)
381 {
382 int size = 0;
383
384 do
385 {
386 value >>= 7;
387 size += 1;
388 }
389 while (value != 0);
390
391 return size;
392 }
393
394 /* Return the size of a signed LEB128 quantity. */
395
396 int
size_of_sleb128(HOST_WIDE_INT value)397 size_of_sleb128 (HOST_WIDE_INT value)
398 {
399 int size = 0, byte;
400
401 do
402 {
403 byte = (value & 0x7f);
404 value >>= 7;
405 size += 1;
406 }
407 while (!((value == 0 && (byte & 0x40) == 0)
408 || (value == -1 && (byte & 0x40) != 0)));
409
410 return size;
411 }
412
413 /* Given an encoding, return the number of bytes the format occupies.
414 This is only defined for fixed-size encodings, and so does not
415 include leb128. */
416
417 int
size_of_encoded_value(int encoding)418 size_of_encoded_value (int encoding)
419 {
420 if (encoding == DW_EH_PE_omit)
421 return 0;
422
423 switch (encoding & 0x07)
424 {
425 case DW_EH_PE_absptr:
426 return POINTER_SIZE_UNITS;
427 case DW_EH_PE_udata2:
428 return 2;
429 case DW_EH_PE_udata4:
430 return 4;
431 case DW_EH_PE_udata8:
432 return 8;
433 default:
434 gcc_unreachable ();
435 }
436 }
437
438 /* Yield a name for a given pointer encoding. */
439
440 const char *
eh_data_format_name(int format)441 eh_data_format_name (int format)
442 {
443 #if HAVE_DESIGNATED_INITIALIZERS
444 #define S(p, v) [p] = v,
445 #else
446 #define S(p, v) case p: return v;
447 #endif
448
449 #if HAVE_DESIGNATED_INITIALIZERS
450 __extension__ static const char * const format_names[256] = {
451 #else
452 switch (format) {
453 #endif
454
455 S(DW_EH_PE_absptr, "absolute")
456 S(DW_EH_PE_omit, "omit")
457 S(DW_EH_PE_aligned, "aligned absolute")
458
459 S(DW_EH_PE_uleb128, "uleb128")
460 S(DW_EH_PE_udata2, "udata2")
461 S(DW_EH_PE_udata4, "udata4")
462 S(DW_EH_PE_udata8, "udata8")
463 S(DW_EH_PE_sleb128, "sleb128")
464 S(DW_EH_PE_sdata2, "sdata2")
465 S(DW_EH_PE_sdata4, "sdata4")
466 S(DW_EH_PE_sdata8, "sdata8")
467
468 S(DW_EH_PE_absptr | DW_EH_PE_pcrel, "pcrel")
469 S(DW_EH_PE_uleb128 | DW_EH_PE_pcrel, "pcrel uleb128")
470 S(DW_EH_PE_udata2 | DW_EH_PE_pcrel, "pcrel udata2")
471 S(DW_EH_PE_udata4 | DW_EH_PE_pcrel, "pcrel udata4")
472 S(DW_EH_PE_udata8 | DW_EH_PE_pcrel, "pcrel udata8")
473 S(DW_EH_PE_sleb128 | DW_EH_PE_pcrel, "pcrel sleb128")
474 S(DW_EH_PE_sdata2 | DW_EH_PE_pcrel, "pcrel sdata2")
475 S(DW_EH_PE_sdata4 | DW_EH_PE_pcrel, "pcrel sdata4")
476 S(DW_EH_PE_sdata8 | DW_EH_PE_pcrel, "pcrel sdata8")
477
478 S(DW_EH_PE_absptr | DW_EH_PE_textrel, "textrel")
479 S(DW_EH_PE_uleb128 | DW_EH_PE_textrel, "textrel uleb128")
480 S(DW_EH_PE_udata2 | DW_EH_PE_textrel, "textrel udata2")
481 S(DW_EH_PE_udata4 | DW_EH_PE_textrel, "textrel udata4")
482 S(DW_EH_PE_udata8 | DW_EH_PE_textrel, "textrel udata8")
483 S(DW_EH_PE_sleb128 | DW_EH_PE_textrel, "textrel sleb128")
484 S(DW_EH_PE_sdata2 | DW_EH_PE_textrel, "textrel sdata2")
485 S(DW_EH_PE_sdata4 | DW_EH_PE_textrel, "textrel sdata4")
486 S(DW_EH_PE_sdata8 | DW_EH_PE_textrel, "textrel sdata8")
487
488 S(DW_EH_PE_absptr | DW_EH_PE_datarel, "datarel")
489 S(DW_EH_PE_uleb128 | DW_EH_PE_datarel, "datarel uleb128")
490 S(DW_EH_PE_udata2 | DW_EH_PE_datarel, "datarel udata2")
491 S(DW_EH_PE_udata4 | DW_EH_PE_datarel, "datarel udata4")
492 S(DW_EH_PE_udata8 | DW_EH_PE_datarel, "datarel udata8")
493 S(DW_EH_PE_sleb128 | DW_EH_PE_datarel, "datarel sleb128")
494 S(DW_EH_PE_sdata2 | DW_EH_PE_datarel, "datarel sdata2")
495 S(DW_EH_PE_sdata4 | DW_EH_PE_datarel, "datarel sdata4")
496 S(DW_EH_PE_sdata8 | DW_EH_PE_datarel, "datarel sdata8")
497
498 S(DW_EH_PE_absptr | DW_EH_PE_funcrel, "funcrel")
499 S(DW_EH_PE_uleb128 | DW_EH_PE_funcrel, "funcrel uleb128")
500 S(DW_EH_PE_udata2 | DW_EH_PE_funcrel, "funcrel udata2")
501 S(DW_EH_PE_udata4 | DW_EH_PE_funcrel, "funcrel udata4")
502 S(DW_EH_PE_udata8 | DW_EH_PE_funcrel, "funcrel udata8")
503 S(DW_EH_PE_sleb128 | DW_EH_PE_funcrel, "funcrel sleb128")
504 S(DW_EH_PE_sdata2 | DW_EH_PE_funcrel, "funcrel sdata2")
505 S(DW_EH_PE_sdata4 | DW_EH_PE_funcrel, "funcrel sdata4")
506 S(DW_EH_PE_sdata8 | DW_EH_PE_funcrel, "funcrel sdata8")
507
508 S(DW_EH_PE_indirect | DW_EH_PE_absptr, "indirect absolute")
509
510 S(DW_EH_PE_indirect | DW_EH_PE_absptr | DW_EH_PE_pcrel,
511 "indirect pcrel")
512 S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_pcrel,
513 "indirect pcrel uleb128")
514 S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_pcrel,
515 "indirect pcrel udata2")
516 S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_pcrel,
517 "indirect pcrel udata4")
518 S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_pcrel,
519 "indirect pcrel udata8")
520 S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_pcrel,
521 "indirect pcrel sleb128")
522 S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_pcrel,
523 "indirect pcrel sdata2")
524 S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_pcrel,
525 "indirect pcrel sdata4")
526 S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_pcrel,
527 "indirect pcrel sdata8")
528
529 S(DW_EH_PE_indirect | DW_EH_PE_absptr | DW_EH_PE_textrel,
530 "indirect textrel")
531 S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_textrel,
532 "indirect textrel uleb128")
533 S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_textrel,
534 "indirect textrel udata2")
535 S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_textrel,
536 "indirect textrel udata4")
537 S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_textrel,
538 "indirect textrel udata8")
539 S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_textrel,
540 "indirect textrel sleb128")
541 S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_textrel,
542 "indirect textrel sdata2")
543 S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_textrel,
544 "indirect textrel sdata4")
545 S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_textrel,
546 "indirect textrel sdata8")
547
548 S(DW_EH_PE_indirect | DW_EH_PE_absptr | DW_EH_PE_datarel,
549 "indirect datarel")
550 S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_datarel,
551 "indirect datarel uleb128")
552 S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_datarel,
553 "indirect datarel udata2")
554 S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_datarel,
555 "indirect datarel udata4")
556 S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_datarel,
557 "indirect datarel udata8")
558 S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_datarel,
559 "indirect datarel sleb128")
560 S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_datarel,
561 "indirect datarel sdata2")
562 S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_datarel,
563 "indirect datarel sdata4")
564 S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_datarel,
565 "indirect datarel sdata8")
566
567 S(DW_EH_PE_indirect | DW_EH_PE_absptr | DW_EH_PE_funcrel,
568 "indirect funcrel")
569 S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_funcrel,
570 "indirect funcrel uleb128")
571 S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_funcrel,
572 "indirect funcrel udata2")
573 S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_funcrel,
574 "indirect funcrel udata4")
575 S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_funcrel,
576 "indirect funcrel udata8")
577 S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_funcrel,
578 "indirect funcrel sleb128")
579 S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_funcrel,
580 "indirect funcrel sdata2")
581 S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_funcrel,
582 "indirect funcrel sdata4")
583 S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_funcrel,
584 "indirect funcrel sdata8")
585
586 #if HAVE_DESIGNATED_INITIALIZERS
587 };
588
589 gcc_assert (format >= 0 && format < 0x100 && format_names[format]);
590
591 return format_names[format];
592 #else
593 }
594 gcc_unreachable ();
595 #endif
596 }
597
598 /* Output an unsigned LEB128 quantity, but only the byte values. */
599
600 void
dw2_asm_output_data_uleb128_raw(unsigned HOST_WIDE_INT value)601 dw2_asm_output_data_uleb128_raw (unsigned HOST_WIDE_INT value)
602 {
603 while (1)
604 {
605 int byte = (value & 0x7f);
606 value >>= 7;
607 if (value != 0)
608 /* More bytes to follow. */
609 byte |= 0x80;
610
611 fprintf (asm_out_file, "%#x", byte);
612 if (value == 0)
613 break;
614 fputc (',', asm_out_file);
615 }
616 }
617
618 /* Output an unsigned LEB128 quantity. */
619
620 void
dw2_asm_output_data_uleb128(unsigned HOST_WIDE_INT value,const char * comment,...)621 dw2_asm_output_data_uleb128 (unsigned HOST_WIDE_INT value,
622 const char *comment, ...)
623 {
624 va_list ap;
625
626 va_start (ap, comment);
627
628 if (HAVE_AS_LEB128)
629 {
630 fputs ("\t.uleb128 ", asm_out_file);
631 fprint_whex (asm_out_file, value);
632
633 if (flag_debug_asm && comment)
634 {
635 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
636 vfprintf (asm_out_file, comment, ap);
637 }
638 }
639 else
640 {
641 unsigned HOST_WIDE_INT work = value;
642 const char *byte_op = targetm.asm_out.byte_op;
643
644 if (byte_op)
645 fputs (byte_op, asm_out_file);
646 do
647 {
648 int byte = (work & 0x7f);
649 work >>= 7;
650 if (work != 0)
651 /* More bytes to follow. */
652 byte |= 0x80;
653
654 if (byte_op)
655 {
656 fprintf (asm_out_file, "%#x", byte);
657 if (work != 0)
658 fputc (',', asm_out_file);
659 }
660 else
661 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
662 }
663 while (work != 0);
664
665 if (flag_debug_asm)
666 {
667 fprintf (asm_out_file, "\t%s uleb128 " HOST_WIDE_INT_PRINT_HEX,
668 ASM_COMMENT_START, value);
669 if (comment)
670 {
671 fputs ("; ", asm_out_file);
672 vfprintf (asm_out_file, comment, ap);
673 }
674 }
675 }
676
677 putc ('\n', asm_out_file);
678
679 va_end (ap);
680 }
681
682 /* Output an signed LEB128 quantity, but only the byte values. */
683
684 void
dw2_asm_output_data_sleb128_raw(HOST_WIDE_INT value)685 dw2_asm_output_data_sleb128_raw (HOST_WIDE_INT value)
686 {
687 int byte, more;
688
689 while (1)
690 {
691 byte = (value & 0x7f);
692 value >>= 7;
693 more = !((value == 0 && (byte & 0x40) == 0)
694 || (value == -1 && (byte & 0x40) != 0));
695 if (more)
696 byte |= 0x80;
697
698 fprintf (asm_out_file, "%#x", byte);
699 if (!more)
700 break;
701 fputc (',', asm_out_file);
702 }
703 }
704
705 /* Output a signed LEB128 quantity. */
706
707 void
dw2_asm_output_data_sleb128(HOST_WIDE_INT value,const char * comment,...)708 dw2_asm_output_data_sleb128 (HOST_WIDE_INT value,
709 const char *comment, ...)
710 {
711 va_list ap;
712
713 va_start (ap, comment);
714
715 if (HAVE_AS_LEB128)
716 {
717 fprintf (asm_out_file, "\t.sleb128 " HOST_WIDE_INT_PRINT_DEC, value);
718
719 if (flag_debug_asm && comment)
720 {
721 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
722 vfprintf (asm_out_file, comment, ap);
723 }
724 }
725 else
726 {
727 HOST_WIDE_INT work = value;
728 int more, byte;
729 const char *byte_op = targetm.asm_out.byte_op;
730
731 if (byte_op)
732 fputs (byte_op, asm_out_file);
733 do
734 {
735 byte = (work & 0x7f);
736 /* arithmetic shift */
737 work >>= 7;
738 more = !((work == 0 && (byte & 0x40) == 0)
739 || (work == -1 && (byte & 0x40) != 0));
740 if (more)
741 byte |= 0x80;
742
743 if (byte_op)
744 {
745 fprintf (asm_out_file, "%#x", byte);
746 if (more)
747 fputc (',', asm_out_file);
748 }
749 else
750 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
751 }
752 while (more);
753
754 if (flag_debug_asm)
755 {
756 fprintf (asm_out_file, "\t%s sleb128 " HOST_WIDE_INT_PRINT_DEC,
757 ASM_COMMENT_START, value);
758 if (comment)
759 {
760 fputs ("; ", asm_out_file);
761 vfprintf (asm_out_file, comment, ap);
762 }
763 }
764 }
765
766 fputc ('\n', asm_out_file);
767
768 va_end (ap);
769 }
770
771 /* Output symbol LAB1 as an unsigned LEB128 quantity. LAB1 should be
772 an assembler-computed constant, e.g. a view number, because we
773 can't have relocations in LEB128 quantities. */
774
775 void
dw2_asm_output_symname_uleb128(const char * lab1 ATTRIBUTE_UNUSED,const char * comment,...)776 dw2_asm_output_symname_uleb128 (const char *lab1 ATTRIBUTE_UNUSED,
777 const char *comment, ...)
778 {
779 va_list ap;
780
781 va_start (ap, comment);
782
783 #ifdef HAVE_AS_LEB128
784 fputs ("\t.uleb128 ", asm_out_file);
785 assemble_name (asm_out_file, lab1);
786 #else
787 gcc_unreachable ();
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
800 void
dw2_asm_output_delta_uleb128(const char * lab1 ATTRIBUTE_UNUSED,const char * lab2 ATTRIBUTE_UNUSED,const char * comment,...)801 dw2_asm_output_delta_uleb128 (const char *lab1 ATTRIBUTE_UNUSED,
802 const char *lab2 ATTRIBUTE_UNUSED,
803 const char *comment, ...)
804 {
805 va_list ap;
806
807 va_start (ap, comment);
808
809 gcc_assert (HAVE_AS_LEB128);
810
811 fputs ("\t.uleb128 ", asm_out_file);
812 assemble_name (asm_out_file, lab1);
813 putc ('-', asm_out_file);
814 /* dwarf2out.c might give us a label expression (e.g. .LVL548-1)
815 as second argument. If so, make it a subexpression, to make
816 sure the substraction is done in the right order. */
817 if (strchr (lab2, '-') != NULL)
818 {
819 putc ('(', asm_out_file);
820 assemble_name (asm_out_file, lab2);
821 putc (')', asm_out_file);
822 }
823 else
824 assemble_name (asm_out_file, lab2);
825
826 if (flag_debug_asm && comment)
827 {
828 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
829 vfprintf (asm_out_file, comment, ap);
830 }
831 fputc ('\n', asm_out_file);
832
833 va_end (ap);
834 }
835
836 #if 0
837
838 void
839 dw2_asm_output_delta_sleb128 (const char *lab1 ATTRIBUTE_UNUSED,
840 const char *lab2 ATTRIBUTE_UNUSED,
841 const char *comment, ...)
842 {
843 va_list ap;
844
845 va_start (ap, comment);
846
847 gcc_assert (HAVE_AS_LEB128);
848
849 fputs ("\t.sleb128 ", asm_out_file);
850 assemble_name (asm_out_file, lab1);
851 putc ('-', asm_out_file);
852 assemble_name (asm_out_file, lab2);
853
854 if (flag_debug_asm && comment)
855 {
856 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
857 vfprintf (asm_out_file, comment, ap);
858 }
859 fputc ('\n', asm_out_file);
860
861 va_end (ap);
862 }
863 #endif /* 0 */
864
865 static GTY(()) hash_map<const char *, tree> *indirect_pool;
866
867 static GTY(()) int dw2_const_labelno;
868
869 #if defined(HAVE_GAS_HIDDEN)
870 # define USE_LINKONCE_INDIRECT (SUPPORTS_ONE_ONLY && !XCOFF_DEBUGGING_INFO)
871 #else
872 # define USE_LINKONCE_INDIRECT 0
873 #endif
874
875 /* Compare two std::pair<const char *, tree> by their first element.
876 Returns <0, 0, or
877 >0 to indicate whether K1 is less than, equal to, or greater than
878 K2, respectively. */
879
880 static int
compare_strings(const void * a,const void * b)881 compare_strings (const void *a, const void *b)
882 {
883 const char *s1 = ((const std::pair<const char *, tree> *) a)->first;
884 const char *s2 = ((const std::pair<const char *, tree> *) b)->first;
885 int ret;
886
887 if (s1 == s2)
888 return 0;
889
890 ret = strcmp (s1, s2);
891
892 /* The strings are always those from IDENTIFIER_NODEs, and,
893 therefore, we should never have two copies of the same
894 string. */
895 gcc_assert (ret);
896
897 return ret;
898 }
899
900 /* Put X, a SYMBOL_REF, in memory. Return a SYMBOL_REF to the allocated
901 memory. Differs from force_const_mem in that a single pool is used for
902 the entire unit of translation, and the memory is not guaranteed to be
903 "near" the function in any interesting sense. IS_PUBLIC controls whether
904 the symbol can be shared across the entire application (or DSO). */
905
906 rtx
dw2_force_const_mem(rtx x,bool is_public)907 dw2_force_const_mem (rtx x, bool is_public)
908 {
909 const char *key;
910 tree decl_id;
911
912 if (! indirect_pool)
913 indirect_pool = hash_map<const char *, tree>::create_ggc (64);
914
915 gcc_assert (GET_CODE (x) == SYMBOL_REF);
916
917 key = XSTR (x, 0);
918 tree *slot = indirect_pool->get (key);
919 if (slot)
920 decl_id = *slot;
921 else
922 {
923 tree id;
924 const char *str = targetm.strip_name_encoding (key);
925
926 if (is_public && USE_LINKONCE_INDIRECT)
927 {
928 char *ref_name = XALLOCAVEC (char, strlen (str) + sizeof "DW.ref.");
929
930 sprintf (ref_name, "DW.ref.%s", str);
931 gcc_assert (!maybe_get_identifier (ref_name));
932 decl_id = get_identifier (ref_name);
933 TREE_PUBLIC (decl_id) = 1;
934 }
935 else
936 {
937 char label[32];
938
939 ASM_GENERATE_INTERNAL_LABEL (label, "LDFCM", dw2_const_labelno);
940 ++dw2_const_labelno;
941 gcc_assert (!maybe_get_identifier (label));
942 decl_id = get_identifier (label);
943 }
944
945 id = maybe_get_identifier (str);
946 if (id)
947 TREE_SYMBOL_REFERENCED (id) = 1;
948
949 indirect_pool->put (key, decl_id);
950 }
951
952 return gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (decl_id));
953 }
954
955 /* A helper function for dw2_output_indirect_constants. Emit one queued
956 constant to memory. */
957
958 static int
dw2_output_indirect_constant_1(const char * sym,tree id)959 dw2_output_indirect_constant_1 (const char *sym, tree id)
960 {
961 rtx sym_ref;
962 tree decl;
963
964 decl = build_decl (UNKNOWN_LOCATION, VAR_DECL, id, ptr_type_node);
965 SET_DECL_ASSEMBLER_NAME (decl, id);
966 DECL_ARTIFICIAL (decl) = 1;
967 DECL_IGNORED_P (decl) = 1;
968 DECL_INITIAL (decl) = build_fold_addr_expr (decl);
969 TREE_READONLY (decl) = 1;
970 TREE_STATIC (decl) = 1;
971
972 if (TREE_PUBLIC (id))
973 {
974 TREE_PUBLIC (decl) = 1;
975 make_decl_one_only (decl, DECL_ASSEMBLER_NAME (decl));
976 if (USE_LINKONCE_INDIRECT)
977 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
978 }
979
980 sym_ref = gen_rtx_SYMBOL_REF (Pmode, sym);
981 /* Disable ASan for decl because redzones cause ABI breakage between GCC and
982 libstdc++ for `.LDFCM*' variables. See PR 78651 for details. */
983 unsigned int save_flag_sanitize = flag_sanitize;
984 flag_sanitize &= ~(SANITIZE_ADDRESS | SANITIZE_USER_ADDRESS
985 | SANITIZE_KERNEL_ADDRESS);
986 /* And also temporarily disable -fsection-anchors. These indirect constants
987 are never referenced from code, so it doesn't make any sense to aggregate
988 them in blocks. */
989 int save_flag_section_anchors = flag_section_anchors;
990 flag_section_anchors = 0;
991 assemble_variable (decl, 1, 1, 1);
992 flag_section_anchors = save_flag_section_anchors;
993 flag_sanitize = save_flag_sanitize;
994 assemble_integer (sym_ref, POINTER_SIZE_UNITS, POINTER_SIZE, 1);
995 /* The following is a hack recognized by use_blocks_for_decl_p to disable
996 section anchor handling of the decl. */
997 DECL_INITIAL (decl) = decl;
998
999 return 0;
1000 }
1001
1002 /* Emit the constants queued through dw2_force_const_mem. */
1003
1004 void
dw2_output_indirect_constants(void)1005 dw2_output_indirect_constants (void)
1006 {
1007 if (!indirect_pool)
1008 return;
1009
1010 auto_vec<std::pair<const char *, tree> > temp (indirect_pool->elements ());
1011 for (hash_map<const char *, tree>::iterator iter = indirect_pool->begin ();
1012 iter != indirect_pool->end (); ++iter)
1013 temp.quick_push (*iter);
1014
1015 temp.qsort (compare_strings);
1016
1017 for (unsigned int i = 0; i < temp.length (); i++)
1018 dw2_output_indirect_constant_1 (temp[i].first, temp[i].second);
1019 }
1020
1021 /* Like dw2_asm_output_addr_rtx, but encode the pointer as directed.
1022 If PUBLIC is set and the encoding is DW_EH_PE_indirect, the indirect
1023 reference is shared across the entire application (or DSO). */
1024
1025 void
dw2_asm_output_encoded_addr_rtx(int encoding,rtx addr,bool is_public,const char * comment,...)1026 dw2_asm_output_encoded_addr_rtx (int encoding, rtx addr, bool is_public,
1027 const char *comment, ...)
1028 {
1029 int size;
1030 va_list ap;
1031
1032 va_start (ap, comment);
1033
1034 size = size_of_encoded_value (encoding);
1035
1036 if (encoding == DW_EH_PE_aligned)
1037 {
1038 assemble_align (POINTER_SIZE);
1039 assemble_integer (addr, size, POINTER_SIZE, 1);
1040 va_end (ap);
1041 return;
1042 }
1043
1044 /* NULL is _always_ represented as a plain zero, as is 1 for Ada's
1045 "all others". */
1046 if (addr == const0_rtx || addr == const1_rtx)
1047 assemble_integer (addr, size, BITS_PER_UNIT, 1);
1048 else
1049 {
1050 restart:
1051 /* Allow the target first crack at emitting this. Some of the
1052 special relocations require special directives instead of
1053 just ".4byte" or whatever. */
1054 #ifdef ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX
1055 ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX (asm_out_file, encoding, size,
1056 addr, done);
1057 #endif
1058
1059 /* Indirection is used to get dynamic relocations out of a
1060 read-only section. */
1061 if (encoding & DW_EH_PE_indirect)
1062 {
1063 /* It is very tempting to use force_const_mem so that we share data
1064 with the normal constant pool. However, we've already emitted
1065 the constant pool for this function. Moreover, we'd like to
1066 share these constants across the entire unit of translation and
1067 even, if possible, across the entire application (or DSO). */
1068 addr = dw2_force_const_mem (addr, is_public);
1069 encoding &= ~DW_EH_PE_indirect;
1070 goto restart;
1071 }
1072
1073 switch (encoding & 0xF0)
1074 {
1075 case DW_EH_PE_absptr:
1076 dw2_assemble_integer (size, addr);
1077 break;
1078
1079 #ifdef ASM_OUTPUT_DWARF_DATAREL
1080 case DW_EH_PE_datarel:
1081 gcc_assert (GET_CODE (addr) == SYMBOL_REF);
1082 ASM_OUTPUT_DWARF_DATAREL (asm_out_file, size, XSTR (addr, 0));
1083 break;
1084 #endif
1085
1086 case DW_EH_PE_pcrel:
1087 gcc_assert (GET_CODE (addr) == SYMBOL_REF);
1088 #ifdef ASM_OUTPUT_DWARF_PCREL
1089 ASM_OUTPUT_DWARF_PCREL (asm_out_file, size, XSTR (addr, 0));
1090 #else
1091 dw2_assemble_integer (size, gen_rtx_MINUS (Pmode, addr, pc_rtx));
1092 #endif
1093 break;
1094
1095 default:
1096 /* Other encodings should have been handled by
1097 ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX. */
1098 gcc_unreachable ();
1099 }
1100
1101 #ifdef ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX
1102 done:;
1103 #endif
1104 }
1105
1106 if (flag_debug_asm && comment)
1107 {
1108 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
1109 vfprintf (asm_out_file, comment, ap);
1110 }
1111 fputc ('\n', asm_out_file);
1112
1113 va_end (ap);
1114 }
1115
1116 #include "gt-dwarf2asm.h"
1117