gcc/dwarf2asm.c

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