gcc/dwarf2asm.c

   1 /* Dwarf2 assembler output helper routines.
   2    Copyright (C) 2001 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU CC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "flags.h"
  25 #include "tree.h"
  26 #include "rtl.h"
  27 #include "output.h"
  28 #include "dwarf2asm.h"
  29 #include "dwarf2.h"
  30 #include "splay-tree.h"
  31 #include "ggc.h"
  32 #include "tm_p.h"
  33
  34
  35 /* How to start an assembler comment.  */
  36 #ifndef ASM_COMMENT_START
  37 #define ASM_COMMENT_START ";#"
  38 #endif
  39
  40 /* Definitions of defaults for assembler-dependent names of various
  41    pseudo-ops and section names.  These may be overridden in the tm.h
  42    file (if necessary) for a particular assembler.  */
  43
  44 #ifdef OBJECT_FORMAT_ELF
  45 #ifndef UNALIGNED_SHORT_ASM_OP
  46 #define UNALIGNED_SHORT_ASM_OP          "\t.2byte\t"
  47 #endif
  48 #ifndef UNALIGNED_INT_ASM_OP
  49 #define UNALIGNED_INT_ASM_OP            "\t.4byte\t"
  50 #endif
  51 #ifndef UNALIGNED_DOUBLE_INT_ASM_OP
  52 #define UNALIGNED_DOUBLE_INT_ASM_OP     "\t.8byte\t"
  53 #endif
  54 #endif /* OBJECT_FORMAT_ELF */
  55
  56 #ifndef ASM_BYTE_OP
  57 #define ASM_BYTE_OP                     "\t.byte\t"
  58 #endif
  59
  60 /* We don't have unaligned support, let's hope the normal output works for
  61    .debug_frame.  But we know it won't work for .debug_info.  */
  62 #if !defined(UNALIGNED_INT_ASM_OP) && defined(DWARF2_DEBUGGING_INFO)
  63  #error DWARF2_DEBUGGING_INFO requires UNALIGNED_INT_ASM_OP.
  64 #endif
  65
  66 \f
  67 #ifdef UNALIGNED_INT_ASM_OP
  68 static const char * unaligned_integer_asm_op  PARAMS ((int));
  69
  70 static inline const char *
  71 unaligned_integer_asm_op (size)
  72      int size;
  73 {
  74   const char *op;
  75   switch (size)
  76     {
  77     case 1:
  78       op = ASM_BYTE_OP;
  79       break;
  80     case 2:
  81       op = UNALIGNED_SHORT_ASM_OP;
  82       break;
  83     case 4:
  84       op = UNALIGNED_INT_ASM_OP;
  85       break;
  86     case 8:
  87 #ifdef UNALIGNED_DOUBLE_INT_ASM_OP
  88       op = UNALIGNED_DOUBLE_INT_ASM_OP;
  89       break;
  90 #endif
  91     default:
  92       abort ();
  93     }
  94   return op;
  95 }
  96 #endif /* UNALIGNED_INT_ASM_OP */
  97
  98 /* Output an immediate constant in a given size.  */
  99
 100 void
 101 dw2_asm_output_data VPARAMS ((int size, unsigned HOST_WIDE_INT value,
 102                               const char *comment, ...))
 103 {
 104 #ifndef ANSI_PROTOTYPES
 105   int size;
 106   unsigned HOST_WIDE_INT value;
 107   const char *comment;
 108 #endif
 109   va_list ap;
 110
 111   VA_START (ap, comment);
 112
 113 #ifndef ANSI_PROTOTYPES
 114   size = va_arg (ap, int);
 115   value = va_arg (ap, unsigned HOST_WIDE_INT);
 116   comment = va_arg (ap, const char *);
 117 #endif
 118
 119   if (size * 8 < HOST_BITS_PER_WIDE_INT)
 120     value &= ~(~(unsigned HOST_WIDE_INT)0 << (size * 8));
 121
 122 #ifdef UNALIGNED_INT_ASM_OP
 123   fputs (unaligned_integer_asm_op (size), asm_out_file);
 124   fprintf (asm_out_file, HOST_WIDE_INT_PRINT_HEX, value);
 125 #else
 126   assemble_integer (GEN_INT (value), size, 1);
 127 #endif
 128
 129   if (flag_debug_asm && comment)
 130     {
 131       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
 132       vfprintf (asm_out_file, comment, ap);
 133     }
 134   fputc ('\n', asm_out_file);
 135
 136   va_end (ap);
 137 }
 138
 139 /* Output the difference between two symbols in a given size.  */
 140 /* ??? There appear to be assemblers that do not like such
 141    subtraction, but do support ASM_SET_OP.  It's unfortunately
 142    impossible to do here, since the ASM_SET_OP for the difference
 143    symbol must appear after both symbols are defined.  */
 144
 145 void
 146 dw2_asm_output_delta VPARAMS ((int size, const char *lab1, const char *lab2,
 147                                const char *comment, ...))
 148 {
 149 #ifndef ANSI_PROTOTYPES
 150   int size;
 151   const char *lab1, *lab2;
 152   const char *comment;
 153 #endif
 154   va_list ap;
 155
 156   VA_START (ap, comment);
 157
 158 #ifndef ANSI_PROTOTYPES
 159   size = va_arg (ap, int);
 160   lab1 = va_arg (ap, const char *);
 161   lab2 = va_arg (ap, const char *);
 162   comment = va_arg (ap, const char *);
 163 #endif
 164
 165 #ifdef UNALIGNED_INT_ASM_OP
 166   fputs (unaligned_integer_asm_op (size), asm_out_file);
 167   assemble_name (asm_out_file, lab1);
 168   fputc ('-', asm_out_file);
 169   assemble_name (asm_out_file, lab2);
 170 #else
 171   assemble_integer (gen_rtx_MINUS (smallest_mode_for_size (size, MODE_INT),
 172                                    gen_rtx_SYMBOL_REF (Pmode, lab1),
 173                                    gen_rtx_SYMBOL_REF (Pmode, lab2)),
 174                     size, 1);
 175 #endif
 176
 177   if (flag_debug_asm && comment)
 178     {
 179       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
 180       vfprintf (asm_out_file, comment, ap);
 181     }
 182   fputc ('\n', asm_out_file);
 183
 184   va_end (ap);
 185 }
 186
 187 /* Output a section-relative reference to a label.  In general this
 188    can only be done for debugging symbols.  E.g. on most targets with
 189    the GNU linker, this is accomplished with a direct reference and
 190    the knowledge that the debugging section will be placed at VMA 0.
 191    Some targets have special relocations for this that we must use.  */
 192
 193 void
 194 dw2_asm_output_offset VPARAMS ((int size, const char *label,
 195                                const char *comment, ...))
 196 {
 197 #ifndef ANSI_PROTOTYPES
 198   int size;
 199   const char *label;
 200   const char *comment;
 201 #endif
 202   va_list ap;
 203
 204   VA_START (ap, comment);
 205
 206 #ifndef ANSI_PROTOTYPES
 207   size = va_arg (ap, int);
 208   label = va_arg (ap, const char *);
 209   comment = va_arg (ap, const char *);
 210 #endif
 211
 212 #ifdef ASM_OUTPUT_DWARF_OFFSET
 213   ASM_OUTPUT_DWARF_OFFSET (asm_out_file, size, label);
 214 #else
 215 #ifdef UNALIGNED_INT_ASM_OP
 216   fputs (unaligned_integer_asm_op (size), asm_out_file);
 217   assemble_name (asm_out_file, label);
 218 #else
 219   assemble_integer (gen_rtx_SYMBOL_REF (Pmode, label), size, 1);
 220 #endif
 221 #endif
 222
 223   if (flag_debug_asm && comment)
 224     {
 225       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
 226       vfprintf (asm_out_file, comment, ap);
 227     }
 228   fputc ('\n', asm_out_file);
 229
 230   va_end (ap);
 231 }
 232
 233 /* Output a self-relative reference to a label, possibly in a
 234    different section or object file.  */
 235
 236 void
 237 dw2_asm_output_pcrel VPARAMS ((int size, const char *label,
 238                                const char *comment, ...))
 239 {
 240 #ifndef ANSI_PROTOTYPES
 241   int size;
 242   const char *label;
 243   const char *comment;
 244 #endif
 245   va_list ap;
 246
 247   VA_START (ap, comment);
 248
 249 #ifndef ANSI_PROTOTYPES
 250   size = va_arg (ap, int);
 251   label = va_arg (ap, const char *);
 252   comment = va_arg (ap, const char *);
 253 #endif
 254
 255 #ifdef ASM_OUTPUT_DWARF_PCREL
 256   ASM_OUTPUT_DWARF_PCREL (asm_out_file, size, label);
 257 #else
 258 #ifdef UNALIGNED_INT_ASM_OP
 259   fputs (unaligned_integer_asm_op (size), asm_out_file);
 260   assemble_name (asm_out_file, label);
 261   fputc ('-', asm_out_file);
 262   fputc ('.', asm_out_file);
 263 #else
 264   abort ();
 265 #endif
 266 #endif
 267
 268   if (flag_debug_asm && comment)
 269     {
 270       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
 271       vfprintf (asm_out_file, comment, ap);
 272     }
 273   fputc ('\n', asm_out_file);
 274
 275   va_end (ap);
 276 }
 277
 278 /* Output an absolute reference to a label.  */
 279
 280 void
 281 dw2_asm_output_addr VPARAMS ((int size, const char *label,
 282                               const char *comment, ...))
 283 {
 284 #ifndef ANSI_PROTOTYPES
 285   int size;
 286   const char *label;
 287   const char *comment;
 288 #endif
 289   va_list ap;
 290
 291   VA_START (ap, comment);
 292
 293 #ifndef ANSI_PROTOTYPES
 294   size = va_arg (ap, int);
 295   label = va_arg (ap, const char *);
 296   comment = va_arg (ap, const char *);
 297 #endif
 298
 299 #ifdef UNALIGNED_INT_ASM_OP
 300   fputs (unaligned_integer_asm_op (size), asm_out_file);
 301   assemble_name (asm_out_file, label);
 302 #else
 303   assemble_integer (gen_rtx_SYMBOL_REF (Pmode, label), size, 1);
 304 #endif
 305
 306   if (flag_debug_asm && comment)
 307     {
 308       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
 309       vfprintf (asm_out_file, comment, ap);
 310     }
 311   fputc ('\n', asm_out_file);
 312
 313   va_end (ap);
 314 }
 315
 316 /* Similar, but use an RTX expression instead of a text label.  */
 317
 318 void
 319 dw2_asm_output_addr_rtx VPARAMS ((int size, rtx addr,
 320                                   const char *comment, ...))
 321 {
 322 #ifndef ANSI_PROTOTYPES
 323   int size;
 324   rtx addr;
 325   const char *comment;
 326 #endif
 327   va_list ap;
 328
 329   VA_START (ap, comment);
 330
 331 #ifndef ANSI_PROTOTYPES
 332   size = va_arg (ap, int);
 333   addr = va_arg (ap, rtx);
 334   comment = va_arg (ap, const char *);
 335 #endif
 336
 337 #ifdef UNALIGNED_INT_ASM_OP
 338   fputs (unaligned_integer_asm_op (size), asm_out_file);
 339   output_addr_const (asm_out_file, addr);
 340 #else
 341   assemble_integer (addr, size, 1);
 342 #endif
 343
 344   if (flag_debug_asm && comment)
 345     {
 346       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
 347       vfprintf (asm_out_file, comment, ap);
 348     }
 349   fputc ('\n', asm_out_file);
 350
 351   va_end (ap);
 352 }
 353
 354 void
 355 dw2_asm_output_nstring VPARAMS ((const char *str, size_t orig_len,
 356                                  const char *comment, ...))
 357 {
 358 #ifndef ANSI_PROTOTYPES
 359   const char *str;
 360   size_t orig_len;
 361   const char *comment;
 362 #endif
 363   va_list ap;
 364   size_t i, len = orig_len;
 365
 366   VA_START (ap, comment);
 367
 368 #ifndef ANSI_PROTOTYPES
 369   str = va_arg (ap, const char *);
 370   len = va_arg (ap, size_t);
 371   comment = va_arg (ap, const char *);
 372 #endif
 373
 374   if (len == (size_t) -1)
 375     len = strlen (str);
 376
 377   if (flag_debug_asm && comment)
 378     {
 379       fputs ("\t.ascii \"", asm_out_file);
 380       for (i = 0; i < len; i++)
 381         {
 382           int c = str[i];
 383           if (c == '\"' || c == '\\')
 384             fputc ('\\', asm_out_file);
 385           if (ISPRINT(c))
 386             fputc (c, asm_out_file);
 387           else
 388             fprintf (asm_out_file, "\\%o", c);
 389         }
 390       fprintf (asm_out_file, "\\0\"\t%s ", ASM_COMMENT_START);
 391       vfprintf (asm_out_file, comment, ap);
 392       fputc ('\n', asm_out_file);
 393     }
 394   else
 395     {
 396       /* If an explicit length was given, we can't assume there
 397          is a null termination in the string buffer.  */
 398       if (orig_len == (size_t) -1)
 399         len += 1;
 400       ASM_OUTPUT_ASCII (asm_out_file, str, len);
 401       if (orig_len != (size_t) -1)
 402         fprintf (asm_out_file, "%s0\n", ASM_BYTE_OP);
 403     }
 404
 405   va_end (ap);
 406 }
 407 \f
 408
 409 /* Return the size of an unsigned LEB128 quantity.  */
 410
 411 int
 412 size_of_uleb128 (value)
 413      unsigned HOST_WIDE_INT value;
 414 {
 415   int size = 0, byte;
 416
 417   do
 418     {
 419       byte = (value & 0x7f);
 420       value >>= 7;
 421       size += 1;
 422     }
 423   while (value != 0);
 424
 425   return size;
 426 }
 427
 428 /* Return the size of a signed LEB128 quantity.  */
 429
 430 int
 431 size_of_sleb128 (value)
 432      HOST_WIDE_INT value;
 433 {
 434   int size = 0, byte;
 435
 436   do
 437     {
 438       byte = (value & 0x7f);
 439       value >>= 7;
 440       size += 1;
 441     }
 442   while (!((value == 0 && (byte & 0x40) == 0)
 443            || (value == -1 && (byte & 0x40) != 0)));
 444
 445   return size;
 446 }
 447
 448 /* Given an encoding, return the number of bytes the format occupies.
 449    This is only defined for fixed-size encodings, and so does not
 450    include leb128.  */
 451
 452 int
 453 size_of_encoded_value (encoding)
 454      int encoding;
 455 {
 456   if (encoding == DW_EH_PE_omit)
 457     return 0;
 458
 459   switch (encoding & 0x07)
 460     {
 461     case DW_EH_PE_absptr:
 462       return POINTER_SIZE / BITS_PER_UNIT;
 463     case DW_EH_PE_udata2:
 464       return 2;
 465     case DW_EH_PE_udata4:
 466       return 4;
 467     case DW_EH_PE_udata8:
 468       return 8;
 469     }
 470   abort ();
 471 }
 472
 473 /* Output an unsigned LEB128 quantity.  */
 474
 475 void
 476 dw2_asm_output_data_uleb128 VPARAMS ((unsigned HOST_WIDE_INT value,
 477                                       const char *comment, ...))
 478 {
 479 #ifndef ANSI_PROTOTYPES
 480   unsigned HOST_WIDE_INT value;
 481   const char *comment;
 482 #endif
 483   va_list ap;
 484
 485   VA_START (ap, comment);
 486
 487 #ifndef ANSI_PROTOTYPES
 488   value = va_arg (ap, unsigned HOST_WIDE_INT);
 489   comment = va_arg (ap, const char *);
 490 #endif
 491
 492 #ifdef HAVE_AS_LEB128
 493   fputs ("\t.uleb128 ", asm_out_file);
 494   fprintf (asm_out_file, HOST_WIDE_INT_PRINT_HEX, value);
 495
 496   if (flag_debug_asm && comment)
 497     {
 498       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
 499       vfprintf (asm_out_file, comment, ap);
 500     }
 501 #else
 502   {
 503     unsigned HOST_WIDE_INT work = value;
 504
 505     fputs (ASM_BYTE_OP, asm_out_file);
 506     do
 507       {
 508         int byte = (work & 0x7f);
 509         work >>= 7;
 510         if (work != 0)
 511           /* More bytes to follow.  */
 512           byte |= 0x80;
 513
 514         fprintf (asm_out_file, "0x%x", byte);
 515         if (work != 0)
 516           fputc (',', asm_out_file);
 517       }
 518     while (work != 0);
 519
 520   if (flag_debug_asm)
 521     {
 522       fprintf (asm_out_file, "\t%s uleb128 ", ASM_COMMENT_START);
 523       fprintf (asm_out_file, HOST_WIDE_INT_PRINT_HEX, value);
 524       if (comment)
 525         {
 526           fputs ("; ", asm_out_file);
 527           vfprintf (asm_out_file, comment, ap);
 528         }
 529     }
 530   }
 531 #endif
 532   fputc ('\n', asm_out_file);
 533
 534   va_end (ap);
 535 }
 536
 537 /* Output an signed LEB128 quantity.  */
 538
 539 void
 540 dw2_asm_output_data_sleb128 VPARAMS ((HOST_WIDE_INT value,
 541                                       const char *comment, ...))
 542 {
 543 #ifndef ANSI_PROTOTYPES
 544   HOST_WIDE_INT value;
 545   const char *comment;
 546 #endif
 547   va_list ap;
 548
 549   VA_START (ap, comment);
 550
 551 #ifndef ANSI_PROTOTYPES
 552   value = va_arg (ap, HOST_WIDE_INT);
 553   comment = va_arg (ap, const char *);
 554 #endif
 555
 556 #ifdef HAVE_AS_LEB128
 557   fputs ("\t.sleb128 ", asm_out_file);
 558   fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC, value);
 559
 560   if (flag_debug_asm && comment)
 561     {
 562       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
 563       vfprintf (asm_out_file, comment, ap);
 564     }
 565 #else
 566   {
 567     HOST_WIDE_INT work = value;
 568     int more, byte;
 569
 570     fputs (ASM_BYTE_OP, asm_out_file);
 571     do
 572       {
 573         byte = (work & 0x7f);
 574         /* arithmetic shift */
 575         work >>= 7;
 576         more = !((work == 0 && (byte & 0x40) == 0)
 577                  || (work == -1 && (byte & 0x40) != 0));
 578         if (more)
 579           byte |= 0x80;
 580
 581         fprintf (asm_out_file, "0x%x", byte);
 582         if (more)
 583           fputc (',', asm_out_file);
 584       }
 585     while (more);
 586
 587   if (flag_debug_asm)
 588     {
 589       fprintf (asm_out_file, "\t%s sleb128 ", ASM_COMMENT_START);
 590       fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC, value);
 591       if (comment)
 592         {
 593           fputs ("; ", asm_out_file);
 594           vfprintf (asm_out_file, comment, ap);
 595         }
 596     }
 597   }
 598 #endif
 599   fputc ('\n', asm_out_file);
 600
 601   va_end (ap);
 602 }
 603
 604 void
 605 dw2_asm_output_delta_uleb128 VPARAMS ((const char *lab1 ATTRIBUTE_UNUSED,
 606                                        const char *lab2 ATTRIBUTE_UNUSED,
 607                                        const char *comment, ...))
 608 {
 609 #ifndef ANSI_PROTOTYPES
 610   const char *lab1, *lab2;
 611   const char *comment;
 612 #endif
 613   va_list ap;
 614
 615   VA_START (ap, comment);
 616
 617 #ifndef ANSI_PROTOTYPES
 618   lab1 = va_arg (ap, const char *);
 619   lab2 = va_arg (ap, const char *);
 620   comment = va_arg (ap, const char *);
 621 #endif
 622
 623 #ifdef HAVE_AS_LEB128
 624   fputs ("\t.uleb128 ", asm_out_file);
 625   assemble_name (asm_out_file, lab1);
 626   fputc ('-', asm_out_file);
 627   assemble_name (asm_out_file, lab2);
 628 #else
 629   abort ();
 630 #endif
 631
 632   if (flag_debug_asm && comment)
 633     {
 634       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
 635       vfprintf (asm_out_file, comment, ap);
 636     }
 637   fputc ('\n', asm_out_file);
 638
 639   va_end (ap);
 640 }
 641
 642 void
 643 dw2_asm_output_delta_sleb128 VPARAMS ((const char *lab1 ATTRIBUTE_UNUSED,
 644                                        const char *lab2 ATTRIBUTE_UNUSED,
 645                                        const char *comment, ...))
 646 {
 647 #ifndef ANSI_PROTOTYPES
 648   const char *lab1, *lab2;
 649   const char *comment;
 650 #endif
 651   va_list ap;
 652
 653   VA_START (ap, comment);
 654
 655 #ifndef ANSI_PROTOTYPES
 656   lab1 = va_arg (ap, const char *);
 657   lab2 = va_arg (ap, const char *);
 658   comment = va_arg (ap, const char *);
 659 #endif
 660
 661 #ifdef HAVE_AS_LEB128
 662   fputs ("\t.sleb128 ", asm_out_file);
 663   assemble_name (asm_out_file, lab1);
 664   fputc ('-', asm_out_file);
 665   assemble_name (asm_out_file, lab2);
 666 #else
 667   abort ();
 668 #endif
 669
 670   if (flag_debug_asm && comment)
 671     {
 672       fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
 673       vfprintf (asm_out_file, comment, ap);
 674     }
 675   fputc ('\n', asm_out_file);
 676
 677   va_end (ap);
 678 }
 679 \f
 680 static rtx dw2_force_const_mem PARAMS ((rtx));
 681 static int dw2_output_indirect_constant_1 PARAMS ((splay_tree_node, void *));
 682
 683 static splay_tree indirect_pool;
 684
 685 static rtx
 686 dw2_force_const_mem (x)
 687      rtx x;
 688 {
 689   splay_tree_node node;
 690   const char *const_sym;
 691
 692   if (! indirect_pool)
 693     indirect_pool = splay_tree_new (splay_tree_compare_pointers, NULL, NULL);
 694
 695   if (GET_CODE (x) != SYMBOL_REF)
 696     abort ();
 697   node = splay_tree_lookup (indirect_pool, (splay_tree_key) XSTR (x, 0));
 698   if (node)
 699     const_sym = (const char *) node->value;
 700   else
 701     {
 702       extern int const_labelno;
 703       char label[32];
 704       tree id;
 705
 706       ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
 707       ++const_labelno;
 708       const_sym = ggc_strdup (label);
 709
 710       id = maybe_get_identifier (XSTR (x, 0));
 711       if (id)
 712         TREE_SYMBOL_REFERENCED (id) = 1;
 713
 714       splay_tree_insert (indirect_pool, (splay_tree_key) XSTR (x, 0),
 715                          (splay_tree_value) const_sym);
 716     }
 717
 718   return gen_rtx_SYMBOL_REF (Pmode, const_sym);
 719 }
 720
 721 static int
 722 dw2_output_indirect_constant_1 (node, data)
 723      splay_tree_node node;
 724      void* data ATTRIBUTE_UNUSED;
 725 {
 726   const char *label, *sym;
 727   rtx sym_ref;
 728
 729   label = (const char *) node->value;
 730   sym = (const char *) node->key;
 731   sym_ref = gen_rtx_SYMBOL_REF (Pmode, sym);
 732
 733   ASM_OUTPUT_LABEL (asm_out_file, label);
 734   assemble_integer (sym_ref, POINTER_SIZE / BITS_PER_UNIT, 1);
 735
 736   return 0;
 737 }
 738
 739 void
 740 dw2_output_indirect_constants ()
 741 {
 742   if (! indirect_pool)
 743     return;
 744
 745   /* Assume that the whole reason we're emitting these symbol references
 746      indirectly is that they contain dynamic relocations, and are thus
 747      read-write.  If there was no possibility of a dynamic relocation, we
 748      might as well have used a direct relocation.  */
 749   data_section ();
 750
 751   /* Everything we're emitting is a pointer.  Align appropriately.  */
 752   assemble_align (POINTER_SIZE);
 753
 754   splay_tree_foreach (indirect_pool, dw2_output_indirect_constant_1, NULL);
 755 }
 756
 757 void
 758 dw2_asm_output_encoded_addr_rtx (encoding, addr)
 759      int encoding;
 760      rtx addr;
 761 {
 762   int size;
 763
 764   switch (encoding & 0x07)
 765     {
 766     case DW_EH_PE_absptr:
 767       size = POINTER_SIZE / BITS_PER_UNIT;
 768       break;
 769     case DW_EH_PE_udata2:
 770       size = 2;
 771       break;
 772     case DW_EH_PE_udata4:
 773       size = 4;
 774       break;
 775     case DW_EH_PE_udata8:
 776       size = 8;
 777       break;
 778     default:
 779       abort ();
 780     }
 781
 782   /* NULL is _always_ represented as a plain zero.  */
 783   if (addr == const0_rtx)
 784     {
 785       assemble_integer (addr, size, 1);
 786       return;
 787     }
 788
 789  restart:
 790
 791   /* Allow the target first crack at emitting this.  Some of the
 792      special relocations require special directives instead of
 793      just ".4byte" or whatever.  */
 794 #ifdef ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX
 795   ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX(asm_out_file, encoding, size, addr, done);
 796 #endif
 797
 798   /* Indirection is used to get dynamic relocations out of a read-only
 799      section.  */
 800   if (encoding & DW_EH_PE_indirect)
 801     {
 802       /* It is very tempting to use force_const_mem so that we share data
 803          with the normal constant pool.  However, we've already emitted
 804          the constant pool for this function.  Moreover, we'd like to share
 805          these constants across the entire unit of translation, or better,
 806          across the entire application (or DSO).  */
 807       addr = dw2_force_const_mem (addr);
 808       encoding &= ~DW_EH_PE_indirect;
 809       goto restart;
 810     }
 811
 812   switch (encoding & 0xF0)
 813     {
 814     case DW_EH_PE_absptr:
 815 #ifdef UNALIGNED_INT_ASM_OP
 816       fputs (unaligned_integer_asm_op (size), asm_out_file);
 817       output_addr_const (asm_out_file, addr);
 818 #else
 819       assemble_integer (addr, size, 1);
 820 #endif
 821       break;
 822
 823     case DW_EH_PE_pcrel:
 824       if (GET_CODE (addr) != SYMBOL_REF)
 825         abort ();
 826 #ifdef ASM_OUTPUT_DWARF_PCREL
 827       ASM_OUTPUT_DWARF_PCREL (asm_out_file, size, XSTR (addr, 0));
 828 #else
 829 #ifdef UNALIGNED_INT_ASM_OP
 830       fputs (unaligned_integer_asm_op (size), asm_out_file);
 831       assemble_name (asm_out_file, XSTR (addr, 0));
 832       fputc ('-', asm_out_file);
 833       fputc ('.', asm_out_file);
 834 #else
 835       abort ();
 836 #endif
 837 #endif
 838       break;
 839
 840     default:
 841       /* Other encodings should have been handled by
 842          ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX.  */
 843       abort ();
 844     }
 845
 846 #ifdef ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX
 847  done:
 848 #endif
 849   fputc ('\n', asm_out_file);
 850 }