gcc/dwarf2asm.c

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