gcc/dwarf2asm.c

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