gcc/dwarf2asm.c

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