gcc/dwarf2asm.c

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