LCOV - code coverage report
Current view: top level - gcc - dwarf2asm.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 295 406 72.7 %
Date: 2020-03-28 11:57:23 Functions: 23 24 95.8 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

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

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.