gcc/dwarf2asm.c

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