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