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   fprintf (asm_out_file, "\t.uleb128 " HOST_WIDE_INT_PRINT_HEX , value);
 518
 519   if (flag_debug_asm && comment)
 520     {
 521       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
 522       vfprintf (asm_out_file, comment, ap);
 523     }
 524 #else
 525   {
 526     unsigned HOST_WIDE_INT work = value;
 527     const char *byte_op = targetm.asm_out.byte_op;
 528
 529     if (byte_op)
 530       fputs (byte_op, asm_out_file);
 531     do
 532       {
 533         int byte = (work & 0x7f);
 534         work >>= 7;
 535         if (work != 0)
 536           /* More bytes to follow.  */
 537           byte |= 0x80;
 538
 539         if (byte_op)
 540           {
 541             fprintf (asm_out_file, "0x%x", byte);
 542             if (work != 0)
 543               fputc (',', asm_out_file);
 544           }
 545         else
 546           assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
 547       }
 548     while (work != 0);
 549
 550   if (flag_debug_asm)
 551     {
 552       fprintf (asm_out_file, "\t%s uleb128 " HOST_WIDE_INT_PRINT_HEX,
 553                ASM_COMMENT_START, value);
 554       if (comment)
 555         {
 556           fputs ("; ", asm_out_file);
 557           vfprintf (asm_out_file, comment, ap);
 558         }
 559     }
 560   }
 561 #endif
 562   fputc ('\n', asm_out_file);
 563
 564   VA_CLOSE (ap);
 565 }
 566
 567 /* Output a signed LEB128 quantity.  */
 568
 569 void
 570 dw2_asm_output_data_sleb128 VPARAMS ((HOST_WIDE_INT value,
 571                                       const char *comment, ...))
 572 {
 573   VA_OPEN (ap, comment);
 574   VA_FIXEDARG (ap, HOST_WIDE_INT, value);
 575   VA_FIXEDARG (ap, const char *, comment);
 576
 577 #ifdef HAVE_AS_LEB128
 578   fprintf (asm_out_file, "\t.sleb128 " HOST_WIDE_INT_PRINT_DEC, value);
 579
 580   if (flag_debug_asm && comment)
 581     {
 582       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
 583       vfprintf (asm_out_file, comment, ap);
 584     }
 585 #else
 586   {
 587     HOST_WIDE_INT work = value;
 588     int more, byte;
 589     const char *byte_op = targetm.asm_out.byte_op;
 590
 591     if (byte_op)
 592       fputs (byte_op, asm_out_file);
 593     do
 594       {
 595         byte = (work & 0x7f);
 596         /* arithmetic shift */
 597         work >>= 7;
 598         more = !((work == 0 && (byte & 0x40) == 0)
 599                  || (work == -1 && (byte & 0x40) != 0));
 600         if (more)
 601           byte |= 0x80;
 602
 603         if (byte_op)
 604           {
 605             fprintf (asm_out_file, "0x%x", byte);
 606             if (more)
 607               fputc (',', asm_out_file);
 608           }
 609         else
 610           assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
 611       }
 612     while (more);
 613
 614   if (flag_debug_asm)
 615     {
 616       fprintf (asm_out_file, "\t%s sleb128 " HOST_WIDE_INT_PRINT_DEC,
 617                ASM_COMMENT_START, value);
 618       if (comment)
 619         {
 620           fputs ("; ", asm_out_file);
 621           vfprintf (asm_out_file, comment, ap);
 622         }
 623     }
 624   }
 625 #endif
 626   fputc ('\n', asm_out_file);
 627
 628   VA_CLOSE (ap);
 629 }
 630
 631 void
 632 dw2_asm_output_delta_uleb128 VPARAMS ((const char *lab1 ATTRIBUTE_UNUSED,
 633                                        const char *lab2 ATTRIBUTE_UNUSED,
 634                                        const char *comment, ...))
 635 {
 636   VA_OPEN (ap, comment);
 637   VA_FIXEDARG (ap, const char *, lab1);
 638   VA_FIXEDARG (ap, const char *, lab2);
 639   VA_FIXEDARG (ap, const char *, comment);
 640
 641 #ifdef HAVE_AS_LEB128
 642   fputs ("\t.uleb128 ", asm_out_file);
 643   assemble_name (asm_out_file, lab1);
 644   fputc ('-', asm_out_file);
 645   assemble_name (asm_out_file, lab2);
 646 #else
 647   abort ();
 648 #endif
 649
 650   if (flag_debug_asm && comment)
 651     {
 652       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
 653       vfprintf (asm_out_file, comment, ap);
 654     }
 655   fputc ('\n', asm_out_file);
 656
 657   VA_CLOSE (ap);
 658 }
 659
 660 void
 661 dw2_asm_output_delta_sleb128 VPARAMS ((const char *lab1 ATTRIBUTE_UNUSED,
 662                                        const char *lab2 ATTRIBUTE_UNUSED,
 663                                        const char *comment, ...))
 664 {
 665   VA_OPEN (ap, comment);
 666   VA_FIXEDARG (ap, const char *, lab1);
 667   VA_FIXEDARG (ap, const char *, lab2);
 668   VA_FIXEDARG (ap, const char *, comment);
 669
 670 #ifdef HAVE_AS_LEB128
 671   fputs ("\t.sleb128 ", asm_out_file);
 672   assemble_name (asm_out_file, lab1);
 673   fputc ('-', asm_out_file);
 674   assemble_name (asm_out_file, lab2);
 675 #else
 676   abort ();
 677 #endif
 678
 679   if (flag_debug_asm && comment)
 680     {
 681       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
 682       vfprintf (asm_out_file, comment, ap);
 683     }
 684   fputc ('\n', asm_out_file);
 685
 686   VA_CLOSE (ap);
 687 }
 688 \f
 689 static rtx dw2_force_const_mem PARAMS ((rtx));
 690 static int dw2_output_indirect_constant_1 PARAMS ((splay_tree_node, void *));
 691
 692 static GTY((param1_is (char *), param2_is (tree))) splay_tree indirect_pool;
 693
 694 static GTY(()) int dw2_const_labelno;
 695
 696 #if defined(HAVE_GAS_HIDDEN) && defined(SUPPORTS_ONE_ONLY)
 697 # define USE_LINKONCE_INDIRECT 1
 698 #else
 699 # define USE_LINKONCE_INDIRECT 0
 700 #endif
 701
 702 /* Put X, a SYMBOL_REF, in memory.  Return a SYMBOL_REF to the allocated
 703    memory.  Differs from force_const_mem in that a single pool is used for
 704    the entire unit of translation, and the memory is not guaranteed to be
 705    "near" the function in any interesting sense.  */
 706
 707 static rtx
 708 dw2_force_const_mem (x)
 709      rtx x;
 710 {
 711   splay_tree_node node;
 712   const char *str;
 713   tree decl;
 714
 715   if (! indirect_pool)
 716     indirect_pool = splay_tree_new_ggc (splay_tree_compare_pointers);
 717
 718   if (GET_CODE (x) != SYMBOL_REF)
 719     abort ();
 720
 721   str = (* targetm.strip_name_encoding) (XSTR (x, 0));
 722   node = splay_tree_lookup (indirect_pool, (splay_tree_key) str);
 723   if (node)
 724     decl = (tree) node->value;
 725   else
 726     {
 727       tree id;
 728
 729       if (USE_LINKONCE_INDIRECT)
 730         {
 731           char *ref_name = alloca (strlen (str) + sizeof "DW.ref.");
 732
 733           sprintf (ref_name, "DW.ref.%s", str);
 734           id = get_identifier (ref_name);
 735           decl = build_decl (VAR_DECL, id, ptr_type_node);
 736           DECL_ARTIFICIAL (decl) = 1;
 737           TREE_PUBLIC (decl) = 1;
 738           DECL_INITIAL (decl) = decl;
 739           make_decl_one_only (decl);
 740         }
 741       else
 742         {
 743           char label[32];
 744
 745           ASM_GENERATE_INTERNAL_LABEL (label, "LDFCM", dw2_const_labelno);
 746           ++dw2_const_labelno;
 747           id = get_identifier (label);
 748           decl = build_decl (VAR_DECL, id, ptr_type_node);
 749           DECL_ARTIFICIAL (decl) = 1;
 750           TREE_STATIC (decl) = 1;
 751           DECL_INITIAL (decl) = decl;
 752         }
 753
 754       id = maybe_get_identifier (str);
 755       if (id)
 756         TREE_SYMBOL_REFERENCED (id) = 1;
 757
 758       splay_tree_insert (indirect_pool, (splay_tree_key) str,
 759                          (splay_tree_value) decl);
 760     }
 761
 762   return XEXP (DECL_RTL (decl), 0);
 763 }
 764
 765 /* A helper function for dw2_output_indirect_constants called through
 766    splay_tree_foreach.  Emit one queued constant to memory.  */
 767
 768 static int
 769 dw2_output_indirect_constant_1 (node, data)
 770      splay_tree_node node;
 771      void* data ATTRIBUTE_UNUSED;
 772 {
 773   const char *sym;
 774   rtx sym_ref;
 775
 776   sym = (const char *) node->key;
 777   sym_ref = gen_rtx_SYMBOL_REF (Pmode, sym);
 778   if (USE_LINKONCE_INDIRECT)
 779     fprintf (asm_out_file, "\t.hidden DW.ref.%s\n", sym);
 780   assemble_variable ((tree) node->value, 1, 1, 1);
 781   assemble_integer (sym_ref, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
 782
 783   return 0;
 784 }
 785
 786 /* Emit the constants queued through dw2_force_const_mem.  */
 787
 788 void
 789 dw2_output_indirect_constants ()
 790 {
 791   if (indirect_pool)
 792     splay_tree_foreach (indirect_pool, dw2_output_indirect_constant_1, NULL);
 793 }
 794
 795 /* Like dw2_asm_output_addr_rtx, but encode the pointer as directed.  */
 796
 797 void
 798 dw2_asm_output_encoded_addr_rtx VPARAMS ((int encoding,
 799                                           rtx addr,
 800                                           const char *comment, ...))
 801 {
 802   int size;
 803
 804   VA_OPEN (ap, comment);
 805   VA_FIXEDARG (ap, int, encoding);
 806   VA_FIXEDARG (ap, rtx, addr);
 807   VA_FIXEDARG (ap, const char *, comment);
 808
 809   size = size_of_encoded_value (encoding);
 810
 811   if (encoding == DW_EH_PE_aligned)
 812     {
 813       assemble_align (POINTER_SIZE);
 814       assemble_integer (addr, size, POINTER_SIZE, 1);
 815       return;
 816     }
 817
 818   /* NULL is _always_ represented as a plain zero, as is 1 for Ada's
 819      "all others".  */
 820   if (addr == const0_rtx || addr == const1_rtx)
 821     assemble_integer (addr, size, BITS_PER_UNIT, 1);
 822   else
 823     {
 824     restart:
 825       /* Allow the target first crack at emitting this.  Some of the
 826          special relocations require special directives instead of
 827          just ".4byte" or whatever.  */
 828 #ifdef ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX
 829       ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX (asm_out_file, encoding, size,
 830                                          addr, done);
 831 #endif
 832
 833       /* Indirection is used to get dynamic relocations out of a
 834          read-only section.  */
 835       if (encoding & DW_EH_PE_indirect)
 836         {
 837           /* It is very tempting to use force_const_mem so that we share data
 838              with the normal constant pool.  However, we've already emitted
 839              the constant pool for this function.  Moreover, we'd like to
 840              share these constants across the entire unit of translation,
 841              or better, across the entire application (or DSO).  */
 842           addr = dw2_force_const_mem (addr);
 843           encoding &= ~DW_EH_PE_indirect;
 844           goto restart;
 845         }
 846
 847       switch (encoding & 0xF0)
 848         {
 849         case DW_EH_PE_absptr:
 850           dw2_assemble_integer (size, addr);
 851           break;
 852
 853         case DW_EH_PE_pcrel:
 854           if (GET_CODE (addr) != SYMBOL_REF)
 855             abort ();
 856 #ifdef ASM_OUTPUT_DWARF_PCREL
 857           ASM_OUTPUT_DWARF_PCREL (asm_out_file, size, XSTR (addr, 0));
 858 #else
 859           dw2_assemble_integer (size, gen_rtx_MINUS (Pmode, addr, pc_rtx));
 860 #endif
 861           break;
 862
 863         default:
 864           /* Other encodings should have been handled by
 865              ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX.  */
 866           abort ();
 867         }
 868
 869 #ifdef ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX
 870     done:;
 871 #endif
 872     }
 873
 874   if (flag_debug_asm && comment)
 875     {
 876       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
 877       vfprintf (asm_out_file, comment, ap);
 878     }
 879   fputc ('\n', asm_out_file);
 880
 881   VA_CLOSE (ap);
 882 }
 883
 884 #include "gt-dwarf2asm.h"