gcc/dwarf2asm.c

   1 /* Dwarf2 assembler output helper routines.
   2    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008
   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 (GET_CODE (x) == CONST_INT)
  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, "0x%x,", bytes[i]);
  84       fprintf (asm_out_file, "0x%x", bytes[0]);
  85     }
  86   else
  87     {
  88       for (i = 0; i < size - 1; ++i)
  89         fprintf (asm_out_file, "0x%x,", bytes[i]);
  90       fprintf (asm_out_file, "0x%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 | DW_EH_PE_pcrel,
 450     "indirect pcrel")
 451   S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_pcrel,
 452     "indirect pcrel uleb128")
 453   S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_pcrel,
 454     "indirect pcrel udata2")
 455   S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_pcrel,
 456     "indirect pcrel udata4")
 457   S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_pcrel,
 458     "indirect pcrel udata8")
 459   S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_pcrel,
 460     "indirect pcrel sleb128")
 461   S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_pcrel,
 462     "indirect pcrel sdata2")
 463   S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_pcrel,
 464     "indirect pcrel sdata4")
 465   S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_pcrel,
 466     "indirect pcrel sdata8")
 467
 468   S(DW_EH_PE_indirect | DW_EH_PE_absptr | DW_EH_PE_textrel,
 469     "indirect textrel")
 470   S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_textrel,
 471     "indirect textrel uleb128")
 472   S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_textrel,
 473     "indirect textrel udata2")
 474   S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_textrel,
 475     "indirect textrel udata4")
 476   S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_textrel,
 477     "indirect textrel udata8")
 478   S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_textrel,
 479     "indirect textrel sleb128")
 480   S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_textrel,
 481     "indirect textrel sdata2")
 482   S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_textrel,
 483     "indirect textrel sdata4")
 484   S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_textrel,
 485     "indirect textrel sdata8")
 486
 487   S(DW_EH_PE_indirect | DW_EH_PE_absptr | DW_EH_PE_datarel,
 488     "indirect datarel")
 489   S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_datarel,
 490     "indirect datarel uleb128")
 491   S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_datarel,
 492     "indirect datarel udata2")
 493   S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_datarel,
 494     "indirect datarel udata4")
 495   S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_datarel,
 496     "indirect datarel udata8")
 497   S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_datarel,
 498     "indirect datarel sleb128")
 499   S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_datarel,
 500     "indirect datarel sdata2")
 501   S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_datarel,
 502     "indirect datarel sdata4")
 503   S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_datarel,
 504     "indirect datarel sdata8")
 505
 506   S(DW_EH_PE_indirect | DW_EH_PE_absptr | DW_EH_PE_funcrel,
 507     "indirect funcrel")
 508   S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_funcrel,
 509     "indirect funcrel uleb128")
 510   S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_funcrel,
 511     "indirect funcrel udata2")
 512   S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_funcrel,
 513     "indirect funcrel udata4")
 514   S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_funcrel,
 515     "indirect funcrel udata8")
 516   S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_funcrel,
 517     "indirect funcrel sleb128")
 518   S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_funcrel,
 519     "indirect funcrel sdata2")
 520   S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_funcrel,
 521     "indirect funcrel sdata4")
 522   S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_funcrel,
 523     "indirect funcrel sdata8")
 524
 525 #if HAVE_DESIGNATED_INITIALIZERS
 526   };
 527
 528   gcc_assert (format >= 0 && format < 0x100 && format_names[format]);
 529
 530   return format_names[format];
 531 #else
 532   }
 533   gcc_unreachable ();
 534 #endif
 535 }
 536
 537 /* Output an unsigned LEB128 quantity, but only the byte values.  */
 538
 539 void
 540 dw2_asm_output_data_uleb128_raw (unsigned HOST_WIDE_INT value)
 541 {
 542   while (1)
 543     {
 544       int byte = (value & 0x7f);
 545       value >>= 7;
 546       if (value != 0)
 547         /* More bytes to follow.  */
 548         byte |= 0x80;
 549
 550       fprintf (asm_out_file, "0x%x", byte);
 551       if (value == 0)
 552         break;
 553       fputc (',', asm_out_file);
 554     }
 555 }
 556
 557 /* Output an unsigned LEB128 quantity.  */
 558
 559 void
 560 dw2_asm_output_data_uleb128 (unsigned HOST_WIDE_INT value,
 561                              const char *comment, ...)
 562 {
 563   va_list ap;
 564
 565   va_start (ap, comment);
 566
 567 #ifdef HAVE_AS_LEB128
 568   fprintf (asm_out_file, "\t.uleb128 " HOST_WIDE_INT_PRINT_HEX , value);
 569
 570   if (flag_debug_asm && comment)
 571     {
 572       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
 573       vfprintf (asm_out_file, comment, ap);
 574     }
 575 #else
 576   {
 577     unsigned HOST_WIDE_INT work = value;
 578     const char *byte_op = targetm.asm_out.byte_op;
 579
 580     if (byte_op)
 581       fputs (byte_op, asm_out_file);
 582     do
 583       {
 584         int byte = (work & 0x7f);
 585         work >>= 7;
 586         if (work != 0)
 587           /* More bytes to follow.  */
 588           byte |= 0x80;
 589
 590         if (byte_op)
 591           {
 592             fprintf (asm_out_file, "0x%x", byte);
 593             if (work != 0)
 594               fputc (',', asm_out_file);
 595           }
 596         else
 597           assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
 598       }
 599     while (work != 0);
 600
 601   if (flag_debug_asm)
 602     {
 603       fprintf (asm_out_file, "\t%s uleb128 " HOST_WIDE_INT_PRINT_HEX,
 604                ASM_COMMENT_START, value);
 605       if (comment)
 606         {
 607           fputs ("; ", asm_out_file);
 608           vfprintf (asm_out_file, comment, ap);
 609         }
 610     }
 611   }
 612 #endif
 613   fputc ('\n', asm_out_file);
 614
 615   va_end (ap);
 616 }
 617
 618 /* Output an signed LEB128 quantity, but only the byte values.  */
 619
 620 void
 621 dw2_asm_output_data_sleb128_raw (HOST_WIDE_INT value)
 622 {
 623   int byte, more;
 624
 625   while (1)
 626     {
 627       byte = (value & 0x7f);
 628       value >>= 7;
 629       more = !((value == 0 && (byte & 0x40) == 0)
 630                 || (value == -1 && (byte & 0x40) != 0));
 631       if (more)
 632         byte |= 0x80;
 633
 634       fprintf (asm_out_file, "0x%x", byte);
 635       if (!more)
 636         break;
 637       fputc (',', asm_out_file);
 638     }
 639 }
 640
 641 /* Output a signed LEB128 quantity.  */
 642
 643 void
 644 dw2_asm_output_data_sleb128 (HOST_WIDE_INT value,
 645                              const char *comment, ...)
 646 {
 647   va_list ap;
 648
 649   va_start (ap, comment);
 650
 651 #ifdef HAVE_AS_LEB128
 652   fprintf (asm_out_file, "\t.sleb128 " HOST_WIDE_INT_PRINT_DEC, value);
 653
 654   if (flag_debug_asm && comment)
 655     {
 656       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
 657       vfprintf (asm_out_file, comment, ap);
 658     }
 659 #else
 660   {
 661     HOST_WIDE_INT work = value;
 662     int more, byte;
 663     const char *byte_op = targetm.asm_out.byte_op;
 664
 665     if (byte_op)
 666       fputs (byte_op, asm_out_file);
 667     do
 668       {
 669         byte = (work & 0x7f);
 670         /* arithmetic shift */
 671         work >>= 7;
 672         more = !((work == 0 && (byte & 0x40) == 0)
 673                  || (work == -1 && (byte & 0x40) != 0));
 674         if (more)
 675           byte |= 0x80;
 676
 677         if (byte_op)
 678           {
 679             fprintf (asm_out_file, "0x%x", byte);
 680             if (more)
 681               fputc (',', asm_out_file);
 682           }
 683         else
 684           assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
 685       }
 686     while (more);
 687
 688   if (flag_debug_asm)
 689     {
 690       fprintf (asm_out_file, "\t%s sleb128 " HOST_WIDE_INT_PRINT_DEC,
 691                ASM_COMMENT_START, value);
 692       if (comment)
 693         {
 694           fputs ("; ", asm_out_file);
 695           vfprintf (asm_out_file, comment, ap);
 696         }
 697     }
 698   }
 699 #endif
 700   fputc ('\n', asm_out_file);
 701
 702   va_end (ap);
 703 }
 704
 705 void
 706 dw2_asm_output_delta_uleb128 (const char *lab1 ATTRIBUTE_UNUSED,
 707                               const char *lab2 ATTRIBUTE_UNUSED,
 708                               const char *comment, ...)
 709 {
 710   va_list ap;
 711
 712   va_start (ap, comment);
 713
 714 #ifdef HAVE_AS_LEB128
 715   fputs ("\t.uleb128 ", asm_out_file);
 716   assemble_name (asm_out_file, lab1);
 717   fputc ('-', asm_out_file);
 718   assemble_name (asm_out_file, lab2);
 719 #else
 720   gcc_unreachable ();
 721 #endif
 722
 723   if (flag_debug_asm && comment)
 724     {
 725       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
 726       vfprintf (asm_out_file, comment, ap);
 727     }
 728   fputc ('\n', asm_out_file);
 729
 730   va_end (ap);
 731 }
 732
 733 #if 0
 734
 735 void
 736 dw2_asm_output_delta_sleb128 (const char *lab1 ATTRIBUTE_UNUSED,
 737                               const char *lab2 ATTRIBUTE_UNUSED,
 738                               const char *comment, ...)
 739 {
 740   va_list ap;
 741
 742   va_start (ap, comment);
 743
 744 #ifdef HAVE_AS_LEB128
 745   fputs ("\t.sleb128 ", asm_out_file);
 746   assemble_name (asm_out_file, lab1);
 747   fputc ('-', asm_out_file);
 748   assemble_name (asm_out_file, lab2);
 749 #else
 750   gcc_unreachable ();
 751 #endif
 752
 753   if (flag_debug_asm && comment)
 754     {
 755       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
 756       vfprintf (asm_out_file, comment, ap);
 757     }
 758   fputc ('\n', asm_out_file);
 759
 760   va_end (ap);
 761 }
 762 #endif /* 0 */
 763 \f
 764 static int dw2_output_indirect_constant_1 (splay_tree_node, void *);
 765
 766 static GTY((param1_is (char *), param2_is (tree))) splay_tree indirect_pool;
 767
 768 static GTY(()) int dw2_const_labelno;
 769
 770 #if defined(HAVE_GAS_HIDDEN) && defined(SUPPORTS_ONE_ONLY)
 771 # define USE_LINKONCE_INDIRECT 1
 772 #else
 773 # define USE_LINKONCE_INDIRECT 0
 774 #endif
 775
 776 /* Comparison function for a splay tree in which the keys are strings.
 777    K1 and K2 have the dynamic type "const char *".  Returns <0, 0, or
 778    >0 to indicate whether K1 is less than, equal to, or greater than
 779    K2, respectively.  */
 780
 781 static int
 782 splay_tree_compare_strings (splay_tree_key k1, splay_tree_key k2)
 783 {
 784   const char *s1 = (const char *)k1;
 785   const char *s2 = (const char *)k2;
 786   int ret;
 787
 788   if (s1 == s2)
 789     return 0;
 790
 791   ret = strcmp (s1, s2);
 792
 793   /* The strings are always those from IDENTIFIER_NODEs, and,
 794      therefore, we should never have two copies of the same
 795      string.  */
 796   gcc_assert (ret);
 797
 798   return ret;
 799 }
 800
 801 /* Put X, a SYMBOL_REF, in memory.  Return a SYMBOL_REF to the allocated
 802    memory.  Differs from force_const_mem in that a single pool is used for
 803    the entire unit of translation, and the memory is not guaranteed to be
 804    "near" the function in any interesting sense.  IS_PUBLIC controls whether
 805    the symbol can be shared across the entire application (or DSO).  */
 806
 807 rtx
 808 dw2_force_const_mem (rtx x, bool is_public)
 809 {
 810   splay_tree_node node;
 811   const char *key;
 812   tree decl_id;
 813
 814   if (! indirect_pool)
 815     /* We use strcmp, rather than just comparing pointers, so that the
 816        sort order will not depend on the host system.  */
 817     indirect_pool = splay_tree_new_ggc (splay_tree_compare_strings);
 818
 819   gcc_assert (GET_CODE (x) == SYMBOL_REF);
 820
 821   key = XSTR (x, 0);
 822   node = splay_tree_lookup (indirect_pool, (splay_tree_key) key);
 823   if (node)
 824     decl_id = (tree) node->value;
 825   else
 826     {
 827       tree id;
 828       const char *str = targetm.strip_name_encoding (key);
 829
 830       if (is_public && USE_LINKONCE_INDIRECT)
 831         {
 832           char *ref_name = XALLOCAVEC (char, strlen (str) + sizeof "DW.ref.");
 833
 834           sprintf (ref_name, "DW.ref.%s", str);
 835           gcc_assert (!maybe_get_identifier (ref_name));
 836           decl_id = get_identifier (ref_name);
 837           TREE_PUBLIC (decl_id) = 1;
 838         }
 839       else
 840         {
 841           char label[32];
 842
 843           ASM_GENERATE_INTERNAL_LABEL (label, "LDFCM", dw2_const_labelno);
 844           ++dw2_const_labelno;
 845           gcc_assert (!maybe_get_identifier (label));
 846           decl_id = get_identifier (label);
 847         }
 848
 849       id = maybe_get_identifier (str);
 850       if (id)
 851         TREE_SYMBOL_REFERENCED (id) = 1;
 852
 853       splay_tree_insert (indirect_pool, (splay_tree_key) key,
 854                          (splay_tree_value) decl_id);
 855     }
 856
 857   return gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (decl_id));
 858 }
 859
 860 /* A helper function for dw2_output_indirect_constants called through
 861    splay_tree_foreach.  Emit one queued constant to memory.  */
 862
 863 static int
 864 dw2_output_indirect_constant_1 (splay_tree_node node,
 865                                 void *data ATTRIBUTE_UNUSED)
 866 {
 867   const char *sym;
 868   rtx sym_ref;
 869   tree id, decl;
 870
 871   sym = (const char *) node->key;
 872   id = (tree) node->value;
 873
 874   decl = build_decl (UNKNOWN_LOCATION, VAR_DECL, id, ptr_type_node);
 875   DECL_ARTIFICIAL (decl) = 1;
 876   DECL_IGNORED_P (decl) = 1;
 877   DECL_INITIAL (decl) = decl;
 878
 879   if (TREE_PUBLIC (id))
 880     {
 881       TREE_PUBLIC (decl) = 1;
 882       make_decl_one_only (decl, DECL_ASSEMBLER_NAME (decl));
 883     }
 884   else
 885     TREE_STATIC (decl) = 1;
 886
 887   sym_ref = gen_rtx_SYMBOL_REF (Pmode, sym);
 888   sym = targetm.strip_name_encoding (sym);
 889   if (TREE_PUBLIC (decl) && USE_LINKONCE_INDIRECT)
 890     fprintf (asm_out_file, "\t.hidden %sDW.ref.%s\n", user_label_prefix, sym);
 891   assemble_variable (decl, 1, 1, 1);
 892   assemble_integer (sym_ref, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
 893
 894   return 0;
 895 }
 896
 897 /* Emit the constants queued through dw2_force_const_mem.  */
 898
 899 void
 900 dw2_output_indirect_constants (void)
 901 {
 902   if (indirect_pool)
 903     splay_tree_foreach (indirect_pool, dw2_output_indirect_constant_1, NULL);
 904 }
 905
 906 /* Like dw2_asm_output_addr_rtx, but encode the pointer as directed.
 907    If PUBLIC is set and the encoding is DW_EH_PE_indirect, the indirect
 908    reference is shared across the entire application (or DSO).  */
 909
 910 void
 911 dw2_asm_output_encoded_addr_rtx (int encoding, rtx addr, bool is_public,
 912                                  const char *comment, ...)
 913 {
 914   int size;
 915   va_list ap;
 916
 917   va_start (ap, comment);
 918
 919   size = size_of_encoded_value (encoding);
 920
 921   if (encoding == DW_EH_PE_aligned)
 922     {
 923       assemble_align (POINTER_SIZE);
 924       assemble_integer (addr, size, POINTER_SIZE, 1);
 925       return;
 926     }
 927
 928   /* NULL is _always_ represented as a plain zero, as is 1 for Ada's
 929      "all others".  */
 930   if (addr == const0_rtx || addr == const1_rtx)
 931     assemble_integer (addr, size, BITS_PER_UNIT, 1);
 932   else
 933     {
 934     restart:
 935       /* Allow the target first crack at emitting this.  Some of the
 936          special relocations require special directives instead of
 937          just ".4byte" or whatever.  */
 938 #ifdef ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX
 939       ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX (asm_out_file, encoding, size,
 940                                          addr, done);
 941 #endif
 942
 943       /* Indirection is used to get dynamic relocations out of a
 944          read-only section.  */
 945       if (encoding & DW_EH_PE_indirect)
 946         {
 947           /* It is very tempting to use force_const_mem so that we share data
 948              with the normal constant pool.  However, we've already emitted
 949              the constant pool for this function.  Moreover, we'd like to
 950              share these constants across the entire unit of translation and
 951              even, if possible, across the entire application (or DSO).  */
 952           addr = dw2_force_const_mem (addr, is_public);
 953           encoding &= ~DW_EH_PE_indirect;
 954           goto restart;
 955         }
 956
 957       switch (encoding & 0xF0)
 958         {
 959         case DW_EH_PE_absptr:
 960           dw2_assemble_integer (size, addr);
 961           break;
 962
 963         case DW_EH_PE_pcrel:
 964           gcc_assert (GET_CODE (addr) == SYMBOL_REF);
 965 #ifdef ASM_OUTPUT_DWARF_PCREL
 966           ASM_OUTPUT_DWARF_PCREL (asm_out_file, size, XSTR (addr, 0));
 967 #else
 968           dw2_assemble_integer (size, gen_rtx_MINUS (Pmode, addr, pc_rtx));
 969 #endif
 970           break;
 971
 972         default:
 973           /* Other encodings should have been handled by
 974              ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX.  */
 975           gcc_unreachable ();
 976         }
 977
 978 #ifdef ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX
 979     done:;
 980 #endif
 981     }
 982
 983   if (flag_debug_asm && comment)
 984     {
 985       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
 986       vfprintf (asm_out_file, comment, ap);
 987     }
 988   fputc ('\n', asm_out_file);
 989
 990   va_end (ap);
 991 }
 992
 993 #include "gt-dwarf2asm.h"