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