1 /* Dwarf2 assembler output helper routines. 2 Copyright (C) 2001-2018 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 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 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 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 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 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 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 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 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 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 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 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 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 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 * 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 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 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 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 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 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 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 assemble_name (asm_out_file, lab2); 815 816 if (flag_debug_asm && comment) 817 { 818 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START); 819 vfprintf (asm_out_file, comment, ap); 820 } 821 fputc ('\n', asm_out_file); 822 823 va_end (ap); 824 } 825 826 #if 0 827 828 void 829 dw2_asm_output_delta_sleb128 (const char *lab1 ATTRIBUTE_UNUSED, 830 const char *lab2 ATTRIBUTE_UNUSED, 831 const char *comment, ...) 832 { 833 va_list ap; 834 835 va_start (ap, comment); 836 837 gcc_assert (HAVE_AS_LEB128); 838 839 fputs ("\t.sleb128 ", asm_out_file); 840 assemble_name (asm_out_file, lab1); 841 putc ('-', asm_out_file); 842 assemble_name (asm_out_file, lab2); 843 844 if (flag_debug_asm && comment) 845 { 846 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START); 847 vfprintf (asm_out_file, comment, ap); 848 } 849 fputc ('\n', asm_out_file); 850 851 va_end (ap); 852 } 853 #endif /* 0 */ 854 855 static GTY(()) hash_map<const char *, tree> *indirect_pool; 856 857 static GTY(()) int dw2_const_labelno; 858 859 #if defined(HAVE_GAS_HIDDEN) 860 # define USE_LINKONCE_INDIRECT (SUPPORTS_ONE_ONLY && !XCOFF_DEBUGGING_INFO) 861 #else 862 # define USE_LINKONCE_INDIRECT 0 863 #endif 864 865 /* Compare two std::pair<const char *, tree> by their first element. 866 Returns <0, 0, or 867 >0 to indicate whether K1 is less than, equal to, or greater than 868 K2, respectively. */ 869 870 static int 871 compare_strings (const void *a, const void *b) 872 { 873 const char *s1 = ((const std::pair<const char *, tree> *) a)->first; 874 const char *s2 = ((const std::pair<const char *, tree> *) b)->first; 875 int ret; 876 877 if (s1 == s2) 878 return 0; 879 880 ret = strcmp (s1, s2); 881 882 /* The strings are always those from IDENTIFIER_NODEs, and, 883 therefore, we should never have two copies of the same 884 string. */ 885 gcc_assert (ret); 886 887 return ret; 888 } 889 890 /* Put X, a SYMBOL_REF, in memory. Return a SYMBOL_REF to the allocated 891 memory. Differs from force_const_mem in that a single pool is used for 892 the entire unit of translation, and the memory is not guaranteed to be 893 "near" the function in any interesting sense. IS_PUBLIC controls whether 894 the symbol can be shared across the entire application (or DSO). */ 895 896 rtx 897 dw2_force_const_mem (rtx x, bool is_public) 898 { 899 const char *key; 900 tree decl_id; 901 902 if (! indirect_pool) 903 indirect_pool = hash_map<const char *, tree>::create_ggc (64); 904 905 gcc_assert (GET_CODE (x) == SYMBOL_REF); 906 907 key = XSTR (x, 0); 908 tree *slot = indirect_pool->get (key); 909 if (slot) 910 decl_id = *slot; 911 else 912 { 913 tree id; 914 const char *str = targetm.strip_name_encoding (key); 915 916 if (is_public && USE_LINKONCE_INDIRECT) 917 { 918 char *ref_name = XALLOCAVEC (char, strlen (str) + sizeof "DW.ref."); 919 920 sprintf (ref_name, "DW.ref.%s", str); 921 gcc_assert (!maybe_get_identifier (ref_name)); 922 decl_id = get_identifier (ref_name); 923 TREE_PUBLIC (decl_id) = 1; 924 } 925 else 926 { 927 char label[32]; 928 929 ASM_GENERATE_INTERNAL_LABEL (label, "LDFCM", dw2_const_labelno); 930 ++dw2_const_labelno; 931 gcc_assert (!maybe_get_identifier (label)); 932 decl_id = get_identifier (label); 933 } 934 935 id = maybe_get_identifier (str); 936 if (id) 937 TREE_SYMBOL_REFERENCED (id) = 1; 938 939 indirect_pool->put (key, decl_id); 940 } 941 942 return gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (decl_id)); 943 } 944 945 /* A helper function for dw2_output_indirect_constants. Emit one queued 946 constant to memory. */ 947 948 static int 949 dw2_output_indirect_constant_1 (const char *sym, tree id) 950 { 951 rtx sym_ref; 952 tree decl; 953 954 decl = build_decl (UNKNOWN_LOCATION, VAR_DECL, id, ptr_type_node); 955 SET_DECL_ASSEMBLER_NAME (decl, id); 956 DECL_ARTIFICIAL (decl) = 1; 957 DECL_IGNORED_P (decl) = 1; 958 DECL_INITIAL (decl) = build_fold_addr_expr (decl); 959 TREE_READONLY (decl) = 1; 960 TREE_STATIC (decl) = 1; 961 962 if (TREE_PUBLIC (id)) 963 { 964 TREE_PUBLIC (decl) = 1; 965 make_decl_one_only (decl, DECL_ASSEMBLER_NAME (decl)); 966 if (USE_LINKONCE_INDIRECT) 967 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN; 968 } 969 970 sym_ref = gen_rtx_SYMBOL_REF (Pmode, sym); 971 /* Disable ASan for decl because redzones cause ABI breakage between GCC and 972 libstdc++ for `.LDFCM*' variables. See PR 78651 for details. */ 973 unsigned int save_flag_sanitize = flag_sanitize; 974 flag_sanitize &= ~(SANITIZE_ADDRESS | SANITIZE_USER_ADDRESS 975 | SANITIZE_KERNEL_ADDRESS); 976 /* And also temporarily disable -fsection-anchors. These indirect constants 977 are never referenced from code, so it doesn't make any sense to aggregate 978 them in blocks. */ 979 int save_flag_section_anchors = flag_section_anchors; 980 flag_section_anchors = 0; 981 assemble_variable (decl, 1, 1, 1); 982 flag_section_anchors = save_flag_section_anchors; 983 flag_sanitize = save_flag_sanitize; 984 assemble_integer (sym_ref, POINTER_SIZE_UNITS, POINTER_SIZE, 1); 985 /* The following is a hack recognized by use_blocks_for_decl_p to disable 986 section anchor handling of the decl. */ 987 DECL_INITIAL (decl) = decl; 988 989 return 0; 990 } 991 992 /* Emit the constants queued through dw2_force_const_mem. */ 993 994 void 995 dw2_output_indirect_constants (void) 996 { 997 if (!indirect_pool) 998 return; 999 1000 auto_vec<std::pair<const char *, tree> > temp (indirect_pool->elements ()); 1001 for (hash_map<const char *, tree>::iterator iter = indirect_pool->begin (); 1002 iter != indirect_pool->end (); ++iter) 1003 temp.quick_push (*iter); 1004 1005 temp.qsort (compare_strings); 1006 1007 for (unsigned int i = 0; i < temp.length (); i++) 1008 dw2_output_indirect_constant_1 (temp[i].first, temp[i].second); 1009 } 1010 1011 /* Like dw2_asm_output_addr_rtx, but encode the pointer as directed. 1012 If PUBLIC is set and the encoding is DW_EH_PE_indirect, the indirect 1013 reference is shared across the entire application (or DSO). */ 1014 1015 void 1016 dw2_asm_output_encoded_addr_rtx (int encoding, rtx addr, bool is_public, 1017 const char *comment, ...) 1018 { 1019 int size; 1020 va_list ap; 1021 1022 va_start (ap, comment); 1023 1024 size = size_of_encoded_value (encoding); 1025 1026 if (encoding == DW_EH_PE_aligned) 1027 { 1028 assemble_align (POINTER_SIZE); 1029 assemble_integer (addr, size, POINTER_SIZE, 1); 1030 va_end (ap); 1031 return; 1032 } 1033 1034 /* NULL is _always_ represented as a plain zero, as is 1 for Ada's 1035 "all others". */ 1036 if (addr == const0_rtx || addr == const1_rtx) 1037 assemble_integer (addr, size, BITS_PER_UNIT, 1); 1038 else 1039 { 1040 restart: 1041 /* Allow the target first crack at emitting this. Some of the 1042 special relocations require special directives instead of 1043 just ".4byte" or whatever. */ 1044 #ifdef ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX 1045 ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX (asm_out_file, encoding, size, 1046 addr, done); 1047 #endif 1048 1049 /* Indirection is used to get dynamic relocations out of a 1050 read-only section. */ 1051 if (encoding & DW_EH_PE_indirect) 1052 { 1053 /* It is very tempting to use force_const_mem so that we share data 1054 with the normal constant pool. However, we've already emitted 1055 the constant pool for this function. Moreover, we'd like to 1056 share these constants across the entire unit of translation and 1057 even, if possible, across the entire application (or DSO). */ 1058 addr = dw2_force_const_mem (addr, is_public); 1059 encoding &= ~DW_EH_PE_indirect; 1060 goto restart; 1061 } 1062 1063 switch (encoding & 0xF0) 1064 { 1065 case DW_EH_PE_absptr: 1066 dw2_assemble_integer (size, addr); 1067 break; 1068 1069 #ifdef ASM_OUTPUT_DWARF_DATAREL 1070 case DW_EH_PE_datarel: 1071 gcc_assert (GET_CODE (addr) == SYMBOL_REF); 1072 ASM_OUTPUT_DWARF_DATAREL (asm_out_file, size, XSTR (addr, 0)); 1073 break; 1074 #endif 1075 1076 case DW_EH_PE_pcrel: 1077 gcc_assert (GET_CODE (addr) == SYMBOL_REF); 1078 #ifdef ASM_OUTPUT_DWARF_PCREL 1079 ASM_OUTPUT_DWARF_PCREL (asm_out_file, size, XSTR (addr, 0)); 1080 #else 1081 dw2_assemble_integer (size, gen_rtx_MINUS (Pmode, addr, pc_rtx)); 1082 #endif 1083 break; 1084 1085 default: 1086 /* Other encodings should have been handled by 1087 ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX. */ 1088 gcc_unreachable (); 1089 } 1090 1091 #ifdef ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX 1092 done:; 1093 #endif 1094 } 1095 1096 if (flag_debug_asm && comment) 1097 { 1098 fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START); 1099 vfprintf (asm_out_file, comment, ap); 1100 } 1101 fputc ('\n', asm_out_file); 1102 1103 va_end (ap); 1104 } 1105 1106 #include "gt-dwarf2asm.h" 1107