LCOV - code coverage report
Current view: top level - gcc - dwarf2out.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 11635 14439 80.6 %
Date: 2020-04-04 11:58:09 Functions: 478 545 87.7 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Output Dwarf2 format symbol table information from GCC.
       2                 :            :    Copyright (C) 1992-2020 Free Software Foundation, Inc.
       3                 :            :    Contributed by Gary Funck (gary@intrepid.com).
       4                 :            :    Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
       5                 :            :    Extensively modified by Jason Merrill (jason@cygnus.com).
       6                 :            : 
       7                 :            : This file is part of GCC.
       8                 :            : 
       9                 :            : GCC is free software; you can redistribute it and/or modify it under
      10                 :            : the terms of the GNU General Public License as published by the Free
      11                 :            : Software Foundation; either version 3, or (at your option) any later
      12                 :            : version.
      13                 :            : 
      14                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      15                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      16                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      17                 :            : for more details.
      18                 :            : 
      19                 :            : You should have received a copy of the GNU General Public License
      20                 :            : along with GCC; see the file COPYING3.  If not see
      21                 :            : <http://www.gnu.org/licenses/>.  */
      22                 :            : 
      23                 :            : /* TODO: Emit .debug_line header even when there are no functions, since
      24                 :            :            the file numbers are used by .debug_info.  Alternately, leave
      25                 :            :            out locations for types and decls.
      26                 :            :          Avoid talking about ctors and op= for PODs.
      27                 :            :          Factor out common prologue sequences into multiple CIEs.  */
      28                 :            : 
      29                 :            : /* The first part of this file deals with the DWARF 2 frame unwind
      30                 :            :    information, which is also used by the GCC efficient exception handling
      31                 :            :    mechanism.  The second part, controlled only by an #ifdef
      32                 :            :    DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
      33                 :            :    information.  */
      34                 :            : 
      35                 :            : /* DWARF2 Abbreviation Glossary:
      36                 :            : 
      37                 :            :    CFA = Canonical Frame Address
      38                 :            :            a fixed address on the stack which identifies a call frame.
      39                 :            :            We define it to be the value of SP just before the call insn.
      40                 :            :            The CFA register and offset, which may change during the course
      41                 :            :            of the function, are used to calculate its value at runtime.
      42                 :            : 
      43                 :            :    CFI = Call Frame Instruction
      44                 :            :            an instruction for the DWARF2 abstract machine
      45                 :            : 
      46                 :            :    CIE = Common Information Entry
      47                 :            :            information describing information common to one or more FDEs
      48                 :            : 
      49                 :            :    DIE = Debugging Information Entry
      50                 :            : 
      51                 :            :    FDE = Frame Description Entry
      52                 :            :            information describing the stack call frame, in particular,
      53                 :            :            how to restore registers
      54                 :            : 
      55                 :            :    DW_CFA_... = DWARF2 CFA call frame instruction
      56                 :            :    DW_TAG_... = DWARF2 DIE tag */
      57                 :            : 
      58                 :            : #include "config.h"
      59                 :            : #include "system.h"
      60                 :            : #include "coretypes.h"
      61                 :            : #include "target.h"
      62                 :            : #include "function.h"
      63                 :            : #include "rtl.h"
      64                 :            : #include "tree.h"
      65                 :            : #include "memmodel.h"
      66                 :            : #include "tm_p.h"
      67                 :            : #include "stringpool.h"
      68                 :            : #include "insn-config.h"
      69                 :            : #include "ira.h"
      70                 :            : #include "cgraph.h"
      71                 :            : #include "diagnostic.h"
      72                 :            : #include "fold-const.h"
      73                 :            : #include "stor-layout.h"
      74                 :            : #include "varasm.h"
      75                 :            : #include "version.h"
      76                 :            : #include "flags.h"
      77                 :            : #include "rtlhash.h"
      78                 :            : #include "reload.h"
      79                 :            : #include "output.h"
      80                 :            : #include "expr.h"
      81                 :            : #include "dwarf2out.h"
      82                 :            : #include "dwarf2asm.h"
      83                 :            : #include "toplev.h"
      84                 :            : #include "md5.h"
      85                 :            : #include "tree-pretty-print.h"
      86                 :            : #include "print-rtl.h"
      87                 :            : #include "debug.h"
      88                 :            : #include "common/common-target.h"
      89                 :            : #include "langhooks.h"
      90                 :            : #include "lra.h"
      91                 :            : #include "dumpfile.h"
      92                 :            : #include "opts.h"
      93                 :            : #include "tree-dfa.h"
      94                 :            : #include "gdb/gdb-index.h"
      95                 :            : #include "rtl-iter.h"
      96                 :            : #include "stringpool.h"
      97                 :            : #include "attribs.h"
      98                 :            : #include "file-prefix-map.h" /* remap_debug_filename()  */
      99                 :            : 
     100                 :            : static void dwarf2out_source_line (unsigned int, unsigned int, const char *,
     101                 :            :                                    int, bool);
     102                 :            : static rtx_insn *last_var_location_insn;
     103                 :            : static rtx_insn *cached_next_real_insn;
     104                 :            : static void dwarf2out_decl (tree);
     105                 :            : static bool is_redundant_typedef (const_tree);
     106                 :            : 
     107                 :            : #ifndef XCOFF_DEBUGGING_INFO
     108                 :            : #define XCOFF_DEBUGGING_INFO 0
     109                 :            : #endif
     110                 :            : 
     111                 :            : #ifndef HAVE_XCOFF_DWARF_EXTRAS
     112                 :            : #define HAVE_XCOFF_DWARF_EXTRAS 0
     113                 :            : #endif
     114                 :            : 
     115                 :            : #ifdef VMS_DEBUGGING_INFO
     116                 :            : int vms_file_stats_name (const char *, long long *, long *, char *, int *);
     117                 :            : 
     118                 :            : /* Define this macro to be a nonzero value if the directory specifications
     119                 :            :     which are output in the debug info should end with a separator.  */
     120                 :            : #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1
     121                 :            : /* Define this macro to evaluate to a nonzero value if GCC should refrain
     122                 :            :    from generating indirect strings in DWARF2 debug information, for instance
     123                 :            :    if your target is stuck with an old version of GDB that is unable to
     124                 :            :    process them properly or uses VMS Debug.  */
     125                 :            : #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1
     126                 :            : #else
     127                 :            : #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0
     128                 :            : #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0
     129                 :            : #endif
     130                 :            : 
     131                 :            : /* ??? Poison these here until it can be done generically.  They've been
     132                 :            :    totally replaced in this file; make sure it stays that way.  */
     133                 :            : #undef DWARF2_UNWIND_INFO
     134                 :            : #undef DWARF2_FRAME_INFO
     135                 :            : #if (GCC_VERSION >= 3000)
     136                 :            :  #pragma GCC poison DWARF2_UNWIND_INFO DWARF2_FRAME_INFO
     137                 :            : #endif
     138                 :            : 
     139                 :            : /* The size of the target's pointer type.  */
     140                 :            : #ifndef PTR_SIZE
     141                 :            : #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
     142                 :            : #endif
     143                 :            : 
     144                 :            : /* Array of RTXes referenced by the debugging information, which therefore
     145                 :            :    must be kept around forever.  */
     146                 :            : static GTY(()) vec<rtx, va_gc> *used_rtx_array;
     147                 :            : 
     148                 :            : /* A pointer to the base of a list of incomplete types which might be
     149                 :            :    completed at some later time.  incomplete_types_list needs to be a
     150                 :            :    vec<tree, va_gc> *because we want to tell the garbage collector about
     151                 :            :    it.  */
     152                 :            : static GTY(()) vec<tree, va_gc> *incomplete_types;
     153                 :            : 
     154                 :            : /* Pointers to various DWARF2 sections.  */
     155                 :            : static GTY(()) section *debug_info_section;
     156                 :            : static GTY(()) section *debug_skeleton_info_section;
     157                 :            : static GTY(()) section *debug_abbrev_section;
     158                 :            : static GTY(()) section *debug_skeleton_abbrev_section;
     159                 :            : static GTY(()) section *debug_aranges_section;
     160                 :            : static GTY(()) section *debug_addr_section;
     161                 :            : static GTY(()) section *debug_macinfo_section;
     162                 :            : static const char *debug_macinfo_section_name;
     163                 :            : static unsigned macinfo_label_base = 1;
     164                 :            : static GTY(()) section *debug_line_section;
     165                 :            : static GTY(()) section *debug_skeleton_line_section;
     166                 :            : static GTY(()) section *debug_loc_section;
     167                 :            : static GTY(()) section *debug_pubnames_section;
     168                 :            : static GTY(()) section *debug_pubtypes_section;
     169                 :            : static GTY(()) section *debug_str_section;
     170                 :            : static GTY(()) section *debug_line_str_section;
     171                 :            : static GTY(()) section *debug_str_dwo_section;
     172                 :            : static GTY(()) section *debug_str_offsets_section;
     173                 :            : static GTY(()) section *debug_ranges_section;
     174                 :            : static GTY(()) section *debug_frame_section;
     175                 :            : 
     176                 :            : /* Maximum size (in bytes) of an artificially generated label.  */
     177                 :            : #define MAX_ARTIFICIAL_LABEL_BYTES      40
     178                 :            : 
     179                 :            : /* According to the (draft) DWARF 3 specification, the initial length
     180                 :            :    should either be 4 or 12 bytes.  When it's 12 bytes, the first 4
     181                 :            :    bytes are 0xffffffff, followed by the length stored in the next 8
     182                 :            :    bytes.
     183                 :            : 
     184                 :            :    However, the SGI/MIPS ABI uses an initial length which is equal to
     185                 :            :    DWARF_OFFSET_SIZE.  It is defined (elsewhere) accordingly.  */
     186                 :            : 
     187                 :            : #ifndef DWARF_INITIAL_LENGTH_SIZE
     188                 :            : #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
     189                 :            : #endif
     190                 :            : 
     191                 :            : #ifndef DWARF_INITIAL_LENGTH_SIZE_STR
     192                 :            : #define DWARF_INITIAL_LENGTH_SIZE_STR (DWARF_OFFSET_SIZE == 4 ? "-4" : "-12")
     193                 :            : #endif
     194                 :            : 
     195                 :            : /* Round SIZE up to the nearest BOUNDARY.  */
     196                 :            : #define DWARF_ROUND(SIZE,BOUNDARY) \
     197                 :            :   ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
     198                 :            : 
     199                 :            : /* CIE identifier.  */
     200                 :            : #if HOST_BITS_PER_WIDE_INT >= 64
     201                 :            : #define DWARF_CIE_ID \
     202                 :            :   (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
     203                 :            : #else
     204                 :            : #define DWARF_CIE_ID DW_CIE_ID
     205                 :            : #endif
     206                 :            : 
     207                 :            : 
     208                 :            : /* A vector for a table that contains frame description
     209                 :            :    information for each routine.  */
     210                 :            : #define NOT_INDEXED (-1U)
     211                 :            : #define NO_INDEX_ASSIGNED (-2U)
     212                 :            : 
     213                 :            : static GTY(()) vec<dw_fde_ref, va_gc> *fde_vec;
     214                 :            : 
     215                 :            : struct GTY((for_user)) indirect_string_node {
     216                 :            :   const char *str;
     217                 :            :   unsigned int refcount;
     218                 :            :   enum dwarf_form form;
     219                 :            :   char *label;
     220                 :            :   unsigned int index;
     221                 :            : };
     222                 :            : 
     223                 :            : struct indirect_string_hasher : ggc_ptr_hash<indirect_string_node>
     224                 :            : {
     225                 :            :   typedef const char *compare_type;
     226                 :            : 
     227                 :            :   static hashval_t hash (indirect_string_node *);
     228                 :            :   static bool equal (indirect_string_node *, const char *);
     229                 :            : };
     230                 :            : 
     231                 :            : static GTY (()) hash_table<indirect_string_hasher> *debug_str_hash;
     232                 :            : 
     233                 :            : static GTY (()) hash_table<indirect_string_hasher> *debug_line_str_hash;
     234                 :            : 
     235                 :            : /* With split_debug_info, both the comp_dir and dwo_name go in the
     236                 :            :    main object file, rather than the dwo, similar to the force_direct
     237                 :            :    parameter elsewhere but with additional complications:
     238                 :            : 
     239                 :            :    1) The string is needed in both the main object file and the dwo.
     240                 :            :    That is, the comp_dir and dwo_name will appear in both places.
     241                 :            : 
     242                 :            :    2) Strings can use four forms: DW_FORM_string, DW_FORM_strp,
     243                 :            :    DW_FORM_line_strp or DW_FORM_strx/GNU_str_index.
     244                 :            : 
     245                 :            :    3) GCC chooses the form to use late, depending on the size and
     246                 :            :    reference count.
     247                 :            : 
     248                 :            :    Rather than forcing the all debug string handling functions and
     249                 :            :    callers to deal with these complications, simply use a separate,
     250                 :            :    special-cased string table for any attribute that should go in the
     251                 :            :    main object file.  This limits the complexity to just the places
     252                 :            :    that need it.  */
     253                 :            : 
     254                 :            : static GTY (()) hash_table<indirect_string_hasher> *skeleton_debug_str_hash;
     255                 :            : 
     256                 :            : static GTY(()) int dw2_string_counter;
     257                 :            : 
     258                 :            : /* True if the compilation unit places functions in more than one section.  */
     259                 :            : static GTY(()) bool have_multiple_function_sections = false;
     260                 :            : 
     261                 :            : /* Whether the default text and cold text sections have been used at all.  */
     262                 :            : static GTY(()) bool text_section_used = false;
     263                 :            : static GTY(()) bool cold_text_section_used = false;
     264                 :            : 
     265                 :            : /* The default cold text section.  */
     266                 :            : static GTY(()) section *cold_text_section;
     267                 :            : 
     268                 :            : /* The DIE for C++14 'auto' in a function return type.  */
     269                 :            : static GTY(()) dw_die_ref auto_die;
     270                 :            : 
     271                 :            : /* The DIE for C++14 'decltype(auto)' in a function return type.  */
     272                 :            : static GTY(()) dw_die_ref decltype_auto_die;
     273                 :            : 
     274                 :            : /* Forward declarations for functions defined in this file.  */
     275                 :            : 
     276                 :            : static void output_call_frame_info (int);
     277                 :            : static void dwarf2out_note_section_used (void);
     278                 :            : 
     279                 :            : /* Personality decl of current unit.  Used only when assembler does not support
     280                 :            :    personality CFI.  */
     281                 :            : static GTY(()) rtx current_unit_personality;
     282                 :            : 
     283                 :            : /* Whether an eh_frame section is required.  */
     284                 :            : static GTY(()) bool do_eh_frame = false;
     285                 :            : 
     286                 :            : /* .debug_rnglists next index.  */
     287                 :            : static unsigned int rnglist_idx;
     288                 :            : 
     289                 :            : /* Data and reference forms for relocatable data.  */
     290                 :            : #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
     291                 :            : #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
     292                 :            : 
     293                 :            : #ifndef DEBUG_FRAME_SECTION
     294                 :            : #define DEBUG_FRAME_SECTION     ".debug_frame"
     295                 :            : #endif
     296                 :            : 
     297                 :            : #ifndef FUNC_BEGIN_LABEL
     298                 :            : #define FUNC_BEGIN_LABEL        "LFB"
     299                 :            : #endif
     300                 :            : 
     301                 :            : #ifndef FUNC_SECOND_SECT_LABEL
     302                 :            : #define FUNC_SECOND_SECT_LABEL  "LFSB"
     303                 :            : #endif
     304                 :            : 
     305                 :            : #ifndef FUNC_END_LABEL
     306                 :            : #define FUNC_END_LABEL          "LFE"
     307                 :            : #endif
     308                 :            : 
     309                 :            : #ifndef PROLOGUE_END_LABEL
     310                 :            : #define PROLOGUE_END_LABEL      "LPE"
     311                 :            : #endif
     312                 :            : 
     313                 :            : #ifndef EPILOGUE_BEGIN_LABEL
     314                 :            : #define EPILOGUE_BEGIN_LABEL    "LEB"
     315                 :            : #endif
     316                 :            : 
     317                 :            : #ifndef FRAME_BEGIN_LABEL
     318                 :            : #define FRAME_BEGIN_LABEL       "Lframe"
     319                 :            : #endif
     320                 :            : #define CIE_AFTER_SIZE_LABEL    "LSCIE"
     321                 :            : #define CIE_END_LABEL           "LECIE"
     322                 :            : #define FDE_LABEL               "LSFDE"
     323                 :            : #define FDE_AFTER_SIZE_LABEL    "LASFDE"
     324                 :            : #define FDE_END_LABEL           "LEFDE"
     325                 :            : #define LINE_NUMBER_BEGIN_LABEL "LSLT"
     326                 :            : #define LINE_NUMBER_END_LABEL   "LELT"
     327                 :            : #define LN_PROLOG_AS_LABEL      "LASLTP"
     328                 :            : #define LN_PROLOG_END_LABEL     "LELTP"
     329                 :            : #define DIE_LABEL_PREFIX        "DW"
     330                 :            : 
     331                 :            : /* Match the base name of a file to the base name of a compilation unit. */
     332                 :            : 
     333                 :            : static int
     334                 :        761 : matches_main_base (const char *path)
     335                 :            : {
     336                 :            :   /* Cache the last query. */
     337                 :        761 :   static const char *last_path = NULL;
     338                 :        761 :   static int last_match = 0;
     339                 :        761 :   if (path != last_path)
     340                 :            :     {
     341                 :        139 :       const char *base;
     342                 :        139 :       int length = base_of_path (path, &base);
     343                 :        139 :       last_path = path;
     344                 :        278 :       last_match = (length == main_input_baselength
     345                 :        221 :                     && memcmp (base, main_input_basename, length) == 0);
     346                 :            :     }
     347                 :        761 :   return last_match;
     348                 :            : }
     349                 :            : 
     350                 :            : #ifdef DEBUG_DEBUG_STRUCT
     351                 :            : 
     352                 :            : static int
     353                 :            : dump_struct_debug (tree type, enum debug_info_usage usage,
     354                 :            :                    enum debug_struct_file criterion, int generic,
     355                 :            :                    int matches, int result)
     356                 :            : {
     357                 :            :   /* Find the type name. */
     358                 :            :   tree type_decl = TYPE_STUB_DECL (type);
     359                 :            :   tree t = type_decl;
     360                 :            :   const char *name = 0;
     361                 :            :   if (TREE_CODE (t) == TYPE_DECL)
     362                 :            :     t = DECL_NAME (t);
     363                 :            :   if (t)
     364                 :            :     name = IDENTIFIER_POINTER (t);
     365                 :            : 
     366                 :            :   fprintf (stderr, "       struct %d %s %s %s %s %d %p %s\n",
     367                 :            :            criterion,
     368                 :            :            DECL_IN_SYSTEM_HEADER (type_decl) ? "sys" : "usr",
     369                 :            :            matches ? "bas" : "hdr",
     370                 :            :            generic ? "gen" : "ord",
     371                 :            :            usage == DINFO_USAGE_DFN ? ";" :
     372                 :            :              usage == DINFO_USAGE_DIR_USE ? "." : "*",
     373                 :            :            result,
     374                 :            :            (void*) type_decl, name);
     375                 :            :   return result;
     376                 :            : }
     377                 :            : #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
     378                 :            :   dump_struct_debug (type, usage, criterion, generic, matches, result)
     379                 :            : 
     380                 :            : #else
     381                 :            : 
     382                 :            : #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
     383                 :            :   (result)
     384                 :            : 
     385                 :            : #endif
     386                 :            : 
     387                 :            : /* Get the number of HOST_WIDE_INTs needed to represent the precision
     388                 :            :    of the number.  Some constants have a large uniform precision, so
     389                 :            :    we get the precision needed for the actual value of the number.  */
     390                 :            : 
     391                 :            : static unsigned int
     392                 :        704 : get_full_len (const wide_int &op)
     393                 :            : {
     394                 :          0 :   int prec = wi::min_precision (op, UNSIGNED);
     395                 :        704 :   return ((prec + HOST_BITS_PER_WIDE_INT - 1)
     396                 :        704 :           / HOST_BITS_PER_WIDE_INT);
     397                 :            : }
     398                 :            : 
     399                 :            : static bool
     400                 :   51562100 : should_emit_struct_debug (tree type, enum debug_info_usage usage)
     401                 :            : {
     402                 :   51562100 :   if (debug_info_level <= DINFO_LEVEL_TERSE)
     403                 :            :     return false;
     404                 :            : 
     405                 :   51562100 :   enum debug_struct_file criterion;
     406                 :   51562100 :   tree type_decl;
     407                 :   51562100 :   bool generic = lang_hooks.types.generic_p (type);
     408                 :            : 
     409                 :   51562100 :   if (generic)
     410                 :   45873900 :     criterion = debug_struct_generic[usage];
     411                 :            :   else
     412                 :    5688200 :     criterion = debug_struct_ordinary[usage];
     413                 :            : 
     414                 :   51562100 :   if (criterion == DINFO_STRUCT_FILE_NONE)
     415                 :            :     return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
     416                 :   51561800 :   if (criterion == DINFO_STRUCT_FILE_ANY)
     417                 :            :     return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
     418                 :            : 
     419                 :        786 :   type_decl = TYPE_STUB_DECL (TYPE_MAIN_VARIANT (type));
     420                 :            : 
     421                 :        786 :   if (type_decl != NULL)
     422                 :            :     {
     423                 :       1186 :      if (criterion == DINFO_STRUCT_FILE_SYS && DECL_IN_SYSTEM_HEADER (type_decl))
     424                 :            :         return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
     425                 :            : 
     426                 :        761 :       if (matches_main_base (DECL_SOURCE_FILE (type_decl)))
     427                 :        167 :         return DUMP_GSTRUCT (type, usage, criterion, generic, true, true);
     428                 :            :     }
     429                 :            : 
     430                 :            :   return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
     431                 :            : }
     432                 :            : 
     433                 :            : /* Switch [BACK] to eh_frame_section.  If we don't have an eh_frame_section,
     434                 :            :    switch to the data section instead, and write out a synthetic start label
     435                 :            :    for collect2 the first time around.  */
     436                 :            : 
     437                 :            : static void
     438                 :         28 : switch_to_eh_frame_section (bool back ATTRIBUTE_UNUSED)
     439                 :            : {
     440                 :         28 :   if (eh_frame_section == 0)
     441                 :            :     {
     442                 :         28 :       int flags;
     443                 :            : 
     444                 :         28 :       if (EH_TABLES_CAN_BE_READ_ONLY)
     445                 :            :         {
     446                 :         28 :           int fde_encoding;
     447                 :         28 :           int per_encoding;
     448                 :         28 :           int lsda_encoding;
     449                 :            : 
     450                 :         28 :           fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
     451                 :            :                                                        /*global=*/0);
     452                 :         28 :           per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
     453                 :            :                                                        /*global=*/1);
     454                 :         28 :           lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
     455                 :            :                                                         /*global=*/0);
     456                 :         56 :           flags = ((! flag_pic
     457                 :          0 :                     || ((fde_encoding & 0x70) != DW_EH_PE_absptr
     458                 :          0 :                         && (fde_encoding & 0x70) != DW_EH_PE_aligned
     459                 :          0 :                         && (per_encoding & 0x70) != DW_EH_PE_absptr
     460                 :          0 :                         && (per_encoding & 0x70) != DW_EH_PE_aligned
     461                 :          0 :                         && (lsda_encoding & 0x70) != DW_EH_PE_absptr
     462                 :          0 :                         && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
     463                 :         28 :                    ? 0 : SECTION_WRITE);
     464                 :            :         }
     465                 :            :       else
     466                 :            :         flags = SECTION_WRITE;
     467                 :            : 
     468                 :            : #ifdef EH_FRAME_SECTION_NAME
     469                 :         28 :       eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL);
     470                 :            : #else
     471                 :            :       eh_frame_section = ((flags == SECTION_WRITE)
     472                 :            :                           ? data_section : readonly_data_section);
     473                 :            : #endif /* EH_FRAME_SECTION_NAME */
     474                 :            :     }
     475                 :            : 
     476                 :         28 :   switch_to_section (eh_frame_section);
     477                 :            : 
     478                 :            : #ifdef EH_FRAME_THROUGH_COLLECT2
     479                 :            :   /* We have no special eh_frame section.  Emit special labels to guide
     480                 :            :      collect2.  */
     481                 :            :   if (!back)
     482                 :            :     {
     483                 :            :       tree label = get_file_function_name ("F");
     484                 :            :       ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
     485                 :            :       targetm.asm_out.globalize_label (asm_out_file,
     486                 :            :                                         IDENTIFIER_POINTER (label));
     487                 :            :       ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
     488                 :            :     }
     489                 :            : #endif
     490                 :         28 : }
     491                 :            : 
     492                 :            : /* Switch [BACK] to the eh or debug frame table section, depending on
     493                 :            :    FOR_EH.  */
     494                 :            : 
     495                 :            : static void
     496                 :         37 : switch_to_frame_table_section (int for_eh, bool back)
     497                 :            : {
     498                 :         37 :   if (for_eh)
     499                 :         28 :     switch_to_eh_frame_section (back);
     500                 :            :   else
     501                 :            :     {
     502                 :          9 :       if (!debug_frame_section)
     503                 :          9 :         debug_frame_section = get_section (DEBUG_FRAME_SECTION,
     504                 :            :                                            SECTION_DEBUG, NULL);
     505                 :          9 :       switch_to_section (debug_frame_section);
     506                 :            :     }
     507                 :         37 : }
     508                 :            : 
     509                 :            : /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used.  */
     510                 :            : 
     511                 :            : enum dw_cfi_oprnd_type
     512                 :   34659700 : dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
     513                 :            : {
     514                 :   34659700 :   switch (cfi)
     515                 :            :     {
     516                 :            :     case DW_CFA_nop:
     517                 :            :     case DW_CFA_GNU_window_save:
     518                 :            :     case DW_CFA_remember_state:
     519                 :            :     case DW_CFA_restore_state:
     520                 :            :       return dw_cfi_oprnd_unused;
     521                 :            : 
     522                 :         24 :     case DW_CFA_set_loc:
     523                 :         24 :     case DW_CFA_advance_loc1:
     524                 :         24 :     case DW_CFA_advance_loc2:
     525                 :         24 :     case DW_CFA_advance_loc4:
     526                 :         24 :     case DW_CFA_MIPS_advance_loc8:
     527                 :         24 :       return dw_cfi_oprnd_addr;
     528                 :            : 
     529                 :    9837320 :     case DW_CFA_offset:
     530                 :    9837320 :     case DW_CFA_offset_extended:
     531                 :    9837320 :     case DW_CFA_def_cfa:
     532                 :    9837320 :     case DW_CFA_offset_extended_sf:
     533                 :    9837320 :     case DW_CFA_def_cfa_sf:
     534                 :    9837320 :     case DW_CFA_restore:
     535                 :    9837320 :     case DW_CFA_restore_extended:
     536                 :    9837320 :     case DW_CFA_undefined:
     537                 :    9837320 :     case DW_CFA_same_value:
     538                 :    9837320 :     case DW_CFA_def_cfa_register:
     539                 :    9837320 :     case DW_CFA_register:
     540                 :    9837320 :     case DW_CFA_expression:
     541                 :    9837320 :     case DW_CFA_val_expression:
     542                 :    9837320 :       return dw_cfi_oprnd_reg_num;
     543                 :            : 
     544                 :   22963000 :     case DW_CFA_def_cfa_offset:
     545                 :   22963000 :     case DW_CFA_GNU_args_size:
     546                 :   22963000 :     case DW_CFA_def_cfa_offset_sf:
     547                 :   22963000 :       return dw_cfi_oprnd_offset;
     548                 :            : 
     549                 :      15061 :     case DW_CFA_def_cfa_expression:
     550                 :      15061 :       return dw_cfi_oprnd_loc;
     551                 :            : 
     552                 :          0 :     default:
     553                 :          0 :       gcc_unreachable ();
     554                 :            :     }
     555                 :            : }
     556                 :            : 
     557                 :            : /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used.  */
     558                 :            : 
     559                 :            : enum dw_cfi_oprnd_type
     560                 :   34659700 : dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
     561                 :            : {
     562                 :   34659700 :   switch (cfi)
     563                 :            :     {
     564                 :            :     case DW_CFA_def_cfa:
     565                 :            :     case DW_CFA_def_cfa_sf:
     566                 :            :     case DW_CFA_offset:
     567                 :            :     case DW_CFA_offset_extended_sf:
     568                 :            :     case DW_CFA_offset_extended:
     569                 :            :       return dw_cfi_oprnd_offset;
     570                 :            : 
     571                 :          0 :     case DW_CFA_register:
     572                 :          0 :       return dw_cfi_oprnd_reg_num;
     573                 :            : 
     574                 :     212123 :     case DW_CFA_expression:
     575                 :     212123 :     case DW_CFA_val_expression:
     576                 :     212123 :       return dw_cfi_oprnd_loc;
     577                 :            : 
     578                 :      15061 :     case DW_CFA_def_cfa_expression:
     579                 :      15061 :       return dw_cfi_oprnd_cfa_loc;
     580                 :            : 
     581                 :   29277800 :     default:
     582                 :   29277800 :       return dw_cfi_oprnd_unused;
     583                 :            :     }
     584                 :            : }
     585                 :            : 
     586                 :            : /* Output one FDE.  */
     587                 :            : 
     588                 :            : static void
     589                 :        100 : output_fde (dw_fde_ref fde, bool for_eh, bool second,
     590                 :            :             char *section_start_label, int fde_encoding, char *augmentation,
     591                 :            :             bool any_lsda_needed, int lsda_encoding)
     592                 :            : {
     593                 :        100 :   const char *begin, *end;
     594                 :        100 :   static unsigned int j;
     595                 :        100 :   char l1[MAX_ARTIFICIAL_LABEL_BYTES], l2[MAX_ARTIFICIAL_LABEL_BYTES];
     596                 :            : 
     597                 :        100 :   targetm.asm_out.emit_unwind_label (asm_out_file, fde->decl, for_eh,
     598                 :            :                                      /* empty */ 0);
     599                 :        100 :   targetm.asm_out.internal_label (asm_out_file, FDE_LABEL,
     600                 :        100 :                                   for_eh + j);
     601                 :        100 :   ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + j);
     602                 :        100 :   ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + j);
     603                 :        100 :   if (!XCOFF_DEBUGGING_INFO || for_eh)
     604                 :            :     {
     605                 :        100 :       if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
     606                 :            :         dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
     607                 :            :                              " indicating 64-bit DWARF extension");
     608                 :        100 :       dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
     609                 :            :                             "FDE Length");
     610                 :            :     }
     611                 :        100 :   ASM_OUTPUT_LABEL (asm_out_file, l1);
     612                 :            : 
     613                 :        100 :   if (for_eh)
     614                 :         76 :     dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
     615                 :            :   else
     616                 :         24 :     dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
     617                 :            :                            debug_frame_section, "FDE CIE offset");
     618                 :            : 
     619                 :        100 :   begin = second ? fde->dw_fde_second_begin : fde->dw_fde_begin;
     620                 :        100 :   end = second ? fde->dw_fde_second_end : fde->dw_fde_end;
     621                 :            : 
     622                 :        100 :   if (for_eh)
     623                 :            :     {
     624                 :         76 :       rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, begin);
     625                 :         76 :       SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;
     626                 :         76 :       dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref, false,
     627                 :            :                                        "FDE initial location");
     628                 :         76 :       dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
     629                 :            :                             end, begin, "FDE address range");
     630                 :            :     }
     631                 :            :   else
     632                 :            :     {
     633                 :         24 :       dw2_asm_output_addr (DWARF2_ADDR_SIZE, begin, "FDE initial location");
     634                 :         24 :       dw2_asm_output_delta (DWARF2_ADDR_SIZE, end, begin, "FDE address range");
     635                 :            :     }
     636                 :            : 
     637                 :        100 :   if (augmentation[0])
     638                 :            :     {
     639                 :         76 :       if (any_lsda_needed)
     640                 :            :         {
     641                 :         76 :           int size = size_of_encoded_value (lsda_encoding);
     642                 :            : 
     643                 :         76 :           if (lsda_encoding == DW_EH_PE_aligned)
     644                 :            :             {
     645                 :          0 :               int offset = (  4         /* Length */
     646                 :            :                             + 4         /* CIE offset */
     647                 :          0 :                             + 2 * size_of_encoded_value (fde_encoding)
     648                 :          0 :                             + 1         /* Augmentation size */ );
     649                 :          0 :               int pad = -offset & (PTR_SIZE - 1);
     650                 :            : 
     651                 :          0 :               size += pad;
     652                 :          0 :               gcc_assert (size_of_uleb128 (size) == 1);
     653                 :            :             }
     654                 :            : 
     655                 :         76 :           dw2_asm_output_data_uleb128 (size, "Augmentation size");
     656                 :            : 
     657                 :         76 :           if (fde->uses_eh_lsda)
     658                 :            :             {
     659                 :         76 :               ASM_GENERATE_INTERNAL_LABEL (l1, second ? "LLSDAC" : "LLSDA",
     660                 :            :                                            fde->funcdef_number);
     661                 :         47 :               dw2_asm_output_encoded_addr_rtx (lsda_encoding,
     662                 :         47 :                                                gen_rtx_SYMBOL_REF (Pmode, l1),
     663                 :            :                                                false,
     664                 :            :                                                "Language Specific Data Area");
     665                 :            :             }
     666                 :            :           else
     667                 :            :             {
     668                 :         29 :               if (lsda_encoding == DW_EH_PE_aligned)
     669                 :          0 :                 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
     670                 :         29 :               dw2_asm_output_data (size_of_encoded_value (lsda_encoding), 0,
     671                 :            :                                    "Language Specific Data Area (none)");
     672                 :            :             }
     673                 :            :         }
     674                 :            :       else
     675                 :          0 :         dw2_asm_output_data_uleb128 (0, "Augmentation size");
     676                 :            :     }
     677                 :            : 
     678                 :            :   /* Loop through the Call Frame Instructions associated with this FDE.  */
     679                 :        100 :   fde->dw_fde_current_label = begin;
     680                 :        100 :   {
     681                 :        100 :     size_t from, until, i;
     682                 :            : 
     683                 :        100 :     from = 0;
     684                 :        100 :     until = vec_safe_length (fde->dw_fde_cfi);
     685                 :            : 
     686                 :        100 :     if (fde->dw_fde_second_begin == NULL)
     687                 :            :       ;
     688                 :         48 :     else if (!second)
     689                 :         24 :       until = fde->dw_fde_switch_cfi_index;
     690                 :            :     else
     691                 :         24 :       from = fde->dw_fde_switch_cfi_index;
     692                 :            : 
     693                 :        532 :     for (i = from; i < until; i++)
     694                 :        432 :       output_cfi ((*fde->dw_fde_cfi)[i], fde, for_eh);
     695                 :            :   }
     696                 :            : 
     697                 :            :   /* If we are to emit a ref/link from function bodies to their frame tables,
     698                 :            :      do it now.  This is typically performed to make sure that tables
     699                 :            :      associated with functions are dragged with them and not discarded in
     700                 :            :      garbage collecting links. We need to do this on a per function basis to
     701                 :            :      cope with -ffunction-sections.  */
     702                 :            : 
     703                 :            : #ifdef ASM_OUTPUT_DWARF_TABLE_REF
     704                 :            :   /* Switch to the function section, emit the ref to the tables, and
     705                 :            :      switch *back* into the table section.  */
     706                 :            :   switch_to_section (function_section (fde->decl));
     707                 :            :   ASM_OUTPUT_DWARF_TABLE_REF (section_start_label);
     708                 :            :   switch_to_frame_table_section (for_eh, true);
     709                 :            : #endif
     710                 :            : 
     711                 :            :   /* Pad the FDE out to an address sized boundary.  */
     712                 :        200 :   ASM_OUTPUT_ALIGN (asm_out_file,
     713                 :            :                     floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
     714                 :        100 :   ASM_OUTPUT_LABEL (asm_out_file, l2);
     715                 :            : 
     716                 :        100 :   j += 2;
     717                 :        100 : }
     718                 :            : 
     719                 :            : /* Return true if frame description entry FDE is needed for EH.  */
     720                 :            : 
     721                 :            : static bool
     722                 :         89 : fde_needed_for_eh_p (dw_fde_ref fde)
     723                 :            : {
     724                 :          0 :   if (flag_asynchronous_unwind_tables)
     725                 :            :     return true;
     726                 :            : 
     727                 :          8 :   if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde->decl))
     728                 :            :     return true;
     729                 :            : 
     730                 :          5 :   if (fde->uses_eh_lsda)
     731                 :            :     return true;
     732                 :            : 
     733                 :            :   /* If exceptions are enabled, we have collected nothrow info.  */
     734                 :          6 :   if (flag_exceptions && (fde->all_throwers_are_sibcalls || fde->nothrow))
     735                 :          0 :     return false;
     736                 :            : 
     737                 :            :   return true;
     738                 :            : }
     739                 :            : 
     740                 :            : /* Output the call frame information used to record information
     741                 :            :    that relates to calculating the frame pointer, and records the
     742                 :            :    location of saved registers.  */
     743                 :            : 
     744                 :            : static void
     745                 :     186165 : output_call_frame_info (int for_eh)
     746                 :            : {
     747                 :     186165 :   unsigned int i;
     748                 :     186165 :   dw_fde_ref fde;
     749                 :     186165 :   dw_cfi_ref cfi;
     750                 :     186165 :   char l1[MAX_ARTIFICIAL_LABEL_BYTES], l2[MAX_ARTIFICIAL_LABEL_BYTES];
     751                 :     186165 :   char section_start_label[MAX_ARTIFICIAL_LABEL_BYTES];
     752                 :     186165 :   bool any_lsda_needed = false;
     753                 :     186165 :   char augmentation[6];
     754                 :     186165 :   int augmentation_size;
     755                 :     186165 :   int fde_encoding = DW_EH_PE_absptr;
     756                 :     186165 :   int per_encoding = DW_EH_PE_absptr;
     757                 :     186165 :   int lsda_encoding = DW_EH_PE_absptr;
     758                 :     186165 :   int return_reg;
     759                 :     186165 :   rtx personality = NULL;
     760                 :     186165 :   int dw_cie_version;
     761                 :            : 
     762                 :            :   /* Don't emit a CIE if there won't be any FDEs.  */
     763                 :     186165 :   if (!fde_vec)
     764                 :     186128 :     return;
     765                 :            : 
     766                 :            :   /* Nothing to do if the assembler's doing it all.  */
     767                 :     183676 :   if (dwarf2out_do_cfi_asm ())
     768                 :            :     return;
     769                 :            : 
     770                 :            :   /* If we don't have any functions we'll want to unwind out of, don't emit
     771                 :            :      any EH unwind information.  If we make FDEs linkonce, we may have to
     772                 :            :      emit an empty label for an FDE that wouldn't otherwise be emitted.  We
     773                 :            :      want to avoid having an FDE kept around when the function it refers to
     774                 :            :      is discarded.  Example where this matters: a primary function template
     775                 :            :      in C++ requires EH information, an explicit specialization doesn't.  */
     776                 :         37 :   if (for_eh)
     777                 :            :     {
     778                 :            :       bool any_eh_needed = false;
     779                 :            : 
     780                 :         87 :       FOR_EACH_VEC_ELT (*fde_vec, i, fde)
     781                 :            :         {
     782                 :         59 :           if (fde->uses_eh_lsda)
     783                 :            :             any_eh_needed = any_lsda_needed = true;
     784                 :         62 :           else if (fde_needed_for_eh_p (fde))
     785                 :            :             any_eh_needed = true;
     786                 :            :           else if (TARGET_USES_WEAK_UNWIND_INFO)
     787                 :            :             targetm.asm_out.emit_unwind_label (asm_out_file, fde->decl, 1, 1);
     788                 :            :         }
     789                 :            : 
     790                 :         28 :       if (!any_eh_needed)
     791                 :            :         return;
     792                 :            :     }
     793                 :            : 
     794                 :            :   /* We're going to be generating comments, so turn on app.  */
     795                 :         37 :   if (flag_debug_asm)
     796                 :          0 :     app_enable ();
     797                 :            : 
     798                 :            :   /* Switch to the proper frame section, first time.  */
     799                 :         37 :   switch_to_frame_table_section (for_eh, false);
     800                 :            : 
     801                 :         37 :   ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
     802                 :         37 :   ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
     803                 :            : 
     804                 :            :   /* Output the CIE.  */
     805                 :         37 :   ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
     806                 :         37 :   ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
     807                 :         37 :   if (!XCOFF_DEBUGGING_INFO || for_eh)
     808                 :            :     {
     809                 :         37 :       if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
     810                 :            :         dw2_asm_output_data (4, 0xffffffff,
     811                 :            :           "Initial length escape value indicating 64-bit DWARF extension");
     812                 :         37 :       dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
     813                 :            :                             "Length of Common Information Entry");
     814                 :            :     }
     815                 :         37 :   ASM_OUTPUT_LABEL (asm_out_file, l1);
     816                 :            : 
     817                 :            :   /* Now that the CIE pointer is PC-relative for EH,
     818                 :            :      use 0 to identify the CIE.  */
     819                 :         46 :   dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
     820                 :            :                        (for_eh ? 0 : DWARF_CIE_ID),
     821                 :            :                        "CIE Identifier Tag");
     822                 :            : 
     823                 :            :   /* Use the CIE version 3 for DWARF3; allow DWARF2 to continue to
     824                 :            :      use CIE version 1, unless that would produce incorrect results
     825                 :            :      due to overflowing the return register column.  */
     826                 :         37 :   return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh);
     827                 :         37 :   dw_cie_version = 1;
     828                 :         37 :   if (return_reg >= 256 || dwarf_version > 2)
     829                 :         19 :     dw_cie_version = 3;
     830                 :         37 :   dw2_asm_output_data (1, dw_cie_version, "CIE Version");
     831                 :            : 
     832                 :         37 :   augmentation[0] = 0;
     833                 :         37 :   augmentation_size = 0;
     834                 :            : 
     835                 :         37 :   personality = current_unit_personality;
     836                 :         37 :   if (for_eh)
     837                 :            :     {
     838                 :         28 :       char *p;
     839                 :            : 
     840                 :            :       /* Augmentation:
     841                 :            :          z      Indicates that a uleb128 is present to size the
     842                 :            :                 augmentation section.
     843                 :            :          L      Indicates the encoding (and thus presence) of
     844                 :            :                 an LSDA pointer in the FDE augmentation.
     845                 :            :          R      Indicates a non-default pointer encoding for
     846                 :            :                 FDE code pointers.
     847                 :            :          P      Indicates the presence of an encoding + language
     848                 :            :                 personality routine in the CIE augmentation.  */
     849                 :            : 
     850                 :         28 :       fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
     851                 :         28 :       per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
     852                 :         28 :       lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
     853                 :            : 
     854                 :         28 :       p = augmentation + 1;
     855                 :         28 :       if (personality)
     856                 :            :         {
     857                 :         28 :           *p++ = 'P';
     858                 :         28 :           augmentation_size += 1 + size_of_encoded_value (per_encoding);
     859                 :         28 :           assemble_external_libcall (personality);
     860                 :            :         }
     861                 :         28 :       if (any_lsda_needed)
     862                 :            :         {
     863                 :         28 :           *p++ = 'L';
     864                 :         28 :           augmentation_size += 1;
     865                 :            :         }
     866                 :         28 :       if (fde_encoding != DW_EH_PE_absptr)
     867                 :            :         {
     868                 :         28 :           *p++ = 'R';
     869                 :         28 :           augmentation_size += 1;
     870                 :            :         }
     871                 :         28 :       if (p > augmentation + 1)
     872                 :            :         {
     873                 :         28 :           augmentation[0] = 'z';
     874                 :         28 :           *p = '\0';
     875                 :            :         }
     876                 :            : 
     877                 :            :       /* Ug.  Some platforms can't do unaligned dynamic relocations at all.  */
     878                 :         28 :       if (personality && per_encoding == DW_EH_PE_aligned)
     879                 :            :         {
     880                 :          0 :           int offset = (  4             /* Length */
     881                 :            :                         + 4             /* CIE Id */
     882                 :            :                         + 1             /* CIE version */
     883                 :          0 :                         + strlen (augmentation) + 1     /* Augmentation */
     884                 :          0 :                         + size_of_uleb128 (1)           /* Code alignment */
     885                 :          0 :                         + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
     886                 :            :                         + 1             /* RA column */
     887                 :            :                         + 1             /* Augmentation size */
     888                 :          0 :                         + 1             /* Personality encoding */ );
     889                 :          0 :           int pad = -offset & (PTR_SIZE - 1);
     890                 :            : 
     891                 :          0 :           augmentation_size += pad;
     892                 :            : 
     893                 :            :           /* Augmentations should be small, so there's scarce need to
     894                 :            :              iterate for a solution.  Die if we exceed one uleb128 byte.  */
     895                 :          0 :           gcc_assert (size_of_uleb128 (augmentation_size) == 1);
     896                 :            :         }
     897                 :            :     }
     898                 :            : 
     899                 :         37 :   dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
     900                 :         37 :   if (dw_cie_version >= 4)
     901                 :            :     {
     902                 :            :       dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "CIE Address Size");
     903                 :            :       dw2_asm_output_data (1, 0, "CIE Segment Size");
     904                 :            :     }
     905                 :         37 :   dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
     906                 :         37 :   dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
     907                 :            :                                "CIE Data Alignment Factor");
     908                 :            : 
     909                 :         37 :   if (dw_cie_version == 1)
     910                 :         18 :     dw2_asm_output_data (1, return_reg, "CIE RA Column");
     911                 :            :   else
     912                 :         19 :     dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column");
     913                 :            : 
     914                 :         37 :   if (augmentation[0])
     915                 :            :     {
     916                 :         28 :       dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
     917                 :         28 :       if (personality)
     918                 :            :         {
     919                 :         28 :           dw2_asm_output_data (1, per_encoding, "Personality (%s)",
     920                 :            :                                eh_data_format_name (per_encoding));
     921                 :         28 :           dw2_asm_output_encoded_addr_rtx (per_encoding,
     922                 :            :                                            personality,
     923                 :            :                                            true, NULL);
     924                 :            :         }
     925                 :            : 
     926                 :         28 :       if (any_lsda_needed)
     927                 :         28 :         dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
     928                 :            :                              eh_data_format_name (lsda_encoding));
     929                 :            : 
     930                 :         28 :       if (fde_encoding != DW_EH_PE_absptr)
     931                 :         28 :         dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
     932                 :            :                              eh_data_format_name (fde_encoding));
     933                 :            :     }
     934                 :            : 
     935                 :        111 :   FOR_EACH_VEC_ELT (*cie_cfi_vec, i, cfi)
     936                 :         74 :     output_cfi (cfi, NULL, for_eh);
     937                 :            : 
     938                 :            :   /* Pad the CIE out to an address sized boundary.  */
     939                 :         74 :   ASM_OUTPUT_ALIGN (asm_out_file,
     940                 :            :                     floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
     941                 :         37 :   ASM_OUTPUT_LABEL (asm_out_file, l2);
     942                 :            : 
     943                 :            :   /* Loop through all of the FDE's.  */
     944                 :        114 :   FOR_EACH_VEC_ELT (*fde_vec, i, fde)
     945                 :            :     {
     946                 :         77 :       unsigned int k;
     947                 :            : 
     948                 :            :       /* Don't emit EH unwind info for leaf functions that don't need it.  */
     949                 :         77 :       if (for_eh && !fde_needed_for_eh_p (fde))
     950                 :          1 :         continue;
     951                 :            : 
     952                 :        280 :       for (k = 0; k < (fde->dw_fde_second_begin ? 2 : 1); k++)
     953                 :        100 :         output_fde (fde, for_eh, k, section_start_label, fde_encoding,
     954                 :            :                     augmentation, any_lsda_needed, lsda_encoding);
     955                 :            :     }
     956                 :            : 
     957                 :         37 :   if (for_eh && targetm.terminate_dw2_eh_frame_info)
     958                 :          0 :     dw2_asm_output_data (4, 0, "End of Table");
     959                 :            : 
     960                 :            :   /* Turn off app to make assembly quicker.  */
     961                 :         37 :   if (flag_debug_asm)
     962                 :          0 :     app_disable ();
     963                 :            : }
     964                 :            : 
     965                 :            : /* Emit .cfi_startproc and .cfi_personality/.cfi_lsda if needed.  */
     966                 :            : 
     967                 :            : static void
     968                 :     997415 : dwarf2out_do_cfi_startproc (bool second)
     969                 :            : {
     970                 :     997415 :   int enc;
     971                 :     997415 :   rtx ref;
     972                 :            : 
     973                 :     997415 :   fprintf (asm_out_file, "\t.cfi_startproc\n");
     974                 :            : 
     975                 :     997415 :   targetm.asm_out.post_cfi_startproc (asm_out_file, current_function_decl);
     976                 :            : 
     977                 :            :   /* .cfi_personality and .cfi_lsda are only relevant to DWARF2
     978                 :            :      eh unwinders.  */
     979                 :     997415 :   if (targetm_common.except_unwind_info (&global_options) != UI_DWARF2)
     980                 :            :     return;
     981                 :            : 
     982                 :     997415 :   rtx personality = get_personality_function (current_function_decl);
     983                 :            : 
     984                 :     997415 :   if (personality)
     985                 :            :     {
     986                 :      53294 :       enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
     987                 :      53294 :       ref = personality;
     988                 :            : 
     989                 :            :       /* ??? The GAS support isn't entirely consistent.  We have to
     990                 :            :          handle indirect support ourselves, but PC-relative is done
     991                 :            :          in the assembler.  Further, the assembler can't handle any
     992                 :            :          of the weirder relocation types.  */
     993                 :      53294 :       if (enc & DW_EH_PE_indirect)
     994                 :       5308 :         ref = dw2_force_const_mem (ref, true);
     995                 :            : 
     996                 :      53294 :       fprintf (asm_out_file, "\t.cfi_personality %#x,", enc);
     997                 :      53294 :       output_addr_const (asm_out_file, ref);
     998                 :      53294 :       fputc ('\n', asm_out_file);
     999                 :            :     }
    1000                 :            : 
    1001                 :     997415 :   if (crtl->uses_eh_lsda)
    1002                 :            :     {
    1003                 :      53256 :       char lab[MAX_ARTIFICIAL_LABEL_BYTES];
    1004                 :            : 
    1005                 :      53256 :       enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
    1006                 :      96279 :       ASM_GENERATE_INTERNAL_LABEL (lab, second ? "LLSDAC" : "LLSDA",
    1007                 :            :                                    current_function_funcdef_no);
    1008                 :      58311 :       ref = gen_rtx_SYMBOL_REF (Pmode, lab);
    1009                 :      53256 :       SYMBOL_REF_FLAGS (ref) = SYMBOL_FLAG_LOCAL;
    1010                 :            : 
    1011                 :      53256 :       if (enc & DW_EH_PE_indirect)
    1012                 :          0 :         ref = dw2_force_const_mem (ref, true);
    1013                 :            : 
    1014                 :      53256 :       fprintf (asm_out_file, "\t.cfi_lsda %#x,", enc);
    1015                 :      53256 :       output_addr_const (asm_out_file, ref);
    1016                 :      53256 :       fputc ('\n', asm_out_file);
    1017                 :            :     }
    1018                 :            : }
    1019                 :            : 
    1020                 :            : /* Allocate CURRENT_FDE.  Immediately initialize all we can, noting that
    1021                 :            :    this allocation may be done before pass_final.  */
    1022                 :            : 
    1023                 :            : dw_fde_ref
    1024                 :     949236 : dwarf2out_alloc_current_fde (void)
    1025                 :            : {
    1026                 :     949236 :   dw_fde_ref fde;
    1027                 :            : 
    1028                 :     949236 :   fde = ggc_cleared_alloc<dw_fde_node> ();
    1029                 :     949236 :   fde->decl = current_function_decl;
    1030                 :     949236 :   fde->funcdef_number = current_function_funcdef_no;
    1031                 :     949236 :   fde->fde_index = vec_safe_length (fde_vec);
    1032                 :     949236 :   fde->all_throwers_are_sibcalls = crtl->all_throwers_are_sibcalls;
    1033                 :     949236 :   fde->uses_eh_lsda = crtl->uses_eh_lsda;
    1034                 :     949236 :   fde->nothrow = crtl->nothrow;
    1035                 :     949236 :   fde->drap_reg = INVALID_REGNUM;
    1036                 :     949236 :   fde->vdrap_reg = INVALID_REGNUM;
    1037                 :            : 
    1038                 :            :   /* Record the FDE associated with this function.  */
    1039                 :     949236 :   cfun->fde = fde;
    1040                 :     949236 :   vec_safe_push (fde_vec, fde);
    1041                 :            : 
    1042                 :     949236 :   return fde;
    1043                 :            : }
    1044                 :            : 
    1045                 :            : /* Output a marker (i.e. a label) for the beginning of a function, before
    1046                 :            :    the prologue.  */
    1047                 :            : 
    1048                 :            : void
    1049                 :     949301 : dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
    1050                 :            :                           unsigned int column ATTRIBUTE_UNUSED,
    1051                 :            :                           const char *file ATTRIBUTE_UNUSED)
    1052                 :            : {
    1053                 :     949301 :   char label[MAX_ARTIFICIAL_LABEL_BYTES];
    1054                 :     949301 :   char * dup_label;
    1055                 :     949301 :   dw_fde_ref fde;
    1056                 :     949301 :   section *fnsec;
    1057                 :     949301 :   bool do_frame;
    1058                 :            : 
    1059                 :     949301 :   current_function_func_begin_label = NULL;
    1060                 :            : 
    1061                 :     949301 :   do_frame = dwarf2out_do_frame ();
    1062                 :            : 
    1063                 :            :   /* ??? current_function_func_begin_label is also used by except.c for
    1064                 :            :      call-site information.  We must emit this label if it might be used.  */
    1065                 :     949301 :   if (!do_frame
    1066                 :     949301 :       && (!flag_exceptions
    1067                 :          0 :           || targetm_common.except_unwind_info (&global_options) == UI_SJLJ))
    1068                 :         65 :     return;
    1069                 :            : 
    1070                 :     949236 :   fnsec = function_section (current_function_decl);
    1071                 :     949236 :   switch_to_section (fnsec);
    1072                 :     949236 :   ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
    1073                 :            :                                current_function_funcdef_no);
    1074                 :     949236 :   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
    1075                 :            :                           current_function_funcdef_no);
    1076                 :     949236 :   dup_label = xstrdup (label);
    1077                 :     949236 :   current_function_func_begin_label = dup_label;
    1078                 :            : 
    1079                 :            :   /* We can elide FDE allocation if we're not emitting frame unwind info.  */
    1080                 :     949236 :   if (!do_frame)
    1081                 :            :     return;
    1082                 :            : 
    1083                 :            :   /* Unlike the debug version, the EH version of frame unwind info is a per-
    1084                 :            :      function setting so we need to record whether we need it for the unit.  */
    1085                 :     949236 :   do_eh_frame |= dwarf2out_do_eh_frame ();
    1086                 :            : 
    1087                 :            :   /* Cater to the various TARGET_ASM_OUTPUT_MI_THUNK implementations that
    1088                 :            :      emit insns as rtx but bypass the bulk of rest_of_compilation, which
    1089                 :            :      would include pass_dwarf2_frame.  If we've not created the FDE yet,
    1090                 :            :      do so now.  */
    1091                 :     949236 :   fde = cfun->fde;
    1092                 :     949236 :   if (fde == NULL)
    1093                 :       5198 :     fde = dwarf2out_alloc_current_fde ();
    1094                 :            : 
    1095                 :            :   /* Initialize the bits of CURRENT_FDE that were not available earlier.  */
    1096                 :     949236 :   fde->dw_fde_begin = dup_label;
    1097                 :     949236 :   fde->dw_fde_current_label = dup_label;
    1098                 :    1898470 :   fde->in_std_section = (fnsec == text_section
    1099                 :     949236 :                          || (cold_text_section && fnsec == cold_text_section));
    1100                 :            : 
    1101                 :            :   /* We only want to output line number information for the genuine dwarf2
    1102                 :            :      prologue case, not the eh frame case.  */
    1103                 :            : #ifdef DWARF2_DEBUGGING_INFO
    1104                 :     949236 :   if (file)
    1105                 :     335133 :     dwarf2out_source_line (line, column, file, 0, true);
    1106                 :            : #endif
    1107                 :            : 
    1108                 :     949236 :   if (dwarf2out_do_cfi_asm ())
    1109                 :     949177 :     dwarf2out_do_cfi_startproc (false);
    1110                 :            :   else
    1111                 :            :     {
    1112                 :         59 :       rtx personality = get_personality_function (current_function_decl);
    1113                 :         59 :       if (!current_unit_personality)
    1114                 :         31 :         current_unit_personality = personality;
    1115                 :            : 
    1116                 :            :       /* We cannot keep a current personality per function as without CFI
    1117                 :            :          asm, at the point where we emit the CFI data, there is no current
    1118                 :            :          function anymore.  */
    1119                 :         59 :       if (personality && current_unit_personality != personality)
    1120                 :          0 :         sorry ("multiple EH personalities are supported only with assemblers "
    1121                 :            :                "supporting %<.cfi_personality%> directive");
    1122                 :            :     }
    1123                 :            : }
    1124                 :            : 
    1125                 :            : /* Output a marker (i.e. a label) for the end of the generated code
    1126                 :            :    for a function prologue.  This gets called *after* the prologue code has
    1127                 :            :    been generated.  */
    1128                 :            : 
    1129                 :            : void
    1130                 :          0 : dwarf2out_vms_end_prologue (unsigned int line ATTRIBUTE_UNUSED,
    1131                 :            :                             const char *file ATTRIBUTE_UNUSED)
    1132                 :            : {
    1133                 :          0 :   char label[MAX_ARTIFICIAL_LABEL_BYTES];
    1134                 :            : 
    1135                 :            :   /* Output a label to mark the endpoint of the code generated for this
    1136                 :            :      function.  */
    1137                 :          0 :   ASM_GENERATE_INTERNAL_LABEL (label, PROLOGUE_END_LABEL,
    1138                 :            :                                current_function_funcdef_no);
    1139                 :          0 :   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, PROLOGUE_END_LABEL,
    1140                 :            :                           current_function_funcdef_no);
    1141                 :          0 :   cfun->fde->dw_fde_vms_end_prologue = xstrdup (label);
    1142                 :          0 : }
    1143                 :            : 
    1144                 :            : /* Output a marker (i.e. a label) for the beginning of the generated code
    1145                 :            :    for a function epilogue.  This gets called *before* the prologue code has
    1146                 :            :    been generated.  */
    1147                 :            : 
    1148                 :            : void
    1149                 :          0 : dwarf2out_vms_begin_epilogue (unsigned int line ATTRIBUTE_UNUSED,
    1150                 :            :                           const char *file ATTRIBUTE_UNUSED)
    1151                 :            : {
    1152                 :          0 :   dw_fde_ref fde = cfun->fde;
    1153                 :          0 :   char label[MAX_ARTIFICIAL_LABEL_BYTES];
    1154                 :            : 
    1155                 :          0 :   if (fde->dw_fde_vms_begin_epilogue)
    1156                 :          0 :     return;
    1157                 :            : 
    1158                 :            :   /* Output a label to mark the endpoint of the code generated for this
    1159                 :            :      function.  */
    1160                 :          0 :   ASM_GENERATE_INTERNAL_LABEL (label, EPILOGUE_BEGIN_LABEL,
    1161                 :            :                                current_function_funcdef_no);
    1162                 :          0 :   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, EPILOGUE_BEGIN_LABEL,
    1163                 :            :                           current_function_funcdef_no);
    1164                 :          0 :   fde->dw_fde_vms_begin_epilogue = xstrdup (label);
    1165                 :            : }
    1166                 :            : 
    1167                 :            : /* Output a marker (i.e. a label) for the absolute end of the generated code
    1168                 :            :    for a function definition.  This gets called *after* the epilogue code has
    1169                 :            :    been generated.  */
    1170                 :            : 
    1171                 :            : void
    1172                 :     949236 : dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
    1173                 :            :                         const char *file ATTRIBUTE_UNUSED)
    1174                 :            : {
    1175                 :     949236 :   dw_fde_ref fde;
    1176                 :     949236 :   char label[MAX_ARTIFICIAL_LABEL_BYTES];
    1177                 :            : 
    1178                 :     949236 :   last_var_location_insn = NULL;
    1179                 :     949236 :   cached_next_real_insn = NULL;
    1180                 :            : 
    1181                 :     949236 :   if (dwarf2out_do_cfi_asm ())
    1182                 :     949177 :     fprintf (asm_out_file, "\t.cfi_endproc\n");
    1183                 :            : 
    1184                 :            :   /* Output a label to mark the endpoint of the code generated for this
    1185                 :            :      function.  */
    1186                 :     949236 :   ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
    1187                 :            :                                current_function_funcdef_no);
    1188                 :     949236 :   ASM_OUTPUT_LABEL (asm_out_file, label);
    1189                 :     949236 :   fde = cfun->fde;
    1190                 :     949236 :   gcc_assert (fde != NULL);
    1191                 :     949236 :   if (fde->dw_fde_second_begin == NULL)
    1192                 :     900980 :     fde->dw_fde_end = xstrdup (label);
    1193                 :     949236 : }
    1194                 :            : 
    1195                 :            : void
    1196                 :     163841 : dwarf2out_frame_finish (void)
    1197                 :            : {
    1198                 :            :   /* Output call frame information.  */
    1199                 :     163841 :   if (targetm.debug_unwind_info () == UI_DWARF2)
    1200                 :      36776 :     output_call_frame_info (0);
    1201                 :            : 
    1202                 :            :   /* Output another copy for the unwinder.  */
    1203                 :     163841 :   if (do_eh_frame)
    1204                 :     149389 :     output_call_frame_info (1);
    1205                 :     163841 : }
    1206                 :            : 
    1207                 :            : /* Note that the current function section is being used for code.  */
    1208                 :            : 
    1209                 :            : static void
    1210                 :     379952 : dwarf2out_note_section_used (void)
    1211                 :            : {
    1212                 :     379952 :   section *sec = current_function_section ();
    1213                 :     379952 :   if (sec == text_section)
    1214                 :     234712 :     text_section_used = true;
    1215                 :     145240 :   else if (sec == cold_text_section)
    1216                 :       8200 :     cold_text_section_used = true;
    1217                 :     379952 : }
    1218                 :            : 
    1219                 :            : static void var_location_switch_text_section (void);
    1220                 :            : static void set_cur_line_info_table (section *);
    1221                 :            : 
    1222                 :            : void
    1223                 :      48256 : dwarf2out_switch_text_section (void)
    1224                 :            : {
    1225                 :      48256 :   char label[MAX_ARTIFICIAL_LABEL_BYTES];
    1226                 :      48256 :   section *sect;
    1227                 :      48256 :   dw_fde_ref fde = cfun->fde;
    1228                 :            : 
    1229                 :      48256 :   gcc_assert (cfun && fde && fde->dw_fde_second_begin == NULL);
    1230                 :            : 
    1231                 :      48256 :   ASM_GENERATE_INTERNAL_LABEL (label, FUNC_SECOND_SECT_LABEL,
    1232                 :            :                                current_function_funcdef_no);
    1233                 :            : 
    1234                 :      48256 :   fde->dw_fde_second_begin = ggc_strdup (label);
    1235                 :      48256 :   if (!in_cold_section_p)
    1236                 :            :     {
    1237                 :          0 :       fde->dw_fde_end = crtl->subsections.cold_section_end_label;
    1238                 :          0 :       fde->dw_fde_second_end = crtl->subsections.hot_section_end_label;
    1239                 :            :     }
    1240                 :            :   else
    1241                 :            :     {
    1242                 :      48256 :       fde->dw_fde_end = crtl->subsections.hot_section_end_label;
    1243                 :      48256 :       fde->dw_fde_second_end = crtl->subsections.cold_section_end_label;
    1244                 :            :     }
    1245                 :      48256 :   have_multiple_function_sections = true;
    1246                 :            : 
    1247                 :            :   /* There is no need to mark used sections when not debugging.  */
    1248                 :      48256 :   if (cold_text_section != NULL)
    1249                 :      12588 :     dwarf2out_note_section_used ();
    1250                 :            : 
    1251                 :      48256 :   if (dwarf2out_do_cfi_asm ())
    1252                 :      48238 :     fprintf (asm_out_file, "\t.cfi_endproc\n");
    1253                 :            : 
    1254                 :            :   /* Now do the real section switch.  */
    1255                 :      48256 :   sect = current_function_section ();
    1256                 :      48256 :   switch_to_section (sect);
    1257                 :            : 
    1258                 :      48256 :   fde->second_in_std_section
    1259                 :      96512 :     = (sect == text_section
    1260                 :      48256 :        || (cold_text_section && sect == cold_text_section));
    1261                 :            : 
    1262                 :      48256 :   if (dwarf2out_do_cfi_asm ())
    1263                 :      48238 :     dwarf2out_do_cfi_startproc (true);
    1264                 :            : 
    1265                 :      48256 :   var_location_switch_text_section ();
    1266                 :            : 
    1267                 :      48256 :   if (cold_text_section != NULL)
    1268                 :      12588 :     set_cur_line_info_table (sect);
    1269                 :      48256 : }
    1270                 :            : 
    1271                 :            : /* And now, the subset of the debugging information support code necessary
    1272                 :            :    for emitting location expressions.  */
    1273                 :            : 
    1274                 :            : /* Data about a single source file.  */
    1275                 :            : struct GTY((for_user)) dwarf_file_data {
    1276                 :            :   const char * filename;
    1277                 :            :   int emitted_number;
    1278                 :            : };
    1279                 :            : 
    1280                 :            : /* Describe an entry into the .debug_addr section.  */
    1281                 :            : 
    1282                 :            : enum ate_kind {
    1283                 :            :   ate_kind_rtx,
    1284                 :            :   ate_kind_rtx_dtprel,
    1285                 :            :   ate_kind_label
    1286                 :            : };
    1287                 :            : 
    1288                 :            : struct GTY((for_user)) addr_table_entry {
    1289                 :            :   enum ate_kind kind;
    1290                 :            :   unsigned int refcount;
    1291                 :            :   unsigned int index;
    1292                 :            :   union addr_table_entry_struct_union
    1293                 :            :     {
    1294                 :            :       rtx GTY ((tag ("0"))) rtl;
    1295                 :            :       char * GTY ((tag ("1"))) label;
    1296                 :            :     }
    1297                 :            :   GTY ((desc ("%1.kind"))) addr;
    1298                 :            : };
    1299                 :            : 
    1300                 :            : typedef unsigned int var_loc_view;
    1301                 :            : 
    1302                 :            : /* Location lists are ranges + location descriptions for that range,
    1303                 :            :    so you can track variables that are in different places over
    1304                 :            :    their entire life.  */
    1305                 :            : typedef struct GTY(()) dw_loc_list_struct {
    1306                 :            :   dw_loc_list_ref dw_loc_next;
    1307                 :            :   const char *begin; /* Label and addr_entry for start of range */
    1308                 :            :   addr_table_entry *begin_entry;
    1309                 :            :   const char *end;  /* Label for end of range */
    1310                 :            :   char *ll_symbol; /* Label for beginning of location list.
    1311                 :            :                       Only on head of list.  */
    1312                 :            :   char *vl_symbol; /* Label for beginning of view list.  Ditto.  */
    1313                 :            :   const char *section; /* Section this loclist is relative to */
    1314                 :            :   dw_loc_descr_ref expr;
    1315                 :            :   var_loc_view vbegin, vend;
    1316                 :            :   hashval_t hash;
    1317                 :            :   /* True if all addresses in this and subsequent lists are known to be
    1318                 :            :      resolved.  */
    1319                 :            :   bool resolved_addr;
    1320                 :            :   /* True if this list has been replaced by dw_loc_next.  */
    1321                 :            :   bool replaced;
    1322                 :            :   /* True if it has been emitted into .debug_loc* / .debug_loclists*
    1323                 :            :      section.  */
    1324                 :            :   unsigned char emitted : 1;
    1325                 :            :   /* True if hash field is index rather than hash value.  */
    1326                 :            :   unsigned char num_assigned : 1;
    1327                 :            :   /* True if .debug_loclists.dwo offset has been emitted for it already.  */
    1328                 :            :   unsigned char offset_emitted : 1;
    1329                 :            :   /* True if note_variable_value_in_expr has been called on it.  */
    1330                 :            :   unsigned char noted_variable_value : 1;
    1331                 :            :   /* True if the range should be emitted even if begin and end
    1332                 :            :      are the same.  */
    1333                 :            :   bool force;
    1334                 :            : } dw_loc_list_node;
    1335                 :            : 
    1336                 :            : static dw_loc_descr_ref int_loc_descriptor (poly_int64);
    1337                 :            : static dw_loc_descr_ref uint_loc_descriptor (unsigned HOST_WIDE_INT);
    1338                 :            : 
    1339                 :            : /* Convert a DWARF stack opcode into its string name.  */
    1340                 :            : 
    1341                 :            : static const char *
    1342                 :   33272500 : dwarf_stack_op_name (unsigned int op)
    1343                 :            : {
    1344                 :          0 :   const char *name = get_DW_OP_name (op);
    1345                 :            : 
    1346                 :   33272500 :   if (name != NULL)
    1347                 :   33272500 :     return name;
    1348                 :            : 
    1349                 :            :   return "OP_<unknown>";
    1350                 :            : }
    1351                 :            : 
    1352                 :            : /* Return TRUE iff we're to output location view lists as a separate
    1353                 :            :    attribute next to the location lists, as an extension compatible
    1354                 :            :    with DWARF 2 and above.  */
    1355                 :            : 
    1356                 :            : static inline bool
    1357                 :   30766200 : dwarf2out_locviews_in_attribute ()
    1358                 :            : {
    1359                 :   30766200 :   return debug_variable_location_views == 1;
    1360                 :            : }
    1361                 :            : 
    1362                 :            : /* Return TRUE iff we're to output location view lists as part of the
    1363                 :            :    location lists, as proposed for standardization after DWARF 5.  */
    1364                 :            : 
    1365                 :            : static inline bool
    1366                 :        607 : dwarf2out_locviews_in_loclist ()
    1367                 :            : {
    1368                 :            : #ifndef DW_LLE_view_pair
    1369                 :            :   return false;
    1370                 :            : #else
    1371                 :        607 :   return debug_variable_location_views == -1;
    1372                 :            : #endif
    1373                 :            : }
    1374                 :            : 
    1375                 :            : /* Return a pointer to a newly allocated location description.  Location
    1376                 :            :    descriptions are simple expression terms that can be strung
    1377                 :            :    together to form more complicated location (address) descriptions.  */
    1378                 :            : 
    1379                 :            : static inline dw_loc_descr_ref
    1380                 :   34578400 : new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
    1381                 :            :                unsigned HOST_WIDE_INT oprnd2)
    1382                 :            : {
    1383                 :   34578400 :   dw_loc_descr_ref descr = ggc_cleared_alloc<dw_loc_descr_node> ();
    1384                 :            : 
    1385                 :   34578400 :   descr->dw_loc_opc = op;
    1386                 :   34578400 :   descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
    1387                 :   34578400 :   descr->dw_loc_oprnd1.val_entry = NULL;
    1388                 :   34578400 :   descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
    1389                 :   34578400 :   descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
    1390                 :   34578400 :   descr->dw_loc_oprnd2.val_entry = NULL;
    1391                 :   34578400 :   descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
    1392                 :            : 
    1393                 :   34578400 :   return descr;
    1394                 :            : }
    1395                 :            : 
    1396                 :            : /* Add a location description term to a location description expression.  */
    1397                 :            : 
    1398                 :            : static inline void
    1399                 :      46626 : add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
    1400                 :            : {
    1401                 :    8199050 :   dw_loc_descr_ref *d;
    1402                 :            : 
    1403                 :            :   /* Find the end of the chain.  */
    1404                 :   57138000 :   for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
    1405                 :            :     ;
    1406                 :            : 
    1407                 :    9925770 :   *d = descr;
    1408                 :      89987 : }
    1409                 :            : 
    1410                 :            : /* Compare two location operands for exact equality.  */
    1411                 :            : 
    1412                 :            : static bool
    1413                 :        756 : dw_val_equal_p (dw_val_node *a, dw_val_node *b)
    1414                 :            : {
    1415                 :        756 :   if (a->val_class != b->val_class)
    1416                 :            :     return false;
    1417                 :        756 :   switch (a->val_class)
    1418                 :            :     {
    1419                 :            :     case dw_val_class_none:
    1420                 :            :       return true;
    1421                 :          0 :     case dw_val_class_addr:
    1422                 :          0 :       return rtx_equal_p (a->v.val_addr, b->v.val_addr);
    1423                 :            : 
    1424                 :        390 :     case dw_val_class_offset:
    1425                 :        390 :     case dw_val_class_unsigned_const:
    1426                 :        390 :     case dw_val_class_const:
    1427                 :        390 :     case dw_val_class_unsigned_const_implicit:
    1428                 :        390 :     case dw_val_class_const_implicit:
    1429                 :        390 :     case dw_val_class_range_list:
    1430                 :            :       /* These are all HOST_WIDE_INT, signed or unsigned.  */
    1431                 :        390 :       return a->v.val_unsigned == b->v.val_unsigned;
    1432                 :            : 
    1433                 :          0 :     case dw_val_class_loc:
    1434                 :          0 :       return a->v.val_loc == b->v.val_loc;
    1435                 :          0 :     case dw_val_class_loc_list:
    1436                 :          0 :       return a->v.val_loc_list == b->v.val_loc_list;
    1437                 :          0 :     case dw_val_class_view_list:
    1438                 :          0 :       return a->v.val_view_list == b->v.val_view_list;
    1439                 :          0 :     case dw_val_class_die_ref:
    1440                 :          0 :       return a->v.val_die_ref.die == b->v.val_die_ref.die;
    1441                 :          0 :     case dw_val_class_fde_ref:
    1442                 :          0 :       return a->v.val_fde_index == b->v.val_fde_index;
    1443                 :          0 :     case dw_val_class_symview:
    1444                 :          0 :       return strcmp (a->v.val_symbolic_view, b->v.val_symbolic_view) == 0;
    1445                 :          0 :     case dw_val_class_lbl_id:
    1446                 :          0 :     case dw_val_class_lineptr:
    1447                 :          0 :     case dw_val_class_macptr:
    1448                 :          0 :     case dw_val_class_loclistsptr:
    1449                 :          0 :     case dw_val_class_high_pc:
    1450                 :          0 :       return strcmp (a->v.val_lbl_id, b->v.val_lbl_id) == 0;
    1451                 :          0 :     case dw_val_class_str:
    1452                 :          0 :       return a->v.val_str == b->v.val_str;
    1453                 :          0 :     case dw_val_class_flag:
    1454                 :          0 :       return a->v.val_flag == b->v.val_flag;
    1455                 :        366 :     case dw_val_class_file:
    1456                 :        366 :     case dw_val_class_file_implicit:
    1457                 :        366 :       return a->v.val_file == b->v.val_file;
    1458                 :          0 :     case dw_val_class_decl_ref:
    1459                 :          0 :       return a->v.val_decl_ref == b->v.val_decl_ref;
    1460                 :            :     
    1461                 :          0 :     case dw_val_class_const_double:
    1462                 :          0 :       return (a->v.val_double.high == b->v.val_double.high
    1463                 :          0 :               && a->v.val_double.low == b->v.val_double.low);
    1464                 :            : 
    1465                 :          0 :     case dw_val_class_wide_int:
    1466                 :          0 :       return *a->v.val_wide == *b->v.val_wide;
    1467                 :            : 
    1468                 :          0 :     case dw_val_class_vec:
    1469                 :          0 :       {
    1470                 :          0 :         size_t a_len = a->v.val_vec.elt_size * a->v.val_vec.length;
    1471                 :          0 :         size_t b_len = b->v.val_vec.elt_size * b->v.val_vec.length;
    1472                 :            : 
    1473                 :          0 :         return (a_len == b_len
    1474                 :          0 :                 && !memcmp (a->v.val_vec.array, b->v.val_vec.array, a_len));
    1475                 :            :       }
    1476                 :            : 
    1477                 :          0 :     case dw_val_class_data8:
    1478                 :          0 :       return memcmp (a->v.val_data8, b->v.val_data8, 8) == 0;
    1479                 :            : 
    1480                 :          0 :     case dw_val_class_vms_delta:
    1481                 :          0 :       return (!strcmp (a->v.val_vms_delta.lbl1, b->v.val_vms_delta.lbl1)
    1482                 :          0 :               && !strcmp (a->v.val_vms_delta.lbl1, b->v.val_vms_delta.lbl1));
    1483                 :            : 
    1484                 :          0 :     case dw_val_class_discr_value:
    1485                 :          0 :       return (a->v.val_discr_value.pos == b->v.val_discr_value.pos
    1486                 :          0 :               && a->v.val_discr_value.v.uval == b->v.val_discr_value.v.uval);
    1487                 :          0 :     case dw_val_class_discr_list:
    1488                 :            :       /* It makes no sense comparing two discriminant value lists.  */
    1489                 :          0 :       return false;
    1490                 :            :     }
    1491                 :          0 :   gcc_unreachable ();
    1492                 :            : }
    1493                 :            : 
    1494                 :            : /* Compare two location atoms for exact equality.  */
    1495                 :            : 
    1496                 :            : static bool
    1497                 :          0 : loc_descr_equal_p_1 (dw_loc_descr_ref a, dw_loc_descr_ref b)
    1498                 :            : {
    1499                 :          0 :   if (a->dw_loc_opc != b->dw_loc_opc)
    1500                 :            :     return false;
    1501                 :            : 
    1502                 :            :   /* ??? This is only ever set for DW_OP_constNu, for N equal to the
    1503                 :            :      address size, but since we always allocate cleared storage it
    1504                 :            :      should be zero for other types of locations.  */
    1505                 :          0 :   if (a->dtprel != b->dtprel)
    1506                 :            :     return false;
    1507                 :            : 
    1508                 :          0 :   return (dw_val_equal_p (&a->dw_loc_oprnd1, &b->dw_loc_oprnd1)
    1509                 :          0 :           && dw_val_equal_p (&a->dw_loc_oprnd2, &b->dw_loc_oprnd2));
    1510                 :            : }
    1511                 :            : 
    1512                 :            : /* Compare two complete location expressions for exact equality.  */
    1513                 :            : 
    1514                 :            : bool
    1515                 :          0 : loc_descr_equal_p (dw_loc_descr_ref a, dw_loc_descr_ref b)
    1516                 :            : {
    1517                 :          0 :   while (1)
    1518                 :            :     {
    1519                 :          0 :       if (a == b)
    1520                 :            :         return true;
    1521                 :          0 :       if (a == NULL || b == NULL)
    1522                 :            :         return false;
    1523                 :          0 :       if (!loc_descr_equal_p_1 (a, b))
    1524                 :            :         return false;
    1525                 :            : 
    1526                 :          0 :       a = a->dw_loc_next;
    1527                 :          0 :       b = b->dw_loc_next;
    1528                 :            :     }
    1529                 :            : }
    1530                 :            : 
    1531                 :            : 
    1532                 :            : /* Add a constant POLY_OFFSET to a location expression.  */
    1533                 :            : 
    1534                 :            : static void
    1535                 :     426285 : loc_descr_plus_const (dw_loc_descr_ref *list_head, poly_int64 poly_offset)
    1536                 :            : {
    1537                 :     426285 :   dw_loc_descr_ref loc;
    1538                 :     426285 :   HOST_WIDE_INT *p;
    1539                 :            : 
    1540                 :     426285 :   gcc_assert (*list_head != NULL);
    1541                 :            : 
    1542                 :     426285 :   if (known_eq (poly_offset, 0))
    1543                 :     426285 :     return;
    1544                 :            : 
    1545                 :            :   /* Find the end of the chain.  */
    1546                 :    1278700 :   for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
    1547                 :            :     ;
    1548                 :            : 
    1549                 :     420730 :   HOST_WIDE_INT offset;
    1550                 :     420730 :   if (!poly_offset.is_constant (&offset))
    1551                 :            :     {
    1552                 :            :       loc->dw_loc_next = int_loc_descriptor (poly_offset);
    1553                 :            :       add_loc_descr (&loc->dw_loc_next, new_loc_descr (DW_OP_plus, 0, 0));
    1554                 :            :       return;
    1555                 :            :     }
    1556                 :            : 
    1557                 :     420730 :   p = NULL;
    1558                 :     420730 :   if (loc->dw_loc_opc == DW_OP_fbreg
    1559                 :     420730 :       || (loc->dw_loc_opc >= DW_OP_breg0 && loc->dw_loc_opc <= DW_OP_breg31))
    1560                 :          1 :     p = &loc->dw_loc_oprnd1.v.val_int;
    1561                 :     420729 :   else if (loc->dw_loc_opc == DW_OP_bregx)
    1562                 :          0 :     p = &loc->dw_loc_oprnd2.v.val_int;
    1563                 :            : 
    1564                 :            :   /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
    1565                 :            :      offset.  Don't optimize if an signed integer overflow would happen.  */
    1566                 :          1 :   if (p != NULL
    1567                 :          1 :       && ((offset > 0 && *p <= INTTYPE_MAXIMUM (HOST_WIDE_INT) - offset)
    1568                 :          1 :           || (offset < 0 && *p >= INTTYPE_MINIMUM (HOST_WIDE_INT) - offset)))
    1569                 :          1 :     *p += offset;
    1570                 :            : 
    1571                 :     420729 :   else if (offset > 0)
    1572                 :     351397 :     loc->dw_loc_next = new_loc_descr (DW_OP_plus_uconst, offset, 0);
    1573                 :            : 
    1574                 :            :   else
    1575                 :            :     {
    1576                 :      69332 :       loc->dw_loc_next
    1577                 :      69332 :         = uint_loc_descriptor (-(unsigned HOST_WIDE_INT) offset);
    1578                 :      69332 :       add_loc_descr (&loc->dw_loc_next, new_loc_descr (DW_OP_minus, 0, 0));
    1579                 :            :     }
    1580                 :            : }
    1581                 :            : 
    1582                 :            : /* Return a pointer to a newly allocated location description for
    1583                 :            :    REG and OFFSET.  */
    1584                 :            : 
    1585                 :            : static inline dw_loc_descr_ref
    1586                 :    3677140 : new_reg_loc_descr (unsigned int reg, poly_int64 offset)
    1587                 :            : {
    1588                 :    3677140 :   HOST_WIDE_INT const_offset;
    1589                 :    3677140 :   if (offset.is_constant (&const_offset))
    1590                 :            :     {
    1591                 :    3677140 :       if (reg <= 31)
    1592                 :    3677140 :         return new_loc_descr ((enum dwarf_location_atom) (DW_OP_breg0 + reg),
    1593                 :    3677140 :                               const_offset, 0);
    1594                 :            :       else
    1595                 :          0 :         return new_loc_descr (DW_OP_bregx, reg, const_offset);
    1596                 :            :     }
    1597                 :            :   else
    1598                 :            :     {
    1599                 :            :       dw_loc_descr_ref ret = new_reg_loc_descr (reg, 0);
    1600                 :            :       loc_descr_plus_const (&ret, offset);
    1601                 :            :       return ret;
    1602                 :            :     }
    1603                 :            : }
    1604                 :            : 
    1605                 :            : /* Add a constant OFFSET to a location list.  */
    1606                 :            : 
    1607                 :            : static void
    1608                 :      93416 : loc_list_plus_const (dw_loc_list_ref list_head, poly_int64 offset)
    1609                 :            : {
    1610                 :          0 :   dw_loc_list_ref d;
    1611                 :     186832 :   for (d = list_head; d != NULL; d = d->dw_loc_next)
    1612                 :      93416 :     loc_descr_plus_const (&d->expr, offset);
    1613                 :          0 : }
    1614                 :            : 
    1615                 :            : #define DWARF_REF_SIZE  \
    1616                 :            :   (dwarf_version == 2 ? DWARF2_ADDR_SIZE : DWARF_OFFSET_SIZE)
    1617                 :            : 
    1618                 :            : /* The number of bits that can be encoded by largest DW_FORM_dataN.
    1619                 :            :    In DWARF4 and earlier it is DW_FORM_data8 with 64 bits, in DWARF5
    1620                 :            :    DW_FORM_data16 with 128 bits.  */
    1621                 :            : #define DWARF_LARGEST_DATA_FORM_BITS \
    1622                 :            :   (dwarf_version >= 5 ? 128 : 64)
    1623                 :            : 
    1624                 :            : /* Utility inline function for construction of ops that were GNU extension
    1625                 :            :    before DWARF 5.  */
    1626                 :            : static inline enum dwarf_location_atom
    1627                 :    1642860 : dwarf_OP (enum dwarf_location_atom op)
    1628                 :            : {
    1629                 :     953322 :   switch (op)
    1630                 :            :     {
    1631                 :     680901 :     case DW_OP_implicit_pointer:
    1632                 :          0 :       if (dwarf_version < 5)
    1633                 :     680901 :         return DW_OP_GNU_implicit_pointer;
    1634                 :            :       break;
    1635                 :            : 
    1636                 :     706594 :     case DW_OP_entry_value:
    1637                 :     706594 :       if (dwarf_version < 5)
    1638                 :     706447 :         return DW_OP_GNU_entry_value;
    1639                 :            :       break;
    1640                 :            : 
    1641                 :      53902 :     case DW_OP_const_type:
    1642                 :      53902 :       if (dwarf_version < 5)
    1643                 :      53902 :         return DW_OP_GNU_const_type;
    1644                 :            :       break;
    1645                 :            : 
    1646                 :      54292 :     case DW_OP_regval_type:
    1647                 :      54292 :       if (dwarf_version < 5)
    1648                 :      54292 :         return DW_OP_GNU_regval_type;
    1649                 :            :       break;
    1650                 :            : 
    1651                 :      66041 :     case DW_OP_deref_type:
    1652                 :      66041 :       if (dwarf_version < 5)
    1653                 :      66041 :         return DW_OP_GNU_deref_type;
    1654                 :            :       break;
    1655                 :            : 
    1656                 :      80221 :     case DW_OP_convert:
    1657                 :      71592 :       if (dwarf_version < 5)
    1658                 :      80221 :         return DW_OP_GNU_convert;
    1659                 :            :       break;
    1660                 :            : 
    1661                 :        901 :     case DW_OP_reinterpret:
    1662                 :        901 :       if (dwarf_version < 5)
    1663                 :        901 :         return DW_OP_GNU_reinterpret;
    1664                 :            :       break;
    1665                 :            : 
    1666                 :          7 :     case DW_OP_addrx:
    1667                 :          7 :       if (dwarf_version < 5)
    1668                 :          7 :         return DW_OP_GNU_addr_index;
    1669                 :            :       break;
    1670                 :            : 
    1671                 :          0 :     case DW_OP_constx:
    1672                 :          0 :       if (dwarf_version < 5)
    1673                 :          0 :         return DW_OP_GNU_const_index;
    1674                 :            :       break;
    1675                 :            : 
    1676                 :            :     default:
    1677                 :            :       break;
    1678                 :            :     }
    1679                 :            :   return op;
    1680                 :            : }
    1681                 :            : 
    1682                 :            : /* Similarly for attributes.  */
    1683                 :            : static inline enum dwarf_attribute
    1684                 :    6545100 : dwarf_AT (enum dwarf_attribute at)
    1685                 :            : {
    1686                 :    6545100 :   switch (at)
    1687                 :            :     {
    1688                 :    2070800 :     case DW_AT_call_return_pc:
    1689                 :    2070800 :       if (dwarf_version < 5)
    1690                 :    2070600 :         return DW_AT_low_pc;
    1691                 :            :       break;
    1692                 :            : 
    1693                 :      38032 :     case DW_AT_call_tail_call:
    1694                 :      38032 :       if (dwarf_version < 5)
    1695                 :      38032 :         return DW_AT_GNU_tail_call;
    1696                 :            :       break;
    1697                 :            : 
    1698                 :    2019520 :     case DW_AT_call_origin:
    1699                 :    2019520 :       if (dwarf_version < 5)
    1700                 :    2019320 :         return DW_AT_abstract_origin;
    1701                 :            :       break;
    1702                 :            : 
    1703                 :       3849 :     case DW_AT_call_target:
    1704                 :       3849 :       if (dwarf_version < 5)
    1705                 :       3849 :         return DW_AT_GNU_call_site_target;
    1706                 :            :       break;
    1707                 :            : 
    1708                 :          0 :     case DW_AT_call_target_clobbered:
    1709                 :          0 :       if (dwarf_version < 5)
    1710                 :          0 :         return DW_AT_GNU_call_site_target_clobbered;
    1711                 :            :       break;
    1712                 :            : 
    1713                 :      20248 :     case DW_AT_call_parameter:
    1714                 :      20248 :       if (dwarf_version < 5)
    1715                 :      20248 :         return DW_AT_abstract_origin;
    1716                 :            :       break;
    1717                 :            : 
    1718                 :    2022120 :     case DW_AT_call_value:
    1719                 :    2022120 :       if (dwarf_version < 5)
    1720                 :    2021690 :         return DW_AT_GNU_call_site_value;
    1721                 :            :       break;
    1722                 :            : 
    1723                 :       5027 :     case DW_AT_call_data_value:
    1724                 :       5027 :       if (dwarf_version < 5)
    1725                 :       5027 :         return DW_AT_GNU_call_site_data_value;
    1726                 :            :       break;
    1727                 :            : 
    1728                 :     168458 :     case DW_AT_call_all_calls:
    1729                 :     168458 :       if (dwarf_version < 5)
    1730                 :     168414 :         return DW_AT_GNU_all_call_sites;
    1731                 :            :       break;
    1732                 :            : 
    1733                 :     197036 :     case DW_AT_call_all_tail_calls:
    1734                 :     197036 :       if (dwarf_version < 5)
    1735                 :     197034 :         return DW_AT_GNU_all_tail_call_sites;
    1736                 :            :       break;
    1737                 :            : 
    1738                 :          8 :     case DW_AT_dwo_name:
    1739                 :          8 :       if (dwarf_version < 5)
    1740                 :          4 :         return DW_AT_GNU_dwo_name;
    1741                 :            :       break;
    1742                 :            : 
    1743                 :          4 :     case DW_AT_addr_base:
    1744                 :          4 :       if (dwarf_version < 5)
    1745                 :          4 :         return DW_AT_GNU_addr_base;
    1746                 :            :       break;
    1747                 :            : 
    1748                 :            :     default:
    1749                 :            :       break;
    1750                 :            :     }
    1751                 :            :   return at;
    1752                 :            : }
    1753                 :            : 
    1754                 :            : /* And similarly for tags.  */
    1755                 :            : static inline enum dwarf_tag
    1756                 :    4092920 : dwarf_TAG (enum dwarf_tag tag)
    1757                 :            : {
    1758                 :    4092920 :   switch (tag)
    1759                 :            :     {
    1760                 :    2070800 :     case DW_TAG_call_site:
    1761                 :    2070800 :       if (dwarf_version < 5)
    1762                 :    2070600 :         return DW_TAG_GNU_call_site;
    1763                 :            :       break;
    1764                 :            : 
    1765                 :    2022120 :     case DW_TAG_call_site_parameter:
    1766                 :    2022120 :       if (dwarf_version < 5)
    1767                 :    2021690 :         return DW_TAG_GNU_call_site_parameter;
    1768                 :            :       break;
    1769                 :            : 
    1770                 :            :     default:
    1771                 :            :       break;
    1772                 :            :     }
    1773                 :            :   return tag;
    1774                 :            : }
    1775                 :            : 
    1776                 :            : /* And similarly for forms.  */
    1777                 :            : static inline enum dwarf_form
    1778                 :   15884500 : dwarf_FORM (enum dwarf_form form)
    1779                 :            : {
    1780                 :   15884500 :   switch (form)
    1781                 :            :     {
    1782                 :         28 :     case DW_FORM_addrx:
    1783                 :         28 :       if (dwarf_version < 5)
    1784                 :         28 :         return DW_FORM_GNU_addr_index;
    1785                 :            :       break;
    1786                 :            : 
    1787                 :   15884500 :     case DW_FORM_strx:
    1788                 :   15884500 :       if (dwarf_version < 5)
    1789                 :   15883300 :         return DW_FORM_GNU_str_index;
    1790                 :            :       break;
    1791                 :            : 
    1792                 :            :     default:
    1793                 :            :       break;
    1794                 :            :     }
    1795                 :            :   return form;
    1796                 :            : }
    1797                 :            : 
    1798                 :            : static unsigned long int get_base_type_offset (dw_die_ref);
    1799                 :            : 
    1800                 :            : /* Return the size of a location descriptor.  */
    1801                 :            : 
    1802                 :            : static unsigned long
    1803                 :   97191000 : size_of_loc_descr (dw_loc_descr_ref loc)
    1804                 :            : {
    1805                 :   97191000 :   unsigned long size = 1;
    1806                 :            : 
    1807                 :   97191000 :   switch (loc->dw_loc_opc)
    1808                 :            :     {
    1809                 :    2152490 :     case DW_OP_addr:
    1810                 :    2152490 :       size += DWARF2_ADDR_SIZE;
    1811                 :    2152490 :       break;
    1812                 :         15 :     case DW_OP_GNU_addr_index:
    1813                 :         15 :     case DW_OP_addrx:
    1814                 :         15 :     case DW_OP_GNU_const_index:
    1815                 :         15 :     case DW_OP_constx:
    1816                 :         15 :       gcc_assert (loc->dw_loc_oprnd1.val_entry->index != NO_INDEX_ASSIGNED);
    1817                 :         15 :       size += size_of_uleb128 (loc->dw_loc_oprnd1.val_entry->index);
    1818                 :         15 :       break;
    1819                 :    1205620 :     case DW_OP_const1u:
    1820                 :    1205620 :     case DW_OP_const1s:
    1821                 :    1205620 :       size += 1;
    1822                 :    1205620 :       break;
    1823                 :     263800 :     case DW_OP_const2u:
    1824                 :     263800 :     case DW_OP_const2s:
    1825                 :     263800 :       size += 2;
    1826                 :     263800 :       break;
    1827                 :     262488 :     case DW_OP_const4u:
    1828                 :     262488 :     case DW_OP_const4s:
    1829                 :     262488 :       size += 4;
    1830                 :     262488 :       break;
    1831                 :       6003 :     case DW_OP_const8u:
    1832                 :       6003 :     case DW_OP_const8s:
    1833                 :       6003 :       size += 8;
    1834                 :       6003 :       break;
    1835                 :     126832 :     case DW_OP_constu:
    1836                 :     126832 :       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
    1837                 :     126832 :       break;
    1838                 :      71239 :     case DW_OP_consts:
    1839                 :      71239 :       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
    1840                 :      71239 :       break;
    1841                 :       2304 :     case DW_OP_pick:
    1842                 :       2304 :       size += 1;
    1843                 :       2304 :       break;
    1844                 :    1449730 :     case DW_OP_plus_uconst:
    1845                 :    1449730 :       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
    1846                 :    1449730 :       break;
    1847                 :     157564 :     case DW_OP_skip:
    1848                 :     157564 :     case DW_OP_bra:
    1849                 :     157564 :       size += 2;
    1850                 :     157564 :       break;
    1851                 :   10308400 :     case DW_OP_breg0:
    1852                 :   10308400 :     case DW_OP_breg1:
    1853                 :   10308400 :     case DW_OP_breg2:
    1854                 :   10308400 :     case DW_OP_breg3:
    1855                 :   10308400 :     case DW_OP_breg4:
    1856                 :   10308400 :     case DW_OP_breg5:
    1857                 :   10308400 :     case DW_OP_breg6:
    1858                 :   10308400 :     case DW_OP_breg7:
    1859                 :   10308400 :     case DW_OP_breg8:
    1860                 :   10308400 :     case DW_OP_breg9:
    1861                 :   10308400 :     case DW_OP_breg10:
    1862                 :   10308400 :     case DW_OP_breg11:
    1863                 :   10308400 :     case DW_OP_breg12:
    1864                 :   10308400 :     case DW_OP_breg13:
    1865                 :   10308400 :     case DW_OP_breg14:
    1866                 :   10308400 :     case DW_OP_breg15:
    1867                 :   10308400 :     case DW_OP_breg16:
    1868                 :   10308400 :     case DW_OP_breg17:
    1869                 :   10308400 :     case DW_OP_breg18:
    1870                 :   10308400 :     case DW_OP_breg19:
    1871                 :   10308400 :     case DW_OP_breg20:
    1872                 :   10308400 :     case DW_OP_breg21:
    1873                 :   10308400 :     case DW_OP_breg22:
    1874                 :   10308400 :     case DW_OP_breg23:
    1875                 :   10308400 :     case DW_OP_breg24:
    1876                 :   10308400 :     case DW_OP_breg25:
    1877                 :   10308400 :     case DW_OP_breg26:
    1878                 :   10308400 :     case DW_OP_breg27:
    1879                 :   10308400 :     case DW_OP_breg28:
    1880                 :   10308400 :     case DW_OP_breg29:
    1881                 :   10308400 :     case DW_OP_breg30:
    1882                 :   10308400 :     case DW_OP_breg31:
    1883                 :   10308400 :       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
    1884                 :   10308400 :       break;
    1885                 :      53844 :     case DW_OP_regx:
    1886                 :      53844 :       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
    1887                 :      53844 :       break;
    1888                 :   10879900 :     case DW_OP_fbreg:
    1889                 :   10879900 :       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
    1890                 :   10879900 :       break;
    1891                 :          0 :     case DW_OP_bregx:
    1892                 :          0 :       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
    1893                 :          0 :       size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
    1894                 :          0 :       break;
    1895                 :   10095900 :     case DW_OP_piece:
    1896                 :   10095900 :       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
    1897                 :   10095900 :       break;
    1898                 :       6282 :     case DW_OP_bit_piece:
    1899                 :       6282 :       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
    1900                 :       6282 :       size += size_of_uleb128 (loc->dw_loc_oprnd2.v.val_unsigned);
    1901                 :       6282 :       break;
    1902                 :     221262 :     case DW_OP_deref_size:
    1903                 :     221262 :     case DW_OP_xderef_size:
    1904                 :     221262 :       size += 1;
    1905                 :     221262 :       break;
    1906                 :          0 :     case DW_OP_call2:
    1907                 :          0 :       size += 2;
    1908                 :          0 :       break;
    1909                 :        172 :     case DW_OP_call4:
    1910                 :        172 :       size += 4;
    1911                 :        172 :       break;
    1912                 :       1050 :     case DW_OP_call_ref:
    1913                 :       1050 :     case DW_OP_GNU_variable_value:
    1914                 :       1050 :       size += DWARF_REF_SIZE;
    1915                 :       1050 :       break;
    1916                 :     226292 :     case DW_OP_implicit_value:
    1917                 :     226292 :       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned)
    1918                 :     226292 :               + loc->dw_loc_oprnd1.v.val_unsigned;
    1919                 :     226292 :       break;
    1920                 :    1153610 :     case DW_OP_implicit_pointer:
    1921                 :    1153610 :     case DW_OP_GNU_implicit_pointer:
    1922                 :    1153610 :       size += DWARF_REF_SIZE + size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
    1923                 :    1153610 :       break;
    1924                 :    2030340 :     case DW_OP_entry_value:
    1925                 :    2030340 :     case DW_OP_GNU_entry_value:
    1926                 :    2030340 :       {
    1927                 :    2030340 :         unsigned long op_size = size_of_locs (loc->dw_loc_oprnd1.v.val_loc);
    1928                 :    2030340 :         size += size_of_uleb128 (op_size) + op_size;
    1929                 :    2030340 :         break;
    1930                 :            :       }
    1931                 :     138690 :     case DW_OP_const_type:
    1932                 :     138690 :     case DW_OP_GNU_const_type:
    1933                 :     138690 :       {
    1934                 :     138690 :         unsigned long o
    1935                 :     138690 :           = get_base_type_offset (loc->dw_loc_oprnd1.v.val_die_ref.die);
    1936                 :     138690 :         size += size_of_uleb128 (o) + 1;
    1937                 :     138690 :         switch (loc->dw_loc_oprnd2.val_class)
    1938                 :            :           {
    1939                 :     129916 :           case dw_val_class_vec:
    1940                 :     129916 :             size += loc->dw_loc_oprnd2.v.val_vec.length
    1941                 :     129916 :                     * loc->dw_loc_oprnd2.v.val_vec.elt_size;
    1942                 :     129916 :             break;
    1943                 :       8385 :           case dw_val_class_const:
    1944                 :       8385 :             size += HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT;
    1945                 :       8385 :             break;
    1946                 :         86 :           case dw_val_class_const_double:
    1947                 :         86 :             size += HOST_BITS_PER_DOUBLE_INT / BITS_PER_UNIT;
    1948                 :         86 :             break;
    1949                 :        303 :           case dw_val_class_wide_int:
    1950                 :        303 :             size += (get_full_len (*loc->dw_loc_oprnd2.v.val_wide)
    1951                 :        303 :                      * HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT);
    1952                 :        303 :             break;
    1953                 :          0 :           default:
    1954                 :          0 :             gcc_unreachable ();
    1955                 :            :           }
    1956                 :            :         break;
    1957                 :            :       }
    1958                 :     169581 :     case DW_OP_regval_type:
    1959                 :     169581 :     case DW_OP_GNU_regval_type:
    1960                 :     169581 :       {
    1961                 :     169581 :         unsigned long o
    1962                 :     169581 :           = get_base_type_offset (loc->dw_loc_oprnd2.v.val_die_ref.die);
    1963                 :     169581 :         size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned)
    1964                 :     169581 :                 + size_of_uleb128 (o);
    1965                 :            :       }
    1966                 :     169581 :       break;
    1967                 :     191686 :     case DW_OP_deref_type:
    1968                 :     191686 :     case DW_OP_GNU_deref_type:
    1969                 :     191686 :       {
    1970                 :     191686 :         unsigned long o
    1971                 :     191686 :           = get_base_type_offset (loc->dw_loc_oprnd2.v.val_die_ref.die);
    1972                 :     191686 :         size += 1 + size_of_uleb128 (o);
    1973                 :            :       }
    1974                 :     191686 :       break;
    1975                 :     240288 :     case DW_OP_convert:
    1976                 :     240288 :     case DW_OP_reinterpret:
    1977                 :     240288 :     case DW_OP_GNU_convert:
    1978                 :     240288 :     case DW_OP_GNU_reinterpret:
    1979                 :     240288 :       if (loc->dw_loc_oprnd1.val_class == dw_val_class_unsigned_const)
    1980                 :      15678 :         size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
    1981                 :            :       else
    1982                 :            :         {
    1983                 :     224610 :           unsigned long o
    1984                 :     224610 :             = get_base_type_offset (loc->dw_loc_oprnd1.v.val_die_ref.die);
    1985                 :     224610 :           size += size_of_uleb128 (o);
    1986                 :            :         }
    1987                 :            :       break;
    1988                 :      29568 :     case DW_OP_GNU_parameter_ref:
    1989                 :      29568 :       size += 4;
    1990                 :      29568 :       break;
    1991                 :            :     default:
    1992                 :            :       break;
    1993                 :            :     }
    1994                 :            : 
    1995                 :   97191000 :   return size;
    1996                 :            : }
    1997                 :            : 
    1998                 :            : /* Return the size of a series of location descriptors.  */
    1999                 :            : 
    2000                 :            : unsigned long
    2001                 :   51691100 : size_of_locs (dw_loc_descr_ref loc)
    2002                 :            : {
    2003                 :   51691100 :   dw_loc_descr_ref l;
    2004                 :   51691100 :   unsigned long size;
    2005                 :            : 
    2006                 :            :   /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
    2007                 :            :      field, to avoid writing to a PCH file.  */
    2008                 :  146000000 :   for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
    2009                 :            :     {
    2010                 :   94423900 :       if (l->dw_loc_opc == DW_OP_skip || l->dw_loc_opc == DW_OP_bra)
    2011                 :            :         break;
    2012                 :   94309400 :       size += size_of_loc_descr (l);
    2013                 :            :     }
    2014                 :   51691100 :   if (! l)
    2015                 :            :     return size;
    2016                 :            : 
    2017                 :    2555460 :   for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
    2018                 :            :     {
    2019                 :    2441010 :       l->dw_loc_addr = size;
    2020                 :    2441010 :       size += size_of_loc_descr (l);
    2021                 :            :     }
    2022                 :            : 
    2023                 :            :   return size;
    2024                 :            : }
    2025                 :            : 
    2026                 :            : /* Return the size of the value in a DW_AT_discr_value attribute.  */
    2027                 :            : 
    2028                 :            : static int
    2029                 :          0 : size_of_discr_value (dw_discr_value *discr_value)
    2030                 :            : {
    2031                 :          0 :   if (discr_value->pos)
    2032                 :          0 :     return size_of_uleb128 (discr_value->v.uval);
    2033                 :            :   else
    2034                 :          0 :     return size_of_sleb128 (discr_value->v.sval);
    2035                 :            : }
    2036                 :            : 
    2037                 :            : /* Return the size of the value in a DW_AT_discr_list attribute.  */
    2038                 :            : 
    2039                 :            : static int
    2040                 :          0 : size_of_discr_list (dw_discr_list_ref discr_list)
    2041                 :            : {
    2042                 :          0 :   int size = 0;
    2043                 :            : 
    2044                 :          0 :   for (dw_discr_list_ref list = discr_list;
    2045                 :          0 :        list != NULL;
    2046                 :          0 :        list = list->dw_discr_next)
    2047                 :            :     {
    2048                 :            :       /* One byte for the discriminant value descriptor, and then one or two
    2049                 :            :          LEB128 numbers, depending on whether it's a single case label or a
    2050                 :            :          range label.  */
    2051                 :          0 :       size += 1;
    2052                 :          0 :       size += size_of_discr_value (&list->dw_discr_lower_bound);
    2053                 :          0 :       if (list->dw_discr_range != 0)
    2054                 :          0 :         size += size_of_discr_value (&list->dw_discr_upper_bound);
    2055                 :            :     }
    2056                 :          0 :   return size;
    2057                 :            : }
    2058                 :            : 
    2059                 :            : static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
    2060                 :            : static void get_ref_die_offset_label (char *, dw_die_ref);
    2061                 :            : static unsigned long int get_ref_die_offset (dw_die_ref);
    2062                 :            : 
    2063                 :            : /* Output location description stack opcode's operands (if any).
    2064                 :            :    The for_eh_or_skip parameter controls whether register numbers are
    2065                 :            :    converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
    2066                 :            :    hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
    2067                 :            :    info).  This should be suppressed for the cases that have not been converted
    2068                 :            :    (i.e. symbolic debug info), by setting the parameter < 0.  See PR47324.  */
    2069                 :            : 
    2070                 :            : static void
    2071                 :   33272500 : output_loc_operands (dw_loc_descr_ref loc, int for_eh_or_skip)
    2072                 :            : {
    2073                 :   33272500 :   dw_val_ref val1 = &loc->dw_loc_oprnd1;
    2074                 :   33272500 :   dw_val_ref val2 = &loc->dw_loc_oprnd2;
    2075                 :            : 
    2076                 :   33272500 :   switch (loc->dw_loc_opc)
    2077                 :            :     {
    2078                 :            : #ifdef DWARF2_DEBUGGING_INFO
    2079                 :      82570 :     case DW_OP_const2u:
    2080                 :      82570 :     case DW_OP_const2s:
    2081                 :      82570 :       dw2_asm_output_data (2, val1->v.val_int, NULL);
    2082                 :      82570 :       break;
    2083                 :      85504 :     case DW_OP_const4u:
    2084                 :      85504 :       if (loc->dtprel)
    2085                 :            :         {
    2086                 :        111 :           gcc_assert (targetm.asm_out.output_dwarf_dtprel);
    2087                 :        111 :           targetm.asm_out.output_dwarf_dtprel (asm_out_file, 4,
    2088                 :            :                                                val1->v.val_addr);
    2089                 :        111 :           fputc ('\n', asm_out_file);
    2090                 :        111 :           break;
    2091                 :            :         }
    2092                 :            :       /* FALLTHRU */
    2093                 :      85393 :     case DW_OP_const4s:
    2094                 :      85393 :       dw2_asm_output_data (4, val1->v.val_int, NULL);
    2095                 :      85393 :       break;
    2096                 :       2204 :     case DW_OP_const8u:
    2097                 :       2204 :       if (loc->dtprel)
    2098                 :            :         {
    2099                 :        762 :           gcc_assert (targetm.asm_out.output_dwarf_dtprel);
    2100                 :        762 :           targetm.asm_out.output_dwarf_dtprel (asm_out_file, 8,
    2101                 :            :                                                val1->v.val_addr);
    2102                 :        762 :           fputc ('\n', asm_out_file);
    2103                 :        762 :           break;
    2104                 :            :         }
    2105                 :            :       /* FALLTHRU */
    2106                 :       1442 :     case DW_OP_const8s:
    2107                 :       1442 :       gcc_assert (HOST_BITS_PER_WIDE_INT >= 64);
    2108                 :       1442 :       dw2_asm_output_data (8, val1->v.val_int, NULL);
    2109                 :       1442 :       break;
    2110                 :      43438 :     case DW_OP_skip:
    2111                 :      43438 :     case DW_OP_bra:
    2112                 :      43438 :       {
    2113                 :      43438 :         int offset;
    2114                 :            : 
    2115                 :      43438 :         gcc_assert (val1->val_class == dw_val_class_loc);
    2116                 :      43438 :         offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
    2117                 :            : 
    2118                 :      43438 :         dw2_asm_output_data (2, offset, NULL);
    2119                 :            :       }
    2120                 :      43438 :       break;
    2121                 :      75879 :     case DW_OP_implicit_value:
    2122                 :      75879 :       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
    2123                 :      75879 :       switch (val2->val_class)
    2124                 :            :         {
    2125                 :      22511 :         case dw_val_class_const:
    2126                 :      22511 :           dw2_asm_output_data (val1->v.val_unsigned, val2->v.val_int, NULL);
    2127                 :      22511 :           break;
    2128                 :      53291 :         case dw_val_class_vec:
    2129                 :      53291 :           {
    2130                 :      53291 :             unsigned int elt_size = val2->v.val_vec.elt_size;
    2131                 :      53291 :             unsigned int len = val2->v.val_vec.length;
    2132                 :      53291 :             unsigned int i;
    2133                 :      53291 :             unsigned char *p;
    2134                 :            : 
    2135                 :      53291 :             if (elt_size > sizeof (HOST_WIDE_INT))
    2136                 :            :               {
    2137                 :          1 :                 elt_size /= 2;
    2138                 :          1 :                 len *= 2;
    2139                 :            :               }
    2140                 :      53291 :             for (i = 0, p = (unsigned char *) val2->v.val_vec.array;
    2141                 :     199456 :                  i < len;
    2142                 :     146165 :                  i++, p += elt_size)
    2143                 :     292330 :               dw2_asm_output_data (elt_size, extract_int (p, elt_size),
    2144                 :            :                                    "fp or vector constant word %u", i);
    2145                 :            :           }
    2146                 :            :           break;
    2147                 :          0 :         case dw_val_class_const_double:
    2148                 :          0 :           {
    2149                 :          0 :             unsigned HOST_WIDE_INT first, second;
    2150                 :            : 
    2151                 :          0 :             if (WORDS_BIG_ENDIAN)
    2152                 :            :               {
    2153                 :            :                 first = val2->v.val_double.high;
    2154                 :            :                 second = val2->v.val_double.low;
    2155                 :            :               }
    2156                 :            :             else
    2157                 :            :               {
    2158                 :          0 :                 first = val2->v.val_double.low;
    2159                 :          0 :                 second = val2->v.val_double.high;
    2160                 :            :               }
    2161                 :          0 :             dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
    2162                 :            :                                  first, NULL);
    2163                 :          0 :             dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
    2164                 :            :                                  second, NULL);
    2165                 :            :           }
    2166                 :          0 :           break;
    2167                 :         77 :         case dw_val_class_wide_int:
    2168                 :         77 :           {
    2169                 :         77 :             int i;
    2170                 :         77 :             int len = get_full_len (*val2->v.val_wide);
    2171                 :         77 :             if (WORDS_BIG_ENDIAN)
    2172                 :            :               for (i = len - 1; i >= 0; --i)
    2173                 :            :                 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
    2174                 :            :                                      val2->v.val_wide->elt (i), NULL);
    2175                 :            :             else
    2176                 :        223 :               for (i = 0; i < len; ++i)
    2177                 :        292 :                 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
    2178                 :        292 :                                      val2->v.val_wide->elt (i), NULL);
    2179                 :            :           }
    2180                 :            :           break;
    2181                 :          0 :         case dw_val_class_addr:
    2182                 :          0 :           gcc_assert (val1->v.val_unsigned == DWARF2_ADDR_SIZE);
    2183                 :          0 :           dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val2->v.val_addr, NULL);
    2184                 :          0 :           break;
    2185                 :          0 :         default:
    2186                 :          0 :           gcc_unreachable ();
    2187                 :            :         }
    2188                 :            :       break;
    2189                 :            : #else
    2190                 :            :     case DW_OP_const2u:
    2191                 :            :     case DW_OP_const2s:
    2192                 :            :     case DW_OP_const4u:
    2193                 :            :     case DW_OP_const4s:
    2194                 :            :     case DW_OP_const8u:
    2195                 :            :     case DW_OP_const8s:
    2196                 :            :     case DW_OP_skip:
    2197                 :            :     case DW_OP_bra:
    2198                 :            :     case DW_OP_implicit_value:
    2199                 :            :       /* We currently don't make any attempt to make sure these are
    2200                 :            :          aligned properly like we do for the main unwind info, so
    2201                 :            :          don't support emitting things larger than a byte if we're
    2202                 :            :          only doing unwinding.  */
    2203                 :            :       gcc_unreachable ();
    2204                 :            : #endif
    2205                 :     390176 :     case DW_OP_const1u:
    2206                 :     390176 :     case DW_OP_const1s:
    2207                 :     390176 :       dw2_asm_output_data (1, val1->v.val_int, NULL);
    2208                 :     390176 :       break;
    2209                 :      40270 :     case DW_OP_constu:
    2210                 :      40270 :       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
    2211                 :      40270 :       break;
    2212                 :      20690 :     case DW_OP_consts:
    2213                 :      20690 :       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
    2214                 :      20690 :       break;
    2215                 :        294 :     case DW_OP_pick:
    2216                 :        294 :       dw2_asm_output_data (1, val1->v.val_int, NULL);
    2217                 :        294 :       break;
    2218                 :     338111 :     case DW_OP_plus_uconst:
    2219                 :     338111 :       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
    2220                 :     338111 :       break;
    2221                 :    3613460 :     case DW_OP_breg0:
    2222                 :    3613460 :     case DW_OP_breg1:
    2223                 :    3613460 :     case DW_OP_breg2:
    2224                 :    3613460 :     case DW_OP_breg3:
    2225                 :    3613460 :     case DW_OP_breg4:
    2226                 :    3613460 :     case DW_OP_breg5:
    2227                 :    3613460 :     case DW_OP_breg6:
    2228                 :    3613460 :     case DW_OP_breg7:
    2229                 :    3613460 :     case DW_OP_breg8:
    2230                 :    3613460 :     case DW_OP_breg9:
    2231                 :    3613460 :     case DW_OP_breg10:
    2232                 :    3613460 :     case DW_OP_breg11:
    2233                 :    3613460 :     case DW_OP_breg12:
    2234                 :    3613460 :     case DW_OP_breg13:
    2235                 :    3613460 :     case DW_OP_breg14:
    2236                 :    3613460 :     case DW_OP_breg15:
    2237                 :    3613460 :     case DW_OP_breg16:
    2238                 :    3613460 :     case DW_OP_breg17:
    2239                 :    3613460 :     case DW_OP_breg18:
    2240                 :    3613460 :     case DW_OP_breg19:
    2241                 :    3613460 :     case DW_OP_breg20:
    2242                 :    3613460 :     case DW_OP_breg21:
    2243                 :    3613460 :     case DW_OP_breg22:
    2244                 :    3613460 :     case DW_OP_breg23:
    2245                 :    3613460 :     case DW_OP_breg24:
    2246                 :    3613460 :     case DW_OP_breg25:
    2247                 :    3613460 :     case DW_OP_breg26:
    2248                 :    3613460 :     case DW_OP_breg27:
    2249                 :    3613460 :     case DW_OP_breg28:
    2250                 :    3613460 :     case DW_OP_breg29:
    2251                 :    3613460 :     case DW_OP_breg30:
    2252                 :    3613460 :     case DW_OP_breg31:
    2253                 :    3613460 :       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
    2254                 :    3613460 :       break;
    2255                 :      17954 :     case DW_OP_regx:
    2256                 :      17954 :       {
    2257                 :      17954 :         unsigned r = val1->v.val_unsigned;
    2258                 :      17954 :         if (for_eh_or_skip >= 0)
    2259                 :            :           r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
    2260                 :      17954 :         gcc_assert (size_of_uleb128 (r) 
    2261                 :            :                     == size_of_uleb128 (val1->v.val_unsigned));
    2262                 :      17954 :         dw2_asm_output_data_uleb128 (r, NULL);  
    2263                 :            :       }
    2264                 :      17954 :       break;
    2265                 :    3861990 :     case DW_OP_fbreg:
    2266                 :    3861990 :       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
    2267                 :    3861990 :       break;
    2268                 :          0 :     case DW_OP_bregx:
    2269                 :          0 :       {
    2270                 :          0 :         unsigned r = val1->v.val_unsigned;
    2271                 :          0 :         if (for_eh_or_skip >= 0)
    2272                 :            :           r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
    2273                 :          0 :         gcc_assert (size_of_uleb128 (r) 
    2274                 :            :                     == size_of_uleb128 (val1->v.val_unsigned));
    2275                 :          0 :         dw2_asm_output_data_uleb128 (r, NULL);  
    2276                 :          0 :         dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
    2277                 :            :       }
    2278                 :          0 :       break;
    2279                 :    3362740 :     case DW_OP_piece:
    2280                 :    3362740 :       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
    2281                 :    3362740 :       break;
    2282                 :       2094 :     case DW_OP_bit_piece:
    2283                 :       2094 :       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
    2284                 :       2094 :       dw2_asm_output_data_uleb128 (val2->v.val_unsigned, NULL);
    2285                 :       2094 :       break;
    2286                 :      72727 :     case DW_OP_deref_size:
    2287                 :      72727 :     case DW_OP_xderef_size:
    2288                 :      72727 :       dw2_asm_output_data (1, val1->v.val_int, NULL);
    2289                 :      72727 :       break;
    2290                 :            : 
    2291                 :     936978 :     case DW_OP_addr:
    2292                 :     936978 :       if (loc->dtprel)
    2293                 :            :         {
    2294                 :          0 :           if (targetm.asm_out.output_dwarf_dtprel)
    2295                 :            :             {
    2296                 :          0 :               targetm.asm_out.output_dwarf_dtprel (asm_out_file,
    2297                 :          0 :                                                    DWARF2_ADDR_SIZE,
    2298                 :            :                                                    val1->v.val_addr);
    2299                 :          0 :               fputc ('\n', asm_out_file);
    2300                 :            :             }
    2301                 :            :           else
    2302                 :          0 :             gcc_unreachable ();
    2303                 :            :         }
    2304                 :            :       else
    2305                 :            :         {
    2306                 :            : #ifdef DWARF2_DEBUGGING_INFO
    2307                 :    1004740 :           dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
    2308                 :            : #else
    2309                 :            :           gcc_unreachable ();
    2310                 :            : #endif
    2311                 :            :         }
    2312                 :            :       break;
    2313                 :            : 
    2314                 :          7 :     case DW_OP_GNU_addr_index:
    2315                 :          7 :     case DW_OP_addrx:
    2316                 :          7 :     case DW_OP_GNU_const_index:
    2317                 :          7 :     case DW_OP_constx:
    2318                 :          7 :       gcc_assert (loc->dw_loc_oprnd1.val_entry->index != NO_INDEX_ASSIGNED);
    2319                 :          7 :       dw2_asm_output_data_uleb128 (loc->dw_loc_oprnd1.val_entry->index,
    2320                 :            :                                    "(index into .debug_addr)");
    2321                 :          7 :       break;
    2322                 :            : 
    2323                 :         86 :     case DW_OP_call2:
    2324                 :         86 :     case DW_OP_call4:
    2325                 :         86 :       {
    2326                 :         86 :         unsigned long die_offset
    2327                 :        172 :           = get_ref_die_offset (val1->v.val_die_ref.die);
    2328                 :            :         /* Make sure the offset has been computed and that we can encode it as
    2329                 :            :            an operand.  */
    2330                 :         86 :         gcc_assert (die_offset > 0
    2331                 :            :                     && die_offset <= (loc->dw_loc_opc == DW_OP_call2
    2332                 :            :                                      ? 0xffff
    2333                 :            :                                      : 0xffffffff));
    2334                 :         86 :         dw2_asm_output_data ((loc->dw_loc_opc == DW_OP_call2) ? 2 : 4,
    2335                 :            :                              die_offset, NULL);
    2336                 :            :       }
    2337                 :         86 :       break;
    2338                 :            : 
    2339                 :        525 :     case DW_OP_call_ref:
    2340                 :        525 :     case DW_OP_GNU_variable_value:
    2341                 :        525 :       {
    2342                 :        525 :         char label[MAX_ARTIFICIAL_LABEL_BYTES
    2343                 :            :                    + HOST_BITS_PER_WIDE_INT / 2 + 2];
    2344                 :        525 :         gcc_assert (val1->val_class == dw_val_class_die_ref);
    2345                 :        525 :         get_ref_die_offset_label (label, val1->v.val_die_ref.die);
    2346                 :        525 :         dw2_asm_output_offset (DWARF_REF_SIZE, label, debug_info_section, NULL);
    2347                 :            :       }
    2348                 :        525 :       break;
    2349                 :            : 
    2350                 :     383283 :     case DW_OP_implicit_pointer:
    2351                 :     383283 :     case DW_OP_GNU_implicit_pointer:
    2352                 :     383283 :       {
    2353                 :     383283 :         char label[MAX_ARTIFICIAL_LABEL_BYTES
    2354                 :            :                    + HOST_BITS_PER_WIDE_INT / 2 + 2];
    2355                 :     383283 :         gcc_assert (val1->val_class == dw_val_class_die_ref);
    2356                 :     383283 :         get_ref_die_offset_label (label, val1->v.val_die_ref.die);
    2357                 :     383283 :         dw2_asm_output_offset (DWARF_REF_SIZE, label, debug_info_section, NULL);
    2358                 :     383283 :         dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
    2359                 :            :       }
    2360                 :     383283 :       break;
    2361                 :            : 
    2362                 :     706310 :     case DW_OP_entry_value:
    2363                 :     706310 :     case DW_OP_GNU_entry_value:
    2364                 :     706310 :       dw2_asm_output_data_uleb128 (size_of_locs (val1->v.val_loc), NULL);
    2365                 :     706310 :       output_loc_sequence (val1->v.val_loc, for_eh_or_skip);
    2366                 :     706310 :       break;
    2367                 :            : 
    2368                 :      48377 :     case DW_OP_const_type:
    2369                 :      48377 :     case DW_OP_GNU_const_type:
    2370                 :      48377 :       {
    2371                 :      48377 :         unsigned long o = get_base_type_offset (val1->v.val_die_ref.die), l;
    2372                 :      48377 :         gcc_assert (o);
    2373                 :      48377 :         dw2_asm_output_data_uleb128 (o, NULL);
    2374                 :      48377 :         switch (val2->val_class)
    2375                 :            :           {
    2376                 :       2781 :           case dw_val_class_const:
    2377                 :       2781 :             l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
    2378                 :       2781 :             dw2_asm_output_data (1, l, NULL);
    2379                 :       2781 :             dw2_asm_output_data (l, val2->v.val_int, NULL);
    2380                 :       2781 :             break;
    2381                 :      45460 :           case dw_val_class_vec:
    2382                 :      45460 :             {
    2383                 :      45460 :               unsigned int elt_size = val2->v.val_vec.elt_size;
    2384                 :      45460 :               unsigned int len = val2->v.val_vec.length;
    2385                 :      45460 :               unsigned int i;
    2386                 :      45460 :               unsigned char *p;
    2387                 :            : 
    2388                 :      45460 :               l = len * elt_size;
    2389                 :      45460 :               dw2_asm_output_data (1, l, NULL);
    2390                 :      45460 :               if (elt_size > sizeof (HOST_WIDE_INT))
    2391                 :            :                 {
    2392                 :          0 :                   elt_size /= 2;
    2393                 :          0 :                   len *= 2;
    2394                 :            :                 }
    2395                 :      45460 :               for (i = 0, p = (unsigned char *) val2->v.val_vec.array;
    2396                 :     183374 :                    i < len;
    2397                 :     137914 :                    i++, p += elt_size)
    2398                 :     275828 :                 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
    2399                 :            :                                      "fp or vector constant word %u", i);
    2400                 :            :             }
    2401                 :            :             break;
    2402                 :         32 :           case dw_val_class_const_double:
    2403                 :         32 :             {
    2404                 :         32 :               unsigned HOST_WIDE_INT first, second;
    2405                 :         32 :               l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
    2406                 :            : 
    2407                 :         32 :               dw2_asm_output_data (1, 2 * l, NULL);
    2408                 :         32 :               if (WORDS_BIG_ENDIAN)
    2409                 :            :                 {
    2410                 :            :                   first = val2->v.val_double.high;
    2411                 :            :                   second = val2->v.val_double.low;
    2412                 :            :                 }
    2413                 :            :               else
    2414                 :            :                 {
    2415                 :         32 :                   first = val2->v.val_double.low;
    2416                 :         32 :                   second = val2->v.val_double.high;
    2417                 :            :                 }
    2418                 :         32 :               dw2_asm_output_data (l, first, NULL);
    2419                 :         32 :               dw2_asm_output_data (l, second, NULL);
    2420                 :            :             }
    2421                 :         32 :             break;
    2422                 :        104 :           case dw_val_class_wide_int:
    2423                 :        104 :             {
    2424                 :        104 :               int i;
    2425                 :        104 :               int len = get_full_len (*val2->v.val_wide);
    2426                 :        104 :               l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
    2427                 :            : 
    2428                 :        104 :               dw2_asm_output_data (1, len * l, NULL);
    2429                 :        104 :               if (WORDS_BIG_ENDIAN)
    2430                 :            :                 for (i = len - 1; i >= 0; --i)
    2431                 :            :                   dw2_asm_output_data (l, val2->v.val_wide->elt (i), NULL);
    2432                 :            :               else
    2433                 :        221 :                 for (i = 0; i < len; ++i)
    2434                 :        234 :                   dw2_asm_output_data (l, val2->v.val_wide->elt (i), NULL);
    2435                 :            :             }
    2436                 :            :             break;
    2437                 :          0 :           default:
    2438                 :          0 :             gcc_unreachable ();
    2439                 :            :           }
    2440                 :            :       }
    2441                 :            :       break;
    2442                 :      53310 :     case DW_OP_regval_type:
    2443                 :      53310 :     case DW_OP_GNU_regval_type:
    2444                 :      53310 :       {
    2445                 :      53310 :         unsigned r = val1->v.val_unsigned;
    2446                 :      53310 :         unsigned long o = get_base_type_offset (val2->v.val_die_ref.die);
    2447                 :      53310 :         gcc_assert (o);
    2448                 :      53310 :         if (for_eh_or_skip >= 0)
    2449                 :            :           {
    2450                 :          0 :             r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
    2451                 :          0 :             gcc_assert (size_of_uleb128 (r)
    2452                 :            :                         == size_of_uleb128 (val1->v.val_unsigned));
    2453                 :            :           }
    2454                 :      53310 :         dw2_asm_output_data_uleb128 (r, NULL);
    2455                 :      53310 :         dw2_asm_output_data_uleb128 (o, NULL);
    2456                 :            :       }
    2457                 :      53310 :       break;
    2458                 :      65151 :     case DW_OP_deref_type:
    2459                 :      65151 :     case DW_OP_GNU_deref_type:
    2460                 :      65151 :       {
    2461                 :      65151 :         unsigned long o = get_base_type_offset (val2->v.val_die_ref.die);
    2462                 :      65151 :         gcc_assert (o);
    2463                 :      65151 :         dw2_asm_output_data (1, val1->v.val_int, NULL);
    2464                 :      65151 :         dw2_asm_output_data_uleb128 (o, NULL);
    2465                 :            :       }
    2466                 :      65151 :       break;
    2467                 :      77199 :     case DW_OP_convert:
    2468                 :      77199 :     case DW_OP_reinterpret:
    2469                 :      77199 :     case DW_OP_GNU_convert:
    2470                 :      77199 :     case DW_OP_GNU_reinterpret:
    2471                 :      77199 :       if (loc->dw_loc_oprnd1.val_class == dw_val_class_unsigned_const)
    2472                 :       4689 :         dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
    2473                 :            :       else
    2474                 :            :         {
    2475                 :      72510 :           unsigned long o = get_base_type_offset (val1->v.val_die_ref.die);
    2476                 :      72510 :           gcc_assert (o);
    2477                 :      72510 :           dw2_asm_output_data_uleb128 (o, NULL);
    2478                 :            :         }
    2479                 :            :       break;
    2480                 :            : 
    2481                 :       9856 :     case DW_OP_GNU_parameter_ref:
    2482                 :       9856 :       {
    2483                 :       9856 :         unsigned long o;
    2484                 :       9856 :         gcc_assert (val1->val_class == dw_val_class_die_ref);
    2485                 :      19712 :         o = get_ref_die_offset (val1->v.val_die_ref.die);
    2486                 :       9856 :         dw2_asm_output_data (4, o, NULL);
    2487                 :            :       }
    2488                 :       9856 :       break;
    2489                 :            : 
    2490                 :            :     default:
    2491                 :            :       /* Other codes have no operands.  */
    2492                 :            :       break;
    2493                 :            :     }
    2494                 :   33272500 : }
    2495                 :            : 
    2496                 :            : /* Output a sequence of location operations.  
    2497                 :            :    The for_eh_or_skip parameter controls whether register numbers are
    2498                 :            :    converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
    2499                 :            :    hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
    2500                 :            :    info).  This should be suppressed for the cases that have not been converted
    2501                 :            :    (i.e. symbolic debug info), by setting the parameter < 0.  See PR47324.  */
    2502                 :            : 
    2503                 :            : void
    2504                 :   18752300 : output_loc_sequence (dw_loc_descr_ref loc, int for_eh_or_skip)
    2505                 :            : {
    2506                 :   52024800 :   for (; loc != NULL; loc = loc->dw_loc_next)
    2507                 :            :     {
    2508                 :   33272500 :       enum dwarf_location_atom opc = loc->dw_loc_opc;
    2509                 :            :       /* Output the opcode.  */
    2510                 :   33272500 :       if (for_eh_or_skip >= 0 
    2511                 :   33272500 :           && opc >= DW_OP_breg0 && opc <= DW_OP_breg31)
    2512                 :            :         {
    2513                 :          0 :           unsigned r = (opc - DW_OP_breg0);
    2514                 :          0 :           r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
    2515                 :          0 :           gcc_assert (r <= 31);
    2516                 :            :           opc = (enum dwarf_location_atom) (DW_OP_breg0 + r);
    2517                 :            :         }
    2518                 :   33272500 :       else if (for_eh_or_skip >= 0 
    2519                 :   33272500 :                && opc >= DW_OP_reg0 && opc <= DW_OP_reg31)
    2520                 :            :         {
    2521                 :          0 :           unsigned r = (opc - DW_OP_reg0);
    2522                 :          0 :           r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
    2523                 :          0 :           gcc_assert (r <= 31);
    2524                 :            :           opc = (enum dwarf_location_atom) (DW_OP_reg0 + r);
    2525                 :            :         }
    2526                 :            : 
    2527                 :   66545000 :       dw2_asm_output_data (1, opc,
    2528                 :            :                              "%s", dwarf_stack_op_name (opc));
    2529                 :            : 
    2530                 :            :       /* Output the operand(s) (if any).  */
    2531                 :   33272500 :       output_loc_operands (loc, for_eh_or_skip);
    2532                 :            :     }
    2533                 :   18752300 : }
    2534                 :            : 
    2535                 :            : /* Output location description stack opcode's operands (if any).
    2536                 :            :    The output is single bytes on a line, suitable for .cfi_escape.  */
    2537                 :            : 
    2538                 :            : static void
    2539                 :      55804 : output_loc_operands_raw (dw_loc_descr_ref loc)
    2540                 :            : {
    2541                 :      55804 :   dw_val_ref val1 = &loc->dw_loc_oprnd1;
    2542                 :      55804 :   dw_val_ref val2 = &loc->dw_loc_oprnd2;
    2543                 :            : 
    2544                 :      55804 :   switch (loc->dw_loc_opc)
    2545                 :            :     {
    2546                 :          0 :     case DW_OP_addr:
    2547                 :          0 :     case DW_OP_GNU_addr_index:
    2548                 :          0 :     case DW_OP_addrx:
    2549                 :          0 :     case DW_OP_GNU_const_index:
    2550                 :          0 :     case DW_OP_constx:
    2551                 :          0 :     case DW_OP_implicit_value:
    2552                 :            :       /* We cannot output addresses in .cfi_escape, only bytes.  */
    2553                 :          0 :       gcc_unreachable ();
    2554                 :            : 
    2555                 :          0 :     case DW_OP_const1u:
    2556                 :          0 :     case DW_OP_const1s:
    2557                 :          0 :     case DW_OP_pick:
    2558                 :          0 :     case DW_OP_deref_size:
    2559                 :          0 :     case DW_OP_xderef_size:
    2560                 :          0 :       fputc (',', asm_out_file);
    2561                 :          0 :       dw2_asm_output_data_raw (1, val1->v.val_int);
    2562                 :          0 :       break;
    2563                 :            : 
    2564                 :          0 :     case DW_OP_const2u:
    2565                 :          0 :     case DW_OP_const2s:
    2566                 :          0 :       fputc (',', asm_out_file);
    2567                 :          0 :       dw2_asm_output_data_raw (2, val1->v.val_int);
    2568                 :          0 :       break;
    2569                 :            : 
    2570                 :          0 :     case DW_OP_const4u:
    2571                 :          0 :     case DW_OP_const4s:
    2572                 :          0 :       fputc (',', asm_out_file);
    2573                 :          0 :       dw2_asm_output_data_raw (4, val1->v.val_int);
    2574                 :          0 :       break;
    2575                 :            : 
    2576                 :          0 :     case DW_OP_const8u:
    2577                 :          0 :     case DW_OP_const8s:
    2578                 :          0 :       gcc_assert (HOST_BITS_PER_WIDE_INT >= 64);
    2579                 :          0 :       fputc (',', asm_out_file);
    2580                 :          0 :       dw2_asm_output_data_raw (8, val1->v.val_int);
    2581                 :          0 :       break;
    2582                 :            : 
    2583                 :          0 :     case DW_OP_skip:
    2584                 :          0 :     case DW_OP_bra:
    2585                 :          0 :       {
    2586                 :          0 :         int offset;
    2587                 :            : 
    2588                 :          0 :         gcc_assert (val1->val_class == dw_val_class_loc);
    2589                 :          0 :         offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
    2590                 :            : 
    2591                 :          0 :         fputc (',', asm_out_file);
    2592                 :          0 :         dw2_asm_output_data_raw (2, offset);
    2593                 :            :       }
    2594                 :          0 :       break;
    2595                 :            : 
    2596                 :          0 :     case DW_OP_regx:
    2597                 :          0 :       {
    2598                 :          0 :         unsigned r = DWARF2_FRAME_REG_OUT (val1->v.val_unsigned, 1);
    2599                 :          0 :         gcc_assert (size_of_uleb128 (r) 
    2600                 :            :                     == size_of_uleb128 (val1->v.val_unsigned));
    2601                 :          0 :         fputc (',', asm_out_file);
    2602                 :          0 :         dw2_asm_output_data_uleb128_raw (r);
    2603                 :            :       }
    2604                 :          0 :       break;
    2605                 :            :       
    2606                 :          0 :     case DW_OP_constu:
    2607                 :          0 :     case DW_OP_plus_uconst:
    2608                 :          0 :     case DW_OP_piece:
    2609                 :          0 :       fputc (',', asm_out_file);
    2610                 :          0 :       dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
    2611                 :          0 :       break;
    2612                 :            : 
    2613                 :          0 :     case DW_OP_bit_piece:
    2614                 :          0 :       fputc (',', asm_out_file);
    2615                 :          0 :       dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
    2616                 :          0 :       dw2_asm_output_data_uleb128_raw (val2->v.val_unsigned);
    2617                 :          0 :       break;
    2618                 :            : 
    2619                 :      48916 :     case DW_OP_consts:
    2620                 :      48916 :     case DW_OP_breg0:
    2621                 :      48916 :     case DW_OP_breg1:
    2622                 :      48916 :     case DW_OP_breg2:
    2623                 :      48916 :     case DW_OP_breg3:
    2624                 :      48916 :     case DW_OP_breg4:
    2625                 :      48916 :     case DW_OP_breg5:
    2626                 :      48916 :     case DW_OP_breg6:
    2627                 :      48916 :     case DW_OP_breg7:
    2628                 :      48916 :     case DW_OP_breg8:
    2629                 :      48916 :     case DW_OP_breg9:
    2630                 :      48916 :     case DW_OP_breg10:
    2631                 :      48916 :     case DW_OP_breg11:
    2632                 :      48916 :     case DW_OP_breg12:
    2633                 :      48916 :     case DW_OP_breg13:
    2634                 :      48916 :     case DW_OP_breg14:
    2635                 :      48916 :     case DW_OP_breg15:
    2636                 :      48916 :     case DW_OP_breg16:
    2637                 :      48916 :     case DW_OP_breg17:
    2638                 :      48916 :     case DW_OP_breg18:
    2639                 :      48916 :     case DW_OP_breg19:
    2640                 :      48916 :     case DW_OP_breg20:
    2641                 :      48916 :     case DW_OP_breg21:
    2642                 :      48916 :     case DW_OP_breg22:
    2643                 :      48916 :     case DW_OP_breg23:
    2644                 :      48916 :     case DW_OP_breg24:
    2645                 :      48916 :     case DW_OP_breg25:
    2646                 :      48916 :     case DW_OP_breg26:
    2647                 :      48916 :     case DW_OP_breg27:
    2648                 :      48916 :     case DW_OP_breg28:
    2649                 :      48916 :     case DW_OP_breg29:
    2650                 :      48916 :     case DW_OP_breg30:
    2651                 :      48916 :     case DW_OP_breg31:
    2652                 :      48916 :     case DW_OP_fbreg:
    2653                 :      48916 :       fputc (',', asm_out_file);
    2654                 :      48916 :       dw2_asm_output_data_sleb128_raw (val1->v.val_int);
    2655                 :      48916 :       break;
    2656                 :            : 
    2657                 :          0 :     case DW_OP_bregx:
    2658                 :          0 :       {
    2659                 :          0 :         unsigned r = DWARF2_FRAME_REG_OUT (val1->v.val_unsigned, 1);
    2660                 :          0 :         gcc_assert (size_of_uleb128 (r) 
    2661                 :            :                     == size_of_uleb128 (val1->v.val_unsigned));
    2662                 :          0 :         fputc (',', asm_out_file);
    2663                 :          0 :         dw2_asm_output_data_uleb128_raw (r);
    2664                 :          0 :         fputc (',', asm_out_file);
    2665                 :          0 :         dw2_asm_output_data_sleb128_raw (val2->v.val_int);
    2666                 :            :       }
    2667                 :          0 :       break;
    2668                 :            : 
    2669                 :          0 :     case DW_OP_implicit_pointer:
    2670                 :          0 :     case DW_OP_entry_value:
    2671                 :          0 :     case DW_OP_const_type:
    2672                 :          0 :     case DW_OP_regval_type:
    2673                 :          0 :     case DW_OP_deref_type:
    2674                 :          0 :     case DW_OP_convert:
    2675                 :          0 :     case DW_OP_reinterpret:
    2676                 :          0 :     case DW_OP_GNU_implicit_pointer:
    2677                 :          0 :     case DW_OP_GNU_entry_value:
    2678                 :          0 :     case DW_OP_GNU_const_type:
    2679                 :          0 :     case DW_OP_GNU_regval_type:
    2680                 :          0 :     case DW_OP_GNU_deref_type:
    2681                 :          0 :     case DW_OP_GNU_convert:
    2682                 :          0 :     case DW_OP_GNU_reinterpret:
    2683                 :          0 :     case DW_OP_GNU_parameter_ref:
    2684                 :          0 :       gcc_unreachable ();
    2685                 :            :       break;
    2686                 :            : 
    2687                 :            :     default:
    2688                 :            :       /* Other codes have no operands.  */
    2689                 :            :       break;
    2690                 :            :     }
    2691                 :      55804 : }
    2692                 :            : 
    2693                 :            : void
    2694                 :      48916 : output_loc_sequence_raw (dw_loc_descr_ref loc)
    2695                 :            : {
    2696                 :      62692 :   while (1)
    2697                 :            :     {
    2698                 :      55804 :       enum dwarf_location_atom opc = loc->dw_loc_opc;
    2699                 :            :       /* Output the opcode.  */
    2700                 :      55804 :       if (opc >= DW_OP_breg0 && opc <= DW_OP_breg31)
    2701                 :            :         {
    2702                 :      48916 :           unsigned r = (opc - DW_OP_breg0);
    2703                 :      48916 :           r = DWARF2_FRAME_REG_OUT (r, 1);
    2704                 :      48916 :           gcc_assert (r <= 31);
    2705                 :            :           opc = (enum dwarf_location_atom) (DW_OP_breg0 + r);
    2706                 :            :         }
    2707                 :       6888 :       else if (opc >= DW_OP_reg0 && opc <= DW_OP_reg31)
    2708                 :            :         {
    2709                 :          0 :           unsigned r = (opc - DW_OP_reg0);
    2710                 :          0 :           r = DWARF2_FRAME_REG_OUT (r, 1);
    2711                 :          0 :           gcc_assert (r <= 31);
    2712                 :            :           opc = (enum dwarf_location_atom) (DW_OP_reg0 + r);
    2713                 :            :         }
    2714                 :            :       /* Output the opcode.  */
    2715                 :      55804 :       fprintf (asm_out_file, "%#x", opc);
    2716                 :      55804 :       output_loc_operands_raw (loc);
    2717                 :            : 
    2718                 :      55804 :       if (!loc->dw_loc_next)
    2719                 :            :         break;
    2720                 :       6888 :       loc = loc->dw_loc_next;
    2721                 :            : 
    2722                 :       6888 :       fputc (',', asm_out_file);
    2723                 :       6888 :     }
    2724                 :      48916 : }
    2725                 :            : 
    2726                 :            : /* This function builds a dwarf location descriptor sequence from a
    2727                 :            :    dw_cfa_location, adding the given OFFSET to the result of the
    2728                 :            :    expression.  */
    2729                 :            : 
    2730                 :            : struct dw_loc_descr_node *
    2731                 :      14590 : build_cfa_loc (dw_cfa_location *cfa, poly_int64 offset)
    2732                 :            : {
    2733                 :      14590 :   struct dw_loc_descr_node *head, *tmp;
    2734                 :            : 
    2735                 :      14590 :   offset += cfa->offset;
    2736                 :            : 
    2737                 :      14590 :   if (cfa->indirect)
    2738                 :            :     {
    2739                 :       5555 :       head = new_reg_loc_descr (cfa->reg, cfa->base_offset);
    2740                 :       5555 :       head->dw_loc_oprnd1.val_class = dw_val_class_const;
    2741                 :       5555 :       head->dw_loc_oprnd1.val_entry = NULL;
    2742                 :       5555 :       tmp = new_loc_descr (DW_OP_deref, 0, 0);
    2743                 :       5555 :       add_loc_descr (&head, tmp);
    2744                 :       5555 :       loc_descr_plus_const (&head, offset);
    2745                 :            :     }
    2746                 :            :   else
    2747                 :       9035 :     head = new_reg_loc_descr (cfa->reg, offset);
    2748                 :            : 
    2749                 :      14590 :   return head;
    2750                 :            : }
    2751                 :            : 
    2752                 :            : /* This function builds a dwarf location descriptor sequence for
    2753                 :            :    the address at OFFSET from the CFA when stack is aligned to
    2754                 :            :    ALIGNMENT byte.  */
    2755                 :            : 
    2756                 :            : struct dw_loc_descr_node *
    2757                 :      14728 : build_cfa_aligned_loc (dw_cfa_location *cfa,
    2758                 :            :                        poly_int64 offset, HOST_WIDE_INT alignment)
    2759                 :            : {
    2760                 :      14728 :   struct dw_loc_descr_node *head;
    2761                 :      29456 :   unsigned int dwarf_fp
    2762                 :      14728 :     = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM);
    2763                 :            : 
    2764                 :            :   /* When CFA is defined as FP+OFFSET, emulate stack alignment.  */
    2765                 :      14728 :   if (cfa->reg == HARD_FRAME_POINTER_REGNUM && cfa->indirect == 0)
    2766                 :            :     {
    2767                 :          0 :       head = new_reg_loc_descr (dwarf_fp, 0);
    2768                 :          0 :       add_loc_descr (&head, int_loc_descriptor (alignment));
    2769                 :          0 :       add_loc_descr (&head, new_loc_descr (DW_OP_and, 0, 0));
    2770                 :          0 :       loc_descr_plus_const (&head, offset);
    2771                 :            :     }
    2772                 :            :   else
    2773                 :      14728 :     head = new_reg_loc_descr (dwarf_fp, offset);
    2774                 :      14728 :   return head;
    2775                 :            : }
    2776                 :            : 
    2777                 :            : /* And now, the support for symbolic debugging information.  */
    2778                 :            : 
    2779                 :            : /* .debug_str support.  */
    2780                 :            : 
    2781                 :            : static void dwarf2out_init (const char *);
    2782                 :            : static void dwarf2out_finish (const char *);
    2783                 :            : static void dwarf2out_early_finish (const char *);
    2784                 :            : static void dwarf2out_assembly_start (void);
    2785                 :            : static void dwarf2out_define (unsigned int, const char *);
    2786                 :            : static void dwarf2out_undef (unsigned int, const char *);
    2787                 :            : static void dwarf2out_start_source_file (unsigned, const char *);
    2788                 :            : static void dwarf2out_end_source_file (unsigned);
    2789                 :            : static void dwarf2out_function_decl (tree);
    2790                 :            : static void dwarf2out_begin_block (unsigned, unsigned);
    2791                 :            : static void dwarf2out_end_block (unsigned, unsigned);
    2792                 :            : static bool dwarf2out_ignore_block (const_tree);
    2793                 :            : static void dwarf2out_early_global_decl (tree);
    2794                 :            : static void dwarf2out_late_global_decl (tree);
    2795                 :            : static void dwarf2out_type_decl (tree, int);
    2796                 :            : static void dwarf2out_imported_module_or_decl (tree, tree, tree, bool, bool);
    2797                 :            : static void dwarf2out_imported_module_or_decl_1 (tree, tree, tree,
    2798                 :            :                                                  dw_die_ref);
    2799                 :            : static void dwarf2out_abstract_function (tree);
    2800                 :            : static void dwarf2out_var_location (rtx_insn *);
    2801                 :            : static void dwarf2out_inline_entry (tree);
    2802                 :            : static void dwarf2out_size_function (tree);
    2803                 :            : static void dwarf2out_begin_function (tree);
    2804                 :            : static void dwarf2out_end_function (unsigned int);
    2805                 :            : static void dwarf2out_register_main_translation_unit (tree unit);
    2806                 :            : static void dwarf2out_set_name (tree, tree);
    2807                 :            : static void dwarf2out_register_external_die (tree decl, const char *sym,
    2808                 :            :                                              unsigned HOST_WIDE_INT off);
    2809                 :            : static bool dwarf2out_die_ref_for_decl (tree decl, const char **sym,
    2810                 :            :                                         unsigned HOST_WIDE_INT *off);
    2811                 :            : 
    2812                 :            : /* The debug hooks structure.  */
    2813                 :            : 
    2814                 :            : const struct gcc_debug_hooks dwarf2_debug_hooks =
    2815                 :            : {
    2816                 :            :   dwarf2out_init,
    2817                 :            :   dwarf2out_finish,
    2818                 :            :   dwarf2out_early_finish,
    2819                 :            :   dwarf2out_assembly_start,
    2820                 :            :   dwarf2out_define,
    2821                 :            :   dwarf2out_undef,
    2822                 :            :   dwarf2out_start_source_file,
    2823                 :            :   dwarf2out_end_source_file,
    2824                 :            :   dwarf2out_begin_block,
    2825                 :            :   dwarf2out_end_block,
    2826                 :            :   dwarf2out_ignore_block,
    2827                 :            :   dwarf2out_source_line,
    2828                 :            :   dwarf2out_begin_prologue,
    2829                 :            : #if VMS_DEBUGGING_INFO
    2830                 :            :   dwarf2out_vms_end_prologue,
    2831                 :            :   dwarf2out_vms_begin_epilogue,
    2832                 :            : #else
    2833                 :            :   debug_nothing_int_charstar,
    2834                 :            :   debug_nothing_int_charstar,
    2835                 :            : #endif
    2836                 :            :   dwarf2out_end_epilogue,
    2837                 :            :   dwarf2out_begin_function,
    2838                 :            :   dwarf2out_end_function,       /* end_function */
    2839                 :            :   dwarf2out_register_main_translation_unit,
    2840                 :            :   dwarf2out_function_decl,      /* function_decl */
    2841                 :            :   dwarf2out_early_global_decl,
    2842                 :            :   dwarf2out_late_global_decl,
    2843                 :            :   dwarf2out_type_decl,          /* type_decl */
    2844                 :            :   dwarf2out_imported_module_or_decl,
    2845                 :            :   dwarf2out_die_ref_for_decl,
    2846                 :            :   dwarf2out_register_external_die,
    2847                 :            :   debug_nothing_tree,           /* deferred_inline_function */
    2848                 :            :   /* The DWARF 2 backend tries to reduce debugging bloat by not
    2849                 :            :      emitting the abstract description of inline functions until
    2850                 :            :      something tries to reference them.  */
    2851                 :            :   dwarf2out_abstract_function,  /* outlining_inline_function */
    2852                 :            :   debug_nothing_rtx_code_label, /* label */
    2853                 :            :   debug_nothing_int,            /* handle_pch */
    2854                 :            :   dwarf2out_var_location,
    2855                 :            :   dwarf2out_inline_entry,       /* inline_entry */
    2856                 :            :   dwarf2out_size_function,      /* size_function */
    2857                 :            :   dwarf2out_switch_text_section,
    2858                 :            :   dwarf2out_set_name,
    2859                 :            :   1,                            /* start_end_main_source_file */
    2860                 :            :   TYPE_SYMTAB_IS_DIE            /* tree_type_symtab_field */
    2861                 :            : };
    2862                 :            : 
    2863                 :            : const struct gcc_debug_hooks dwarf2_lineno_debug_hooks =
    2864                 :            : {
    2865                 :            :   dwarf2out_init,
    2866                 :            :   debug_nothing_charstar,
    2867                 :            :   debug_nothing_charstar,
    2868                 :            :   dwarf2out_assembly_start,
    2869                 :            :   debug_nothing_int_charstar,
    2870                 :            :   debug_nothing_int_charstar,
    2871                 :            :   debug_nothing_int_charstar,
    2872                 :            :   debug_nothing_int,
    2873                 :            :   debug_nothing_int_int,                 /* begin_block */
    2874                 :            :   debug_nothing_int_int,                 /* end_block */
    2875                 :            :   debug_true_const_tree,                 /* ignore_block */
    2876                 :            :   dwarf2out_source_line,                 /* source_line */
    2877                 :            :   debug_nothing_int_int_charstar,        /* begin_prologue */
    2878                 :            :   debug_nothing_int_charstar,            /* end_prologue */
    2879                 :            :   debug_nothing_int_charstar,            /* begin_epilogue */
    2880                 :            :   debug_nothing_int_charstar,            /* end_epilogue */
    2881                 :            :   debug_nothing_tree,                    /* begin_function */
    2882                 :            :   debug_nothing_int,                     /* end_function */
    2883                 :            :   debug_nothing_tree,                    /* register_main_translation_unit */
    2884                 :            :   debug_nothing_tree,                    /* function_decl */
    2885                 :            :   debug_nothing_tree,                    /* early_global_decl */
    2886                 :            :   debug_nothing_tree,                    /* late_global_decl */
    2887                 :            :   debug_nothing_tree_int,                /* type_decl */
    2888                 :            :   debug_nothing_tree_tree_tree_bool_bool,/* imported_module_or_decl */
    2889                 :            :   debug_false_tree_charstarstar_uhwistar,/* die_ref_for_decl */
    2890                 :            :   debug_nothing_tree_charstar_uhwi,      /* register_external_die */
    2891                 :            :   debug_nothing_tree,                    /* deferred_inline_function */
    2892                 :            :   debug_nothing_tree,                    /* outlining_inline_function */
    2893                 :            :   debug_nothing_rtx_code_label,          /* label */
    2894                 :            :   debug_nothing_int,                     /* handle_pch */
    2895                 :            :   debug_nothing_rtx_insn,                /* var_location */
    2896                 :            :   debug_nothing_tree,                    /* inline_entry */
    2897                 :            :   debug_nothing_tree,                    /* size_function */
    2898                 :            :   debug_nothing_void,                    /* switch_text_section */
    2899                 :            :   debug_nothing_tree_tree,               /* set_name */
    2900                 :            :   0,                                     /* start_end_main_source_file */
    2901                 :            :   TYPE_SYMTAB_IS_ADDRESS                 /* tree_type_symtab_field */
    2902                 :            : };
    2903                 :            : 
    2904                 :            : /* NOTE: In the comments in this file, many references are made to
    2905                 :            :    "Debugging Information Entries".  This term is abbreviated as `DIE'
    2906                 :            :    throughout the remainder of this file.  */
    2907                 :            : 
    2908                 :            : /* An internal representation of the DWARF output is built, and then
    2909                 :            :    walked to generate the DWARF debugging info.  The walk of the internal
    2910                 :            :    representation is done after the entire program has been compiled.
    2911                 :            :    The types below are used to describe the internal representation.  */
    2912                 :            : 
    2913                 :            : /* Whether to put type DIEs into their own section .debug_types instead
    2914                 :            :    of making them part of the .debug_info section.  Only supported for
    2915                 :            :    Dwarf V4 or higher and the user didn't disable them through
    2916                 :            :    -fno-debug-types-section.  It is more efficient to put them in a
    2917                 :            :    separate comdat sections since the linker will then be able to
    2918                 :            :    remove duplicates.  But not all tools support .debug_types sections
    2919                 :            :    yet.  For Dwarf V5 or higher .debug_types doesn't exist any more,
    2920                 :            :    it is DW_UT_type unit type in .debug_info section.  For late LTO
    2921                 :            :    debug there should be almost no types emitted so avoid enabling
    2922                 :            :    -fdebug-types-section there.  */
    2923                 :            : 
    2924                 :            : #define use_debug_types (dwarf_version >= 4 \
    2925                 :            :                          && flag_debug_types_section \
    2926                 :            :                          && !in_lto_p)
    2927                 :            : 
    2928                 :            : /* Various DIE's use offsets relative to the beginning of the
    2929                 :            :    .debug_info section to refer to each other.  */
    2930                 :            : 
    2931                 :            : typedef long int dw_offset;
    2932                 :            : 
    2933                 :            : struct comdat_type_node;
    2934                 :            : 
    2935                 :            : /* The entries in the line_info table more-or-less mirror the opcodes
    2936                 :            :    that are used in the real dwarf line table.  Arrays of these entries
    2937                 :            :    are collected per section when DWARF2_ASM_LINE_DEBUG_INFO is not
    2938                 :            :    supported.  */
    2939                 :            : 
    2940                 :            : enum dw_line_info_opcode {
    2941                 :            :   /* Emit DW_LNE_set_address; the operand is the label index.  */
    2942                 :            :   LI_set_address,
    2943                 :            : 
    2944                 :            :   /* Emit a row to the matrix with the given line.  This may be done
    2945                 :            :      via any combination of DW_LNS_copy, DW_LNS_advance_line, and
    2946                 :            :      special opcodes.  */
    2947                 :            :   LI_set_line,
    2948                 :            : 
    2949                 :            :   /* Emit a DW_LNS_set_file.  */
    2950                 :            :   LI_set_file,
    2951                 :            : 
    2952                 :            :   /* Emit a DW_LNS_set_column.  */
    2953                 :            :   LI_set_column,
    2954                 :            : 
    2955                 :            :   /* Emit a DW_LNS_negate_stmt; the operand is ignored.  */
    2956                 :            :   LI_negate_stmt,
    2957                 :            : 
    2958                 :            :   /* Emit a DW_LNS_set_prologue_end/epilogue_begin; the operand is ignored.  */
    2959                 :            :   LI_set_prologue_end,
    2960                 :            :   LI_set_epilogue_begin,
    2961                 :            : 
    2962                 :            :   /* Emit a DW_LNE_set_discriminator.  */
    2963                 :            :   LI_set_discriminator,
    2964                 :            : 
    2965                 :            :   /* Output a Fixed Advance PC; the target PC is the label index; the
    2966                 :            :      base PC is the previous LI_adv_address or LI_set_address entry.
    2967                 :            :      We only use this when emitting debug views without assembler
    2968                 :            :      support, at explicit user request.  Ideally, we should only use
    2969                 :            :      it when the offset might be zero but we can't tell: it's the only
    2970                 :            :      way to maybe change the PC without resetting the view number.  */
    2971                 :            :   LI_adv_address
    2972                 :            : };
    2973                 :            : 
    2974                 :            : typedef struct GTY(()) dw_line_info_struct {
    2975                 :            :   enum dw_line_info_opcode opcode;
    2976                 :            :   unsigned int val;
    2977                 :            : } dw_line_info_entry;
    2978                 :            : 
    2979                 :            : 
    2980                 :            : struct GTY(()) dw_line_info_table {
    2981                 :            :   /* The label that marks the end of this section.  */
    2982                 :            :   const char *end_label;
    2983                 :            : 
    2984                 :            :   /* The values for the last row of the matrix, as collected in the table.
    2985                 :            :      These are used to minimize the changes to the next row.  */
    2986                 :            :   unsigned int file_num;
    2987                 :            :   unsigned int line_num;
    2988                 :            :   unsigned int column_num;
    2989                 :            :   int discrim_num;
    2990                 :            :   bool is_stmt;
    2991                 :            :   bool in_use;
    2992                 :            : 
    2993                 :            :   /* This denotes the NEXT view number.
    2994                 :            : 
    2995                 :            :      If it is 0, it is known that the NEXT view will be the first view
    2996                 :            :      at the given PC.
    2997                 :            : 
    2998                 :            :      If it is -1, we're forcing the view number to be reset, e.g. at a
    2999                 :            :      function entry.
    3000                 :            : 
    3001                 :            :      The meaning of other nonzero values depends on whether we're
    3002                 :            :      computing views internally or leaving it for the assembler to do
    3003                 :            :      so.  If we're emitting them internally, view denotes the view
    3004                 :            :      number since the last known advance of PC.  If we're leaving it
    3005                 :            :      for the assembler, it denotes the LVU label number that we're
    3006                 :            :      going to ask the assembler to assign.  */
    3007                 :            :   var_loc_view view;
    3008                 :            : 
    3009                 :            :   /* This counts the number of symbolic views emitted in this table
    3010                 :            :      since the latest view reset.  Its max value, over all tables,
    3011                 :            :      sets symview_upper_bound.  */
    3012                 :            :   var_loc_view symviews_since_reset;
    3013                 :            : 
    3014                 :            : #define FORCE_RESET_NEXT_VIEW(x) ((x) = (var_loc_view)-1)
    3015                 :            : #define RESET_NEXT_VIEW(x) ((x) = (var_loc_view)0)
    3016                 :            : #define FORCE_RESETTING_VIEW_P(x) ((x) == (var_loc_view)-1)
    3017                 :            : #define RESETTING_VIEW_P(x) ((x) == (var_loc_view)0 || FORCE_RESETTING_VIEW_P (x))
    3018                 :            : 
    3019                 :            :   vec<dw_line_info_entry, va_gc> *entries;
    3020                 :            : };
    3021                 :            : 
    3022                 :            : /* This is an upper bound for view numbers that the assembler may
    3023                 :            :    assign to symbolic views output in this translation.  It is used to
    3024                 :            :    decide how big a field to use to represent view numbers in
    3025                 :            :    symview-classed attributes.  */
    3026                 :            : 
    3027                 :            : static var_loc_view symview_upper_bound;
    3028                 :            : 
    3029                 :            : /* If we're keep track of location views and their reset points, and
    3030                 :            :    INSN is a reset point (i.e., it necessarily advances the PC), mark
    3031                 :            :    the next view in TABLE as reset.  */
    3032                 :            : 
    3033                 :            : static void
    3034                 :   28254500 : maybe_reset_location_view (rtx_insn *insn, dw_line_info_table *table)
    3035                 :            : {
    3036                 :   28254500 :   if (!debug_internal_reset_location_views)
    3037                 :            :     return;
    3038                 :            : 
    3039                 :            :   /* Maybe turn (part of?) this test into a default target hook.  */
    3040                 :          0 :   int reset = 0;
    3041                 :            : 
    3042                 :          0 :   if (targetm.reset_location_view)
    3043                 :          0 :     reset = targetm.reset_location_view (insn);
    3044                 :            : 
    3045                 :          0 :   if (reset)
    3046                 :            :     ;
    3047                 :          0 :   else if (JUMP_TABLE_DATA_P (insn))
    3048                 :            :     reset = 1;
    3049                 :          0 :   else if (GET_CODE (insn) == USE
    3050                 :            :            || GET_CODE (insn) == CLOBBER
    3051                 :          0 :            || GET_CODE (insn) == ASM_INPUT
    3052                 :          0 :            || asm_noperands (insn) >= 0)
    3053                 :            :     ;
    3054                 :          0 :   else if (get_attr_min_length (insn) > 0)
    3055                 :            :     reset = 1;
    3056                 :            : 
    3057                 :          0 :   if (reset > 0 && !RESETTING_VIEW_P (table->view))
    3058                 :          0 :     RESET_NEXT_VIEW (table->view);
    3059                 :            : }
    3060                 :            : 
    3061                 :            : /* Each DIE attribute has a field specifying the attribute kind,
    3062                 :            :    a link to the next attribute in the chain, and an attribute value.
    3063                 :            :    Attributes are typically linked below the DIE they modify.  */
    3064                 :            : 
    3065                 :            : typedef struct GTY(()) dw_attr_struct {
    3066                 :            :   enum dwarf_attribute dw_attr;
    3067                 :            :   dw_val_node dw_attr_val;
    3068                 :            : }
    3069                 :            : dw_attr_node;
    3070                 :            : 
    3071                 :            : 
    3072                 :            : /* The Debugging Information Entry (DIE) structure.  DIEs form a tree.
    3073                 :            :    The children of each node form a circular list linked by
    3074                 :            :    die_sib.  die_child points to the node *before* the "first" child node.  */
    3075                 :            : 
    3076                 :            : typedef struct GTY((chain_circular ("%h.die_sib"), for_user)) die_struct {
    3077                 :            :   union die_symbol_or_type_node
    3078                 :            :     {
    3079                 :            :       const char * GTY ((tag ("0"))) die_symbol;
    3080                 :            :       comdat_type_node *GTY ((tag ("1"))) die_type_node;
    3081                 :            :     }
    3082                 :            :   GTY ((desc ("%0.comdat_type_p"))) die_id;
    3083                 :            :   vec<dw_attr_node, va_gc> *die_attr;
    3084                 :            :   dw_die_ref die_parent;
    3085                 :            :   dw_die_ref die_child;
    3086                 :            :   dw_die_ref die_sib;
    3087                 :            :   dw_die_ref die_definition; /* ref from a specification to its definition */
    3088                 :            :   dw_offset die_offset;
    3089                 :            :   unsigned long die_abbrev;
    3090                 :            :   int die_mark;
    3091                 :            :   unsigned int decl_id;
    3092                 :            :   enum dwarf_tag die_tag;
    3093                 :            :   /* Die is used and must not be pruned as unused.  */
    3094                 :            :   BOOL_BITFIELD die_perennial_p : 1;
    3095                 :            :   BOOL_BITFIELD comdat_type_p : 1; /* DIE has a type signature */
    3096                 :            :   /* For an external ref to die_symbol if die_offset contains an extra
    3097                 :            :      offset to that symbol.  */
    3098                 :            :   BOOL_BITFIELD with_offset : 1;
    3099                 :            :   /* Whether this DIE was removed from the DIE tree, for example via
    3100                 :            :      prune_unused_types.  We don't consider those present from the
    3101                 :            :      DIE lookup routines.  */
    3102                 :            :   BOOL_BITFIELD removed : 1;
    3103                 :            :   /* Lots of spare bits.  */
    3104                 :            : }
    3105                 :            : die_node;
    3106                 :            : 
    3107                 :            : /* Set to TRUE while dwarf2out_early_global_decl is running.  */
    3108                 :            : static bool early_dwarf;
    3109                 :            : static bool early_dwarf_finished;
    3110                 :            : class set_early_dwarf {
    3111                 :            : public:
    3112                 :            :   bool saved;
    3113                 :   19107000 :   set_early_dwarf () : saved(early_dwarf)
    3114                 :            :     {
    3115                 :   19107000 :       gcc_assert (! early_dwarf_finished);
    3116                 :   19107000 :       early_dwarf = true;
    3117                 :   19107000 :     }
    3118                 :          0 :   ~set_early_dwarf () { early_dwarf = saved; }
    3119                 :            : };
    3120                 :            : 
    3121                 :            : /* Evaluate 'expr' while 'c' is set to each child of DIE in order.  */
    3122                 :            : #define FOR_EACH_CHILD(die, c, expr) do {       \
    3123                 :            :   c = die->die_child;                                \
    3124                 :            :   if (c) do {                                   \
    3125                 :            :     c = c->die_sib;                          \
    3126                 :            :     expr;                                       \
    3127                 :            :   } while (c != die->die_child);             \
    3128                 :            : } while (0)
    3129                 :            : 
    3130                 :            : /* The pubname structure */
    3131                 :            : 
    3132                 :            : typedef struct GTY(()) pubname_struct {
    3133                 :            :   dw_die_ref die;
    3134                 :            :   const char *name;
    3135                 :            : }
    3136                 :            : pubname_entry;
    3137                 :            : 
    3138                 :            : 
    3139                 :            : struct GTY(()) dw_ranges {
    3140                 :            :   const char *label;
    3141                 :            :   /* If this is positive, it's a block number, otherwise it's a
    3142                 :            :      bitwise-negated index into dw_ranges_by_label.  */
    3143                 :            :   int num;
    3144                 :            :   /* Index for the range list for DW_FORM_rnglistx.  */
    3145                 :            :   unsigned int idx : 31;
    3146                 :            :   /* True if this range might be possibly in a different section
    3147                 :            :      from previous entry.  */
    3148                 :            :   unsigned int maybe_new_sec : 1;
    3149                 :            : };
    3150                 :            : 
    3151                 :            : /* A structure to hold a macinfo entry.  */
    3152                 :            : 
    3153                 :            : typedef struct GTY(()) macinfo_struct {
    3154                 :            :   unsigned char code;
    3155                 :            :   unsigned HOST_WIDE_INT lineno;
    3156                 :            :   const char *info;
    3157                 :            : }
    3158                 :            : macinfo_entry;
    3159                 :            : 
    3160                 :            : 
    3161                 :            : struct GTY(()) dw_ranges_by_label {
    3162                 :            :   const char *begin;
    3163                 :            :   const char *end;
    3164                 :            : };
    3165                 :            : 
    3166                 :            : /* The comdat type node structure.  */
    3167                 :            : struct GTY(()) comdat_type_node
    3168                 :            : {
    3169                 :            :   dw_die_ref root_die;
    3170                 :            :   dw_die_ref type_die;
    3171                 :            :   dw_die_ref skeleton_die;
    3172                 :            :   char signature[DWARF_TYPE_SIGNATURE_SIZE];
    3173                 :            :   comdat_type_node *next;
    3174                 :            : };
    3175                 :            : 
    3176                 :            : /* A list of DIEs for which we can't determine ancestry (parent_die
    3177                 :            :    field) just yet.  Later in dwarf2out_finish we will fill in the
    3178                 :            :    missing bits.  */
    3179                 :            : typedef struct GTY(()) limbo_die_struct {
    3180                 :            :   dw_die_ref die;
    3181                 :            :   /* The tree for which this DIE was created.  We use this to
    3182                 :            :      determine ancestry later.  */
    3183                 :            :   tree created_for;
    3184                 :            :   struct limbo_die_struct *next;
    3185                 :            : }
    3186                 :            : limbo_die_node;
    3187                 :            : 
    3188                 :            : typedef struct skeleton_chain_struct
    3189                 :            : {
    3190                 :            :   dw_die_ref old_die;
    3191                 :            :   dw_die_ref new_die;
    3192                 :            :   struct skeleton_chain_struct *parent;
    3193                 :            : }
    3194                 :            : skeleton_chain_node;
    3195                 :            : 
    3196                 :            : /* Define a macro which returns nonzero for a TYPE_DECL which was
    3197                 :            :    implicitly generated for a type.
    3198                 :            : 
    3199                 :            :    Note that, unlike the C front-end (which generates a NULL named
    3200                 :            :    TYPE_DECL node for each complete tagged type, each array type,
    3201                 :            :    and each function type node created) the C++ front-end generates
    3202                 :            :    a _named_ TYPE_DECL node for each tagged type node created.
    3203                 :            :    These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
    3204                 :            :    generate a DW_TAG_typedef DIE for them.  Likewise with the Ada
    3205                 :            :    front-end, but for each type, tagged or not.  */
    3206                 :            : 
    3207                 :            : #define TYPE_DECL_IS_STUB(decl)                         \
    3208                 :            :   (DECL_NAME (decl) == NULL_TREE                        \
    3209                 :            :    || (DECL_ARTIFICIAL (decl)                           \
    3210                 :            :        && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl)))  \
    3211                 :            :            /* This is necessary for stub decls that     \
    3212                 :            :               appear in nested inline functions.  */    \
    3213                 :            :            || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
    3214                 :            :                && (decl_ultimate_origin (decl)          \
    3215                 :            :                    == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
    3216                 :            : 
    3217                 :            : /* Information concerning the compilation unit's programming
    3218                 :            :    language, and compiler version.  */
    3219                 :            : 
    3220                 :            : /* Fixed size portion of the DWARF compilation unit header.  */
    3221                 :            : #define DWARF_COMPILE_UNIT_HEADER_SIZE \
    3222                 :            :   (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE                        \
    3223                 :            :    + (dwarf_version >= 5 ? 4 : 3))
    3224                 :            : 
    3225                 :            : /* Fixed size portion of the DWARF comdat type unit header.  */
    3226                 :            : #define DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE \
    3227                 :            :   (DWARF_COMPILE_UNIT_HEADER_SIZE                                       \
    3228                 :            :    + DWARF_TYPE_SIGNATURE_SIZE + DWARF_OFFSET_SIZE)
    3229                 :            : 
    3230                 :            : /* Fixed size portion of the DWARF skeleton compilation unit header.  */
    3231                 :            : #define DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE \
    3232                 :            :   (DWARF_COMPILE_UNIT_HEADER_SIZE + (dwarf_version >= 5 ? 8 : 0))
    3233                 :            : 
    3234                 :            : /* Fixed size portion of public names info.  */
    3235                 :            : #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
    3236                 :            : 
    3237                 :            : /* Fixed size portion of the address range info.  */
    3238                 :            : #define DWARF_ARANGES_HEADER_SIZE                                       \
    3239                 :            :   (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4,      \
    3240                 :            :                 DWARF2_ADDR_SIZE * 2)                                   \
    3241                 :            :    - DWARF_INITIAL_LENGTH_SIZE)
    3242                 :            : 
    3243                 :            : /* Size of padding portion in the address range info.  It must be
    3244                 :            :    aligned to twice the pointer size.  */
    3245                 :            : #define DWARF_ARANGES_PAD_SIZE \
    3246                 :            :   (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
    3247                 :            :                 DWARF2_ADDR_SIZE * 2)                              \
    3248                 :            :    - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
    3249                 :            : 
    3250                 :            : /* Use assembler line directives if available.  */
    3251                 :            : #ifndef DWARF2_ASM_LINE_DEBUG_INFO
    3252                 :            : #ifdef HAVE_AS_DWARF2_DEBUG_LINE
    3253                 :            : #define DWARF2_ASM_LINE_DEBUG_INFO 1
    3254                 :            : #else
    3255                 :            : #define DWARF2_ASM_LINE_DEBUG_INFO 0
    3256                 :            : #endif
    3257                 :            : #endif
    3258                 :            : 
    3259                 :            : /* Use assembler views in line directives if available.  */
    3260                 :            : #ifndef DWARF2_ASM_VIEW_DEBUG_INFO
    3261                 :            : #ifdef HAVE_AS_DWARF2_DEBUG_VIEW
    3262                 :            : #define DWARF2_ASM_VIEW_DEBUG_INFO 1
    3263                 :            : #else
    3264                 :            : #define DWARF2_ASM_VIEW_DEBUG_INFO 0
    3265                 :            : #endif
    3266                 :            : #endif
    3267                 :            : 
    3268                 :            : /* Return true if GCC configure detected assembler support for .loc.  */
    3269                 :            : 
    3270                 :            : bool
    3271                 :     200711 : dwarf2out_default_as_loc_support (void)
    3272                 :            : {
    3273                 :     200711 :   return DWARF2_ASM_LINE_DEBUG_INFO;
    3274                 :            : #if (GCC_VERSION >= 3000)
    3275                 :            : # undef DWARF2_ASM_LINE_DEBUG_INFO
    3276                 :            : # pragma GCC poison DWARF2_ASM_LINE_DEBUG_INFO
    3277                 :            : #endif
    3278                 :            : }
    3279                 :            : 
    3280                 :            : /* Return true if GCC configure detected assembler support for views
    3281                 :            :    in .loc directives.  */
    3282                 :            : 
    3283                 :            : bool
    3284                 :     200711 : dwarf2out_default_as_locview_support (void)
    3285                 :            : {
    3286                 :     200711 :   return DWARF2_ASM_VIEW_DEBUG_INFO;
    3287                 :            : #if (GCC_VERSION >= 3000)
    3288                 :            : # undef DWARF2_ASM_VIEW_DEBUG_INFO
    3289                 :            : # pragma GCC poison DWARF2_ASM_VIEW_DEBUG_INFO
    3290                 :            : #endif
    3291                 :            : }
    3292                 :            : 
    3293                 :            : /* A bit is set in ZERO_VIEW_P if we are using the assembler-supported
    3294                 :            :    view computation, and it refers to a view identifier for which we
    3295                 :            :    will not emit a label because it is known to map to a view number
    3296                 :            :    zero.  We won't allocate the bitmap if we're not using assembler
    3297                 :            :    support for location views, but we have to make the variable
    3298                 :            :    visible for GGC and for code that will be optimized out for lack of
    3299                 :            :    support but that's still parsed and compiled.  We could abstract it
    3300                 :            :    out with macros, but it's not worth it.  */
    3301                 :            : static GTY(()) bitmap zero_view_p;
    3302                 :            : 
    3303                 :            : /* Evaluate to TRUE iff N is known to identify the first location view
    3304                 :            :    at its PC.  When not using assembler location view computation,
    3305                 :            :    that must be view number zero.  Otherwise, ZERO_VIEW_P is allocated
    3306                 :            :    and views label numbers recorded in it are the ones known to be
    3307                 :            :    zero.  */
    3308                 :            : #define ZERO_VIEW_P(N) ((N) == (var_loc_view)0                          \
    3309                 :            :                         || (N) == (var_loc_view)-1                      \
    3310                 :            :                         || (zero_view_p                                 \
    3311                 :            :                             && bitmap_bit_p (zero_view_p, (N))))
    3312                 :            : 
    3313                 :            : /* Return true iff we're to emit .loc directives for the assembler to
    3314                 :            :    generate line number sections.
    3315                 :            : 
    3316                 :            :    When we're not emitting views, all we need from the assembler is
    3317                 :            :    support for .loc directives.
    3318                 :            : 
    3319                 :            :    If we are emitting views, we can only use the assembler's .loc
    3320                 :            :    support if it also supports views.
    3321                 :            : 
    3322                 :            :    When the compiler is emitting the line number programs and
    3323                 :            :    computing view numbers itself, it resets view numbers at known PC
    3324                 :            :    changes and counts from that, and then it emits view numbers as
    3325                 :            :    literal constants in locviewlists.  There are cases in which the
    3326                 :            :    compiler is not sure about PC changes, e.g. when extra alignment is
    3327                 :            :    requested for a label.  In these cases, the compiler may not reset
    3328                 :            :    the view counter, and the potential PC advance in the line number
    3329                 :            :    program will use an opcode that does not reset the view counter
    3330                 :            :    even if the PC actually changes, so that compiler and debug info
    3331                 :            :    consumer can keep view numbers in sync.
    3332                 :            : 
    3333                 :            :    When the compiler defers view computation to the assembler, it
    3334                 :            :    emits symbolic view numbers in locviewlists, with the exception of
    3335                 :            :    views known to be zero (forced resets, or reset after
    3336                 :            :    compiler-visible PC changes): instead of emitting symbols for
    3337                 :            :    these, we emit literal zero and assert the assembler agrees with
    3338                 :            :    the compiler's assessment.  We could use symbolic views everywhere,
    3339                 :            :    instead of special-casing zero views, but then we'd be unable to
    3340                 :            :    optimize out locviewlists that contain only zeros.  */
    3341                 :            : 
    3342                 :            : static bool
    3343                 :   24823100 : output_asm_line_debug_info (void)
    3344                 :            : {
    3345                 :   24823100 :   return (dwarf2out_as_loc_support
    3346                 :   24823100 :           && (dwarf2out_as_locview_support
    3347                 :          0 :               || !debug_variable_location_views));
    3348                 :            : }
    3349                 :            : 
    3350                 :            : /* Minimum line offset in a special line info. opcode.
    3351                 :            :    This value was chosen to give a reasonable range of values.  */
    3352                 :            : #define DWARF_LINE_BASE  -10
    3353                 :            : 
    3354                 :            : /* First special line opcode - leave room for the standard opcodes.  */
    3355                 :            : #define DWARF_LINE_OPCODE_BASE  ((int)DW_LNS_set_isa + 1)
    3356                 :            : 
    3357                 :            : /* Range of line offsets in a special line info. opcode.  */
    3358                 :            : #define DWARF_LINE_RANGE  (254-DWARF_LINE_OPCODE_BASE+1)
    3359                 :            : 
    3360                 :            : /* Flag that indicates the initial value of the is_stmt_start flag.
    3361                 :            :    In the present implementation, we do not mark any lines as
    3362                 :            :    the beginning of a source statement, because that information
    3363                 :            :    is not made available by the GCC front-end.  */
    3364                 :            : #define DWARF_LINE_DEFAULT_IS_STMT_START 1
    3365                 :            : 
    3366                 :            : /* Maximum number of operations per instruction bundle.  */
    3367                 :            : #ifndef DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
    3368                 :            : #define DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN 1
    3369                 :            : #endif
    3370                 :            : 
    3371                 :            : /* This location is used by calc_die_sizes() to keep track
    3372                 :            :    the offset of each DIE within the .debug_info section.  */
    3373                 :            : static unsigned long next_die_offset;
    3374                 :            : 
    3375                 :            : /* Record the root of the DIE's built for the current compilation unit.  */
    3376                 :            : static GTY(()) dw_die_ref single_comp_unit_die;
    3377                 :            : 
    3378                 :            : /* A list of type DIEs that have been separated into comdat sections.  */
    3379                 :            : static GTY(()) comdat_type_node *comdat_type_list;
    3380                 :            : 
    3381                 :            : /* A list of CU DIEs that have been separated.  */
    3382                 :            : static GTY(()) limbo_die_node *cu_die_list;
    3383                 :            : 
    3384                 :            : /* A list of DIEs with a NULL parent waiting to be relocated.  */
    3385                 :            : static GTY(()) limbo_die_node *limbo_die_list;
    3386                 :            : 
    3387                 :            : /* A list of DIEs for which we may have to generate
    3388                 :            :    DW_AT_{,MIPS_}linkage_name once their DECL_ASSEMBLER_NAMEs are set.  */
    3389                 :            : static GTY(()) limbo_die_node *deferred_asm_name;
    3390                 :            : 
    3391                 :            : struct dwarf_file_hasher : ggc_ptr_hash<dwarf_file_data>
    3392                 :            : {
    3393                 :            :   typedef const char *compare_type;
    3394                 :            : 
    3395                 :            :   static hashval_t hash (dwarf_file_data *);
    3396                 :            :   static bool equal (dwarf_file_data *, const char *);
    3397                 :            : };
    3398                 :            : 
    3399                 :            : /* Filenames referenced by this compilation unit.  */
    3400                 :            : static GTY(()) hash_table<dwarf_file_hasher> *file_table;
    3401                 :            : 
    3402                 :            : struct decl_die_hasher : ggc_ptr_hash<die_node>
    3403                 :            : {
    3404                 :            :   typedef tree compare_type;
    3405                 :            : 
    3406                 :            :   static hashval_t hash (die_node *);
    3407                 :            :   static bool equal (die_node *, tree);
    3408                 :            : };
    3409                 :            : /* A hash table of references to DIE's that describe declarations.
    3410                 :            :    The key is a DECL_UID() which is a unique number identifying each decl.  */
    3411                 :            : static GTY (()) hash_table<decl_die_hasher> *decl_die_table;
    3412                 :            : 
    3413                 :            : struct GTY ((for_user)) variable_value_struct {
    3414                 :            :   unsigned int decl_id;
    3415                 :            :   vec<dw_die_ref, va_gc> *dies;
    3416                 :            : };
    3417                 :            : 
    3418                 :            : struct variable_value_hasher : ggc_ptr_hash<variable_value_struct>
    3419                 :            : {
    3420                 :            :   typedef tree compare_type;
    3421                 :            : 
    3422                 :            :   static hashval_t hash (variable_value_struct *);
    3423                 :            :   static bool equal (variable_value_struct *, tree);
    3424                 :            : };
    3425                 :            : /* A hash table of DIEs that contain DW_OP_GNU_variable_value with
    3426                 :            :    dw_val_class_decl_ref class, indexed by FUNCTION_DECLs which is
    3427                 :            :    DECL_CONTEXT of the referenced VAR_DECLs.  */
    3428                 :            : static GTY (()) hash_table<variable_value_hasher> *variable_value_hash;
    3429                 :            : 
    3430                 :            : struct block_die_hasher : ggc_ptr_hash<die_struct>
    3431                 :            : {
    3432                 :            :   static hashval_t hash (die_struct *);
    3433                 :            :   static bool equal (die_struct *, die_struct *);
    3434                 :            : };
    3435                 :            : 
    3436                 :            : /* A hash table of references to DIE's that describe COMMON blocks.
    3437                 :            :    The key is DECL_UID() ^ die_parent.  */
    3438                 :            : static GTY (()) hash_table<block_die_hasher> *common_block_die_table;
    3439                 :            : 
    3440                 :            : typedef struct GTY(()) die_arg_entry_struct {
    3441                 :            :     dw_die_ref die;
    3442                 :            :     tree arg;
    3443                 :            : } die_arg_entry;
    3444                 :            : 
    3445                 :            : 
    3446                 :            : /* Node of the variable location list.  */
    3447                 :            : struct GTY ((chain_next ("%h.next"))) var_loc_node {
    3448                 :            :   /* Either NOTE_INSN_VAR_LOCATION, or, for SRA optimized variables,
    3449                 :            :      EXPR_LIST chain.  For small bitsizes, bitsize is encoded
    3450                 :            :      in mode of the EXPR_LIST node and first EXPR_LIST operand
    3451                 :            :      is either NOTE_INSN_VAR_LOCATION for a piece with a known
    3452                 :            :      location or NULL for padding.  For larger bitsizes,
    3453                 :            :      mode is 0 and first operand is a CONCAT with bitsize
    3454                 :            :      as first CONCAT operand and NOTE_INSN_VAR_LOCATION resp.
    3455                 :            :      NULL as second operand.  */
    3456                 :            :   rtx GTY (()) loc;
    3457                 :            :   const char * GTY (()) label;
    3458                 :            :   struct var_loc_node * GTY (()) next;
    3459                 :            :   var_loc_view view;
    3460                 :            : };
    3461                 :            : 
    3462                 :            : /* Variable location list.  */
    3463                 :            : struct GTY ((for_user)) var_loc_list_def {
    3464                 :            :   struct var_loc_node * GTY (()) first;
    3465                 :            : 
    3466                 :            :   /* Pointer to the last but one or last element of the
    3467                 :            :      chained list.  If the list is empty, both first and
    3468                 :            :      last are NULL, if the list contains just one node
    3469                 :            :      or the last node certainly is not redundant, it points
    3470                 :            :      to the last node, otherwise points to the last but one.
    3471                 :            :      Do not mark it for GC because it is marked through the chain.  */
    3472                 :            :   struct var_loc_node * GTY ((skip ("%h"))) last;
    3473                 :            : 
    3474                 :            :   /* Pointer to the last element before section switch,
    3475                 :            :      if NULL, either sections weren't switched or first
    3476                 :            :      is after section switch.  */
    3477                 :            :   struct var_loc_node * GTY ((skip ("%h"))) last_before_switch;
    3478                 :            : 
    3479                 :            :   /* DECL_UID of the variable decl.  */
    3480                 :            :   unsigned int decl_id;
    3481                 :            : };
    3482                 :            : typedef struct var_loc_list_def var_loc_list;
    3483                 :            : 
    3484                 :            : /* Call argument location list.  */
    3485                 :            : struct GTY ((chain_next ("%h.next"))) call_arg_loc_node {
    3486                 :            :   rtx GTY (()) call_arg_loc_note;
    3487                 :            :   const char * GTY (()) label;
    3488                 :            :   tree GTY (()) block;
    3489                 :            :   bool tail_call_p;
    3490                 :            :   rtx GTY (()) symbol_ref;
    3491                 :            :   struct call_arg_loc_node * GTY (()) next;
    3492                 :            : };
    3493                 :            : 
    3494                 :            : 
    3495                 :            : struct decl_loc_hasher : ggc_ptr_hash<var_loc_list>
    3496                 :            : {
    3497                 :            :   typedef const_tree compare_type;
    3498                 :            : 
    3499                 :            :   static hashval_t hash (var_loc_list *);
    3500                 :            :   static bool equal (var_loc_list *, const_tree);
    3501                 :            : };
    3502                 :            : 
    3503                 :            : /* Table of decl location linked lists.  */
    3504                 :            : static GTY (()) hash_table<decl_loc_hasher> *decl_loc_table;
    3505                 :            : 
    3506                 :            : /* Head and tail of call_arg_loc chain.  */
    3507                 :            : static GTY (()) struct call_arg_loc_node *call_arg_locations;
    3508                 :            : static struct call_arg_loc_node *call_arg_loc_last;
    3509                 :            : 
    3510                 :            : /* Number of call sites in the current function.  */
    3511                 :            : static int call_site_count = -1;
    3512                 :            : /* Number of tail call sites in the current function.  */
    3513                 :            : static int tail_call_site_count = -1;
    3514                 :            : 
    3515                 :            : /* A cached location list.  */
    3516                 :            : struct GTY ((for_user)) cached_dw_loc_list_def {
    3517                 :            :   /* The DECL_UID of the decl that this entry describes.  */
    3518                 :            :   unsigned int decl_id;
    3519                 :            : 
    3520                 :            :   /* The cached location list.  */
    3521                 :            :   dw_loc_list_ref loc_list;
    3522                 :            : };
    3523                 :            : typedef struct cached_dw_loc_list_def cached_dw_loc_list;
    3524                 :            : 
    3525                 :            : struct dw_loc_list_hasher : ggc_ptr_hash<cached_dw_loc_list>
    3526                 :            : {
    3527                 :            : 
    3528                 :            :   typedef const_tree compare_type;
    3529                 :            :   
    3530                 :            :   static hashval_t hash (cached_dw_loc_list *);
    3531                 :            :   static bool equal (cached_dw_loc_list *, const_tree);
    3532                 :            : };
    3533                 :            : 
    3534                 :            : /* Table of cached location lists.  */
    3535                 :            : static GTY (()) hash_table<dw_loc_list_hasher> *cached_dw_loc_list_table;
    3536                 :            : 
    3537                 :            : /* A vector of references to DIE's that are uniquely identified by their tag,
    3538                 :            :    presence/absence of children DIE's, and list of attribute/value pairs.  */
    3539                 :            : static GTY(()) vec<dw_die_ref, va_gc> *abbrev_die_table;
    3540                 :            : 
    3541                 :            : /* A hash map to remember the stack usage for DWARF procedures.  The value
    3542                 :            :    stored is the stack size difference between before the DWARF procedure
    3543                 :            :    invokation and after it returned.  In other words, for a DWARF procedure
    3544                 :            :    that consumes N stack slots and that pushes M ones, this stores M - N.  */
    3545                 :            : static hash_map<dw_die_ref, int> *dwarf_proc_stack_usage_map;
    3546                 :            : 
    3547                 :            : /* A global counter for generating labels for line number data.  */
    3548                 :            : static unsigned int line_info_label_num;
    3549                 :            : 
    3550                 :            : /* The current table to which we should emit line number information
    3551                 :            :    for the current function.  This will be set up at the beginning of
    3552                 :            :    assembly for the function.  */
    3553                 :            : static GTY(()) dw_line_info_table *cur_line_info_table;
    3554                 :            : 
    3555                 :            : /* The two default tables of line number info.  */
    3556                 :            : static GTY(()) dw_line_info_table *text_section_line_info;
    3557                 :            : static GTY(()) dw_line_info_table *cold_text_section_line_info;
    3558                 :            : 
    3559                 :            : /* The set of all non-default tables of line number info.  */
    3560                 :            : static GTY(()) vec<dw_line_info_table *, va_gc> *separate_line_info;
    3561                 :            : 
    3562                 :            : /* A flag to tell pubnames/types export if there is an info section to
    3563                 :            :    refer to.  */
    3564                 :            : static bool info_section_emitted;
    3565                 :            : 
    3566                 :            : /* A pointer to the base of a table that contains a list of publicly
    3567                 :            :    accessible names.  */
    3568                 :            : static GTY (()) vec<pubname_entry, va_gc> *pubname_table;
    3569                 :            : 
    3570                 :            : /* A pointer to the base of a table that contains a list of publicly
    3571                 :            :    accessible types.  */
    3572                 :            : static GTY (()) vec<pubname_entry, va_gc> *pubtype_table;
    3573                 :            : 
    3574                 :            : /* A pointer to the base of a table that contains a list of macro
    3575                 :            :    defines/undefines (and file start/end markers).  */
    3576                 :            : static GTY (()) vec<macinfo_entry, va_gc> *macinfo_table;
    3577                 :            : 
    3578                 :            : /* True if .debug_macinfo or .debug_macros section is going to be
    3579                 :            :    emitted.  */
    3580                 :            : #define have_macinfo \
    3581                 :            :   ((!XCOFF_DEBUGGING_INFO || HAVE_XCOFF_DWARF_EXTRAS) \
    3582                 :            :    && debug_info_level >= DINFO_LEVEL_VERBOSE \
    3583                 :            :    && !macinfo_table->is_empty ())
    3584                 :            : 
    3585                 :            : /* Vector of dies for which we should generate .debug_ranges info.  */
    3586                 :            : static GTY (()) vec<dw_ranges, va_gc> *ranges_table;
    3587                 :            : 
    3588                 :            : /* Vector of pairs of labels referenced in ranges_table.  */
    3589                 :            : static GTY (()) vec<dw_ranges_by_label, va_gc> *ranges_by_label;
    3590                 :            : 
    3591                 :            : /* Whether we have location lists that need outputting */
    3592                 :            : static GTY(()) bool have_location_lists;
    3593                 :            : 
    3594                 :            : /* Unique label counter.  */
    3595                 :            : static GTY(()) unsigned int loclabel_num;
    3596                 :            : 
    3597                 :            : /* Unique label counter for point-of-call tables.  */
    3598                 :            : static GTY(()) unsigned int poc_label_num;
    3599                 :            : 
    3600                 :            : /* The last file entry emitted by maybe_emit_file().  */
    3601                 :            : static GTY(()) struct dwarf_file_data * last_emitted_file;
    3602                 :            : 
    3603                 :            : /* Number of internal labels generated by gen_internal_sym().  */
    3604                 :            : static GTY(()) int label_num;
    3605                 :            : 
    3606                 :            : static GTY(()) vec<die_arg_entry, va_gc> *tmpl_value_parm_die_table;
    3607                 :            : 
    3608                 :            : /* Instances of generic types for which we need to generate debug
    3609                 :            :    info that describe their generic parameters and arguments. That
    3610                 :            :    generation needs to happen once all types are properly laid out so
    3611                 :            :    we do it at the end of compilation.  */
    3612                 :            : static GTY(()) vec<tree, va_gc> *generic_type_instances;
    3613                 :            : 
    3614                 :            : /* Offset from the "steady-state frame pointer" to the frame base,
    3615                 :            :    within the current function.  */
    3616                 :            : static poly_int64 frame_pointer_fb_offset;
    3617                 :            : static bool frame_pointer_fb_offset_valid;
    3618                 :            : 
    3619                 :            : static vec<dw_die_ref> base_types;
    3620                 :            : 
    3621                 :            : /* Flags to represent a set of attribute classes for attributes that represent
    3622                 :            :    a scalar value (bounds, pointers, ...).  */
    3623                 :            : enum dw_scalar_form
    3624                 :            : {
    3625                 :            :   dw_scalar_form_constant = 0x01,
    3626                 :            :   dw_scalar_form_exprloc = 0x02,
    3627                 :            :   dw_scalar_form_reference = 0x04
    3628                 :            : };
    3629                 :            : 
    3630                 :            : /* Forward declarations for functions defined in this file.  */
    3631                 :            : 
    3632                 :            : static int is_pseudo_reg (const_rtx);
    3633                 :            : static tree type_main_variant (tree);
    3634                 :            : static int is_tagged_type (const_tree);
    3635                 :            : static const char *dwarf_tag_name (unsigned);
    3636                 :            : static const char *dwarf_attr_name (unsigned);
    3637                 :            : static const char *dwarf_form_name (unsigned);
    3638                 :            : static tree decl_ultimate_origin (const_tree);
    3639                 :            : static tree decl_class_context (tree);
    3640                 :            : static void add_dwarf_attr (dw_die_ref, dw_attr_node *);
    3641                 :            : static inline enum dw_val_class AT_class (dw_attr_node *);
    3642                 :            : static inline unsigned int AT_index (dw_attr_node *);
    3643                 :            : static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
    3644                 :            : static inline unsigned AT_flag (dw_attr_node *);
    3645                 :            : static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
    3646                 :            : static inline HOST_WIDE_INT AT_int (dw_attr_node *);
    3647                 :            : static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
    3648                 :            : static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_node *);
    3649                 :            : static void add_AT_double (dw_die_ref, enum dwarf_attribute,
    3650                 :            :                            HOST_WIDE_INT, unsigned HOST_WIDE_INT);
    3651                 :            : static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int,
    3652                 :            :                                unsigned int, unsigned char *);
    3653                 :            : static void add_AT_data8 (dw_die_ref, enum dwarf_attribute, unsigned char *);
    3654                 :            : static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
    3655                 :            : static inline const char *AT_string (dw_attr_node *);
    3656                 :            : static enum dwarf_form AT_string_form (dw_attr_node *);
    3657                 :            : static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
    3658                 :            : static void add_AT_specification (dw_die_ref, dw_die_ref);
    3659                 :            : static inline dw_die_ref AT_ref (dw_attr_node *);
    3660                 :            : static inline int AT_ref_external (dw_attr_node *);
    3661                 :            : static inline void set_AT_ref_external (dw_attr_node *, int);
    3662                 :            : static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
    3663                 :            : static inline dw_loc_descr_ref AT_loc (dw_attr_node *);
    3664                 :            : static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
    3665                 :            :                              dw_loc_list_ref);
    3666                 :            : static inline dw_loc_list_ref AT_loc_list (dw_attr_node *);
    3667                 :            : static void add_AT_view_list (dw_die_ref, enum dwarf_attribute);
    3668                 :            : static inline dw_loc_list_ref AT_loc_list (dw_attr_node *);
    3669                 :            : static addr_table_entry *add_addr_table_entry (void *, enum ate_kind);
    3670                 :            : static void remove_addr_table_entry (addr_table_entry *);
    3671                 :            : static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx, bool);
    3672                 :            : static inline rtx AT_addr (dw_attr_node *);
    3673                 :            : static void add_AT_symview (dw_die_ref, enum dwarf_attribute, const char *);
    3674                 :            : static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
    3675                 :            : static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *);
    3676                 :            : static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *);
    3677                 :            : static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
    3678                 :            :                                unsigned long, bool);
    3679                 :            : static inline const char *AT_lbl (dw_attr_node *);
    3680                 :            : static dw_attr_node *get_AT (dw_die_ref, enum dwarf_attribute);
    3681                 :            : static const char *get_AT_low_pc (dw_die_ref);
    3682                 :            : static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
    3683                 :            : static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
    3684                 :            : static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
    3685                 :            : static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
    3686                 :            : static bool is_c (void);
    3687                 :            : static bool is_cxx (void);
    3688                 :            : static bool is_cxx (const_tree);
    3689                 :            : static bool is_fortran (void);
    3690                 :            : static bool is_ada (void);
    3691                 :            : static bool remove_AT (dw_die_ref, enum dwarf_attribute);
    3692                 :            : static void remove_child_TAG (dw_die_ref, enum dwarf_tag);
    3693                 :            : static void add_child_die (dw_die_ref, dw_die_ref);
    3694                 :            : static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
    3695                 :            : static dw_die_ref lookup_type_die (tree);
    3696                 :            : static dw_die_ref strip_naming_typedef (tree, dw_die_ref);
    3697                 :            : static dw_die_ref lookup_type_die_strip_naming_typedef (tree);
    3698                 :            : static void equate_type_number_to_die (tree, dw_die_ref);
    3699                 :            : static dw_die_ref lookup_decl_die (tree);
    3700                 :            : static var_loc_list *lookup_decl_loc (const_tree);
    3701                 :            : static void equate_decl_number_to_die (tree, dw_die_ref);
    3702                 :            : static struct var_loc_node *add_var_loc_to_decl (tree, rtx, const char *, var_loc_view);
    3703                 :            : static void print_spaces (FILE *);
    3704                 :            : static void print_die (dw_die_ref, FILE *);
    3705                 :            : static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
    3706                 :            : static void attr_checksum (dw_attr_node *, struct md5_ctx *, int *);
    3707                 :            : static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
    3708                 :            : static void checksum_sleb128 (HOST_WIDE_INT, struct md5_ctx *);
    3709                 :            : static void checksum_uleb128 (unsigned HOST_WIDE_INT, struct md5_ctx *);
    3710                 :            : static void loc_checksum_ordered (dw_loc_descr_ref, struct md5_ctx *);
    3711                 :            : static void attr_checksum_ordered (enum dwarf_tag, dw_attr_node *,
    3712                 :            :                                    struct md5_ctx *, int *);
    3713                 :            : struct checksum_attributes;
    3714                 :            : static void collect_checksum_attributes (struct checksum_attributes *, dw_die_ref);
    3715                 :            : static void die_checksum_ordered (dw_die_ref, struct md5_ctx *, int *);
    3716                 :            : static void checksum_die_context (dw_die_ref, struct md5_ctx *);
    3717                 :            : static void generate_type_signature (dw_die_ref, comdat_type_node *);
    3718                 :            : static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
    3719                 :            : static int same_dw_val_p (const dw_val_node *, const dw_val_node *, int *);
    3720                 :            : static int same_attr_p (dw_attr_node *, dw_attr_node *, int *);
    3721                 :            : static int same_die_p (dw_die_ref, dw_die_ref, int *);
    3722                 :            : static int is_type_die (dw_die_ref);
    3723                 :            : static inline bool is_template_instantiation (dw_die_ref);
    3724                 :            : static int is_declaration_die (dw_die_ref);
    3725                 :            : static int should_move_die_to_comdat (dw_die_ref);
    3726                 :            : static dw_die_ref clone_as_declaration (dw_die_ref);
    3727                 :            : static dw_die_ref clone_die (dw_die_ref);
    3728                 :            : static dw_die_ref clone_tree (dw_die_ref);
    3729                 :            : static dw_die_ref copy_declaration_context (dw_die_ref, dw_die_ref);
    3730                 :            : static void generate_skeleton_ancestor_tree (skeleton_chain_node *);
    3731                 :            : static void generate_skeleton_bottom_up (skeleton_chain_node *);
    3732                 :            : static dw_die_ref generate_skeleton (dw_die_ref);
    3733                 :            : static dw_die_ref remove_child_or_replace_with_skeleton (dw_die_ref,
    3734                 :            :                                                          dw_die_ref,
    3735                 :            :                                                          dw_die_ref);
    3736                 :            : static void break_out_comdat_types (dw_die_ref);
    3737                 :            : static void copy_decls_for_unworthy_types (dw_die_ref);
    3738                 :            : 
    3739                 :            : static void add_sibling_attributes (dw_die_ref);
    3740                 :            : static void output_location_lists (dw_die_ref);
    3741                 :            : static int constant_size (unsigned HOST_WIDE_INT);
    3742                 :            : static unsigned long size_of_die (dw_die_ref);
    3743                 :            : static void calc_die_sizes (dw_die_ref);
    3744                 :            : static void calc_base_type_die_sizes (void);
    3745                 :            : static void mark_dies (dw_die_ref);
    3746                 :            : static void unmark_dies (dw_die_ref);
    3747                 :            : static void unmark_all_dies (dw_die_ref);
    3748                 :            : static unsigned long size_of_pubnames (vec<pubname_entry, va_gc> *);
    3749                 :            : static unsigned long size_of_aranges (void);
    3750                 :            : static enum dwarf_form value_format (dw_attr_node *);
    3751                 :            : static void output_value_format (dw_attr_node *);
    3752                 :            : static void output_abbrev_section (void);
    3753                 :            : static void output_die_abbrevs (unsigned long, dw_die_ref);
    3754                 :            : static void output_die (dw_die_ref);
    3755                 :            : static void output_compilation_unit_header (enum dwarf_unit_type);
    3756                 :            : static void output_comp_unit (dw_die_ref, int, const unsigned char *);
    3757                 :            : static void output_comdat_type_unit (comdat_type_node *, bool);
    3758                 :            : static const char *dwarf2_name (tree, int);
    3759                 :            : static void add_pubname (tree, dw_die_ref);
    3760                 :            : static void add_enumerator_pubname (const char *, dw_die_ref);
    3761                 :            : static void add_pubname_string (const char *, dw_die_ref);
    3762                 :            : static void add_pubtype (tree, dw_die_ref);
    3763                 :            : static void output_pubnames (vec<pubname_entry, va_gc> *);
    3764                 :            : static void output_aranges (void);
    3765                 :            : static unsigned int add_ranges (const_tree, bool = false);
    3766                 :            : static void add_ranges_by_labels (dw_die_ref, const char *, const char *,
    3767                 :            :                                   bool *, bool);
    3768                 :            : static void output_ranges (void);
    3769                 :            : static dw_line_info_table *new_line_info_table (void);
    3770                 :            : static void output_line_info (bool);
    3771                 :            : static void output_file_names (void);
    3772                 :            : static dw_die_ref base_type_die (tree, bool);
    3773                 :            : static int is_base_type (tree);
    3774                 :            : static dw_die_ref subrange_type_die (tree, tree, tree, tree, dw_die_ref);
    3775                 :            : static int decl_quals (const_tree);
    3776                 :            : static dw_die_ref modified_type_die (tree, int, bool, dw_die_ref);
    3777                 :            : static dw_die_ref generic_parameter_die (tree, tree, bool, dw_die_ref);
    3778                 :            : static dw_die_ref template_parameter_pack_die (tree, tree, dw_die_ref);
    3779                 :            : static unsigned int dbx_reg_number (const_rtx);
    3780                 :            : static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
    3781                 :            : static dw_loc_descr_ref reg_loc_descriptor (rtx, enum var_init_status);
    3782                 :            : static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int,
    3783                 :            :                                                 enum var_init_status);
    3784                 :            : static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx,
    3785                 :            :                                                      enum var_init_status);
    3786                 :            : static dw_loc_descr_ref based_loc_descr (rtx, poly_int64,
    3787                 :            :                                          enum var_init_status);
    3788                 :            : static int is_based_loc (const_rtx);
    3789                 :            : static bool resolve_one_addr (rtx *);
    3790                 :            : static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx,
    3791                 :            :                                                enum var_init_status);
    3792                 :            : static dw_loc_descr_ref loc_descriptor (rtx, machine_mode mode,
    3793                 :            :                                         enum var_init_status);
    3794                 :            : struct loc_descr_context;
    3795                 :            : static void add_loc_descr_to_each (dw_loc_list_ref list, dw_loc_descr_ref ref);
    3796                 :            : static void add_loc_list (dw_loc_list_ref *ret, dw_loc_list_ref list);
    3797                 :            : static dw_loc_list_ref loc_list_from_tree (tree, int,
    3798                 :            :                                            struct loc_descr_context *);
    3799                 :            : static dw_loc_descr_ref loc_descriptor_from_tree (tree, int,
    3800                 :            :                                                   struct loc_descr_context *);
    3801                 :            : static tree field_type (const_tree);
    3802                 :            : static unsigned int simple_type_align_in_bits (const_tree);
    3803                 :            : static unsigned int simple_decl_align_in_bits (const_tree);
    3804                 :            : static unsigned HOST_WIDE_INT simple_type_size_in_bits (const_tree);
    3805                 :            : struct vlr_context;
    3806                 :            : static dw_loc_descr_ref field_byte_offset (const_tree, struct vlr_context *,
    3807                 :            :                                            HOST_WIDE_INT *);
    3808                 :            : static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
    3809                 :            :                                          dw_loc_list_ref);
    3810                 :            : static void add_data_member_location_attribute (dw_die_ref, tree,
    3811                 :            :                                                 struct vlr_context *);
    3812                 :            : static bool add_const_value_attribute (dw_die_ref, rtx);
    3813                 :            : static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
    3814                 :            : static void insert_wide_int (const wide_int &, unsigned char *, int);
    3815                 :            : static void insert_float (const_rtx, unsigned char *);
    3816                 :            : static rtx rtl_for_decl_location (tree);
    3817                 :            : static bool add_location_or_const_value_attribute (dw_die_ref, tree, bool);
    3818                 :            : static bool tree_add_const_value_attribute (dw_die_ref, tree);
    3819                 :            : static bool tree_add_const_value_attribute_for_decl (dw_die_ref, tree);
    3820                 :            : static void add_name_attribute (dw_die_ref, const char *);
    3821                 :            : static void add_desc_attribute (dw_die_ref, tree);
    3822                 :            : static void add_gnat_descriptive_type_attribute (dw_die_ref, tree, dw_die_ref);
    3823                 :            : static void add_comp_dir_attribute (dw_die_ref);
    3824                 :            : static void add_scalar_info (dw_die_ref, enum dwarf_attribute, tree, int,
    3825                 :            :                              struct loc_descr_context *);
    3826                 :            : static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree,
    3827                 :            :                             struct loc_descr_context *);
    3828                 :            : static void add_subscript_info (dw_die_ref, tree, bool);
    3829                 :            : static void add_byte_size_attribute (dw_die_ref, tree);
    3830                 :            : static void add_alignment_attribute (dw_die_ref, tree);
    3831                 :            : static inline void add_bit_offset_attribute (dw_die_ref, tree,
    3832                 :            :                                              struct vlr_context *);
    3833                 :            : static void add_bit_size_attribute (dw_die_ref, tree);
    3834                 :            : static void add_prototyped_attribute (dw_die_ref, tree);
    3835                 :            : static void add_abstract_origin_attribute (dw_die_ref, tree);
    3836                 :            : static void add_pure_or_virtual_attribute (dw_die_ref, tree);
    3837                 :            : static void add_src_coords_attributes (dw_die_ref, tree);
    3838                 :            : static void add_name_and_src_coords_attributes (dw_die_ref, tree, bool = false);
    3839                 :            : static void add_discr_value (dw_die_ref, dw_discr_value *);
    3840                 :            : static void add_discr_list (dw_die_ref, dw_discr_list_ref);
    3841                 :            : static inline dw_discr_list_ref AT_discr_list (dw_attr_node *);
    3842                 :            : static dw_die_ref scope_die_for (tree, dw_die_ref);
    3843                 :            : static inline int local_scope_p (dw_die_ref);
    3844                 :            : static inline int class_scope_p (dw_die_ref);
    3845                 :            : static inline int class_or_namespace_scope_p (dw_die_ref);
    3846                 :            : static void add_type_attribute (dw_die_ref, tree, int, bool, dw_die_ref);
    3847                 :            : static void add_calling_convention_attribute (dw_die_ref, tree);
    3848                 :            : static const char *type_tag (const_tree);
    3849                 :            : static tree member_declared_type (const_tree);
    3850                 :            : #if 0
    3851                 :            : static const char *decl_start_label (tree);
    3852                 :            : #endif
    3853                 :            : static void gen_array_type_die (tree, dw_die_ref);
    3854                 :            : static void gen_descr_array_type_die (tree, struct array_descr_info *, dw_die_ref);
    3855                 :            : #if 0
    3856                 :            : static void gen_entry_point_die (tree, dw_die_ref);
    3857                 :            : #endif
    3858                 :            : static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
    3859                 :            : static dw_die_ref gen_formal_parameter_die (tree, tree, bool, dw_die_ref);
    3860                 :            : static dw_die_ref gen_formal_parameter_pack_die  (tree, tree, dw_die_ref, tree*);
    3861                 :            : static void gen_unspecified_parameters_die (tree, dw_die_ref);
    3862                 :            : static void gen_formal_types_die (tree, dw_die_ref);
    3863                 :            : static void gen_subprogram_die (tree, dw_die_ref);
    3864                 :            : static void gen_variable_die (tree, tree, dw_die_ref);
    3865                 :            : static void gen_const_die (tree, dw_die_ref);
    3866                 :            : static void gen_label_die (tree, dw_die_ref);
    3867                 :            : static void gen_lexical_block_die (tree, dw_die_ref);
    3868                 :            : static void gen_inlined_subroutine_die (tree, dw_die_ref);
    3869                 :            : static void gen_field_die (tree, struct vlr_context *, dw_die_ref);
    3870                 :            : static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
    3871                 :            : static dw_die_ref gen_compile_unit_die (const char *);
    3872                 :            : static void gen_inheritance_die (tree, tree, tree, dw_die_ref);
    3873                 :            : static void gen_member_die (tree, dw_die_ref);
    3874                 :            : static void gen_struct_or_union_type_die (tree, dw_die_ref,
    3875                 :            :                                                 enum debug_info_usage);
    3876                 :            : static void gen_subroutine_type_die (tree, dw_die_ref);
    3877                 :            : static void gen_typedef_die (tree, dw_die_ref);
    3878                 :            : static void gen_type_die (tree, dw_die_ref);
    3879                 :            : static void gen_block_die (tree, dw_die_ref);
    3880                 :            : static void decls_for_scope (tree, dw_die_ref, bool = true);
    3881                 :            : static bool is_naming_typedef_decl (const_tree);
    3882                 :            : static inline dw_die_ref get_context_die (tree);
    3883                 :            : static void gen_namespace_die (tree, dw_die_ref);
    3884                 :            : static dw_die_ref gen_namelist_decl (tree, dw_die_ref, tree);
    3885                 :            : static dw_die_ref gen_decl_die (tree, tree, struct vlr_context *, dw_die_ref);
    3886                 :            : static dw_die_ref force_decl_die (tree);
    3887                 :            : static dw_die_ref force_type_die (tree);
    3888                 :            : static dw_die_ref setup_namespace_context (tree, dw_die_ref);
    3889                 :            : static dw_die_ref declare_in_namespace (tree, dw_die_ref);
    3890                 :            : static struct dwarf_file_data * lookup_filename (const char *);
    3891                 :            : static void retry_incomplete_types (void);
    3892                 :            : static void gen_type_die_for_member (tree, tree, dw_die_ref);
    3893                 :            : static void gen_generic_params_dies (tree);
    3894                 :            : static void gen_tagged_type_die (tree, dw_die_ref, enum debug_info_usage);
    3895                 :            : static void gen_type_die_with_usage (tree, dw_die_ref, enum debug_info_usage);
    3896                 :            : static void splice_child_die (dw_die_ref, dw_die_ref);
    3897                 :            : static int file_info_cmp (const void *, const void *);
    3898                 :            : static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *, var_loc_view,
    3899                 :            :                                      const char *, var_loc_view, const char *);
    3900                 :            : static void output_loc_list (dw_loc_list_ref);
    3901                 :            : static char *gen_internal_sym (const char *);
    3902                 :            : static bool want_pubnames (void);
    3903                 :            : 
    3904                 :            : static void prune_unmark_dies (dw_die_ref);
    3905                 :            : static void prune_unused_types_mark_generic_parms_dies (dw_die_ref);
    3906                 :            : static void prune_unused_types_mark (dw_die_ref, int);
    3907                 :            : static void prune_unused_types_walk (dw_die_ref);
    3908                 :            : static void prune_unused_types_walk_attribs (dw_die_ref);
    3909                 :            : static void prune_unused_types_prune (dw_die_ref);
    3910                 :            : static void prune_unused_types (void);
    3911                 :            : static int maybe_emit_file (struct dwarf_file_data *fd);
    3912                 :            : static inline const char *AT_vms_delta1 (dw_attr_node *);
    3913                 :            : static inline const char *AT_vms_delta2 (dw_attr_node *);
    3914                 :            : static inline void add_AT_vms_delta (dw_die_ref, enum dwarf_attribute,
    3915                 :            :                                      const char *, const char *);
    3916                 :            : static void append_entry_to_tmpl_value_parm_die_table (dw_die_ref, tree);
    3917                 :            : static void gen_remaining_tmpl_value_param_die_attribute (void);
    3918                 :            : static bool generic_type_p (tree);
    3919                 :            : static void schedule_generic_params_dies_gen (tree t);
    3920                 :            : static void gen_scheduled_generic_parms_dies (void);
    3921                 :            : static void resolve_variable_values (void);
    3922                 :            : 
    3923                 :            : static const char *comp_dir_string (void);
    3924                 :            : 
    3925                 :            : static void hash_loc_operands (dw_loc_descr_ref, inchash::hash &);
    3926                 :            : 
    3927                 :            : /* enum for tracking thread-local variables whose address is really an offset
    3928                 :            :    relative to the TLS pointer, which will need link-time relocation, but will
    3929                 :            :    not need relocation by the DWARF consumer.  */
    3930                 :            : 
    3931                 :            : enum dtprel_bool
    3932                 :            : {
    3933                 :            :   dtprel_false = 0,
    3934                 :            :   dtprel_true = 1
    3935                 :            : };
    3936                 :            : 
    3937                 :            : /* Return the operator to use for an address of a variable.  For dtprel_true, we
    3938                 :            :    use DW_OP_const*.  For regular variables, which need both link-time
    3939                 :            :    relocation and consumer-level relocation (e.g., to account for shared objects
    3940                 :            :    loaded at a random address), we use DW_OP_addr*.  */
    3941                 :            : 
    3942                 :            : static inline enum dwarf_location_atom
    3943                 :    1005910 : dw_addr_op (enum dtprel_bool dtprel)
    3944                 :            : {
    3945                 :    1005910 :   if (dtprel == dtprel_true)
    3946                 :       5460 :     return (dwarf_split_debug_info ? dwarf_OP (DW_OP_constx)
    3947                 :       5460 :             : (DWARF2_ADDR_SIZE == 4 ? DW_OP_const4u : DW_OP_const8u));
    3948                 :            :   else
    3949                 :    1000450 :     return dwarf_split_debug_info ? dwarf_OP (DW_OP_addrx) : DW_OP_addr;
    3950                 :            : }
    3951                 :            : 
    3952                 :            : /* Return a pointer to a newly allocated address location description.  If
    3953                 :            :    dwarf_split_debug_info is true, then record the address with the appropriate
    3954                 :            :    relocation.  */
    3955                 :            : static inline dw_loc_descr_ref
    3956                 :    1005910 : new_addr_loc_descr (rtx addr, enum dtprel_bool dtprel)
    3957                 :            : {
    3958                 :    1005910 :   dw_loc_descr_ref ref = new_loc_descr (dw_addr_op (dtprel), 0, 0);
    3959                 :            : 
    3960                 :    1005910 :   ref->dw_loc_oprnd1.val_class = dw_val_class_addr;
    3961                 :    1005910 :   ref->dw_loc_oprnd1.v.val_addr = addr;
    3962                 :    1005910 :   ref->dtprel = dtprel;
    3963                 :    1005910 :   if (dwarf_split_debug_info)
    3964                 :          7 :     ref->dw_loc_oprnd1.val_entry
    3965                 :         14 :       = add_addr_table_entry (addr,
    3966                 :            :                               dtprel ? ate_kind_rtx_dtprel : ate_kind_rtx);
    3967                 :            :   else
    3968                 :    1005900 :     ref->dw_loc_oprnd1.val_entry = NULL;
    3969                 :            : 
    3970                 :    1005910 :   return ref;
    3971                 :            : }
    3972                 :            : 
    3973                 :            : /* Section names used to hold DWARF debugging information.  */
    3974                 :            : 
    3975                 :            : #ifndef DEBUG_INFO_SECTION
    3976                 :            : #define DEBUG_INFO_SECTION      ".debug_info"
    3977                 :            : #endif
    3978                 :            : #ifndef DEBUG_DWO_INFO_SECTION
    3979                 :            : #define DEBUG_DWO_INFO_SECTION ".debug_info.dwo"
    3980                 :            : #endif
    3981                 :            : #ifndef DEBUG_LTO_INFO_SECTION
    3982                 :            : #define DEBUG_LTO_INFO_SECTION  ".gnu.debuglto_.debug_info"
    3983                 :            : #endif
    3984                 :            : #ifndef DEBUG_LTO_DWO_INFO_SECTION
    3985                 :            : #define DEBUG_LTO_DWO_INFO_SECTION ".gnu.debuglto_.debug_info.dwo"
    3986                 :            : #endif
    3987                 :            : #ifndef DEBUG_ABBREV_SECTION
    3988                 :            : #define DEBUG_ABBREV_SECTION    ".debug_abbrev"
    3989                 :            : #endif
    3990                 :            : #ifndef DEBUG_LTO_ABBREV_SECTION
    3991                 :            : #define DEBUG_LTO_ABBREV_SECTION ".gnu.debuglto_.debug_abbrev"
    3992                 :            : #endif
    3993                 :            : #ifndef DEBUG_DWO_ABBREV_SECTION
    3994                 :            : #define DEBUG_DWO_ABBREV_SECTION ".debug_abbrev.dwo"
    3995                 :            : #endif
    3996                 :            : #ifndef DEBUG_LTO_DWO_ABBREV_SECTION
    3997                 :            : #define DEBUG_LTO_DWO_ABBREV_SECTION ".gnu.debuglto_.debug_abbrev.dwo"
    3998                 :            : #endif
    3999                 :            : #ifndef DEBUG_ARANGES_SECTION
    4000                 :            : #define DEBUG_ARANGES_SECTION   ".debug_aranges"
    4001                 :            : #endif
    4002                 :            : #ifndef DEBUG_ADDR_SECTION
    4003                 :            : #define DEBUG_ADDR_SECTION     ".debug_addr"
    4004                 :            : #endif
    4005                 :            : #ifndef DEBUG_MACINFO_SECTION
    4006                 :            : #define DEBUG_MACINFO_SECTION     ".debug_macinfo"
    4007                 :            : #endif
    4008                 :            : #ifndef DEBUG_LTO_MACINFO_SECTION
    4009                 :            : #define DEBUG_LTO_MACINFO_SECTION      ".gnu.debuglto_.debug_macinfo"
    4010                 :            : #endif
    4011                 :            : #ifndef DEBUG_DWO_MACINFO_SECTION
    4012                 :            : #define DEBUG_DWO_MACINFO_SECTION      ".debug_macinfo.dwo"
    4013                 :            : #endif
    4014                 :            : #ifndef DEBUG_LTO_DWO_MACINFO_SECTION
    4015                 :            : #define DEBUG_LTO_DWO_MACINFO_SECTION  ".gnu.debuglto_.debug_macinfo.dwo"
    4016                 :            : #endif
    4017                 :            : #ifndef DEBUG_MACRO_SECTION
    4018                 :            : #define DEBUG_MACRO_SECTION     ".debug_macro"
    4019                 :            : #endif
    4020                 :            : #ifndef DEBUG_LTO_MACRO_SECTION
    4021                 :            : #define DEBUG_LTO_MACRO_SECTION ".gnu.debuglto_.debug_macro"
    4022                 :            : #endif
    4023                 :            : #ifndef DEBUG_DWO_MACRO_SECTION
    4024                 :            : #define DEBUG_DWO_MACRO_SECTION        ".debug_macro.dwo"
    4025                 :            : #endif
    4026                 :            : #ifndef DEBUG_LTO_DWO_MACRO_SECTION
    4027                 :            : #define DEBUG_LTO_DWO_MACRO_SECTION    ".gnu.debuglto_.debug_macro.dwo"
    4028                 :            : #endif
    4029                 :            : #ifndef DEBUG_LINE_SECTION
    4030                 :            : #define DEBUG_LINE_SECTION      ".debug_line"
    4031                 :            : #endif
    4032                 :            : #ifndef DEBUG_LTO_LINE_SECTION
    4033                 :            : #define DEBUG_LTO_LINE_SECTION ".gnu.debuglto_.debug_line"
    4034                 :            : #endif
    4035                 :            : #ifndef DEBUG_DWO_LINE_SECTION
    4036                 :            : #define DEBUG_DWO_LINE_SECTION ".debug_line.dwo"
    4037                 :            : #endif
    4038                 :            : #ifndef DEBUG_LTO_DWO_LINE_SECTION
    4039                 :            : #define DEBUG_LTO_DWO_LINE_SECTION ".gnu.debuglto_.debug_line.dwo"
    4040                 :            : #endif
    4041                 :            : #ifndef DEBUG_LOC_SECTION
    4042                 :            : #define DEBUG_LOC_SECTION       ".debug_loc"
    4043                 :            : #endif
    4044                 :            : #ifndef DEBUG_DWO_LOC_SECTION
    4045                 :            : #define DEBUG_DWO_LOC_SECTION  ".debug_loc.dwo"
    4046                 :            : #endif
    4047                 :            : #ifndef DEBUG_LOCLISTS_SECTION
    4048                 :            : #define DEBUG_LOCLISTS_SECTION  ".debug_loclists"
    4049                 :            : #endif
    4050                 :            : #ifndef DEBUG_DWO_LOCLISTS_SECTION
    4051                 :            : #define DEBUG_DWO_LOCLISTS_SECTION  ".debug_loclists.dwo"
    4052                 :            : #endif
    4053                 :            : #ifndef DEBUG_PUBNAMES_SECTION
    4054                 :            : #define DEBUG_PUBNAMES_SECTION  \
    4055                 :            :   ((debug_generate_pub_sections == 2) \
    4056                 :            :    ? ".debug_gnu_pubnames" : ".debug_pubnames")
    4057                 :            : #endif
    4058                 :            : #ifndef DEBUG_PUBTYPES_SECTION
    4059                 :            : #define DEBUG_PUBTYPES_SECTION  \
    4060                 :            :   ((debug_generate_pub_sections == 2) \
    4061                 :            :    ? ".debug_gnu_pubtypes" : ".debug_pubtypes")
    4062                 :            : #endif
    4063                 :            : #ifndef DEBUG_STR_OFFSETS_SECTION
    4064                 :            : #define DEBUG_STR_OFFSETS_SECTION ".debug_str_offsets"
    4065                 :            : #endif
    4066                 :            : #ifndef DEBUG_DWO_STR_OFFSETS_SECTION
    4067                 :            : #define DEBUG_DWO_STR_OFFSETS_SECTION ".debug_str_offsets.dwo"
    4068                 :            : #endif
    4069                 :            : #ifndef DEBUG_LTO_DWO_STR_OFFSETS_SECTION
    4070                 :            : #define DEBUG_LTO_DWO_STR_OFFSETS_SECTION ".gnu.debuglto_.debug_str_offsets.dwo"
    4071                 :            : #endif
    4072                 :            : #ifndef DEBUG_STR_SECTION
    4073                 :            : #define DEBUG_STR_SECTION  ".debug_str"
    4074                 :            : #endif
    4075                 :            : #ifndef DEBUG_LTO_STR_SECTION
    4076                 :            : #define DEBUG_LTO_STR_SECTION ".gnu.debuglto_.debug_str"
    4077                 :            : #endif
    4078                 :            : #ifndef DEBUG_STR_DWO_SECTION
    4079                 :            : #define DEBUG_STR_DWO_SECTION   ".debug_str.dwo"
    4080                 :            : #endif
    4081                 :            : #ifndef DEBUG_LTO_STR_DWO_SECTION
    4082                 :            : #define DEBUG_LTO_STR_DWO_SECTION ".gnu.debuglto_.debug_str.dwo"
    4083                 :            : #endif
    4084                 :            : #ifndef DEBUG_RANGES_SECTION
    4085                 :            : #define DEBUG_RANGES_SECTION    ".debug_ranges"
    4086                 :            : #endif
    4087                 :            : #ifndef DEBUG_RNGLISTS_SECTION
    4088                 :            : #define DEBUG_RNGLISTS_SECTION  ".debug_rnglists"
    4089                 :            : #endif
    4090                 :            : #ifndef DEBUG_LINE_STR_SECTION
    4091                 :            : #define DEBUG_LINE_STR_SECTION  ".debug_line_str"
    4092                 :            : #endif
    4093                 :            : #ifndef DEBUG_LTO_LINE_STR_SECTION
    4094                 :            : #define DEBUG_LTO_LINE_STR_SECTION  ".gnu.debuglto_.debug_line_str"
    4095                 :            : #endif
    4096                 :            : 
    4097                 :            : /* Standard ELF section names for compiled code and data.  */
    4098                 :            : #ifndef TEXT_SECTION_NAME
    4099                 :            : #define TEXT_SECTION_NAME       ".text"
    4100                 :            : #endif
    4101                 :            : 
    4102                 :            : /* Section flags for .debug_str section.  */
    4103                 :            : #define DEBUG_STR_SECTION_FLAGS                                 \
    4104                 :            :   (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings               \
    4105                 :            :    ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1        \
    4106                 :            :    : SECTION_DEBUG)
    4107                 :            : 
    4108                 :            : /* Section flags for .debug_str.dwo section.  */
    4109                 :            : #define DEBUG_STR_DWO_SECTION_FLAGS (SECTION_DEBUG | SECTION_EXCLUDE)
    4110                 :            : 
    4111                 :            : /* Attribute used to refer to the macro section.  */
    4112                 :            : #define DEBUG_MACRO_ATTRIBUTE (dwarf_version >= 5 ? DW_AT_macros \
    4113                 :            :                    : dwarf_strict ? DW_AT_macro_info : DW_AT_GNU_macros)
    4114                 :            : 
    4115                 :            : /* Labels we insert at beginning sections we can reference instead of
    4116                 :            :    the section names themselves.  */
    4117                 :            : 
    4118                 :            : #ifndef TEXT_SECTION_LABEL
    4119                 :            : #define TEXT_SECTION_LABEL                 "Ltext"
    4120                 :            : #endif
    4121                 :            : #ifndef COLD_TEXT_SECTION_LABEL
    4122                 :            : #define COLD_TEXT_SECTION_LABEL             "Ltext_cold"
    4123                 :            : #endif
    4124                 :            : #ifndef DEBUG_LINE_SECTION_LABEL
    4125                 :            : #define DEBUG_LINE_SECTION_LABEL           "Ldebug_line"
    4126                 :            : #endif
    4127                 :            : #ifndef DEBUG_SKELETON_LINE_SECTION_LABEL
    4128                 :            : #define DEBUG_SKELETON_LINE_SECTION_LABEL   "Lskeleton_debug_line"
    4129                 :            : #endif
    4130                 :            : #ifndef DEBUG_INFO_SECTION_LABEL
    4131                 :            : #define DEBUG_INFO_SECTION_LABEL           "Ldebug_info"
    4132                 :            : #endif
    4133                 :            : #ifndef DEBUG_SKELETON_INFO_SECTION_LABEL
    4134                 :            : #define DEBUG_SKELETON_INFO_SECTION_LABEL   "Lskeleton_debug_info"
    4135                 :            : #endif
    4136                 :            : #ifndef DEBUG_ABBREV_SECTION_LABEL
    4137                 :            : #define DEBUG_ABBREV_SECTION_LABEL         "Ldebug_abbrev"
    4138                 :            : #endif
    4139                 :            : #ifndef DEBUG_SKELETON_ABBREV_SECTION_LABEL
    4140                 :            : #define DEBUG_SKELETON_ABBREV_SECTION_LABEL "Lskeleton_debug_abbrev"
    4141                 :            : #endif
    4142                 :            : #ifndef DEBUG_ADDR_SECTION_LABEL
    4143                 :            : #define DEBUG_ADDR_SECTION_LABEL           "Ldebug_addr"
    4144                 :            : #endif
    4145                 :            : #ifndef DEBUG_LOC_SECTION_LABEL
    4146                 :            : #define DEBUG_LOC_SECTION_LABEL                    "Ldebug_loc"
    4147                 :            : #endif
    4148                 :            : #ifndef DEBUG_RANGES_SECTION_LABEL
    4149                 :            : #define DEBUG_RANGES_SECTION_LABEL         "Ldebug_ranges"
    4150                 :            : #endif
    4151                 :            : #ifndef DEBUG_MACINFO_SECTION_LABEL
    4152                 :            : #define DEBUG_MACINFO_SECTION_LABEL         "Ldebug_macinfo"
    4153                 :            : #endif
    4154                 :            : #ifndef DEBUG_MACRO_SECTION_LABEL
    4155                 :            : #define DEBUG_MACRO_SECTION_LABEL          "Ldebug_macro"
    4156                 :            : #endif
    4157                 :            : #define SKELETON_COMP_DIE_ABBREV 1
    4158                 :            : #define SKELETON_TYPE_DIE_ABBREV 2
    4159                 :            : 
    4160                 :            : /* Definitions of defaults for formats and names of various special
    4161                 :            :    (artificial) labels which may be generated within this file (when the -g
    4162                 :            :    options is used and DWARF2_DEBUGGING_INFO is in effect.
    4163                 :            :    If necessary, these may be overridden from within the tm.h file, but
    4164                 :            :    typically, overriding these defaults is unnecessary.  */
    4165                 :            : 
    4166                 :            : static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
    4167                 :            : static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
    4168                 :            : static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
    4169                 :            : static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
    4170                 :            : static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
    4171                 :            : static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
    4172                 :            : static char debug_skeleton_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
    4173                 :            : static char debug_skeleton_abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
    4174                 :            : static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
    4175                 :            : static char debug_addr_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
    4176                 :            : static char debug_skeleton_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
    4177                 :            : static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
    4178                 :            : static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
    4179                 :            : static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
    4180                 :            : static char ranges_base_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
    4181                 :            : 
    4182                 :            : #ifndef TEXT_END_LABEL
    4183                 :            : #define TEXT_END_LABEL          "Letext"
    4184                 :            : #endif
    4185                 :            : #ifndef COLD_END_LABEL
    4186                 :            : #define COLD_END_LABEL          "Letext_cold"
    4187                 :            : #endif
    4188                 :            : #ifndef BLOCK_BEGIN_LABEL
    4189                 :            : #define BLOCK_BEGIN_LABEL       "LBB"
    4190                 :            : #endif
    4191                 :            : #ifndef BLOCK_INLINE_ENTRY_LABEL
    4192                 :            : #define BLOCK_INLINE_ENTRY_LABEL "LBI"
    4193                 :            : #endif
    4194                 :            : #ifndef BLOCK_END_LABEL
    4195                 :            : #define BLOCK_END_LABEL         "LBE"
    4196                 :            : #endif
    4197                 :            : #ifndef LINE_CODE_LABEL
    4198                 :            : #define LINE_CODE_LABEL         "LM"
    4199                 :            : #endif
    4200                 :            : 
    4201                 :            : 
    4202                 :            : /* Return the root of the DIE's built for the current compilation unit.  */
    4203                 :            : static dw_die_ref
    4204                 :  108043000 : comp_unit_die (void)
    4205                 :            : {
    4206                 :      37784 :   if (!single_comp_unit_die)
    4207                 :      38895 :     single_comp_unit_die = gen_compile_unit_die (NULL);
    4208                 :  108042000 :   return single_comp_unit_die;
    4209                 :            : }
    4210                 :            : 
    4211                 :            : /* We allow a language front-end to designate a function that is to be
    4212                 :            :    called to "demangle" any name before it is put into a DIE.  */
    4213                 :            : 
    4214                 :            : static const char *(*demangle_name_func) (const char *);
    4215                 :            : 
    4216                 :            : void
    4217                 :          0 : dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
    4218                 :            : {
    4219                 :          0 :   demangle_name_func = func;
    4220                 :          0 : }
    4221                 :            : 
    4222                 :            : /* Test if rtl node points to a pseudo register.  */
    4223                 :            : 
    4224                 :            : static inline int
    4225                 :     928553 : is_pseudo_reg (const_rtx rtl)
    4226                 :            : {
    4227                 :     638190 :   return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
    4228                 :    1260300 :           || (GET_CODE (rtl) == SUBREG
    4229                 :        108 :               && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
    4230                 :            : }
    4231                 :            : 
    4232                 :            : /* Return a reference to a type, with its const and volatile qualifiers
    4233                 :            :    removed.  */
    4234                 :            : 
    4235                 :            : static inline tree
    4236                 :  122261000 : type_main_variant (tree type)
    4237                 :            : {
    4238                 :  122261000 :   type = TYPE_MAIN_VARIANT (type);
    4239                 :            : 
    4240                 :            :   /* ??? There really should be only one main variant among any group of
    4241                 :            :      variants of a given type (and all of the MAIN_VARIANT values for all
    4242                 :            :      members of the group should point to that one type) but sometimes the C
    4243                 :            :      front-end messes this up for array types, so we work around that bug
    4244                 :            :      here.  */
    4245                 :  122261000 :   if (TREE_CODE (type) == ARRAY_TYPE)
    4246                 :          0 :     while (type != TYPE_MAIN_VARIANT (type))
    4247                 :          0 :       type = TYPE_MAIN_VARIANT (type);
    4248                 :            : 
    4249                 :  122261000 :   return type;
    4250                 :            : }
    4251                 :            : 
    4252                 :            : /* Return nonzero if the given type node represents a tagged type.  */
    4253                 :            : 
    4254                 :            : static inline int
    4255                 :  159443000 : is_tagged_type (const_tree type)
    4256                 :            : {
    4257                 :  159443000 :   enum tree_code code = TREE_CODE (type);
    4258                 :            : 
    4259                 :  159443000 :   return (code == RECORD_TYPE || code == UNION_TYPE
    4260                 :  159443000 :           || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
    4261                 :            : }
    4262                 :            : 
    4263                 :            : /* Set label to debug_info_section_label + die_offset of a DIE reference.  */
    4264                 :            : 
    4265                 :            : static void
    4266                 :     383808 : get_ref_die_offset_label (char *label, dw_die_ref ref)
    4267                 :            : {
    4268                 :     383808 :   sprintf (label, "%s+%ld", debug_info_section_label, ref->die_offset);
    4269                 :          0 : }
    4270                 :            : 
    4271                 :            : /* Return die_offset of a DIE reference to a base type.  */
    4272                 :            : 
    4273                 :            : static unsigned long int
    4274                 :     963915 : get_base_type_offset (dw_die_ref ref)
    4275                 :            : {
    4276                 :     963915 :   if (ref->die_offset)
    4277                 :     730836 :     return ref->die_offset;
    4278                 :     233079 :   if (comp_unit_die ()->die_abbrev)
    4279                 :            :     {
    4280                 :          0 :       calc_base_type_die_sizes ();
    4281                 :          0 :       gcc_assert (ref->die_offset);
    4282                 :            :     }
    4283                 :     233079 :   return ref->die_offset;
    4284                 :            : }
    4285                 :            : 
    4286                 :            : /* Return die_offset of a DIE reference other than base type.  */
    4287                 :            : 
    4288                 :            : static unsigned long int
    4289                 :       9942 : get_ref_die_offset (dw_die_ref ref)
    4290                 :            : {
    4291                 :       9942 :   gcc_assert (ref->die_offset);
    4292                 :       9942 :   return ref->die_offset;
    4293                 :            : }
    4294                 :            : 
    4295                 :            : /* Convert a DIE tag into its string name.  */
    4296                 :            : 
    4297                 :            : static const char *
    4298                 :   47521600 : dwarf_tag_name (unsigned int tag)
    4299                 :            : {
    4300                 :          0 :   const char *name = get_DW_TAG_name (tag);
    4301                 :            : 
    4302                 :   47521600 :   if (name != NULL)
    4303                 :   47521600 :     return name;
    4304                 :            : 
    4305                 :            :   return "DW_TAG_<unknown>";
    4306                 :            : }
    4307                 :            : 
    4308                 :            : /* Convert a DWARF attribute code into its string name.  */
    4309                 :            : 
    4310                 :            : static const char *
    4311                 :  212661000 : dwarf_attr_name (unsigned int attr)
    4312                 :            : {
    4313                 :  212661000 :   const char *name;
    4314                 :            : 
    4315                 :  212661000 :   switch (attr)
    4316                 :            :     {
    4317                 :            : #if VMS_DEBUGGING_INFO
    4318                 :            :     case DW_AT_HP_prologue:
    4319                 :            :       return "DW_AT_HP_prologue";
    4320                 :            : #else
    4321                 :            :     case DW_AT_MIPS_loop_unroll_factor:
    4322                 :            :       return "DW_AT_MIPS_loop_unroll_factor";
    4323                 :            : #endif
    4324                 :            : 
    4325                 :            : #if VMS_DEBUGGING_INFO
    4326                 :            :     case DW_AT_HP_epilogue:
    4327                 :            :       return "DW_AT_HP_epilogue";
    4328                 :            : #else
    4329                 :          0 :     case DW_AT_MIPS_stride:
    4330                 :          0 :       return "DW_AT_MIPS_stride";
    4331                 :            : #endif
    4332                 :            :     }
    4333                 :            : 
    4334                 :  212661000 :   name = get_DW_AT_name (attr);
    4335                 :            : 
    4336                 :  212661000 :   if (name != NULL)
    4337                 :  212661000 :     return name;
    4338                 :            : 
    4339                 :            :   return "DW_AT_<unknown>";
    4340                 :            : }
    4341                 :            : 
    4342                 :            : /* Convert a DWARF value form code into its string name.  */
    4343                 :            : 
    4344                 :            : static const char *
    4345                 :   11048800 : dwarf_form_name (unsigned int form)
    4346                 :            : {
    4347                 :          0 :   const char *name = get_DW_FORM_name (form);
    4348                 :            : 
    4349                 :   11048800 :   if (name != NULL)
    4350                 :   11048800 :     return name;
    4351                 :            : 
    4352                 :            :   return "DW_FORM_<unknown>";
    4353                 :            : }
    4354                 :            : 
    4355                 :            : /* Determine the "ultimate origin" of a decl.  The decl may be an inlined
    4356                 :            :    instance of an inlined instance of a decl which is local to an inline
    4357                 :            :    function, so we have to trace all of the way back through the origin chain
    4358                 :            :    to find out what sort of node actually served as the original seed for the
    4359                 :            :    given block.  */
    4360                 :            : 
    4361                 :            : static tree
    4362                 :   67225600 : decl_ultimate_origin (const_tree decl)
    4363                 :            : {
    4364                 :   67225600 :   if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON))
    4365                 :            :     return NULL_TREE;
    4366                 :            : 
    4367                 :            :   /* DECL_ABSTRACT_ORIGIN can point to itself; ignore that if
    4368                 :            :      we're trying to output the abstract instance of this function.  */
    4369                 :   67225600 :   if (DECL_ABSTRACT_P (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
    4370                 :            :     return NULL_TREE;
    4371                 :            : 
    4372                 :            :   /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
    4373                 :            :      most distant ancestor, this should never happen.  */
    4374                 :  134451000 :   gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));
    4375                 :            : 
    4376                 :   67225600 :   return DECL_ABSTRACT_ORIGIN (decl);
    4377                 :            : }
    4378                 :            : 
    4379                 :            : /* Get the class to which DECL belongs, if any.  In g++, the DECL_CONTEXT
    4380                 :            :    of a virtual function may refer to a base class, so we check the 'this'
    4381                 :            :    parameter.  */
    4382                 :            : 
    4383                 :            : static tree
    4384                 :   12730200 : decl_class_context (tree decl)
    4385                 :            : {
    4386                 :   12730200 :   tree context = NULL_TREE;
    4387                 :            : 
    4388                 :   12730200 :   if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
    4389                 :   12366300 :     context = DECL_CONTEXT (decl);
    4390                 :            :   else
    4391                 :     727728 :     context = TYPE_MAIN_VARIANT
    4392                 :            :       (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
    4393                 :            : 
    4394                 :   12730200 :   if (context && !TYPE_P (context))
    4395                 :    2766870 :     context = NULL_TREE;
    4396                 :            : 
    4397                 :   12730200 :   return context;
    4398                 :            : }
    4399                 :            : 
    4400                 :            : /* Add an attribute/value pair to a DIE.  */
    4401                 :            : 
    4402                 :            : static inline void
    4403                 :  427253000 : add_dwarf_attr (dw_die_ref die, dw_attr_node *attr)
    4404                 :            : {
    4405                 :            :   /* Maybe this should be an assert?  */
    4406                 :  427253000 :   if (die == NULL)
    4407                 :            :     return;
    4408                 :            : 
    4409                 :  427172000 :   if (flag_checking)
    4410                 :            :     {
    4411                 :            :       /* Check we do not add duplicate attrs.  Can't use get_AT here
    4412                 :            :          because that recurses to the specification/abstract origin DIE.  */
    4413                 :            :       dw_attr_node *a;
    4414                 :            :       unsigned ix;
    4415                 : 1544690000 :       FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
    4416                 : 1117520000 :         gcc_assert (a->dw_attr != attr->dw_attr);
    4417                 :            :     }
    4418                 :            : 
    4419                 :  427172000 :   vec_safe_reserve (die->die_attr, 1);
    4420                 :  427172000 :   vec_safe_push (die->die_attr, *attr);
    4421                 :            : }
    4422                 :            : 
    4423                 :            : static inline enum dw_val_class
    4424                 : 3297160000 : AT_class (dw_attr_node *a)
    4425                 :            : {
    4426                 : 3297160000 :   return a->dw_attr_val.val_class;
    4427                 :            : }
    4428                 :            : 
    4429                 :            : /* Return the index for any attribute that will be referenced with a
    4430                 :            :    DW_FORM_addrx/GNU_addr_index or DW_FORM_strx/GNU_str_index.  String
    4431                 :            :    indices are stored in dw_attr_val.v.val_str for reference counting
    4432                 :            :    pruning.  */
    4433                 :            : 
    4434                 :            : static inline unsigned int
    4435                 :   24574100 : AT_index (dw_attr_node *a)
    4436                 :            : {
    4437                 :         18 :   if (AT_class (a) == dw_val_class_str)
    4438                 :         30 :     return a->dw_attr_val.v.val_str->index;
    4439                 :   24574100 :   else if (a->dw_attr_val.val_entry != NULL)
    4440                 :         84 :     return a->dw_attr_val.val_entry->index;
    4441                 :            :   return NOT_INDEXED;
    4442                 :            : }
    4443                 :            : 
    4444                 :            : /* Add a flag value attribute to a DIE.  */
    4445                 :            : 
    4446                 :            : static inline void
    4447                 :   40350500 : add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
    4448                 :            : {
    4449                 :   40350500 :   dw_attr_node attr;
    4450                 :            : 
    4451                 :   40350500 :   attr.dw_attr = attr_kind;
    4452                 :   40350500 :   attr.dw_attr_val.val_class = dw_val_class_flag;
    4453                 :   40350500 :   attr.dw_attr_val.val_entry = NULL;
    4454                 :   40350500 :   attr.dw_attr_val.v.val_flag = flag;
    4455                 :   40350500 :   add_dwarf_attr (die, &attr);
    4456                 :   14687100 : }
    4457                 :            : 
    4458                 :            : static inline unsigned
    4459                 :   18786600 : AT_flag (dw_attr_node *a)
    4460                 :            : {
    4461                 :    4159330 :   gcc_assert (a && AT_class (a) == dw_val_class_flag);
    4462                 :   18786600 :   return a->dw_attr_val.v.val_flag;
    4463                 :            : }
    4464                 :            : 
    4465                 :            : /* Add a signed integer attribute value to a DIE.  */
    4466                 :            : 
    4467                 :            : static inline void
    4468                 :      62092 : add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val)
    4469                 :            : {
    4470                 :      62092 :   dw_attr_node attr;
    4471                 :            : 
    4472                 :      62092 :   attr.dw_attr = attr_kind;
    4473                 :      62092 :   attr.dw_attr_val.val_class = dw_val_class_const;
    4474                 :      62092 :   attr.dw_attr_val.val_entry = NULL;
    4475                 :      62092 :   attr.dw_attr_val.v.val_int = int_val;
    4476                 :      62092 :   add_dwarf_attr (die, &attr);
    4477                 :      32567 : }
    4478                 :            : 
    4479                 :            : static inline HOST_WIDE_INT
    4480                 :      29946 : AT_int (dw_attr_node *a)
    4481                 :            : {
    4482                 :      29946 :   gcc_assert (a && (AT_class (a) == dw_val_class_const
    4483                 :            :                     || AT_class (a) == dw_val_class_const_implicit));
    4484                 :      29946 :   return a->dw_attr_val.v.val_int;
    4485                 :            : }
    4486                 :            : 
    4487                 :            : /* Add an unsigned integer attribute value to a DIE.  */
    4488                 :            : 
    4489                 :            : static inline void
    4490                 :  119186000 : add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
    4491                 :            :                  unsigned HOST_WIDE_INT unsigned_val)
    4492                 :            : {
    4493                 :  119186000 :   dw_attr_node attr;
    4494                 :            : 
    4495                 :  119186000 :   attr.dw_attr = attr_kind;
    4496                 :  119186000 :   attr.dw_attr_val.val_class = dw_val_class_unsigned_const;
    4497                 :  119186000 :   attr.dw_attr_val.val_entry = NULL;
    4498                 :  119186000 :   attr.dw_attr_val.v.val_unsigned = unsigned_val;
    4499                 :     318172 :   add_dwarf_attr (die, &attr);
    4500                 :   72710700 : }
    4501                 :            : 
    4502                 :            : static inline unsigned HOST_WIDE_INT
    4503                 :  274424000 : AT_unsigned (dw_attr_node *a)
    4504                 :            : {
    4505                 :  274424000 :   gcc_assert (a && (AT_class (a) == dw_val_class_unsigned_const
    4506                 :            :                     || AT_class (a) == dw_val_class_unsigned_const_implicit));
    4507                 :  274424000 :   return a->dw_attr_val.v.val_unsigned;
    4508                 :            : }
    4509                 :            : 
    4510                 :            : /* Add an unsigned wide integer attribute value to a DIE.  */
    4511                 :            : 
    4512                 :            : static inline void
    4513                 :          9 : add_AT_wide (dw_die_ref die, enum dwarf_attribute attr_kind,
    4514                 :            :              const wide_int& w)
    4515                 :            : {
    4516                 :          9 :   dw_attr_node attr;
    4517                 :            : 
    4518                 :          9 :   attr.dw_attr = attr_kind;
    4519                 :          9 :   attr.dw_attr_val.val_class = dw_val_class_wide_int;
    4520                 :          9 :   attr.dw_attr_val.val_entry = NULL;
    4521                 :          9 :   attr.dw_attr_val.v.val_wide = ggc_alloc<wide_int> ();
    4522                 :          9 :   *attr.dw_attr_val.v.val_wide = w;
    4523                 :          9 :   add_dwarf_attr (die, &attr);
    4524                 :          9 : }
    4525                 :            : 
    4526                 :            : /* Add an unsigned double integer attribute value to a DIE.  */
    4527                 :            : 
    4528                 :            : static inline void
    4529                 :            : add_AT_double (dw_die_ref die, enum dwarf_attribute attr_kind,
    4530                 :            :                HOST_WIDE_INT high, unsigned HOST_WIDE_INT low)
    4531                 :            : {
    4532                 :            :   dw_attr_node attr;
    4533                 :            : 
    4534                 :            :   attr.dw_attr = attr_kind;
    4535                 :            :   attr.dw_attr_val.val_class = dw_val_class_const_double;
    4536                 :            :   attr.dw_attr_val.val_entry = NULL;
    4537                 :            :   attr.dw_attr_val.v.val_double.high = high;
    4538                 :            :   attr.dw_attr_val.v.val_double.low = low;
    4539                 :            :   add_dwarf_attr (die, &attr);
    4540                 :            : }
    4541                 :            : 
    4542                 :            : /* Add a floating point attribute value to a DIE and return it.  */
    4543                 :            : 
    4544                 :            : static inline void
    4545                 :      58268 : add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind,
    4546                 :            :             unsigned int length, unsigned int elt_size, unsigned char *array)
    4547                 :            : {
    4548                 :      58268 :   dw_attr_node attr;
    4549                 :            : 
    4550                 :      58268 :   attr.dw_attr = attr_kind;
    4551                 :      58268 :   attr.dw_attr_val.val_class = dw_val_class_vec;
    4552                 :      58268 :   attr.dw_attr_val.val_entry = NULL;
    4553                 :      58268 :   attr.dw_attr_val.v.val_vec.length = length;
    4554                 :      58268 :   attr.dw_attr_val.v.val_vec.elt_size = elt_size;
    4555                 :      58268 :   attr.dw_attr_val.v.val_vec.array = array;
    4556                 :      58268 :   add_dwarf_attr (die, &attr);
    4557                 :            : }
    4558                 :            : 
    4559                 :            : /* Add an 8-byte data attribute value to a DIE.  */
    4560                 :            : 
    4561                 :            : static inline void
    4562                 :         88 : add_AT_data8 (dw_die_ref die, enum dwarf_attribute attr_kind,
    4563                 :            :               unsigned char data8[8])
    4564                 :            : {
    4565                 :         88 :   dw_attr_node attr;
    4566                 :            : 
    4567                 :         88 :   attr.dw_attr = attr_kind;
    4568                 :         88 :   attr.dw_attr_val.val_class = dw_val_class_data8;
    4569                 :         88 :   attr.dw_attr_val.val_entry = NULL;
    4570                 :         88 :   memcpy (attr.dw_attr_val.v.val_data8, data8, 8);
    4571                 :         88 :   add_dwarf_attr (die, &attr);
    4572                 :         84 : }
    4573                 :            : 
    4574                 :            : /* Add DW_AT_low_pc and DW_AT_high_pc to a DIE.  When using
    4575                 :            :    dwarf_split_debug_info, address attributes in dies destined for the
    4576                 :            :    final executable have force_direct set to avoid using indexed
    4577                 :            :    references.  */
    4578                 :            : 
    4579                 :            : static inline void
    4580                 :    2536390 : add_AT_low_high_pc (dw_die_ref die, const char *lbl_low, const char *lbl_high,
    4581                 :            :                     bool force_direct)
    4582                 :            : {
    4583                 :    2536390 :   dw_attr_node attr;
    4584                 :    2536390 :   char * lbl_id;
    4585                 :            : 
    4586                 :    2536390 :   lbl_id = xstrdup (lbl_low);
    4587                 :    2536390 :   attr.dw_attr = DW_AT_low_pc;
    4588                 :    2536390 :   attr.dw_attr_val.val_class = dw_val_class_lbl_id;
    4589                 :    2536390 :   attr.dw_attr_val.v.val_lbl_id = lbl_id;
    4590                 :    2536390 :   if (dwarf_split_debug_info && !force_direct)
    4591                 :          3 :     attr.dw_attr_val.val_entry
    4592                 :          3 :       = add_addr_table_entry (lbl_id, ate_kind_label);
    4593                 :            :   else
    4594                 :    2536380 :     attr.dw_attr_val.val_entry = NULL;
    4595                 :    2536390 :   add_dwarf_attr (die, &attr);
    4596                 :            : 
    4597                 :    2536390 :   attr.dw_attr = DW_AT_high_pc;
    4598                 :    2536390 :   if (dwarf_version < 4)
    4599                 :       4724 :     attr.dw_attr_val.val_class = dw_val_class_lbl_id;
    4600                 :            :   else
    4601                 :    2531660 :     attr.dw_attr_val.val_class = dw_val_class_high_pc;
    4602                 :    2536390 :   lbl_id = xstrdup (lbl_high);
    4603                 :    2536390 :   attr.dw_attr_val.v.val_lbl_id = lbl_id;
    4604                 :    2536390 :   if (attr.dw_attr_val.val_class == dw_val_class_lbl_id
    4605                 :       4724 :       && dwarf_split_debug_info && !force_direct)
    4606                 :          0 :     attr.dw_attr_val.val_entry
    4607                 :          0 :       = add_addr_table_entry (lbl_id, ate_kind_label);
    4608                 :            :   else
    4609                 :    2536390 :     attr.dw_attr_val.val_entry = NULL;
    4610                 :    2536390 :   add_dwarf_attr (die, &attr);
    4611                 :    2536390 : }
    4612                 :            : 
    4613                 :            : /* Hash and equality functions for debug_str_hash.  */
    4614                 :            : 
    4615                 :            : hashval_t
    4616                 :  729202000 : indirect_string_hasher::hash (indirect_string_node *x)
    4617                 :            : {
    4618                 :  729202000 :   return htab_hash_string (x->str);
    4619                 :            : }
    4620                 :            : 
    4621                 :            : bool
    4622                 :  788648000 : indirect_string_hasher::equal (indirect_string_node *x1, const char *x2)
    4623                 :            : {
    4624                 :  788648000 :   return strcmp (x1->str, x2) == 0;
    4625                 :            : }
    4626                 :            : 
    4627                 :            : /* Add STR to the given string hash table.  */
    4628                 :            : 
    4629                 :            : static struct indirect_string_node *
    4630                 :   95938600 : find_AT_string_in_table (const char *str,
    4631                 :            :                          hash_table<indirect_string_hasher> *table,
    4632                 :            :                          enum insert_option insert = INSERT)
    4633                 :            : {
    4634                 :   95938600 :   struct indirect_string_node *node;
    4635                 :            : 
    4636                 :   95938600 :   indirect_string_node **slot
    4637                 :   95938600 :     = table->find_slot_with_hash (str, htab_hash_string (str), insert);
    4638                 :   95938600 :   if (*slot == NULL)
    4639                 :            :     {
    4640                 :   60330300 :       node = ggc_cleared_alloc<indirect_string_node> ();
    4641                 :   60330300 :       node->str = ggc_strdup (str);
    4642                 :   60330300 :       *slot = node;
    4643                 :            :     }
    4644                 :            :   else
    4645                 :            :     node = *slot;
    4646                 :            : 
    4647                 :   95938600 :   node->refcount++;
    4648                 :   95938600 :   return node;
    4649                 :            : }
    4650                 :            : 
    4651                 :            : /* Add STR to the indirect string hash table.  */
    4652                 :            : 
    4653                 :            : static struct indirect_string_node *
    4654                 :   95938600 : find_AT_string (const char *str, enum insert_option insert = INSERT)
    4655                 :            : {
    4656                 :   95938600 :   if (! debug_str_hash)
    4657                 :      38895 :     debug_str_hash = hash_table<indirect_string_hasher>::create_ggc (10);
    4658                 :            : 
    4659                 :   95938600 :   return find_AT_string_in_table (str, debug_str_hash, insert);
    4660                 :            : }
    4661                 :            : 
    4662                 :            : /* Add a string attribute value to a DIE.  */
    4663                 :            : 
    4664                 :            : static inline void
    4665                 :   95538900 : add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
    4666                 :            : {
    4667                 :   95538900 :   dw_attr_node attr;
    4668                 :   95538900 :   struct indirect_string_node *node;
    4669                 :            : 
    4670                 :   95538900 :   node = find_AT_string (str);
    4671                 :            : 
    4672                 :   95538900 :   attr.dw_attr = attr_kind;
    4673                 :   95538900 :   attr.dw_attr_val.val_class = dw_val_class_str;
    4674                 :   95538900 :   attr.dw_attr_val.val_entry = NULL;
    4675                 :   95538900 :   attr.dw_attr_val.v.val_str = node;
    4676                 :   95538900 :   add_dwarf_attr (die, &attr);
    4677                 :   95538900 : }
    4678                 :            : 
    4679                 :            : static inline const char *
    4680                 :   19297900 : AT_string (dw_attr_node *a)
    4681                 :            : {
    4682                 :       1104 :   gcc_assert (a && AT_class (a) == dw_val_class_str);
    4683                 :   19176600 :   return a->dw_attr_val.v.val_str->str;
    4684                 :            : }
    4685                 :            : 
    4686                 :            : /* Call this function directly to bypass AT_string_form's logic to put
    4687                 :            :    the string inline in the die. */
    4688                 :            : 
    4689                 :            : static void
    4690                 :   11703500 : set_indirect_string (struct indirect_string_node *node)
    4691                 :            : {
    4692                 :   11703500 :   char label[MAX_ARTIFICIAL_LABEL_BYTES];
    4693                 :            :   /* Already indirect is a no op.  */
    4694                 :   11703500 :   if (node->form == DW_FORM_strp
    4695                 :   11703500 :       || node->form == DW_FORM_line_strp
    4696                 :   23405700 :       || node->form == dwarf_FORM (DW_FORM_strx))
    4697                 :            :     {
    4698                 :        631 :       gcc_assert (node->label);
    4699                 :        631 :       return;
    4700                 :            :     }
    4701                 :   11702800 :   ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
    4702                 :   11702800 :   ++dw2_string_counter;
    4703                 :   11702800 :   node->label = xstrdup (label);
    4704                 :            : 
    4705                 :   11702800 :   if (!dwarf_split_debug_info)
    4706                 :            :     {
    4707                 :   11702000 :       node->form = DW_FORM_strp;
    4708                 :   11702000 :       node->index = NOT_INDEXED;
    4709                 :            :     }
    4710                 :            :   else
    4711                 :            :     {
    4712                 :        780 :       node->form = dwarf_FORM (DW_FORM_strx);
    4713                 :        780 :       node->index = NO_INDEX_ASSIGNED;
    4714                 :            :     }
    4715                 :            : }
    4716                 :            : 
    4717                 :            : /* A helper function for dwarf2out_finish, called to reset indirect
    4718                 :            :    string decisions done for early LTO dwarf output before fat object
    4719                 :            :    dwarf output.  */
    4720                 :            : 
    4721                 :            : int
    4722                 :      12336 : reset_indirect_string (indirect_string_node **h, void *)
    4723                 :            : {
    4724                 :      12336 :   struct indirect_string_node *node = *h;
    4725                 :      14701 :   if (node->form == DW_FORM_strp || node->form == dwarf_FORM (DW_FORM_strx))
    4726                 :            :     {
    4727                 :       9947 :       free (node->label);
    4728                 :       9947 :       node->label = NULL;
    4729                 :       9947 :       node->form = (dwarf_form) 0;
    4730                 :       9947 :       node->index = 0;
    4731                 :            :     }
    4732                 :      12336 :   return 1;
    4733                 :            : }
    4734                 :            : 
    4735                 :            : /* Find out whether a string should be output inline in DIE
    4736                 :            :    or out-of-line in .debug_str section.  */
    4737                 :            : 
    4738                 :            : static enum dwarf_form
    4739                 :  115889000 : find_string_form (struct indirect_string_node *node)
    4740                 :            : {
    4741                 :  115889000 :   unsigned int len;
    4742                 :            : 
    4743                 :  115889000 :   if (node->form)
    4744                 :            :     return node->form;
    4745                 :            : 
    4746                 :   11991000 :   len = strlen (node->str) + 1;
    4747                 :            : 
    4748                 :            :   /* If the string is shorter or equal to the size of the reference, it is
    4749                 :            :      always better to put it inline.  */
    4750                 :   11991000 :   if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
    4751                 :     468026 :     return node->form = DW_FORM_string;
    4752                 :            : 
    4753                 :            :   /* If we cannot expect the linker to merge strings in .debug_str
    4754                 :            :      section, only put it into .debug_str if it is worth even in this
    4755                 :            :      single module.  */
    4756                 :   11523000 :   if (DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
    4757                 :   11523000 :       || ((debug_str_section->common.flags & SECTION_MERGE) == 0
    4758                 :        963 :           && (len - DWARF_OFFSET_SIZE) * node->refcount <= len))
    4759                 :        934 :     return node->form = DW_FORM_string;
    4760                 :            : 
    4761                 :   11522100 :   set_indirect_string (node);
    4762                 :            : 
    4763                 :   11522100 :   return node->form;
    4764                 :            : }
    4765                 :            : 
    4766                 :            : /* Find out whether the string referenced from the attribute should be
    4767                 :            :    output inline in DIE or out-of-line in .debug_str section.  */
    4768                 :            : 
    4769                 :            : static enum dwarf_form
    4770                 :  103716000 : AT_string_form (dw_attr_node *a)
    4771                 :            : {
    4772                 :  103716000 :   gcc_assert (a && AT_class (a) == dw_val_class_str);
    4773                 :  103716000 :   return find_string_form (a->dw_attr_val.v.val_str);
    4774                 :            : }
    4775                 :            : 
    4776                 :            : /* Add a DIE reference attribute value to a DIE.  */
    4777                 :            : 
    4778                 :            : static inline void
    4779                 :   97484000 : add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
    4780                 :            : {
    4781                 :   97484000 :   dw_attr_node attr;
    4782                 :   97484000 :   gcc_checking_assert (targ_die != NULL);
    4783                 :            : 
    4784                 :            :   /* With LTO we can end up trying to reference something we didn't create
    4785                 :            :      a DIE for.  Avoid crashing later on a NULL referenced DIE.  */
    4786                 :   97484000 :   if (targ_die == NULL)
    4787                 :            :     return;
    4788                 :            : 
    4789                 :   97484000 :   attr.dw_attr = attr_kind;
    4790                 :   97484000 :   attr.dw_attr_val.val_class = dw_val_class_die_ref;
    4791                 :   97484000 :   attr.dw_attr_val.val_entry = NULL;
    4792                 :   97484000 :   attr.dw_attr_val.v.val_die_ref.die = targ_die;
    4793                 :   97484000 :   attr.dw_attr_val.v.val_die_ref.external = 0;
    4794                 :   97484000 :   add_dwarf_attr (die, &attr);
    4795                 :            : }
    4796                 :            : 
    4797                 :            : /* Change DIE reference REF to point to NEW_DIE instead.  */
    4798                 :            : 
    4799                 :            : static inline void
    4800                 :        159 : change_AT_die_ref (dw_attr_node *ref, dw_die_ref new_die)
    4801                 :            : {
    4802                 :          0 :   gcc_assert (ref->dw_attr_val.val_class == dw_val_class_die_ref);
    4803                 :        159 :   ref->dw_attr_val.v.val_die_ref.die = new_die;
    4804                 :        159 :   ref->dw_attr_val.v.val_die_ref.external = 0;
    4805                 :        159 : }
    4806                 :            : 
    4807                 :            : /* Add an AT_specification attribute to a DIE, and also make the back
    4808                 :            :    pointer from the specification to the definition.  */
    4809                 :            : 
    4810                 :            : static inline void
    4811                 :    1791830 : add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
    4812                 :            : {
    4813                 :    1791830 :   add_AT_die_ref (die, DW_AT_specification, targ_die);
    4814                 :    1791830 :   gcc_assert (!targ_die->die_definition);
    4815                 :    1791830 :   targ_die->die_definition = die;
    4816                 :    1791830 : }
    4817                 :            : 
    4818                 :            : static inline dw_die_ref
    4819                 :  279783000 : AT_ref (dw_attr_node *a)
    4820                 :            : {
    4821                 :    1578450 :   gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
    4822                 :  279783000 :   return a->dw_attr_val.v.val_die_ref.die;
    4823                 :            : }
    4824                 :            : 
    4825                 :            : static inline int
    4826                 :  215321000 : AT_ref_external (dw_attr_node *a)
    4827                 :            : {
    4828                 :  215321000 :   if (a && AT_class (a) == dw_val_class_die_ref)
    4829                 :  215321000 :     return a->dw_attr_val.v.val_die_ref.external;
    4830                 :            : 
    4831                 :            :   return 0;
    4832                 :            : }
    4833                 :            : 
    4834                 :            : static inline void
    4835                 :      23001 : set_AT_ref_external (dw_attr_node *a, int i)
    4836                 :            : {
    4837                 :          0 :   gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
    4838                 :      23001 :   a->dw_attr_val.v.val_die_ref.external = i;
    4839                 :      23001 : }
    4840                 :            : 
    4841                 :            : /* Add a location description attribute value to a DIE.  */
    4842                 :            : 
    4843                 :            : static inline void
    4844                 :    5391990 : add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
    4845                 :            : {
    4846                 :    5391990 :   dw_attr_node attr;
    4847                 :            : 
    4848                 :    5391990 :   attr.dw_attr = attr_kind;
    4849                 :    5391990 :   attr.dw_attr_val.val_class = dw_val_class_loc;
    4850                 :    5391990 :   attr.dw_attr_val.val_entry = NULL;
    4851                 :    5391990 :   attr.dw_attr_val.v.val_loc = loc;
    4852                 :    5391990 :   add_dwarf_attr (die, &attr);
    4853                 :    2618340 : }
    4854                 :            : 
    4855                 :            : static inline dw_loc_descr_ref
    4856                 :   20746600 : AT_loc (dw_attr_node *a)
    4857                 :            : {
    4858                 :        889 :   gcc_assert (a && AT_class (a) == dw_val_class_loc);
    4859                 :   20746600 :   return a->dw_attr_val.v.val_loc;
    4860                 :            : }
    4861                 :            : 
    4862                 :            : static inline void
    4863                 :    6348970 : add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
    4864                 :            : {
    4865                 :    6348970 :   dw_attr_node attr;
    4866                 :            : 
    4867                 :    6348970 :   if (XCOFF_DEBUGGING_INFO && !HAVE_XCOFF_DWARF_EXTRAS)
    4868                 :            :     return;
    4869                 :            : 
    4870                 :    6348970 :   attr.dw_attr = attr_kind;
    4871                 :    6348970 :   attr.dw_attr_val.val_class = dw_val_class_loc_list;
    4872                 :    6348970 :   attr.dw_attr_val.val_entry = NULL;
    4873                 :    6348970 :   attr.dw_attr_val.v.val_loc_list = loc_list;
    4874                 :    6348970 :   add_dwarf_attr (die, &attr);
    4875                 :       1887 :   have_location_lists = true;
    4876                 :            : }
    4877                 :            : 
    4878                 :            : static inline dw_loc_list_ref
    4879                 :   18247300 : AT_loc_list (dw_attr_node *a)
    4880                 :            : {
    4881                 :    6082310 :   gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
    4882                 :   18247300 :   return a->dw_attr_val.v.val_loc_list;
    4883                 :            : }
    4884                 :            : 
    4885                 :            : /* Add a view list attribute to DIE.  It must have a DW_AT_location
    4886                 :            :    attribute, because the view list complements the location list.  */
    4887                 :            : 
    4888                 :            : static inline void
    4889                 :    6280620 : add_AT_view_list (dw_die_ref die, enum dwarf_attribute attr_kind)
    4890                 :            : {
    4891                 :    6280620 :   dw_attr_node attr;
    4892                 :            : 
    4893                 :    6280620 :   if (XCOFF_DEBUGGING_INFO && !HAVE_XCOFF_DWARF_EXTRAS)
    4894                 :            :     return;
    4895                 :            : 
    4896                 :    6280620 :   attr.dw_attr = attr_kind;
    4897                 :    6280620 :   attr.dw_attr_val.val_class = dw_val_class_view_list;
    4898                 :    6280620 :   attr.dw_attr_val.val_entry = NULL;
    4899                 :    6280620 :   attr.dw_attr_val.v.val_view_list = die;
    4900                 :    6280620 :   add_dwarf_attr (die, &attr);
    4901                 :    6280620 :   gcc_checking_assert (get_AT (die, DW_AT_location));
    4902                 :    6280620 :   gcc_assert (have_location_lists);
    4903                 :            : }
    4904                 :            : 
    4905                 :            : /* Return a pointer to the location list referenced by the attribute.
    4906                 :            :    If the named attribute is a view list, look up the corresponding
    4907                 :            :    DW_AT_location attribute and return its location list.  */
    4908                 :            : 
    4909                 :            : static inline dw_loc_list_ref *
    4910                 :   12362900 : AT_loc_list_ptr (dw_attr_node *a)
    4911                 :            : {
    4912                 :   18376600 :   gcc_assert (a);
    4913                 :   18376600 :   switch (AT_class (a))
    4914                 :            :     {
    4915                 :   12362900 :     case dw_val_class_loc_list:
    4916                 :   12362900 :       return &a->dw_attr_val.v.val_loc_list;
    4917                 :    6013620 :     case dw_val_class_view_list:
    4918                 :    6013620 :       {
    4919                 :    6013620 :         dw_attr_node *l;
    4920                 :    6013620 :         l = get_AT (a->dw_attr_val.v.val_view_list, DW_AT_location);
    4921                 :    6013620 :         if (!l)
    4922                 :            :           return NULL;
    4923                 :    6013620 :         gcc_checking_assert (l + 1 == a);
    4924                 :            :         return AT_loc_list_ptr (l);
    4925                 :            :       }
    4926                 :          0 :     default:
    4927                 :          0 :       gcc_unreachable ();
    4928                 :            :     }
    4929                 :            : }
    4930                 :            : 
    4931                 :            : /* Return the location attribute value associated with a view list
    4932                 :            :    attribute value.  */
    4933                 :            : 
    4934                 :            : static inline dw_val_node *
    4935                 :    6280660 : view_list_to_loc_list_val_node (dw_val_node *val)
    4936                 :            : {
    4937                 :    6280660 :   gcc_assert (val->val_class == dw_val_class_view_list);
    4938                 :    6280660 :   dw_attr_node *loc = get_AT (val->v.val_view_list, DW_AT_location);
    4939                 :    6280660 :   if (!loc)
    4940                 :            :     return NULL;
    4941                 :    6013660 :   gcc_checking_assert (&(loc + 1)->dw_attr_val == val);
    4942                 :    6013660 :   gcc_assert (AT_class (loc) == dw_val_class_loc_list);
    4943                 :    6013660 :   return &loc->dw_attr_val;
    4944                 :            : }
    4945                 :            : 
    4946                 :            : struct addr_hasher : ggc_ptr_hash<addr_table_entry>
    4947                 :            : {
    4948                 :            :   static hashval_t hash (addr_table_entry *);
    4949                 :            :   static bool equal (addr_table_entry *, addr_table_entry *);
    4950                 :            : };
    4951                 :            : 
    4952                 :            : /* Table of entries into the .debug_addr section.  */
    4953                 :            : 
    4954                 :            : static GTY (()) hash_table<addr_hasher> *addr_index_table;
    4955                 :            : 
    4956                 :            : /* Hash an address_table_entry.  */
    4957                 :            : 
    4958                 :            : hashval_t
    4959                 :        153 : addr_hasher::hash (addr_table_entry *a)
    4960                 :            : {
    4961                 :        153 :   inchash::hash hstate;
    4962                 :        153 :   switch (a->kind)
    4963                 :            :     {
    4964                 :         65 :       case ate_kind_rtx:
    4965                 :         65 :         hstate.add_int (0);
    4966                 :            :         break;
    4967                 :          0 :       case ate_kind_rtx_dtprel:
    4968                 :          0 :         hstate.add_int (1);
    4969                 :            :         break;
    4970                 :         88 :       case ate_kind_label:
    4971                 :         88 :         return htab_hash_string (a->addr.label);
    4972                 :          0 :       default:
    4973                 :          0 :         gcc_unreachable ();
    4974                 :            :     }
    4975                 :         65 :   inchash::add_rtx (a->addr.rtl, hstate);
    4976                 :         65 :   return hstate.end ();
    4977                 :            : }
    4978                 :            : 
    4979                 :            : /* Determine equality for two address_table_entries.  */
    4980                 :            : 
    4981                 :            : bool
    4982                 :        119 : addr_hasher::equal (addr_table_entry *a1, addr_table_entry *a2)
    4983                 :            : {
    4984                 :        119 :   if (a1->kind != a2->kind)
    4985                 :            :     return 0;
    4986                 :         52 :   switch (a1->kind)
    4987                 :            :     {
    4988                 :         28 :       case ate_kind_rtx:
    4989                 :         28 :       case ate_kind_rtx_dtprel:
    4990                 :         28 :         return rtx_equal_p (a1->addr.rtl, a2->addr.rtl);
    4991                 :         24 :       case ate_kind_label:
    4992                 :         24 :         return strcmp (a1->addr.label, a2->addr.label) == 0;
    4993                 :          0 :       default:
    4994                 :          0 :         gcc_unreachable ();
    4995                 :            :     }
    4996                 :            : }
    4997                 :            : 
    4998                 :            : /* Initialize an addr_table_entry.  */
    4999                 :            : 
    5000                 :            : void
    5001                 :         73 : init_addr_table_entry (addr_table_entry *e, enum ate_kind kind, void *addr)
    5002                 :            : {
    5003                 :         73 :   e->kind = kind;
    5004                 :         73 :   switch (kind)
    5005                 :            :     {
    5006                 :         37 :       case ate_kind_rtx:
    5007                 :         37 :       case ate_kind_rtx_dtprel:
    5008                 :         37 :         e->addr.rtl = (rtx) addr;
    5009                 :         37 :         break;
    5010                 :         36 :       case ate_kind_label:
    5011                 :         36 :         e->addr.label = (char *) addr;
    5012                 :         36 :         break;
    5013                 :            :     }
    5014                 :         73 :   e->refcount = 0;
    5015                 :         73 :   e->index = NO_INDEX_ASSIGNED;
    5016                 :         73 : }
    5017                 :            : 
    5018                 :            : /* Add attr to the address table entry to the table.  Defer setting an
    5019                 :            :    index until output time.  */
    5020                 :            : 
    5021                 :            : static addr_table_entry *
    5022                 :         42 : add_addr_table_entry (void *addr, enum ate_kind kind)
    5023                 :            : {
    5024                 :         42 :   addr_table_entry *node;
    5025                 :         42 :   addr_table_entry finder;
    5026                 :            : 
    5027                 :         42 :   gcc_assert (dwarf_split_debug_info);
    5028                 :         42 :   if (! addr_index_table)
    5029                 :          4 :     addr_index_table = hash_table<addr_hasher>::create_ggc (10);
    5030                 :         42 :   init_addr_table_entry (&finder, kind, addr);
    5031                 :         42 :   addr_table_entry **slot = addr_index_table->find_slot (&finder, INSERT);
    5032                 :            : 
    5033                 :         42 :   if (*slot == HTAB_EMPTY_ENTRY)
    5034                 :            :     {
    5035                 :         31 :       node = ggc_cleared_alloc<addr_table_entry> ();
    5036                 :         31 :       init_addr_table_entry (node, kind, addr);
    5037                 :         31 :       *slot = node;
    5038                 :            :     }
    5039                 :            :   else
    5040                 :            :     node = *slot;
    5041                 :            : 
    5042                 :         42 :   node->refcount++;
    5043                 :         42 :   return node;
    5044                 :            : }
    5045                 :            : 
    5046                 :            : /* Remove an entry from the addr table by decrementing its refcount.
    5047                 :            :    Strictly, decrementing the refcount would be enough, but the
    5048                 :            :    assertion that the entry is actually in the table has found
    5049                 :            :    bugs.  */
    5050                 :            : 
    5051                 :            : static void
    5052                 :          7 : remove_addr_table_entry (addr_table_entry *entry)
    5053                 :            : {
    5054                 :          7 :   gcc_assert (dwarf_split_debug_info && addr_index_table);
    5055                 :            :   /* After an index is assigned, the table is frozen.  */
    5056                 :          7 :   gcc_assert (entry->refcount > 0 && entry->index == NO_INDEX_ASSIGNED);
    5057                 :          7 :   entry->refcount--;
    5058                 :          7 : }
    5059                 :            : 
    5060                 :            : /* Given a location list, remove all addresses it refers to from the
    5061                 :            :    address_table.  */
    5062                 :            : 
    5063                 :            : static void
    5064                 :        167 : remove_loc_list_addr_table_entries (dw_loc_descr_ref descr)
    5065                 :            : {
    5066                 :       1281 :   for (; descr; descr = descr->dw_loc_next)
    5067                 :       1114 :     if (descr->dw_loc_oprnd1.val_entry != NULL)
    5068                 :            :       {
    5069                 :          0 :         gcc_assert (descr->dw_loc_oprnd1.val_entry->index == NO_INDEX_ASSIGNED);
    5070                 :          0 :         remove_addr_table_entry (descr->dw_loc_oprnd1.val_entry);
    5071                 :            :       }
    5072                 :        167 : }
    5073                 :            : 
    5074                 :            : /* A helper function for dwarf2out_finish called through
    5075                 :            :    htab_traverse.  Assign an addr_table_entry its index.  All entries
    5076                 :            :    must be collected into the table when this function is called,
    5077                 :            :    because the indexing code relies on htab_traverse to traverse nodes
    5078                 :            :    in the same order for each run. */
    5079                 :            : 
    5080                 :            : int
    5081                 :         31 : index_addr_table_entry (addr_table_entry **h, unsigned int *index)
    5082                 :            : {
    5083                 :         31 :   addr_table_entry *node = *h;
    5084                 :            : 
    5085                 :            :   /* Don't index unreferenced nodes.  */
    5086                 :         31 :   if (node->refcount == 0)
    5087                 :            :     return 1;
    5088                 :            : 
    5089                 :         31 :   gcc_assert (node->index == NO_INDEX_ASSIGNED);
    5090                 :         31 :   node->index = *index;
    5091                 :         31 :   *index += 1;
    5092                 :            : 
    5093                 :         31 :   return 1;
    5094                 :            : }
    5095                 :            : 
    5096                 :            : /* Add an address constant attribute value to a DIE.  When using
    5097                 :            :    dwarf_split_debug_info, address attributes in dies destined for the
    5098                 :            :    final executable should be direct references--setting the parameter
    5099                 :            :    force_direct ensures this behavior.  */
    5100                 :            : 
    5101                 :            : static inline void
    5102                 :    1533440 : add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr,
    5103                 :            :              bool force_direct)
    5104                 :            : {
    5105                 :    1533440 :   dw_attr_node attr;
    5106                 :            : 
    5107                 :    1533440 :   attr.dw_attr = attr_kind;
    5108                 :    1533440 :   attr.dw_attr_val.val_class = dw_val_class_addr;
    5109                 :    1533440 :   attr.dw_attr_val.v.val_addr = addr;
    5110                 :    1533440 :   if (dwarf_split_debug_info && !force_direct)
    5111                 :          9 :     attr.dw_attr_val.val_entry = add_addr_table_entry (addr, ate_kind_rtx);
    5112                 :            :   else
    5113                 :    1533430 :     attr.dw_attr_val.val_entry = NULL;
    5114                 :    1533440 :   add_dwarf_attr (die, &attr);
    5115                 :    1533440 : }
    5116                 :            : 
    5117                 :            : /* Get the RTX from to an address DIE attribute.  */
    5118                 :            : 
    5119                 :            : static inline rtx
    5120                 :      22569 : AT_addr (dw_attr_node *a)
    5121                 :            : {
    5122                 :          0 :   gcc_assert (a && AT_class (a) == dw_val_class_addr);
    5123                 :      22569 :   return a->dw_attr_val.v.val_addr;
    5124                 :            : }
    5125                 :            : 
    5126                 :            : /* Add a file attribute value to a DIE.  */
    5127                 :            : 
    5128                 :            : static inline void
    5129                 :   39288800 : add_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind,
    5130                 :            :              struct dwarf_file_data *fd)
    5131                 :            : {
    5132                 :   39288800 :   dw_attr_node attr;
    5133                 :            : 
    5134                 :   39288800 :   attr.dw_attr = attr_kind;
    5135                 :   39288800 :   attr.dw_attr_val.val_class = dw_val_class_file;
    5136                 :   39288800 :   attr.dw_attr_val.val_entry = NULL;
    5137                 :   39288800 :   attr.dw_attr_val.v.val_file = fd;
    5138                 :   39288800 :   add_dwarf_attr (die, &attr);
    5139                 :      31742 : }
    5140                 :            : 
    5141                 :            : /* Get the dwarf_file_data from a file DIE attribute.  */
    5142                 :            : 
    5143                 :            : static inline struct dwarf_file_data *
    5144                 :    2130850 : AT_file (dw_attr_node *a)
    5145                 :            : {
    5146                 :    2130850 :   gcc_assert (a && (AT_class (a) == dw_val_class_file
    5147                 :            :                     || AT_class (a) == dw_val_class_file_implicit));
    5148                 :    2130850 :   return a->dw_attr_val.v.val_file;
    5149                 :            : }
    5150                 :            : 
    5151                 :            : /* Add a vms delta attribute value to a DIE.  */
    5152                 :            : 
    5153                 :            : static inline void
    5154                 :            : add_AT_vms_delta (dw_die_ref die, enum dwarf_attribute attr_kind,
    5155                 :            :                   const char *lbl1, const char *lbl2)
    5156                 :            : {
    5157                 :            :   dw_attr_node attr;
    5158                 :            : 
    5159                 :            :   attr.dw_attr = attr_kind;
    5160                 :            :   attr.dw_attr_val.val_class = dw_val_class_vms_delta;
    5161                 :            :   attr.dw_attr_val.val_entry = NULL;
    5162                 :            :   attr.dw_attr_val.v.val_vms_delta.lbl1 = xstrdup (lbl1);
    5163                 :            :   attr.dw_attr_val.v.val_vms_delta.lbl2 = xstrdup (lbl2);
    5164                 :            :   add_dwarf_attr (die, &attr);
    5165                 :            : }
    5166                 :            : 
    5167                 :            : /* Add a symbolic view identifier attribute value to a DIE.  */
    5168                 :            : 
    5169                 :            : static inline void
    5170                 :    3321610 : add_AT_symview (dw_die_ref die, enum dwarf_attribute attr_kind,
    5171                 :            :                const char *view_label)
    5172                 :            : {
    5173                 :    3321610 :   dw_attr_node attr;
    5174                 :            : 
    5175                 :    3321610 :   attr.dw_attr = attr_kind;
    5176                 :    3321610 :   attr.dw_attr_val.val_class = dw_val_class_symview;
    5177                 :    3321610 :   attr.dw_attr_val.val_entry = NULL;
    5178                 :    3321610 :   attr.dw_attr_val.v.val_symbolic_view = xstrdup (view_label);
    5179                 :    3321610 :   add_dwarf_attr (die, &attr);
    5180                 :    3321610 : }
    5181                 :            : 
    5182                 :            : /* Add a label identifier attribute value to a DIE.  */
    5183                 :            : 
    5184                 :            : static inline void
    5185                 :    5394700 : add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind,
    5186                 :            :                const char *lbl_id)
    5187                 :            : {
    5188                 :    5394700 :   dw_attr_node attr;
    5189                 :            : 
    5190                 :    5394700 :   attr.dw_attr = attr_kind;
    5191                 :    5394700 :   attr.dw_attr_val.val_class = dw_val_class_lbl_id;
    5192                 :    5394700 :   attr.dw_attr_val.val_entry = NULL;
    5193                 :    5394700 :   attr.dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
    5194                 :    5394700 :   if (dwarf_split_debug_info)
    5195                 :         11 :     attr.dw_attr_val.val_entry
    5196                 :         11 :         = add_addr_table_entry (attr.dw_attr_val.v.val_lbl_id,
    5197                 :            :                                 ate_kind_label);
    5198                 :    5394700 :   add_dwarf_attr (die, &attr);
    5199                 :    5394700 : }
    5200                 :            : 
    5201                 :            : /* Add a section offset attribute value to a DIE, an offset into the
    5202                 :            :    debug_line section.  */
    5203                 :            : 
    5204                 :            : static inline void
    5205                 :      37769 : add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind,
    5206                 :            :                 const char *label)
    5207                 :            : {
    5208                 :      37769 :   dw_attr_node attr;
    5209                 :            : 
    5210                 :      37769 :   attr.dw_attr = attr_kind;
    5211                 :      37769 :   attr.dw_attr_val.val_class = dw_val_class_lineptr;
    5212                 :      37769 :   attr.dw_attr_val.val_entry = NULL;
    5213                 :      37769 :   attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
    5214                 :      37769 :   add_dwarf_attr (die, &attr);
    5215                 :      37769 : }
    5216                 :            : 
    5217                 :            : /* Add a section offset attribute value to a DIE, an offset into the
    5218                 :            :    debug_macinfo section.  */
    5219                 :            : 
    5220                 :            : static inline void
    5221                 :        475 : add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind,
    5222                 :            :                const char *label)
    5223                 :            : {
    5224                 :        475 :   dw_attr_node attr;
    5225                 :            : 
    5226                 :        475 :   attr.dw_attr = attr_kind;
    5227                 :        475 :   attr.dw_attr_val.val_class = dw_val_class_macptr;
    5228                 :        475 :   attr.dw_attr_val.val_entry = NULL;
    5229                 :        475 :   attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
    5230                 :        475 :   add_dwarf_attr (die, &attr);
    5231                 :        475 : }
    5232                 :            : 
    5233                 :            : /* Add a range_list attribute value to a DIE.  When using
    5234                 :            :    dwarf_split_debug_info, address attributes in dies destined for the
    5235                 :            :    final executable should be direct references--setting the parameter
    5236                 :            :    force_direct ensures this behavior.  */
    5237                 :            : 
    5238                 :            : #define UNRELOCATED_OFFSET ((addr_table_entry *) 1)
    5239                 :            : #define RELOCATED_OFFSET (NULL)
    5240                 :            : 
    5241                 :            : static void
    5242                 :    1900600 : add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
    5243                 :            :                    long unsigned int offset, bool force_direct)
    5244                 :            : {
    5245                 :    1900600 :   dw_attr_node attr;
    5246                 :            : 
    5247                 :    1900600 :   attr.dw_attr = attr_kind;
    5248                 :    1900600 :   attr.dw_attr_val.val_class = dw_val_class_range_list;
    5249                 :            :   /* For the range_list attribute, use val_entry to store whether the
    5250                 :            :      offset should follow split-debug-info or normal semantics.  This
    5251                 :            :      value is read in output_range_list_offset.  */
    5252                 :      34719 :   if (dwarf_split_debug_info && !force_direct)
    5253                 :          2 :     attr.dw_attr_val.val_entry = UNRELOCATED_OFFSET;
    5254                 :            :   else
    5255                 :    1900590 :     attr.dw_attr_val.val_entry = RELOCATED_OFFSET;
    5256                 :    1900600 :   attr.dw_attr_val.v.val_offset = offset;
    5257                 :    1900600 :   add_dwarf_attr (die, &attr);
    5258                 :      34719 : }
    5259                 :            : 
    5260                 :            : /* Return the start label of a delta attribute.  */
    5261                 :            : 
    5262                 :            : static inline const char *
    5263                 :          0 : AT_vms_delta1 (dw_attr_node *a)
    5264                 :            : {
    5265                 :          0 :   gcc_assert (a && (AT_class (a) == dw_val_class_vms_delta));
    5266                 :          0 :   return a->dw_attr_val.v.val_vms_delta.lbl1;
    5267                 :            : }
    5268                 :            : 
    5269                 :            : /* Return the end label of a delta attribute.  */
    5270                 :            : 
    5271                 :            : static inline const char *
    5272                 :          0 : AT_vms_delta2 (dw_attr_node *a)
    5273                 :            : {
    5274                 :          0 :   gcc_assert (a && (AT_class (a) == dw_val_class_vms_delta));
    5275                 :          0 :   return a->dw_attr_val.v.val_vms_delta.lbl2;
    5276                 :            : }
    5277                 :            : 
    5278                 :            : static inline const char *
    5279                 :   13036900 : AT_lbl (dw_attr_node *a)
    5280                 :            : {
    5281                 :   13036900 :   gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
    5282                 :            :                     || AT_class (a) == dw_val_class_lineptr
    5283                 :            :                     || AT_class (a) == dw_val_class_macptr
    5284                 :            :                     || AT_class (a) == dw_val_class_loclistsptr
    5285                 :            :                     || AT_class (a) == dw_val_class_high_pc));
    5286                 :   13036900 :   return a->dw_attr_val.v.val_lbl_id;
    5287                 :            : }
    5288                 :            : 
    5289                 :            : /* Get the attribute of type attr_kind.  */
    5290                 :            : 
    5291                 :            : static dw_attr_node *
    5292                 :  168549000 : get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
    5293                 :            : {
    5294                 :  188039000 :   dw_attr_node *a;
    5295                 :  188039000 :   unsigned ix;
    5296                 :  188039000 :   dw_die_ref spec = NULL;
    5297                 :            : 
    5298                 :  188039000 :   if (! die)
    5299                 :            :     return NULL;
    5300                 :            : 
    5301                 :  597914000 :   FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
    5302                 :  535242000 :     if (a->dw_attr == attr_kind)
    5303                 :  125367000 :       return a;
    5304                 :  409875000 :     else if (a->dw_attr == DW_AT_specification
    5305                 :  402563000 :              || a->dw_attr == DW_AT_abstract_origin)
    5306                 :   40115900 :       spec = AT_ref (a);
    5307                 :            : 
    5308                 :   62671600 :   if (spec)
    5309                 :            :     return get_AT (spec, attr_kind);
    5310                 :            : 
    5311                 :            :   return NULL;
    5312                 :            : }
    5313                 :            : 
    5314                 :            : /* Returns the parent of the declaration of DIE.  */
    5315                 :            : 
    5316                 :            : static dw_die_ref
    5317                 :         83 : get_die_parent (dw_die_ref die)
    5318                 :            : {
    5319                 :         83 :   dw_die_ref t;
    5320                 :            : 
    5321                 :         83 :   if (!die)
    5322                 :            :     return NULL;
    5323                 :            : 
    5324                 :         83 :   if ((t = get_AT_ref (die, DW_AT_abstract_origin))
    5325                 :         83 :       || (t = get_AT_ref (die, DW_AT_specification)))
    5326                 :            :     die = t;
    5327                 :            : 
    5328                 :         83 :   return die->die_parent;
    5329                 :            : }
    5330                 :            : 
    5331                 :            : /* Return the "low pc" attribute value, typically associated with a subprogram
    5332                 :            :    DIE.  Return null if the "low pc" attribute is either not present, or if it
    5333                 :            :    cannot be represented as an assembler label identifier.  */
    5334                 :            : 
    5335                 :            : static inline const char *
    5336                 :    2531660 : get_AT_low_pc (dw_die_ref die)
    5337                 :            : {
    5338                 :    2531660 :   dw_attr_node *a = get_AT (die, DW_AT_low_pc);
    5339                 :            : 
    5340                 :    2531660 :   return a ? AT_lbl (a) : NULL;
    5341                 :            : }
    5342                 :            : 
    5343                 :            : /* Return the value of the string attribute designated by ATTR_KIND, or
    5344                 :            :    NULL if it is not present.  */
    5345                 :            : 
    5346                 :            : static inline const char *
    5347                 :       1127 : get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
    5348                 :            : {
    5349                 :       1127 :   dw_attr_node *a = get_AT (die, attr_kind);
    5350                 :            : 
    5351                 :       2231 :   return a ? AT_string (a) : NULL;
    5352                 :            : }
    5353                 :            : 
    5354                 :            : /* Return the value of the flag attribute designated by ATTR_KIND, or -1
    5355                 :            :    if it is not present.  */
    5356                 :            : 
    5357                 :            : static inline int
    5358                 :   12988400 : get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
    5359                 :            : {
    5360                 :   12988400 :   dw_attr_node *a = get_AT (die, attr_kind);
    5361                 :            : 
    5362                 :   17147700 :   return a ? AT_flag (a) : 0;
    5363                 :            : }
    5364                 :            : 
    5365                 :            : /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
    5366                 :            :    if it is not present.  */
    5367                 :            : 
    5368                 :            : static inline unsigned
    5369                 :   55760800 : get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
    5370                 :            : {
    5371                 :   55760800 :   dw_attr_node *a = get_AT (die, attr_kind);
    5372                 :            : 
    5373                 :   55760800 :   return a ? AT_unsigned (a) : 0;
    5374                 :            : }
    5375                 :            : 
    5376                 :            : static inline dw_die_ref
    5377                 :    7578170 : get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
    5378                 :            : {
    5379                 :    7578170 :   dw_attr_node *a = get_AT (die, attr_kind);
    5380                 :            : 
    5381                 :    9156620 :   return a ? AT_ref (a) : NULL;
    5382                 :            : }
    5383                 :            : 
    5384                 :            : static inline struct dwarf_file_data *
    5385                 :    2083150 : get_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind)
    5386                 :            : {
    5387                 :    2083150 :   dw_attr_node *a = get_AT (die, attr_kind);
    5388                 :            : 
    5389                 :    2083150 :   return a ? AT_file (a) : NULL;
    5390                 :            : }
    5391                 :            : 
    5392                 :            : /* Return TRUE if the language is C.  */
    5393                 :            : 
    5394                 :            : static inline bool
    5395                 :       4330 : is_c (void)
    5396                 :            : {
    5397                 :       4330 :   unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
    5398                 :            : 
    5399                 :       4330 :   return (lang == DW_LANG_C || lang == DW_LANG_C89 || lang == DW_LANG_C99
    5400                 :       4330 :           || lang == DW_LANG_C11 || lang == DW_LANG_ObjC);
    5401                 :            : 
    5402                 :            : 
    5403                 :            : }
    5404                 :            : 
    5405                 :            : /* Return TRUE if the language is C++.  */
    5406                 :            : 
    5407                 :            : static inline bool
    5408                 :    5230720 : is_cxx (void)
    5409                 :            : {
    5410                 :    5230720 :   unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
    5411                 :            : 
    5412                 :    5230720 :   return (lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus
    5413                 :    5230720 :           || lang == DW_LANG_C_plus_plus_11 || lang == DW_LANG_C_plus_plus_14);
    5414                 :            : }
    5415                 :            : 
    5416                 :            : /* Return TRUE if DECL was created by the C++ frontend.  */
    5417                 :            : 
    5418                 :            : static bool
    5419                 :    4362570 : is_cxx (const_tree decl)
    5420                 :            : {
    5421                 :    4362570 :   if (in_lto_p)
    5422                 :            :     {
    5423                 :         16 :       const_tree context = get_ultimate_context (decl);
    5424                 :         32 :       if (context && TRANSLATION_UNIT_LANGUAGE (context))
    5425                 :         16 :         return strncmp (TRANSLATION_UNIT_LANGUAGE (context), "GNU C++", 7) == 0;
    5426                 :            :     }
    5427                 :    4362550 :   return is_cxx ();
    5428                 :            : }
    5429                 :            : 
    5430                 :            : /* Return TRUE if the language is Fortran.  */
    5431                 :            : 
    5432                 :            : static inline bool
    5433                 :   23033500 : is_fortran (void)
    5434                 :            : {
    5435                 :   23033500 :   unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
    5436                 :            : 
    5437                 :   23033500 :   return (lang == DW_LANG_Fortran77
    5438                 :   23033500 :           || lang == DW_LANG_Fortran90
    5439                 :   23033500 :           || lang == DW_LANG_Fortran95
    5440                 :            :           || lang == DW_LANG_Fortran03
    5441                 :   23033500 :           || lang == DW_LANG_Fortran08);
    5442                 :            : }
    5443                 :            : 
    5444                 :            : static inline bool
    5445                 :         91 : is_fortran (const_tree decl)
    5446                 :            : {
    5447                 :         91 :   if (in_lto_p)
    5448                 :            :     {
    5449                 :         91 :       const_tree context = get_ultimate_context (decl);
    5450                 :        182 :       if (context && TRANSLATION_UNIT_LANGUAGE (context))
    5451                 :         91 :         return (strncmp (TRANSLATION_UNIT_LANGUAGE (context),
    5452                 :            :                          "GNU Fortran", 11) == 0
    5453                 :         91 :                 || strcmp (TRANSLATION_UNIT_LANGUAGE (context),
    5454                 :            :                            "GNU F77") == 0);
    5455                 :            :     }
    5456                 :          0 :   return is_fortran ();
    5457                 :            : }
    5458                 :            : 
    5459                 :            : /* Return TRUE if the language is Ada.  */
    5460                 :            : 
    5461                 :            : static inline bool
    5462                 :     789090 : is_ada (void)
    5463                 :            : {
    5464                 :     789090 :   unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
    5465                 :            : 
    5466                 :     789090 :   return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
    5467                 :            : }
    5468                 :            : 
    5469                 :            : /* Return TRUE if the language is D.  */
    5470                 :            : 
    5471                 :            : static inline bool
    5472                 :   13440900 : is_dlang (void)
    5473                 :            : {
    5474                 :   13440900 :   unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
    5475                 :            : 
    5476                 :   13440900 :   return lang == DW_LANG_D;
    5477                 :            : }
    5478                 :            : 
    5479                 :            : /* Remove the specified attribute if present.  Return TRUE if removal
    5480                 :            :    was successful.  */
    5481                 :            : 
    5482                 :            : static bool
    5483                 :   11937600 : remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
    5484                 :            : {
    5485                 :   11937600 :   dw_attr_node *a;
    5486                 :   11937600 :   unsigned ix;
    5487                 :            : 
    5488                 :   11937600 :   if (! die)
    5489                 :            :     return false;
    5490                 :            : 
    5491                 :   25158700 :   FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
    5492                 :   24827700 :     if (a->dw_attr == attr_kind)
    5493                 :            :       {
    5494                 :   11606700 :         if (AT_class (a) == dw_val_class_str)
    5495                 :          8 :           if (a->dw_attr_val.v.val_str->refcount)
    5496                 :          8 :             a->dw_attr_val.v.val_str->refcount--;
    5497                 :            : 
    5498                 :            :         /* vec::ordered_remove should help reduce the number of abbrevs
    5499                 :            :            that are needed.  */
    5500                 :   11606700 :         die->die_attr->ordered_remove (ix);
    5501                 :   11606700 :         return true;
    5502                 :            :       }
    5503                 :            :   return false;
    5504                 :            : }
    5505                 :            : 
    5506                 :            : /* Remove CHILD from its parent.  PREV must have the property that
    5507                 :            :    PREV->DIE_SIB == CHILD.  Does not alter CHILD.  */
    5508                 :            : 
    5509                 :            : static void
    5510                 :     366059 : remove_child_with_prev (dw_die_ref child, dw_die_ref prev)
    5511                 :            : {
    5512                 :     366059 :   gcc_assert (child->die_parent == prev->die_parent);
    5513                 :     366059 :   gcc_assert (prev->die_sib == child);
    5514                 :     366059 :   if (prev == child)
    5515                 :            :     {
    5516                 :       4239 :       gcc_assert (child->die_parent->die_child == child);
    5517                 :            :       prev = NULL;
    5518                 :            :     }
    5519                 :            :   else
    5520                 :     361820 :     prev->die_sib = child->die_sib;
    5521                 :     366059 :   if (child->die_parent->die_child == child)
    5522                 :       5926 :     child->die_parent->die_child = prev;
    5523                 :     366059 :   child->die_sib = NULL;
    5524                 :     366059 : }
    5525                 :            : 
    5526                 :            : /* Replace OLD_CHILD with NEW_CHILD.  PREV must have the property that
    5527                 :            :    PREV->DIE_SIB == OLD_CHILD.  Does not alter OLD_CHILD.  */
    5528                 :            : 
    5529                 :            : static void
    5530                 :        157 : replace_child (dw_die_ref old_child, dw_die_ref new_child, dw_die_ref prev)
    5531                 :            : {
    5532                 :        157 :   dw_die_ref parent = old_child->die_parent;
    5533                 :            : 
    5534                 :        157 :   gcc_assert (parent == prev->die_parent);
    5535                 :        157 :   gcc_assert (prev->die_sib == old_child);
    5536                 :            : 
    5537                 :        157 :   new_child->die_parent = parent;
    5538                 :        157 :   if (prev == old_child)
    5539                 :            :     {
    5540                 :         24 :       gcc_assert (parent->die_child == old_child);
    5541                 :         24 :       new_child->die_sib = new_child;
    5542                 :            :     }
    5543                 :            :   else
    5544                 :            :     {
    5545                 :        133 :       prev->die_sib = new_child;
    5546                 :        133 :       new_child->die_sib = old_child->die_sib;
    5547                 :            :     }
    5548                 :        157 :   if (old_child->die_parent->die_child == old_child)
    5549                 :         31 :     old_child->die_parent->die_child = new_child;
    5550                 :        157 :   old_child->die_sib = NULL;
    5551                 :        157 : }
    5552                 :            : 
    5553                 :            : /* Move all children from OLD_PARENT to NEW_PARENT.  */
    5554                 :            : 
    5555                 :            : static void
    5556                 :         87 : move_all_children (dw_die_ref old_parent, dw_die_ref new_parent)
    5557                 :            : {
    5558                 :         87 :   dw_die_ref c;
    5559                 :         87 :   new_parent->die_child = old_parent->die_child;
    5560                 :         87 :   old_parent->die_child = NULL;
    5561                 :        122 :   FOR_EACH_CHILD (new_parent, c, c->die_parent = new_parent);
    5562                 :          0 : }
    5563                 :            : 
    5564                 :            : /* Remove child DIE whose die_tag is TAG.  Do nothing if no child
    5565                 :            :    matches TAG.  */
    5566                 :            : 
    5567                 :            : static void
    5568                 :       8629 : remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
    5569                 :            : {
    5570                 :       8629 :   dw_die_ref c;
    5571                 :            : 
    5572                 :       8629 :   c = die->die_child;
    5573                 :       8629 :   if (c) do {
    5574                 :      10360 :     dw_die_ref prev = c;
    5575                 :      10360 :     c = c->die_sib;
    5576                 :      17804 :     while (c->die_tag == tag)
    5577                 :            :       {
    5578                 :      11682 :         remove_child_with_prev (c, prev);
    5579                 :      11682 :         c->die_parent = NULL;
    5580                 :            :         /* Might have removed every child.  */
    5581                 :      11682 :         if (die->die_child == NULL)
    5582                 :            :           return;
    5583                 :       7444 :         c = prev->die_sib;
    5584                 :            :       }
    5585                 :       6122 :   } while (c != die->die_child);
    5586                 :            : }
    5587                 :            : 
    5588                 :            : /* Add a CHILD_DIE as the last child of DIE.  */
    5589                 :            : 
    5590                 :            : static void
    5591                 :  108616000 : add_child_die (dw_die_ref die, dw_die_ref child_die)
    5592                 :            : {
    5593                 :            :   /* FIXME this should probably be an assert.  */
    5594                 :  108616000 :   if (! die || ! child_die)
    5595                 :            :     return;
    5596                 :  108614000 :   gcc_assert (die != child_die);
    5597                 :            : 
    5598                 :  108614000 :   child_die->die_parent = die;
    5599                 :  108614000 :   if (die->die_child)
    5600                 :            :     {
    5601                 :   82046600 :       child_die->die_sib = die->die_child->die_sib;
    5602                 :   82046600 :       die->die_child->die_sib = child_die;
    5603                 :            :     }
    5604                 :            :   else
    5605                 :   26567400 :     child_die->die_sib = child_die;
    5606                 :  108614000 :   die->die_child = child_die;
    5607                 :            : }
    5608                 :            : 
    5609                 :            : /* Like add_child_die, but put CHILD_DIE after AFTER_DIE.  */
    5610                 :            : 
    5611                 :            : static void
    5612                 :    1234390 : add_child_die_after (dw_die_ref die, dw_die_ref child_die,
    5613                 :            :                      dw_die_ref after_die)
    5614                 :            : {
    5615                 :    1234390 :   gcc_assert (die
    5616                 :            :               && child_die
    5617                 :            :               && after_die
    5618                 :            :               && die->die_child
    5619                 :            :               && die != child_die);
    5620                 :            : 
    5621                 :    1234390 :   child_die->die_parent = die;
    5622                 :    1234390 :   child_die->die_sib = after_die->die_sib;
    5623                 :    1234390 :   after_die->die_sib = child_die;
    5624                 :    1234390 :   if (die->die_child == after_die)
    5625                 :     569397 :     die->die_child = child_die;
    5626                 :    1234390 : }
    5627                 :            : 
    5628                 :            : /* Unassociate CHILD from its parent, and make its parent be
    5629                 :            :    NEW_PARENT.  */
    5630                 :            : 
    5631                 :            : static void
    5632                 :     349096 : reparent_child (dw_die_ref child, dw_die_ref new_parent)
    5633                 :            : {
    5634                 :     349096 :   for (dw_die_ref p = child->die_parent->die_child; ; p = p->die_sib)
    5635                 :  233936000 :     if (p->die_sib == child)
    5636                 :            :       {
    5637                 :     349096 :         remove_child_with_prev (child, p);
    5638                 :     349096 :         break;
    5639                 :            :       }
    5640                 :     349096 :   add_child_die (new_parent, child);
    5641                 :     349096 : }
    5642                 :            : 
    5643                 :            : /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
    5644                 :            :    is the specification, to the end of PARENT's list of children.
    5645                 :            :    This is done by removing and re-adding it.  */
    5646                 :            : 
    5647                 :            : static void
    5648                 :        489 : splice_child_die (dw_die_ref parent, dw_die_ref child)
    5649                 :            : {
    5650                 :            :   /* We want the declaration DIE from inside the class, not the
    5651                 :            :      specification DIE at toplevel.  */
    5652                 :        489 :   if (child->die_parent != parent)
    5653                 :            :     {
    5654                 :        275 :       dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
    5655                 :            : 
    5656                 :        275 :       if (tmp)
    5657                 :        275 :         child = tmp;
    5658                 :            :     }
    5659                 :            : 
    5660                 :        489 :   gcc_assert (child->die_parent == parent
    5661                 :            :               || (child->die_parent
    5662                 :            :                   == get_AT_ref (parent, DW_AT_specification)));
    5663                 :            : 
    5664                 :        489 :   reparent_child (child, parent);
    5665                 :        489 : }
    5666                 :            : 
    5667                 :            : /* Create and return a new die with TAG_VALUE as tag.  */
    5668                 :            :  
    5669                 :            : static inline dw_die_ref
    5670                 :  109561000 : new_die_raw (enum dwarf_tag tag_value)
    5671                 :            : {
    5672                 :  219122000 :   dw_die_ref die = ggc_cleared_alloc<die_node> ();
    5673                 :  109561000 :   die->die_tag = tag_value;
    5674                 :  109561000 :   return die;
    5675                 :            : }
    5676                 :            : 
    5677                 :            : /* Create and return a new die with a parent of PARENT_DIE.  If
    5678                 :            :    PARENT_DIE is NULL, the new DIE is placed in limbo and an
    5679                 :            :    associated tree T must be supplied to determine parenthood
    5680                 :            :    later.  */
    5681                 :            : 
    5682                 :            : static inline dw_die_ref
    5683                 :  108075000 : new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
    5684                 :            : {
    5685                 :  108075000 :   dw_die_ref die = new_die_raw (tag_value);
    5686                 :            : 
    5687                 :  108075000 :   if (parent_die != NULL)
    5688                 :  108029000 :     add_child_die (parent_die, die);
    5689                 :            :   else
    5690                 :            :     {
    5691                 :      45925 :       limbo_die_node *limbo_node;
    5692                 :            : 
    5693                 :            :       /* No DIEs created after early dwarf should end up in limbo,
    5694                 :            :          because the limbo list should not persist past LTO
    5695                 :            :          streaming.  */
    5696                 :      45925 :       if (tag_value != DW_TAG_compile_unit
    5697                 :            :           /* These are allowed because they're generated while
    5698                 :            :              breaking out COMDAT units late.  */
    5699                 :      45925 :           && tag_value != DW_TAG_type_unit
    5700                 :       6939 :           && tag_value != DW_TAG_skeleton_unit
    5701                 :       6939 :           && !early_dwarf
    5702                 :            :           /* Allow nested functions to live in limbo because they will
    5703                 :            :              only temporarily live there, as decls_for_scope will fix
    5704                 :            :              them up.  */
    5705                 :       2522 :           && (TREE_CODE (t) != FUNCTION_DECL
    5706                 :          0 :               || !decl_function_context (t))
    5707                 :            :           /* Same as nested functions above but for types.  Types that
    5708                 :            :              are local to a function will be fixed in
    5709                 :            :              decls_for_scope.  */
    5710                 :       2522 :           && (!RECORD_OR_UNION_TYPE_P (t)
    5711                 :          0 :               || !TYPE_CONTEXT (t)
    5712                 :          0 :               || TREE_CODE (TYPE_CONTEXT (t)) != FUNCTION_DECL)
    5713                 :            :           /* FIXME debug-early: Allow late limbo DIE creation for LTO,
    5714                 :            :              especially in the ltrans stage, but once we implement LTO
    5715                 :            :              dwarf streaming, we should remove this exception.  */
    5716                 :      48447 :           && !in_lto_p)
    5717                 :            :         {
    5718                 :          0 :           fprintf (stderr, "symbol ended up in limbo too late:");
    5719                 :          0 :           debug_generic_stmt (t);
    5720                 :          0 :           gcc_unreachable ();
    5721                 :            :         }
    5722                 :            : 
    5723                 :      45925 :       limbo_node = ggc_cleared_alloc<limbo_die_node> ();
    5724                 :      45925 :       limbo_node->die = die;
    5725                 :      45925 :       limbo_node->created_for = t;
    5726                 :      45925 :       limbo_node->next = limbo_die_list;
    5727                 :      45925 :       limbo_die_list = limbo_node;
    5728                 :            :     }
    5729                 :            : 
    5730                 :  108075000 :   return die;
    5731                 :            : }
    5732                 :            : 
    5733                 :            : /* Return the DIE associated with the given type specifier.  */
    5734                 :            : 
    5735                 :            : static inline dw_die_ref
    5736                 :  256380000 : lookup_type_die (tree type)
    5737                 :            : {
    5738                 :  256380000 :   dw_die_ref die = TYPE_SYMTAB_DIE (type);
    5739                 :  256380000 :   if (die && die->removed)
    5740                 :            :     {
    5741                 :        570 :       TYPE_SYMTAB_DIE (type) = NULL;
    5742                 :        570 :       return NULL;
    5743                 :            :     }
    5744                 :            :   return die;
    5745                 :            : }
    5746                 :            : 
    5747                 :            : /* Given a TYPE_DIE representing the type TYPE, if TYPE is an
    5748                 :            :    anonymous type named by the typedef TYPE_DIE, return the DIE of the
    5749                 :            :    anonymous type instead the one of the naming typedef.  */
    5750                 :            : 
    5751                 :            : static inline dw_die_ref
    5752                 :    2333260 : strip_naming_typedef (tree type, dw_die_ref type_die)
    5753                 :            : {
    5754                 :    2333260 :   if (type
    5755                 :    2333260 :       && TREE_CODE (type) == RECORD_TYPE
    5756                 :    2304880 :       && type_die
    5757                 :    2304880 :       && type_die->die_tag == DW_TAG_typedef
    5758                 :    2333280 :       && is_naming_typedef_decl (TYPE_NAME (type)))
    5759                 :         15 :     type_die = get_AT_ref (type_die, DW_AT_type);
    5760                 :    2333260 :   return type_die;
    5761                 :            : }
    5762                 :            : 
    5763                 :            : /* Like lookup_type_die, but if type is an anonymous type named by a
    5764                 :            :    typedef[1], return the DIE of the anonymous type instead the one of
    5765                 :            :    the naming typedef.  This is because in gen_typedef_die, we did
    5766                 :            :    equate the anonymous struct named by the typedef with the DIE of
    5767                 :            :    the naming typedef. So by default, lookup_type_die on an anonymous
    5768                 :            :    struct yields the DIE of the naming typedef.
    5769                 :            : 
    5770                 :            :    [1]: Read the comment of is_naming_typedef_decl to learn about what
    5771                 :            :    a naming typedef is.  */
    5772                 :            : 
    5773                 :            : static inline dw_die_ref
    5774                 :      49358 : lookup_type_die_strip_naming_typedef (tree type)
    5775                 :            : {
    5776                 :      98716 :   dw_die_ref die = lookup_type_die (type);
    5777                 :      49358 :   return strip_naming_typedef (type, die);
    5778                 :            : }
    5779                 :            : 
    5780                 :            : /* Equate a DIE to a given type specifier.  */
    5781                 :            : 
    5782                 :            : static inline void
    5783                 :   24864200 : equate_type_number_to_die (tree type, dw_die_ref type_die)
    5784                 :            : {
    5785                 :    8707090 :   TYPE_SYMTAB_DIE (type) = type_die;
    5786                 :   13485000 : }
    5787                 :            : 
    5788                 :            : static dw_die_ref maybe_create_die_with_external_ref (tree);
    5789                 :            : struct GTY(()) sym_off_pair 
    5790                 :            : {
    5791                 :            :   const char * GTY((skip)) sym;
    5792                 :            :   unsigned HOST_WIDE_INT off;
    5793                 :            : };
    5794                 :            : static GTY(()) hash_map<tree, sym_off_pair> *external_die_map;
    5795                 :            : 
    5796                 :            : /* Returns a hash value for X (which really is a die_struct).  */
    5797                 :            : 
    5798                 :            : inline hashval_t
    5799                 : 1825950000 : decl_die_hasher::hash (die_node *x)
    5800                 :            : {
    5801                 : 1825950000 :   return (hashval_t) x->decl_id;
    5802                 :            : }
    5803                 :            : 
    5804                 :            : /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y.  */
    5805                 :            : 
    5806                 :            : inline bool
    5807                 : 1993560000 : decl_die_hasher::equal (die_node *x, tree y)
    5808                 :            : {
    5809                 : 1993560000 :   return (x->decl_id == DECL_UID (y));
    5810                 :            : }
    5811                 :            : 
    5812                 :            : /* Return the DIE associated with a given declaration.  */
    5813                 :            : 
    5814                 :            : static inline dw_die_ref
    5815                 :  186739000 : lookup_decl_die (tree decl)
    5816                 :            : {
    5817                 :  186739000 :   dw_die_ref *die = decl_die_table->find_slot_with_hash (decl, DECL_UID (decl),
    5818                 :            :                                                          NO_INSERT);
    5819                 :  186739000 :   if (!die)
    5820                 :            :     {
    5821                 :   83117800 :       if (in_lto_p)
    5822                 :      38158 :         return maybe_create_die_with_external_ref (decl);
    5823                 :            :       return NULL;
    5824                 :            :     }
    5825                 :  103621000 :   if ((*die)->removed)
    5826                 :            :     {
    5827                 :        110 :       decl_die_table->clear_slot (die);
    5828                 :        110 :       return NULL;
    5829                 :            :     }
    5830                 :            :   return *die;
    5831                 :            : }
    5832                 :            : 
    5833                 :            : 
    5834                 :            : /* Return the DIE associated with BLOCK.  */
    5835                 :            : 
    5836                 :            : static inline dw_die_ref
    5837                 :   12949700 : lookup_block_die (tree block)
    5838                 :            : {
    5839                 :   12949700 :   dw_die_ref die = BLOCK_DIE (block);
    5840                 :   12949700 :   if (!die && in_lto_p)
    5841                 :       8315 :     return maybe_create_die_with_external_ref (block);
    5842                 :            :   return die;
    5843                 :            : }
    5844                 :            : 
    5845                 :            : /* Associate DIE with BLOCK.  */
    5846                 :            : 
    5847                 :            : static inline void
    5848                 :    4113260 : equate_block_to_die (tree block, dw_die_ref die)
    5849                 :            : {
    5850                 :    8226170 :   BLOCK_DIE (block) = die;
    5851                 :    4113260 : }
    5852                 :            : #undef BLOCK_DIE
    5853                 :            : 
    5854                 :            : 
    5855                 :            : /* For DECL which might have early dwarf output query a SYMBOL + OFFSET
    5856                 :            :    style reference.  Return true if we found one refering to a DIE for
    5857                 :            :    DECL, otherwise return false.  */
    5858                 :            : 
    5859                 :            : static bool
    5860                 :      98346 : dwarf2out_die_ref_for_decl (tree decl, const char **sym,
    5861                 :            :                             unsigned HOST_WIDE_INT *off)
    5862                 :            : {
    5863                 :      98346 :   dw_die_ref die;
    5864                 :            : 
    5865                 :      98346 :   if (in_lto_p)
    5866                 :            :     {
    5867                 :            :       /* During WPA stage and incremental linking we use a hash-map
    5868                 :            :          to store the decl <-> label + offset map.  */
    5869                 :      13886 :       if (!external_die_map)
    5870                 :            :         return false;
    5871                 :      13805 :       sym_off_pair *desc = external_die_map->get (decl);
    5872                 :       9731 :       if (!desc)
    5873                 :            :         return false;
    5874                 :       9731 :       *sym = desc->sym;
    5875                 :       9731 :       *off = desc->off;
    5876                 :       9731 :       return true;
    5877                 :            :     }
    5878                 :            : 
    5879                 :      84460 :   if (TREE_CODE (decl) == BLOCK)
    5880                 :      18387 :     die = lookup_block_die (decl);
    5881                 :            :   else
    5882                 :      66073 :     die = lookup_decl_die (decl);
    5883                 :      84460 :   if (!die)
    5884                 :            :     return false;
    5885                 :            : 
    5886                 :            :   /* Similar to get_ref_die_offset_label, but using the "correct"
    5887                 :            :      label.  */
    5888                 :      31056 :   *off = die->die_offset;
    5889                 :      81582 :   while (die->die_parent)
    5890                 :            :     die = die->die_parent;
    5891                 :            :   /* For the containing CU DIE we compute a die_symbol in
    5892                 :            :      compute_comp_unit_symbol.  */
    5893                 :      31056 :   gcc_assert (die->die_tag == DW_TAG_compile_unit
    5894                 :            :               && die->die_id.die_symbol != NULL);
    5895                 :      31056 :   *sym = die->die_id.die_symbol;
    5896                 :      31056 :   return true;
    5897                 :            : }
    5898                 :            : 
    5899                 :            : /* Add a reference of kind ATTR_KIND to a DIE at SYMBOL + OFFSET to DIE.  */
    5900                 :            : 
    5901                 :            : static void
    5902                 :      22907 : add_AT_external_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind,
    5903                 :            :                          const char *symbol, HOST_WIDE_INT offset)
    5904                 :            : {
    5905                 :            :   /* Create a fake DIE that contains the reference.  Don't use
    5906                 :            :      new_die because we don't want to end up in the limbo list.  */
    5907                 :            :   /* ???  We probably want to share these, thus put a ref to the DIE
    5908                 :            :      we create here to the external_die_map entry.  */
    5909                 :      22907 :   dw_die_ref ref = new_die_raw (die->die_tag);
    5910                 :      22907 :   ref->die_id.die_symbol = symbol;
    5911                 :      22907 :   ref->die_offset = offset;
    5912                 :      22907 :   ref->with_offset = 1;
    5913                 :      22907 :   add_AT_die_ref (die, attr_kind, ref);
    5914                 :      22907 : }
    5915                 :            : 
    5916                 :            : /* Create a DIE for DECL if required and add a reference to a DIE
    5917                 :            :    at SYMBOL + OFFSET which contains attributes dumped early.  */
    5918                 :            : 
    5919                 :            : static void
    5920                 :      38004 : dwarf2out_register_external_die (tree decl, const char *sym,
    5921                 :            :                                  unsigned HOST_WIDE_INT off)
    5922                 :            : {
    5923                 :      38004 :   if (debug_info_level == DINFO_LEVEL_NONE)
    5924                 :          0 :     return;
    5925                 :            : 
    5926                 :      38004 :   if (!external_die_map)
    5927                 :        942 :     external_die_map = hash_map<tree, sym_off_pair>::create_ggc (1000);
    5928                 :      38004 :   gcc_checking_assert (!external_die_map->get (decl));
    5929                 :      38004 :   sym_off_pair p = { IDENTIFIER_POINTER (get_identifier (sym)), off };
    5930                 :      38004 :   external_die_map->put (decl, p);
    5931                 :            : }
    5932                 :            : 
    5933                 :            : /* If we have a registered external DIE for DECL return a new DIE for
    5934                 :            :    the concrete instance with an appropriate abstract origin.  */
    5935                 :            : 
    5936                 :            : static dw_die_ref
    5937                 :      46473 : maybe_create_die_with_external_ref (tree decl)
    5938                 :            : {
    5939                 :      46473 :   if (!external_die_map)
    5940                 :            :     return NULL;
    5941                 :      46320 :   sym_off_pair *desc = external_die_map->get (decl);
    5942                 :      20644 :   if (!desc)
    5943                 :            :     return NULL;
    5944                 :            : 
    5945                 :      20644 :   const char *sym = desc->sym;
    5946                 :      20644 :   unsigned HOST_WIDE_INT off = desc->off;
    5947                 :            : 
    5948                 :      20644 :   in_lto_p = false;
    5949                 :      20644 :   dw_die_ref die = (TREE_CODE (decl) == BLOCK
    5950                 :      20644 :                     ? lookup_block_die (decl) : lookup_decl_die (decl));
    5951                 :      20644 :   gcc_assert (!die);
    5952                 :      20644 :   in_lto_p = true;
    5953                 :            : 
    5954                 :      20644 :   tree ctx;
    5955                 :      20644 :   dw_die_ref parent = NULL;
    5956                 :            :   /* Need to lookup a DIE for the decls context - the containing
    5957                 :            :      function or translation unit.  */
    5958                 :      20644 :   if (TREE_CODE (decl) == BLOCK)
    5959                 :            :     {
    5960                 :        352 :       ctx = BLOCK_SUPERCONTEXT (decl);
    5961                 :            :       /* ???  We do not output DIEs for all scopes thus skip as
    5962                 :            :          many DIEs as needed.  */
    5963                 :        828 :       while (TREE_CODE (ctx) == BLOCK
    5964                 :        828 :              && !lookup_block_die (ctx))
    5965                 :        476 :         ctx = BLOCK_SUPERCONTEXT (ctx);
    5966                 :            :     }
    5967                 :            :   else
    5968                 :      20292 :     ctx = DECL_CONTEXT (decl);
    5969                 :            :   /* Peel types in the context stack.  */
    5970                 :      21201 :   while (ctx && TYPE_P (ctx))
    5971                 :        557 :     ctx = TYPE_CONTEXT (ctx);
    5972                 :            :   /* Likewise namespaces in case we do not want to emit DIEs for them.  */
    5973                 :      20644 :   if (debug_info_level <= DINFO_LEVEL_TERSE)
    5974                 :          6 :     while (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
    5975                 :          0 :       ctx = DECL_CONTEXT (ctx);
    5976                 :      20644 :   if (ctx)
    5977                 :            :     {
    5978                 :      20075 :       if (TREE_CODE (ctx) == BLOCK)
    5979                 :         44 :         parent = lookup_block_die (ctx);
    5980                 :      20031 :       else if (TREE_CODE (ctx) == TRANSLATION_UNIT_DECL
    5981                 :            :                /* Keep the 1:1 association during WPA.  */
    5982                 :       3078 :                && !flag_wpa
    5983                 :       3078 :                && flag_incremental_link != INCREMENTAL_LINK_LTO)
    5984                 :            :         /* Otherwise all late annotations go to the main CU which
    5985                 :            :            imports the original CUs.  */
    5986                 :       3078 :         parent = comp_unit_die ();
    5987                 :      16953 :       else if (TREE_CODE (ctx) == FUNCTION_DECL
    5988                 :      12165 :                && TREE_CODE (decl) != FUNCTION_DECL
    5989                 :      12153 :                && TREE_CODE (decl) != PARM_DECL
    5990                 :       2830 :                && TREE_CODE (decl) != RESULT_DECL
    5991                 :       2830 :                && TREE_CODE (decl) != BLOCK)
    5992                 :            :         /* Leave function local entities parent determination to when
    5993                 :            :            we process scope vars.  */
    5994                 :            :         ;
    5995                 :            :       else
    5996                 :      14431 :         parent = lookup_decl_die (ctx);
    5997                 :            :     }
    5998                 :            :   else
    5999                 :            :     /* In some cases the FEs fail to set DECL_CONTEXT properly.
    6000                 :            :        Handle this case gracefully by globalizing stuff.  */
    6001                 :        569 :     parent = comp_unit_die ();
    6002                 :            :   /* Create a DIE "stub".  */
    6003                 :      20644 :   switch (TREE_CODE (decl))
    6004                 :            :     {
    6005                 :        569 :     case TRANSLATION_UNIT_DECL:
    6006                 :        569 :       {
    6007                 :        569 :         die = comp_unit_die ();
    6008                 :            :         /* We re-target all CU decls to the LTRANS CU DIE, so no need
    6009                 :            :            to create a DIE for the original CUs.  */
    6010                 :        569 :         return die;
    6011                 :            :       }
    6012                 :         91 :     case NAMESPACE_DECL:
    6013                 :         91 :       if (is_fortran (decl))
    6014                 :          6 :         die = new_die (DW_TAG_module, parent, decl);
    6015                 :            :       else
    6016                 :         85 :         die = new_die (DW_TAG_namespace, parent, decl);
    6017                 :            :       break;
    6018                 :       7043 :     case FUNCTION_DECL:
    6019                 :       7043 :       die = new_die (DW_TAG_subprogram, parent, decl);
    6020                 :       7043 :       break;
    6021                 :       3258 :     case VAR_DECL:
    6022                 :       3258 :       die = new_die (DW_TAG_variable, parent, decl);
    6023                 :       3258 :       break;
    6024                 :          0 :     case RESULT_DECL:
    6025                 :          0 :       die = new_die (DW_TAG_variable, parent, decl);
    6026                 :          0 :       break;
    6027                 :       9323 :     case PARM_DECL:
    6028                 :       9323 :       die = new_die (DW_TAG_formal_parameter, parent, decl);
    6029                 :       9323 :       break;
    6030                 :          0 :     case CONST_DECL:
    6031                 :          0 :       die = new_die (DW_TAG_constant, parent, decl);
    6032                 :          0 :       break;
    6033                 :          8 :     case LABEL_DECL:
    6034                 :          8 :       die = new_die (DW_TAG_label, parent, decl);
    6035                 :          8 :       break;
    6036                 :        352 :     case BLOCK:
    6037                 :        352 :       die = new_die (DW_TAG_lexical_block, parent, decl);
    6038                 :        352 :       break;
    6039                 :          0 :     default:
    6040                 :          0 :       gcc_unreachable ();
    6041                 :            :     }
    6042                 :      20075 :   if (TREE_CODE (decl) == BLOCK)
    6043                 :        352 :     equate_block_to_die (decl, die);
    6044                 :            :   else
    6045                 :      19723 :     equate_decl_number_to_die (decl, die);
    6046                 :            : 
    6047                 :      20075 :   add_desc_attribute (die, decl);
    6048                 :            : 
    6049                 :            :   /* Add a reference to the DIE providing early debug at $sym + off.  */
    6050                 :      20075 :   add_AT_external_die_ref (die, DW_AT_abstract_origin, sym, off);
    6051                 :            : 
    6052                 :      20075 :   return die;
    6053                 :            : }
    6054                 :            : 
    6055                 :            : /* Returns a hash value for X (which really is a var_loc_list).  */
    6056                 :            : 
    6057                 :            : inline hashval_t
    6058                 :  132460000 : decl_loc_hasher::hash (var_loc_list *x)
    6059                 :            : {
    6060                 :  132460000 :   return (hashval_t) x->decl_id;
    6061                 :            : }
    6062                 :            : 
    6063                 :            : /* Return nonzero if decl_id of var_loc_list X is the same as
    6064                 :            :    UID of decl *Y.  */
    6065                 :            : 
    6066                 :            : inline bool
    6067                 :  173715000 : decl_loc_hasher::equal (var_loc_list *x, const_tree y)
    6068                 :            : {
    6069                 :  173715000 :   return (x->decl_id == DECL_UID (y));
    6070                 :            : }
    6071                 :            : 
    6072                 :            : /* Return the var_loc list associated with a given declaration.  */
    6073                 :            : 
    6074                 :            : static inline var_loc_list *
    6075                 :   16430600 : lookup_decl_loc (const_tree decl)
    6076                 :            : {
    6077                 :   16430600 :   if (!decl_loc_table)
    6078                 :            :     return NULL;
    6079                 :   16430600 :   return decl_loc_table->find_with_hash (decl, DECL_UID (decl));
    6080                 :            : }
    6081                 :            : 
    6082                 :            : /* Returns a hash value for X (which really is a cached_dw_loc_list_list).  */
    6083                 :            : 
    6084                 :            : inline hashval_t
    6085                 :          0 : dw_loc_list_hasher::hash (cached_dw_loc_list *x)
    6086                 :            : {
    6087                 :          0 :   return (hashval_t) x->decl_id;
    6088                 :            : }
    6089                 :            : 
    6090                 :            : /* Return nonzero if decl_id of cached_dw_loc_list X is the same as
    6091                 :            :    UID of decl *Y.  */
    6092                 :            : 
    6093                 :            : inline bool
    6094                 :          0 : dw_loc_list_hasher::equal (cached_dw_loc_list *x, const_tree y)
    6095                 :            : {
    6096                 :          0 :   return (x->decl_id == DECL_UID (y));
    6097                 :            : }
    6098                 :            : 
    6099                 :            : /* Equate a DIE to a particular declaration.  */
    6100                 :            : 
    6101                 :            : static void
    6102                 :   26638100 : equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
    6103                 :            : {
    6104                 :   26638100 :   unsigned int decl_id = DECL_UID (decl);
    6105                 :            : 
    6106                 :   26638100 :   *decl_die_table->find_slot_with_hash (decl, decl_id, INSERT) = decl_die;
    6107                 :   26638100 :   decl_die->decl_id = decl_id;
    6108                 :   26638100 : }
    6109                 :            : 
    6110                 :            : /* Return how many bits covers PIECE EXPR_LIST.  */
    6111                 :            : 
    6112                 :            : static HOST_WIDE_INT
    6113                 :   19770900 : decl_piece_bitsize (rtx piece)
    6114                 :            : {
    6115                 :   19770900 :   int ret = (int) GET_MODE (piece);
    6116                 :   19770900 :   if (ret)
    6117                 :   19719400 :     return ret;
    6118                 :      51569 :   gcc_assert (GET_CODE (XEXP (piece, 0)) == CONCAT
    6119                 :            :               && CONST_INT_P (XEXP (XEXP (piece, 0), 0)));
    6120                 :      51569 :   return INTVAL (XEXP (XEXP (piece, 0), 0));
    6121                 :            : }
    6122                 :            : 
    6123                 :            : /* Return pointer to the location of location note in PIECE EXPR_LIST.  */
    6124                 :            : 
    6125                 :            : static rtx *
    6126                 :   10353100 : decl_piece_varloc_ptr (rtx piece)
    6127                 :            : {
    6128                 :          0 :   if ((int) GET_MODE (piece))
    6129                 :   10329400 :     return &XEXP (piece, 0);
    6130                 :            :   else
    6131                 :      23704 :     return &XEXP (XEXP (piece, 0), 1);
    6132                 :            : }
    6133                 :            : 
    6134                 :            : /* Create an EXPR_LIST for location note LOC_NOTE covering BITSIZE bits.
    6135                 :            :    Next is the chain of following piece nodes.  */
    6136                 :            : 
    6137                 :            : static rtx_expr_list *
    6138                 :    4463810 : decl_piece_node (rtx loc_note, HOST_WIDE_INT bitsize, rtx next)
    6139                 :            : {
    6140                 :    4463810 :   if (bitsize > 0 && bitsize <= (int) MAX_MACHINE_MODE)
    6141                 :    4444950 :     return alloc_EXPR_LIST (bitsize, loc_note, next);
    6142                 :            :   else
    6143                 :      18860 :     return alloc_EXPR_LIST (0, gen_rtx_CONCAT (VOIDmode,
    6144                 :            :                                                GEN_INT (bitsize),
    6145                 :      18860 :                                                loc_note), next);
    6146                 :            : }
    6147                 :            : 
    6148                 :            : /* Return rtx that should be stored into loc field for
    6149                 :            :    LOC_NOTE and BITPOS/BITSIZE.  */
    6150                 :            : 
    6151                 :            : static rtx
    6152                 :   22255800 : construct_piece_list (rtx loc_note, HOST_WIDE_INT bitpos,
    6153                 :            :                       HOST_WIDE_INT bitsize)
    6154                 :            : {
    6155                 :   22255800 :   if (bitsize != -1)
    6156                 :            :     {
    6157                 :     389397 :       loc_note = decl_piece_node (loc_note, bitsize, NULL_RTX);
    6158                 :     389397 :       if (bitpos != 0)
    6159                 :      48771 :         loc_note = decl_piece_node (NULL_RTX, bitpos, loc_note);
    6160                 :            :     }
    6161                 :   22255800 :   return loc_note;
    6162                 :            : }
    6163                 :            : 
    6164                 :            : /* This function either modifies location piece list *DEST in
    6165                 :            :    place (if SRC and INNER is NULL), or copies location piece list
    6166                 :            :    *SRC to *DEST while modifying it.  Location BITPOS is modified
    6167                 :            :    to contain LOC_NOTE, any pieces overlapping it are removed resp.
    6168                 :            :    not copied and if needed some padding around it is added.
    6169                 :            :    When modifying in place, DEST should point to EXPR_LIST where
    6170                 :            :    earlier pieces cover PIECE_BITPOS bits, when copying SRC points
    6171                 :            :    to the start of the whole list and INNER points to the EXPR_LIST
    6172                 :            :    where earlier pieces cover PIECE_BITPOS bits.  */
    6173                 :            : 
    6174                 :            : static void
    6175                 :    3602920 : adjust_piece_list (rtx *dest, rtx *src, rtx *inner,
    6176                 :            :                    HOST_WIDE_INT bitpos, HOST_WIDE_INT piece_bitpos,
    6177                 :            :                    HOST_WIDE_INT bitsize, rtx loc_note)
    6178                 :            : {
    6179                 :    3602920 :   HOST_WIDE_INT diff;
    6180                 :    3602920 :   bool copy = inner != NULL;
    6181                 :            : 
    6182                 :    3602920 :   if (copy)
    6183                 :            :     {
    6184                 :            :       /* First copy all nodes preceding the current bitpos.  */
    6185                 :    2407990 :       while (src != inner)
    6186                 :            :         {
    6187                 :    1478830 :           *dest = decl_piece_node (*decl_piece_varloc_ptr (*src),
    6188                 :            :                                    decl_piece_bitsize (*src), NULL_RTX);
    6189                 :     739417 :           dest = &XEXP (*dest, 1);
    6190                 :     739417 :           src = &XEXP (*src, 1);
    6191                 :            :         }
    6192                 :            :     }
    6193                 :            :   /* Add padding if needed.  */
    6194                 :    3602920 :   if (bitpos != piece_bitpos)
    6195                 :            :     {
    6196                 :       6548 :       *dest = decl_piece_node (NULL_RTX, bitpos - piece_bitpos,
    6197                 :            :                                copy ? NULL_RTX : *dest);
    6198                 :       6548 :       dest = &XEXP (*dest, 1);
    6199                 :            :     }
    6200                 :    3596380 :   else if (*dest && decl_piece_bitsize (*dest) == bitsize)
    6201                 :            :     {
    6202                 :    1680490 :       gcc_assert (!copy);
    6203                 :            :       /* A piece with correct bitpos and bitsize already exist,
    6204                 :            :          just update the location for it and return.  */
    6205                 :    1680490 :       *decl_piece_varloc_ptr (*dest) = loc_note;
    6206                 :    1680490 :       return;
    6207                 :            :     }
    6208                 :            :   /* Add the piece that changed.  */
    6209                 :    1922430 :   *dest = decl_piece_node (loc_note, bitsize, copy ? NULL_RTX : *dest);
    6210                 :    1922430 :   dest = &XEXP (*dest, 1);
    6211                 :            :   /* Skip over pieces that overlap it.  */
    6212                 :    1922430 :   diff = bitpos - piece_bitpos + bitsize;
    6213                 :    1922430 :   if (!copy)
    6214                 :     253860 :     src = dest;
    6215                 :    3572680 :   while (diff > 0 && *src)
    6216                 :            :     {
    6217                 :    1650240 :       rtx piece = *src;
    6218                 :    1650240 :       diff -= decl_piece_bitsize (piece);
    6219                 :    1650240 :       if (copy)
    6220                 :    1647390 :         src = &XEXP (piece, 1);
    6221                 :            :       else
    6222                 :            :         {
    6223                 :       2858 :           *src = XEXP (piece, 1);
    6224                 :       2858 :           free_EXPR_LIST_node (piece);
    6225                 :            :         }
    6226                 :            :     }
    6227                 :            :   /* Add padding if needed.  */
    6228                 :    1922430 :   if (diff < 0 && *src)
    6229                 :            :     {
    6230                 :       1653 :       if (!copy)
    6231                 :       1172 :         dest = src;
    6232                 :       1653 :       *dest = decl_piece_node (NULL_RTX, -diff, copy ? NULL_RTX : *dest);
    6233                 :       1653 :       dest = &XEXP (*dest, 1);
    6234                 :            :     }
    6235                 :    1922430 :   if (!copy)
    6236                 :            :     return;
    6237                 :            :   /* Finally copy all nodes following it.  */
    6238                 :    3024160 :   while (*src)
    6239                 :            :     {
    6240                 :    2711180 :       *dest = decl_piece_node (*decl_piece_varloc_ptr (*src),
    6241                 :            :                                decl_piece_bitsize (*src), NULL_RTX);
    6242                 :    1355590 :       dest = &XEXP (*dest, 1);
    6243                 :    1355590 :       src = &XEXP (*src, 1);
    6244                 :            :     }
    6245                 :            : }
    6246                 :            : 
    6247                 :            : /* Add a variable location node to the linked list for DECL.  */
    6248                 :            : 
    6249                 :            : static struct var_loc_node *
    6250                 :   31134600 : add_var_loc_to_decl (tree decl, rtx loc_note, const char *label, var_loc_view view)
    6251                 :            : {
    6252                 :   31134600 :   unsigned int decl_id;
    6253                 :   31134600 :   var_loc_list *temp;
    6254                 :   31134600 :   struct var_loc_node *loc = NULL;
    6255                 :   31134600 :   HOST_WIDE_INT bitsize = -1, bitpos = -1;
    6256                 :            : 
    6257                 :   31134600 :   if (VAR_P (decl) && DECL_HAS_DEBUG_EXPR_P (decl))
    6258                 :            :     {
    6259                 :    4902750 :       tree realdecl = DECL_DEBUG_EXPR (decl);
    6260                 :    4902750 :       if (handled_component_p (realdecl)
    6261                 :     286637 :           || (TREE_CODE (realdecl) == MEM_REF
    6262                 :     286637 :               && TREE_CODE (TREE_OPERAND (realdecl, 0)) == ADDR_EXPR))
    6263                 :            :         {
    6264                 :    4902750 :           bool reverse;
    6265                 :    4902750 :           tree innerdecl = get_ref_base_and_extent_hwi (realdecl, &bitpos,
    6266                 :            :                                                         &bitsize, &reverse);
    6267                 :    4902750 :           if (!innerdecl
    6268                 :    4902750 :               || !DECL_P (innerdecl)
    6269                 :    4902750 :               || DECL_IGNORED_P (innerdecl)
    6270                 :    4902750 :               || TREE_STATIC (innerdecl)
    6271                 :    4902750 :               || bitsize == 0
    6272                 :    9805500 :               || bitpos + bitsize > 256)
    6273                 :          0 :             return NULL;
    6274                 :    4902750 :           decl = innerdecl;
    6275                 :            :         }
    6276                 :            :     }
    6277                 :            : 
    6278                 :   31134600 :   decl_id = DECL_UID (decl);
    6279                 :   31134600 :   var_loc_list **slot
    6280                 :   31134600 :     = decl_loc_table->find_slot_with_hash (decl, decl_id, INSERT);
    6281                 :   31134600 :   if (*slot == NULL)
    6282                 :            :     {
    6283                 :    7181200 :       temp = ggc_cleared_alloc<var_loc_list> ();
    6284                 :    7181200 :       temp->decl_id = decl_id;
    6285                 :    7181200 :       *slot = temp;
    6286                 :            :     }
    6287                 :            :   else
    6288                 :            :     temp = *slot;
    6289                 :            : 
    6290                 :            :   /* For PARM_DECLs try to keep around the original incoming value,
    6291                 :            :      even if that means we'll emit a zero-range .debug_loc entry.  */
    6292                 :   31134600 :   if (temp->last
    6293                 :   23953400 :       && temp->first == temp->last
    6294                 :   11694100 :       && TREE_CODE (decl) == PARM_DECL
    6295                 :     672786 :       && NOTE_P (temp->first->loc)
    6296                 :     637422 :       && NOTE_VAR_LOCATION_DECL (temp->first->loc) == decl
    6297                 :     637422 :       && DECL_INCOMING_RTL (decl)
    6298                 :     637422 :       && NOTE_VAR_LOCATION_LOC (temp->first->loc)
    6299                 :     636968 :       && GET_CODE (NOTE_VAR_LOCATION_LOC (temp->first->loc))
    6300                 :     636968 :          == GET_CODE (DECL_INCOMING_RTL (decl))
    6301                 :     636941 :       && prev_real_insn (as_a<rtx_insn *> (temp->first->loc)) == NULL_RTX
    6302                 :   31771600 :       && (bitsize != -1
    6303                 :     636871 :           || !rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->first->loc),
    6304                 :     636871 :                            NOTE_VAR_LOCATION_LOC (loc_note))
    6305                 :     217549 :           || (NOTE_VAR_LOCATION_STATUS (temp->first->loc)
    6306                 :     217549 :               != NOTE_VAR_LOCATION_STATUS (loc_note))))
    6307                 :            :     {
    6308                 :     419392 :       loc = ggc_cleared_alloc<var_loc_node> ();
    6309                 :     419392 :       temp->first->next = loc;
    6310                 :     419392 :       temp->last = loc;
    6311                 :     419392 :       loc->loc = construct_piece_list (loc_note, bitpos, bitsize);
    6312                 :            :     }
    6313                 :   30715200 :   else if (temp->last)
    6314                 :            :     {
    6315                 :   23534000 :       struct var_loc_node *last = temp->last, *unused = NULL;
    6316                 :   23534000 :       rtx *piece_loc = NULL, last_loc_note;
    6317                 :   23534000 :       HOST_WIDE_INT piece_bitpos = 0;
    6318                 :   23534000 :       if (last->next)
    6319                 :            :         {
    6320                 :   15027200 :           last = last->next;
    6321                 :   15027200 :           gcc_assert (last->next == NULL);
    6322                 :            :         }
    6323                 :   23534000 :       if (bitsize != -1 && GET_CODE (last->loc) == EXPR_LIST)
    6324                 :            :         {
    6325                 :    4513350 :           piece_loc = &last->loc;
    6326                 :    7766100 :           do
    6327                 :            :             {
    6328                 :    7766100 :               HOST_WIDE_INT cur_bitsize = decl_piece_bitsize (*piece_loc);
    6329                 :    7766100 :               if (piece_bitpos + cur_bitsize > bitpos)
    6330                 :            :                 break;
    6331                 :    3524940 :               piece_bitpos += cur_bitsize;
    6332                 :    3524940 :               piece_loc = &XEXP (*piece_loc, 1);
    6333                 :            :             }
    6334                 :    3524940 :           while (*piece_loc);
    6335                 :            :         }
    6336                 :            :       /* TEMP->LAST here is either pointer to the last but one or
    6337                 :            :          last element in the chained list, LAST is pointer to the
    6338                 :            :          last element.  */
    6339                 :   23534000 :       if (label && strcmp (last->label, label) == 0 && last->view == view)
    6340                 :            :         {
    6341                 :            :           /* For SRA optimized variables if there weren't any real
    6342                 :            :              insns since last note, just modify the last node.  */
    6343                 :    2731350 :           if (piece_loc != NULL)
    6344                 :            :             {
    6345                 :    1934350 :               adjust_piece_list (piece_loc, NULL, NULL,
    6346                 :            :                                  bitpos, piece_bitpos, bitsize, loc_note);
    6347                 :    1934350 :               return NULL;
    6348                 :            :             }
    6349                 :            :           /* If the last note doesn't cover any instructions, remove it.  */
    6350                 :     796998 :           if (temp->last != last)
    6351                 :            :             {
    6352                 :     727238 :               temp->last->next = NULL;
    6353                 :     727238 :               unused = last;
    6354                 :     727238 :               last = temp->last;
    6355                 :     727238 :               gcc_assert (strcmp (last->label, label) != 0 || last->view != view);
    6356                 :            :             }
    6357                 :            :           else
    6358                 :            :             {
    6359                 :      69760 :               gcc_assert (temp->first == temp->last
    6360                 :            :                           || (temp->first->next == temp->last
    6361                 :            :                               && TREE_CODE (decl) == PARM_DECL));
    6362                 :      69760 :               memset (temp->last, '\0', sizeof (*temp->last));
    6363                 :      69760 :               temp->last->loc = construct_piece_list (loc_note, bitpos, bitsize);
    6364                 :      69760 :               return temp->last;
    6365                 :            :             }
    6366                 :            :         }
    6367                 :   21529900 :       if (bitsize == -1 && NOTE_P (last->loc))
    6368                 :            :         last_loc_note = last->loc;
    6369                 :    2719810 :       else if (piece_loc != NULL
    6370                 :    2579000 :                && *piece_loc != NULL_RTX
    6371                 :    2557820 :                && piece_bitpos == bitpos
    6372                 :    5277330 :                && decl_piece_bitsize (*piece_loc) == bitsize)
    6373                 :    5114150 :         last_loc_note = *decl_piece_varloc_ptr (*piece_loc);
    6374                 :            :       else
    6375                 :            :         last_loc_note = NULL_RTX;
    6376                 :            :       /* If the current location is the same as the end of the list,
    6377                 :            :          and either both or neither of the locations is uninitialized,
    6378                 :            :          we have nothing to do.  */
    6379                 :   21367200 :       if (last_loc_note == NULL_RTX
    6380                 :   21360700 :           || (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (last_loc_note),
    6381                 :   21360700 :                             NOTE_VAR_LOCATION_LOC (loc_note)))
    6382                 :   26643100 :           || ((NOTE_VAR_LOCATION_STATUS (last_loc_note)
    6383                 :    5275890 :                != NOTE_VAR_LOCATION_STATUS (loc_note))
    6384                 :          0 :               && ((NOTE_VAR_LOCATION_STATUS (last_loc_note)
    6385                 :            :                    == VAR_INIT_STATUS_UNINITIALIZED)
    6386                 :          0 :                   || (NOTE_VAR_LOCATION_STATUS (loc_note)
    6387                 :            :                       == VAR_INIT_STATUS_UNINITIALIZED))))
    6388                 :            :         {
    6389                 :            :           /* Add LOC to the end of list and update LAST.  If the last
    6390                 :            :              element of the list has been removed above, reuse its
    6391                 :            :              memory for the new node, otherwise allocate a new one.  */
    6392                 :   16254000 :           if (unused)
    6393                 :            :             {
    6394                 :     533778 :               loc = unused;
    6395                 :     533778 :               memset (loc, '\0', sizeof (*loc));
    6396                 :            :             }
    6397                 :            :           else
    6398                 :   15720300 :             loc = ggc_cleared_alloc<var_loc_node> ();
    6399                 :   16254000 :           if (bitsize == -1 || piece_loc == NULL)
    6400                 :   14585500 :             loc->loc = construct_piece_list (loc_note, bitpos, bitsize);
    6401                 :            :           else
    6402                 :    1668570 :             adjust_piece_list (&loc->loc, &last->loc, piece_loc,
    6403                 :            :                                bitpos, piece_bitpos, bitsize, loc_note);
    6404                 :   16254000 :           last->next = loc;
    6405                 :            :           /* Ensure TEMP->LAST will point either to the new last but one
    6406                 :            :              element of the chain, or to the last element in it.  */
    6407                 :   16254000 :           if (last != temp->last)
    6408                 :    8997660 :             temp->last = last;
    6409                 :            :         }
    6410                 :    5275890 :       else if (unused)
    6411                 :     193460 :         ggc_free (unused);
    6412                 :            :     }
    6413                 :            :   else
    6414                 :            :     {
    6415                 :    7181200 :       loc = ggc_cleared_alloc<var_loc_node> ();
    6416                 :    7181200 :       temp->first = loc;
    6417                 :    7181200 :       temp->last = loc;
    6418                 :    7181200 :       loc->loc = construct_piece_list (loc_note, bitpos, bitsize);
    6419                 :            :     }
    6420                 :            :   return loc;
    6421                 :            : }
    6422                 :            : 
    6423                 :            : /* Keep track of the number of spaces used to indent the
    6424                 :            :    output of the debugging routines that print the structure of
    6425                 :            :    the DIE internal representation.  */
    6426                 :            : static int print_indent;
    6427                 :            : 
    6428                 :            : /* Indent the line the number of spaces given by print_indent.  */
    6429                 :            : 
    6430                 :            : static inline void
    6431                 :       1692 : print_spaces (FILE *outfile)
    6432                 :            : {
    6433                 :       1692 :   fprintf (outfile, "%*s", print_indent, "");
    6434                 :            : }
    6435                 :            : 
    6436                 :            : /* Print a type signature in hex.  */
    6437                 :            : 
    6438                 :            : static inline void
    6439                 :          0 : print_signature (FILE *outfile, char *sig)
    6440                 :            : {
    6441                 :          0 :   int i;
    6442                 :            : 
    6443                 :          0 :   for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
    6444                 :          0 :     fprintf (outfile, "%02x", sig[i] & 0xff);
    6445                 :            : }
    6446                 :            : 
    6447                 :            : static inline void
    6448                 :            : print_discr_value (FILE *outfile, dw_discr_value *discr_value)
    6449                 :            : {
    6450                 :            :   if (discr_value->pos)
    6451                 :            :     fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, discr_value->v.sval);
    6452                 :            :   else
    6453                 :            :     fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, discr_value->v.uval);
    6454                 :            : }
    6455                 :            : 
    6456                 :            : static void print_loc_descr (dw_loc_descr_ref, FILE *);
    6457                 :            : 
    6458                 :            : /* Print the value associated to the VAL DWARF value node to OUTFILE.  If
    6459                 :            :    RECURSE, output location descriptor operations.  */
    6460                 :            : 
    6461                 :            : static void
    6462                 :       1184 : print_dw_val (dw_val_node *val, bool recurse, FILE *outfile)
    6463                 :            : {
    6464                 :       1184 :   switch (val->val_class)
    6465                 :            :     {
    6466                 :         12 :     case dw_val_class_addr:
    6467                 :         12 :       fprintf (outfile, "address");
    6468                 :         12 :       break;
    6469                 :          0 :     case dw_val_class_offset:
    6470                 :          0 :       fprintf (outfile, "offset");
    6471                 :          0 :       break;
    6472                 :         28 :     case dw_val_class_loc:
    6473                 :         28 :       fprintf (outfile, "location descriptor");
    6474                 :         28 :       if (val->v.val_loc == NULL)
    6475                 :          0 :         fprintf (outfile, " -> <null>\n");
    6476                 :         28 :       else if (recurse)
    6477                 :            :         {
    6478                 :         28 :           fprintf (outfile, ":\n");
    6479                 :         28 :           print_indent += 4;
    6480                 :         28 :           print_loc_descr (val->v.val_loc, outfile);
    6481                 :         28 :           print_indent -= 4;
    6482                 :            :         }
    6483                 :            :       else
    6484                 :            :         {
    6485                 :          0 :           if (flag_dump_noaddr || flag_dump_unnumbered)
    6486                 :          0 :             fprintf (outfile, " #\n");
    6487                 :            :           else
    6488                 :          0 :             fprintf (outfile, " (%p)\n", (void *) val->v.val_loc);
    6489                 :            :         }
    6490                 :            :       break;
    6491                 :         36 :     case dw_val_class_loc_list:
    6492                 :         36 :       fprintf (outfile, "location list -> label:%s",
    6493                 :         36 :                val->v.val_loc_list->ll_symbol);
    6494                 :         36 :       break;
    6495                 :         36 :     case dw_val_class_view_list:
    6496                 :         36 :       val = view_list_to_loc_list_val_node (val);
    6497                 :         36 :       fprintf (outfile, "location list with views -> labels:%s and %s",
    6498                 :            :                val->v.val_loc_list->ll_symbol,
    6499                 :         36 :                val->v.val_loc_list->vl_symbol);
    6500                 :         36 :       break;
    6501                 :          0 :     case dw_val_class_range_list:
    6502                 :          0 :       fprintf (outfile, "range list");
    6503                 :          0 :       break;
    6504                 :          0 :     case dw_val_class_const:
    6505                 :          0 :     case dw_val_class_const_implicit:
    6506                 :          0 :       fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, val->v.val_int);
    6507                 :          0 :       break;
    6508                 :        452 :     case dw_val_class_unsigned_const:
    6509                 :        452 :     case dw_val_class_unsigned_const_implicit:
    6510                 :        452 :       fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, val->v.val_unsigned);
    6511                 :        452 :       break;
    6512                 :          0 :     case dw_val_class_const_double:
    6513                 :          0 :       fprintf (outfile, "constant (" HOST_WIDE_INT_PRINT_DEC","\
    6514                 :            :                         HOST_WIDE_INT_PRINT_UNSIGNED")",
    6515                 :            :                val->v.val_double.high,
    6516                 :            :                val->v.val_double.low);
    6517                 :          0 :       break;
    6518                 :          0 :     case dw_val_class_wide_int:
    6519                 :          0 :       {
    6520                 :          0 :         int i = val->v.val_wide->get_len ();
    6521                 :          0 :         fprintf (outfile, "constant (");
    6522                 :          0 :         gcc_assert (i > 0);
    6523                 :          0 :         if (val->v.val_wide->elt (i - 1) == 0)
    6524                 :          0 :           fprintf (outfile, "0x");
    6525                 :          0 :         fprintf (outfile, HOST_WIDE_INT_PRINT_HEX,
    6526                 :          0 :                  val->v.val_wide->elt (--i));
    6527                 :          0 :         while (--i >= 0)
    6528                 :          0 :           fprintf (outfile, HOST_WIDE_INT_PRINT_PADDED_HEX,
    6529                 :          0 :                    val->v.val_wide->elt (i));
    6530                 :          0 :         fprintf (outfile, ")");
    6531                 :          0 :         break;
    6532                 :            :       }
    6533                 :          0 :     case dw_val_class_vec:
    6534                 :          0 :       fprintf (outfile, "floating-point or vector constant");
    6535                 :          0 :       break;
    6536                 :         56 :     case dw_val_class_flag:
    6537                 :         56 :       fprintf (outfile, "%u", val->v.val_flag);
    6538                 :         56 :       break;
    6539                 :        216 :     case dw_val_class_die_ref:
    6540                 :        216 :       if (val->v.val_die_ref.die != NULL)
    6541                 :            :         {
    6542                 :        216 :           dw_die_ref die = val->v.val_die_ref.die;
    6543                 :            : 
    6544                 :        216 :           if (die->comdat_type_p)
    6545                 :            :             {
    6546                 :          0 :               fprintf (outfile, "die -> signature: ");
    6547                 :        216 :               print_signature (outfile,
    6548                 :          0 :                                die->die_id.die_type_node->signature);
    6549                 :            :             }
    6550                 :        216 :           else if (die->die_id.die_symbol)
    6551                 :            :             {
    6552                 :          0 :               fprintf (outfile, "die -> label: %s", die->die_id.die_symbol);
    6553                 :          0 :               if (die->with_offset)
    6554                 :          0 :                 fprintf (outfile, " + %ld", die->die_offset);
    6555                 :            :             }
    6556                 :            :           else
    6557                 :        216 :             fprintf (outfile, "die -> %ld", die->die_offset);
    6558                 :        216 :           if (flag_dump_noaddr || flag_dump_unnumbered)
    6559                 :        216 :             fprintf (outfile, " #");
    6560                 :            :           else
    6561                 :          0 :             fprintf (outfile, " (%p)", (void *) die);
    6562                 :            :         }
    6563                 :            :       else
    6564                 :          0 :         fprintf (outfile, "die -> <null>");
    6565                 :            :       break;
    6566                 :          0 :     case dw_val_class_vms_delta:
    6567                 :          0 :       fprintf (outfile, "delta: @slotcount(%s-%s)",
    6568                 :            :                val->v.val_vms_delta.lbl2, val->v.val_vms_delta.lbl1);
    6569                 :          0 :       break;
    6570                 :          0 :     case dw_val_class_symview:
    6571                 :          0 :       fprintf (outfile, "view: %s", val->v.val_symbolic_view);
    6572                 :          0 :       break;
    6573                 :         20 :     case dw_val_class_lbl_id:
    6574                 :         20 :     case dw_val_class_lineptr:
    6575                 :         20 :     case dw_val_class_macptr:
    6576                 :         20 :     case dw_val_class_loclistsptr:
    6577                 :         20 :     case dw_val_class_high_pc:
    6578                 :         20 :       fprintf (outfile, "label: %s", val->v.val_lbl_id);
    6579                 :         20 :       break;
    6580                 :        184 :     case dw_val_class_str:
    6581                 :        184 :       if (val->v.val_str->str != NULL)
    6582                 :        184 :         fprintf (outfile, "\"%s\"", val->v.val_str->str);
    6583                 :            :       else
    6584                 :          0 :         fprintf (outfile, "<null>");
    6585                 :            :       break;
    6586                 :        144 :     case dw_val_class_file:
    6587                 :        144 :     case dw_val_class_file_implicit:
    6588                 :        144 :       fprintf (outfile, "\"%s\" (%d)", val->v.val_file->filename,
    6589                 :        144 :                val->v.val_file->emitted_number);
    6590                 :        144 :       break;
    6591                 :            :     case dw_val_class_data8:
    6592                 :            :       {
    6593                 :            :         int i;
    6594                 :            : 
    6595                 :          0 :         for (i = 0; i < 8; i++)
    6596                 :          0 :           fprintf (outfile, "%02x", val->v.val_data8[i]);
    6597                 :            :         break;
    6598                 :            :       }
    6599                 :          0 :     case dw_val_class_discr_value:
    6600                 :          0 :       print_discr_value (outfile, &val->v.val_discr_value);
    6601                 :          0 :       break;
    6602                 :          0 :     case dw_val_class_discr_list:
    6603                 :          0 :       for (dw_discr_list_ref node = val->v.val_discr_list;
    6604                 :          0 :            node != NULL;
    6605                 :          0 :            node = node->dw_discr_next)
    6606                 :            :         {
    6607                 :          0 :           if (node->dw_discr_range)
    6608                 :            :             {
    6609                 :          0 :               fprintf (outfile, " .. ");
    6610                 :          0 :               print_discr_value (outfile, &node->dw_discr_lower_bound);
    6611                 :          0 :               print_discr_value (outfile, &node->dw_discr_upper_bound);
    6612                 :            :             }
    6613                 :            :           else
    6614                 :          0 :             print_discr_value (outfile, &node->dw_discr_lower_bound);
    6615                 :            : 
    6616                 :          0 :           if (node->dw_discr_next != NULL)
    6617                 :          0 :             fprintf (outfile, " | ");
    6618                 :            :         }
    6619                 :            :     default:
    6620                 :            :       break;
    6621                 :            :     }
    6622                 :       1184 : }
    6623                 :            : 
    6624                 :            : /* Likewise, for a DIE attribute.  */
    6625                 :            : 
    6626                 :            : static void
    6627                 :       1128 : print_attribute (dw_attr_node *a, bool recurse, FILE *outfile)
    6628                 :            : {
    6629                 :          0 :   print_dw_val (&a->dw_attr_val, recurse, outfile);
    6630                 :          0 : }
    6631                 :            : 
    6632                 :            : 
    6633                 :            : /* Print the list of operands in the LOC location description to OUTFILE.  This
    6634                 :            :    routine is a debugging aid only.  */
    6635                 :            : 
    6636                 :            : static void
    6637                 :         28 : print_loc_descr (dw_loc_descr_ref loc, FILE *outfile)
    6638                 :            : {
    6639                 :         28 :   dw_loc_descr_ref l = loc;
    6640                 :            : 
    6641                 :         28 :   if (loc == NULL)
    6642                 :            :     {
    6643                 :          0 :       print_spaces (outfile);
    6644                 :          0 :       fprintf (outfile, "<null>\n");
    6645                 :          0 :       return;
    6646                 :            :     }
    6647                 :            : 
    6648                 :         56 :   for (l = loc; l != NULL; l = l->dw_loc_next)
    6649                 :            :     {
    6650                 :         28 :       print_spaces (outfile);
    6651                 :         28 :       if (flag_dump_noaddr || flag_dump_unnumbered)
    6652                 :         28 :         fprintf (outfile, "#");
    6653                 :            :       else
    6654                 :          0 :         fprintf (outfile, "(%p)", (void *) l);
    6655                 :         28 :       fprintf (outfile, " %s",
    6656                 :         28 :                dwarf_stack_op_name (l->dw_loc_opc));
    6657                 :         28 :       if (l->dw_loc_oprnd1.val_class != dw_val_class_none)
    6658                 :            :         {
    6659                 :         28 :           fprintf (outfile, " ");
    6660                 :         28 :           print_dw_val (&l->dw_loc_oprnd1, false, outfile);
    6661                 :            :         }
    6662                 :         28 :       if (l->dw_loc_oprnd2.val_class != dw_val_class_none)
    6663                 :            :         {
    6664                 :         28 :           fprintf (outfile, ", ");
    6665                 :         28 :           print_dw_val (&l->dw_loc_oprnd2, false, outfile);
    6666                 :            :         }
    6667                 :         28 :       fprintf (outfile, "\n");
    6668                 :            :     }
    6669                 :            : }
    6670                 :            : 
    6671                 :            : /* Print the information associated with a given DIE, and its children.
    6672                 :            :    This routine is a debugging aid only.  */
    6673                 :            : 
    6674                 :            : static void
    6675                 :        268 : print_die (dw_die_ref die, FILE *outfile)
    6676                 :            : {
    6677                 :        268 :   dw_attr_node *a;
    6678                 :        268 :   dw_die_ref c;
    6679                 :        268 :   unsigned ix;
    6680                 :            : 
    6681                 :        268 :   print_spaces (outfile);
    6682                 :        268 :   fprintf (outfile, "DIE %4ld: %s ",
    6683                 :        268 :            die->die_offset, dwarf_tag_name (die->die_tag));
    6684                 :        268 :   if (flag_dump_noaddr || flag_dump_unnumbered)
    6685                 :        268 :     fprintf (outfile, "#\n");
    6686                 :            :   else
    6687                 :          0 :     fprintf (outfile, "(%p)\n", (void*) die);
    6688                 :        268 :   print_spaces (outfile);
    6689                 :        268 :   fprintf (outfile, "  abbrev id: %lu", die->die_abbrev);
    6690                 :        268 :   fprintf (outfile, " offset: %ld", die->die_offset);
    6691                 :        268 :   fprintf (outfile, " mark: %d\n", die->die_mark);
    6692                 :            : 
    6693                 :        268 :   if (die->comdat_type_p)
    6694                 :            :     {
    6695                 :          0 :       print_spaces (outfile);
    6696                 :          0 :       fprintf (outfile, "  signature: ");
    6697                 :          0 :       print_signature (outfile, die->die_id.die_type_node->signature);
    6698                 :          0 :       fprintf (outfile, "\n");
    6699                 :            :     }
    6700                 :            : 
    6701                 :       1396 :   FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
    6702                 :            :     {
    6703                 :       1128 :       print_spaces (outfile);
    6704                 :       1128 :       fprintf (outfile, "  %s: ", dwarf_attr_name (a->dw_attr));
    6705                 :            : 
    6706                 :       1128 :       print_attribute (a, true, outfile);
    6707                 :       1128 :       fprintf (outfile, "\n");
    6708                 :            :     }
    6709                 :            : 
    6710                 :        268 :   if (die->die_child != NULL)
    6711                 :            :     {
    6712                 :         44 :       print_indent += 4;
    6713                 :        260 :       FOR_EACH_CHILD (die, c, print_die (c, outfile));
    6714                 :         44 :       print_indent -= 4;
    6715                 :            :     }
    6716                 :        268 :   if (print_indent == 0)
    6717                 :          8 :     fprintf (outfile, "\n");
    6718                 :        268 : }
    6719                 :            : 
    6720                 :            : /* Print the list of operations in the LOC location description.  */
    6721                 :            : 
    6722                 :            : DEBUG_FUNCTION void
    6723                 :          0 : debug_dwarf_loc_descr (dw_loc_descr_ref loc)
    6724                 :            : {
    6725                 :          0 :   print_loc_descr (loc, stderr);
    6726                 :          0 : }
    6727                 :            : 
    6728                 :            : /* Print the information collected for a given DIE.  */
    6729                 :            : 
    6730                 :            : DEBUG_FUNCTION void
    6731                 :          0 : debug_dwarf_die (dw_die_ref die)
    6732                 :            : {
    6733                 :          0 :   print_die (die, stderr);
    6734                 :          0 : }
    6735                 :            : 
    6736                 :            : DEBUG_FUNCTION void
    6737                 :          0 : debug (die_struct &ref)
    6738                 :            : {
    6739                 :          0 :   print_die (&ref, stderr);
    6740                 :          0 : }
    6741                 :            : 
    6742                 :            : DEBUG_FUNCTION void
    6743                 :          0 : debug (die_struct *ptr)
    6744                 :            : {
    6745                 :          0 :   if (ptr)
    6746                 :          0 :     debug (*ptr);
    6747                 :            :   else
    6748                 :          0 :     fprintf (stderr, "<nil>\n");
    6749                 :          0 : }
    6750                 :            : 
    6751                 :            : 
    6752                 :            : /* Print all DWARF information collected for the compilation unit.
    6753                 :            :    This routine is a debugging aid only.  */
    6754                 :            : 
    6755                 :            : DEBUG_FUNCTION void
    6756                 :          0 : debug_dwarf (void)
    6757                 :            : {
    6758                 :          0 :   print_indent = 0;
    6759                 :          0 :   print_die (comp_unit_die (), stderr);
    6760                 :          0 : }
    6761                 :            : 
    6762                 :            : /* Verify the DIE tree structure.  */
    6763                 :            : 
    6764                 :            : DEBUG_FUNCTION void
    6765                 :      36775 : verify_die (dw_die_ref die)
    6766                 :            : {
    6767                 :      36775 :   gcc_assert (!die->die_mark);
    6768                 :      36775 :   if (die->die_parent == NULL
    6769                 :      36775 :       && die->die_sib == NULL)
    6770                 :            :     return;
    6771                 :            :   /* Verify the die_sib list is cyclic.  */
    6772                 :            :   dw_die_ref x = die;
    6773                 :          0 :   do
    6774                 :            :     {
    6775                 :          0 :       x->die_mark = 1;
    6776                 :          0 :       x = x->die_sib;
    6777                 :            :     }
    6778                 :          0 :   while (x && !x->die_mark);
    6779                 :          0 :   gcc_assert (x == die);
    6780                 :            :   x = die;
    6781                 :          0 :   do
    6782                 :            :     {
    6783                 :            :       /* Verify all dies have the same parent.  */
    6784                 :          0 :       gcc_assert (x->die_parent == die->die_parent);
    6785                 :          0 :       if (x->die_child)
    6786                 :            :         {
    6787                 :            :           /* Verify the child has the proper parent and recurse.  */
    6788                 :          0 :           gcc_assert (x->die_child->die_parent == x);
    6789                 :          0 :           verify_die (x->die_child);
    6790                 :            :         }
    6791                 :          0 :       x->die_mark = 0;
    6792                 :          0 :       x = x->die_sib;
    6793                 :            :     }
    6794                 :          0 :   while (x && x->die_mark);
    6795                 :            : }
    6796                 :            : 
    6797                 :            : /* Sanity checks on DIEs.  */
    6798                 :            : 
    6799                 :            : static void
    6800                 :  108419000 : check_die (dw_die_ref die)
    6801                 :            : {
    6802                 :  108419000 :   unsigned ix;
    6803                 :  108419000 :   dw_attr_node *a;
    6804                 :  108419000 :   bool inline_found = false;
    6805                 :  108419000 :   int n_location = 0, n_low_pc = 0, n_high_pc = 0, n_artificial = 0;
    6806                 :  108419000 :   int n_decl_line = 0, n_decl_column = 0, n_decl_file = 0;
    6807                 :  545361000 :   FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
    6808                 :            :     {
    6809                 :  436942000 :       switch (a->dw_attr)
    6810                 :            :         {
    6811                 :     382165 :         case DW_AT_inline:
    6812                 :     382165 :           if (a->dw_attr_val.v.val_unsigned)
    6813                 :     382164 :             inline_found = true;
    6814                 :            :           break;
    6815                 :        780 :         case DW_AT_location:
    6816                 :        780 :           ++n_location;
    6817                 :        780 :           break;
    6818                 :     322691 :         case DW_AT_low_pc:
    6819                 :     322691 :           ++n_low_pc;
    6820                 :     322691 :           break;
    6821                 :     322691 :         case DW_AT_high_pc:
    6822                 :     322691 :           ++n_high_pc;
    6823                 :     322691 :           break;
    6824                 :      83049 :         case DW_AT_artificial:
    6825                 :      83049 :           ++n_artificial;
    6826                 :      83049 :           break;
    6827                 :   69109400 :         case DW_AT_decl_column:
    6828                 :   69109400 :           ++n_decl_column;
    6829                 :   69109400 :           break;
    6830                 :   69502100 :         case DW_AT_decl_line:
    6831                 :   69502100 :           ++n_decl_line;
    6832                 :   69502100 :           break;
    6833                 :   69492300 :         case DW_AT_decl_file:
    6834                 :   69492300 :           ++n_decl_file;
    6835                 :   69492300 :           break;
    6836                 :            :         default:
    6837                 :            :           break;
    6838                 :            :         }
    6839                 :            :     }
    6840                 :  108419000 :   if (n_location > 1 || n_low_pc > 1 || n_high_pc > 1 || n_artificial > 1
    6841                 :  108419000 :       || n_decl_column > 1 || n_decl_line > 1 || n_decl_file > 1)
    6842                 :            :     {
    6843                 :          0 :       fprintf (stderr, "Duplicate attributes in DIE:\n");
    6844                 :          0 :       debug_dwarf_die (die);
    6845                 :          0 :       gcc_unreachable ();
    6846                 :            :     }
    6847                 :  108419000 :   if (inline_found)
    6848                 :            :     {
    6849                 :            :       /* A debugging information entry that is a member of an abstract
    6850                 :            :          instance tree [that has DW_AT_inline] should not contain any
    6851                 :            :          attributes which describe aspects of the subroutine which vary
    6852                 :            :          between distinct inlined expansions or distinct out-of-line
    6853                 :            :          expansions.  */
    6854                 :    4066840 :       FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
    6855                 :    3684680 :         gcc_assert (a->dw_attr != DW_AT_low_pc
    6856                 :            :                     && a->dw_attr != DW_AT_high_pc
    6857                 :            :                     && a->dw_attr != DW_AT_location
    6858                 :            :                     && a->dw_attr != DW_AT_frame_base
    6859                 :            :                     && a->dw_attr != DW_AT_call_all_calls
    6860                 :            :                     && a->dw_attr != DW_AT_GNU_all_call_sites);
    6861                 :            :     }
    6862                 :  108419000 : }
    6863                 :            : 
    6864                 :            : #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
    6865                 :            : #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
    6866                 :            : #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
    6867                 :            : 
    6868                 :            : /* Calculate the checksum of a location expression.  */
    6869                 :            : 
    6870                 :            : static inline void
    6871                 :        634 : loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
    6872                 :            : {
    6873                 :        634 :   int tem;
    6874                 :        634 :   inchash::hash hstate;
    6875                 :        634 :   hashval_t hash;
    6876                 :            : 
    6877                 :        634 :   tem = (loc->dtprel << 8) | ((unsigned int) loc->dw_loc_opc);
    6878                 :        634 :   CHECKSUM (tem);
    6879                 :        634 :   hash_loc_operands (loc, hstate);
    6880                 :        634 :   hash = hstate.end();
    6881                 :        634 :   CHECKSUM (hash);
    6882                 :        634 : }
    6883                 :            : 
    6884                 :            : /* Calculate the checksum of an attribute.  */
    6885                 :            : 
    6886                 :            : static void
    6887                 :     754608 : attr_checksum (dw_attr_node *at, struct md5_ctx *ctx, int *mark)
    6888                 :            : {
    6889                 :     754608 :   dw_loc_descr_ref loc;
    6890                 :     754608 :   rtx r;
    6891                 :            : 
    6892                 :     754608 :   CHECKSUM (at->dw_attr);
    6893                 :            : 
    6894                 :            :   /* We don't care that this was compiled with a different compiler
    6895                 :            :      snapshot; if the output is the same, that's what matters.  */
    6896                 :     754608 :   if (at->dw_attr == DW_AT_producer)
    6897                 :            :     return;
    6898                 :            : 
    6899                 :     753696 :   switch (AT_class (at))
    6900                 :            :     {
    6901                 :         16 :     case dw_val_class_const:
    6902                 :         16 :     case dw_val_class_const_implicit:
    6903                 :         16 :       CHECKSUM (at->dw_attr_val.v.val_int);
    6904                 :         16 :       break;
    6905                 :     209170 :     case dw_val_class_unsigned_const:
    6906                 :     209170 :     case dw_val_class_unsigned_const_implicit:
    6907                 :     209170 :       CHECKSUM (at->dw_attr_val.v.val_unsigned);
    6908                 :     209170 :       break;
    6909                 :          0 :     case dw_val_class_const_double:
    6910                 :          0 :       CHECKSUM (at->dw_attr_val.v.val_double);
    6911                 :          0 :       break;
    6912                 :          0 :     case dw_val_class_wide_int:
    6913                 :          0 :       CHECKSUM_BLOCK (at->dw_attr_val.v.val_wide->get_val (),
    6914                 :            :                       get_full_len (*at->dw_attr_val.v.val_wide)
    6915                 :            :                       * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR);
    6916                 :          0 :       break;
    6917                 :         61 :     case dw_val_class_vec:
    6918                 :         61 :       CHECKSUM_BLOCK (at->dw_attr_val.v.val_vec.array,
    6919                 :            :                       (at->dw_attr_val.v.val_vec.length
    6920                 :            :                        * at->dw_attr_val.v.val_vec.elt_size));
    6921                 :         61 :       break;
    6922                 :     104453 :     case dw_val_class_flag:
    6923                 :     104453 :       CHECKSUM (at->dw_attr_val.v.val_flag);
    6924                 :     104453 :       break;
    6925                 :     120970 :     case dw_val_class_str:
    6926                 :     120970 :       CHECKSUM_STRING (AT_string (at));
    6927                 :     120970 :       break;
    6928                 :            : 
    6929                 :          0 :     case dw_val_class_addr:
    6930                 :          0 :       r = AT_addr (at);
    6931                 :          0 :       gcc_assert (GET_CODE (r) == SYMBOL_REF);
    6932                 :          0 :       CHECKSUM_STRING (XSTR (r, 0));
    6933                 :          0 :       break;
    6934                 :            : 
    6935                 :          0 :     case dw_val_class_offset:
    6936                 :          0 :       CHECKSUM (at->dw_attr_val.v.val_offset);
    6937                 :          0 :       break;
    6938                 :            : 
    6939                 :        254 :     case dw_val_class_loc:
    6940                 :        888 :       for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
    6941                 :        634 :         loc_checksum (loc, ctx);
    6942                 :            :       break;
    6943                 :            : 
    6944                 :     243567 :     case dw_val_class_die_ref:
    6945                 :     243567 :       die_checksum (AT_ref (at), ctx, mark);
    6946                 :     243567 :       break;
    6947                 :            : 
    6948                 :            :     case dw_val_class_fde_ref:
    6949                 :            :     case dw_val_class_vms_delta:
    6950                 :            :     case dw_val_class_symview:
    6951                 :            :     case dw_val_class_lbl_id:
    6952                 :            :     case dw_val_class_lineptr:
    6953                 :            :     case dw_val_class_macptr:
    6954                 :            :     case dw_val_class_loclistsptr:
    6955                 :            :     case dw_val_class_high_pc:
    6956                 :            :       break;
    6957                 :            : 
    6958                 :      74264 :     case dw_val_class_file:
    6959                 :      74264 :     case dw_val_class_file_implicit:
    6960                 :      74264 :       CHECKSUM_STRING (AT_file (at)->filename);
    6961                 :      74264 :       break;
    6962                 :            : 
    6963                 :          0 :     case dw_val_class_data8:
    6964                 :          0 :       CHECKSUM (at->dw_attr_val.v.val_data8);
    6965                 :          0 :       break;
    6966                 :            : 
    6967                 :            :     default:
    6968                 :            :       break;
    6969                 :            :     }
    6970                 :            : }
    6971                 :            : 
    6972                 :            : /* Calculate the checksum of a DIE.  */
    6973                 :            : 
    6974                 :            : static void
    6975                 :     437966 : die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
    6976                 :            : {
    6977                 :     437966 :   dw_die_ref c;
    6978                 :     437966 :   dw_attr_node *a;
    6979                 :     437966 :   unsigned ix;
    6980                 :            : 
    6981                 :            :   /* To avoid infinite recursion.  */
    6982                 :     437966 :   if (die->die_mark)
    6983                 :            :     {
    6984                 :     243567 :       CHECKSUM (die->die_mark);
    6985                 :     243567 :       return;
    6986                 :            :     }
    6987                 :     194399 :   die->die_mark = ++(*mark);
    6988                 :            : 
    6989                 :     194399 :   CHECKSUM (die->die_tag);
    6990                 :            : 
    6991                 :     949007 :   FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
    6992                 :     754608 :     attr_checksum (a, ctx, mark);
    6993                 :            : 
    6994                 :     338927 :   FOR_EACH_CHILD (die, c, die_checksum (c, ctx, mark));
    6995                 :            : }
    6996                 :            : 
    6997                 :            : #undef CHECKSUM
    6998                 :            : #undef CHECKSUM_BLOCK
    6999                 :            : #undef CHECKSUM_STRING
    7000                 :            : 
    7001                 :            : /* For DWARF-4 types, include the trailing NULL when checksumming strings.  */
    7002                 :            : #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
    7003                 :            : #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
    7004                 :            : #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO) + 1, ctx)
    7005                 :            : #define CHECKSUM_SLEB128(FOO) checksum_sleb128 ((FOO), ctx)
    7006                 :            : #define CHECKSUM_ULEB128(FOO) checksum_uleb128 ((FOO), ctx)
    7007                 :            : #define CHECKSUM_ATTR(FOO) \
    7008                 :            :   if (FOO) attr_checksum_ordered (die->die_tag, (FOO), ctx, mark)
    7009                 :            : 
    7010                 :            : /* Calculate the checksum of a number in signed LEB128 format.  */
    7011                 :            : 
    7012                 :            : static void
    7013                 :        270 : checksum_sleb128 (HOST_WIDE_INT value, struct md5_ctx *ctx)
    7014                 :            : {
    7015                 :        270 :   unsigned char byte;
    7016                 :        270 :   bool more;
    7017                 :            : 
    7018                 :        270 :   while (1)
    7019                 :            :     {
    7020                 :        270 :       byte = (value & 0x7f);
    7021                 :        270 :       value >>= 7;
    7022                 :        270 :       more = !((value == 0 && (byte & 0x40) == 0)
    7023                 :          0 :                 || (value == -1 && (byte & 0x40) != 0));
    7024                 :            :       if (more)
    7025                 :          0 :         byte |= 0x80;
    7026                 :        270 :       CHECKSUM (byte);
    7027                 :        270 :       if (!more)
    7028                 :            :         break;
    7029                 :            :     }
    7030                 :        270 : }
    7031                 :            : 
    7032                 :            : /* Calculate the checksum of a number in unsigned LEB128 format.  */
    7033                 :            : 
    7034                 :            : static void
    7035                 :     183996 : checksum_uleb128 (unsigned HOST_WIDE_INT value, struct md5_ctx *ctx)
    7036                 :            : {
    7037                 :     191544 :   while (1)
    7038                 :            :     {
    7039                 :     187770 :       unsigned char byte = (value & 0x7f);
    7040                 :     187770 :       value >>= 7;
    7041                 :     187770 :       if (value != 0)
    7042                 :            :         /* More bytes to follow.  */
    7043                 :       3774 :         byte |= 0x80;
    7044                 :     187770 :       CHECKSUM (byte);
    7045                 :     187770 :       if (value == 0)
    7046                 :            :         break;
    7047                 :       3774 :     }
    7048                 :     183996 : }
    7049                 :            : 
    7050                 :            : /* Checksum the context of the DIE.  This adds the names of any
    7051                 :            :    surrounding namespaces or structures to the checksum.  */
    7052                 :            : 
    7053                 :            : static void
    7054                 :        349 : checksum_die_context (dw_die_ref die, struct md5_ctx *ctx)
    7055                 :            : {
    7056                 :        349 :   const char *name;
    7057                 :        349 :   dw_die_ref spec;
    7058                 :        349 :   int tag = die->die_tag;
    7059                 :            : 
    7060                 :        349 :   if (tag != DW_TAG_namespace
    7061                 :        349 :       && tag != DW_TAG_structure_type
    7062                 :        255 :       && tag != DW_TAG_class_type)
    7063                 :            :     return;
    7064                 :            : 
    7065                 :        100 :   name = get_AT_string (die, DW_AT_name);
    7066                 :            : 
    7067                 :        100 :   spec = get_AT_ref (die, DW_AT_specification);
    7068                 :        100 :   if (spec != NULL)
    7069                 :          0 :     die = spec;
    7070                 :            : 
    7071                 :        100 :   if (die->die_parent != NULL)
    7072                 :        100 :     checksum_die_context (die->die_parent, ctx);
    7073                 :            : 
    7074                 :        100 :   CHECKSUM_ULEB128 ('C');
    7075                 :        100 :   CHECKSUM_ULEB128 (tag);
    7076                 :        100 :   if (name != NULL)
    7077                 :         80 :     CHECKSUM_STRING (name);
    7078                 :            : }
    7079                 :            : 
    7080                 :            : /* Calculate the checksum of a location expression.  */
    7081                 :            : 
    7082                 :            : static inline void
    7083                 :          0 : loc_checksum_ordered (dw_loc_descr_ref loc, struct md5_ctx *ctx)
    7084                 :            : {
    7085                 :            :   /* Special case for lone DW_OP_plus_uconst: checksum as if the location
    7086                 :            :      were emitted as a DW_FORM_sdata instead of a location expression.  */
    7087                 :          0 :   if (loc->dw_loc_opc == DW_OP_plus_uconst && loc->dw_loc_next == NULL)
    7088                 :            :     {
    7089                 :          0 :       CHECKSUM_ULEB128 (DW_FORM_sdata);
    7090                 :          0 :       CHECKSUM_SLEB128 ((HOST_WIDE_INT) loc->dw_loc_oprnd1.v.val_unsigned);
    7091                 :          0 :       return;
    7092                 :            :     }
    7093                 :            : 
    7094                 :            :   /* Otherwise, just checksum the raw location expression.  */
    7095                 :          0 :   while (loc != NULL)
    7096                 :            :     {
    7097                 :          0 :       inchash::hash hstate;
    7098                 :          0 :       hashval_t hash;
    7099                 :            : 
    7100                 :          0 :       CHECKSUM_ULEB128 (loc->dtprel);
    7101                 :          0 :       CHECKSUM_ULEB128 (loc->dw_loc_opc);
    7102                 :          0 :       hash_loc_operands (loc, hstate);
    7103                 :          0 :       hash = hstate.end ();
    7104                 :          0 :       CHECKSUM (hash);
    7105                 :          0 :       loc = loc->dw_loc_next;
    7106                 :            :     }
    7107                 :            : }
    7108                 :            : 
    7109                 :            : /* Calculate the checksum of an attribute.  */
    7110                 :            : 
    7111                 :            : static void
    7112                 :        595 : attr_checksum_ordered (enum dwarf_tag tag, dw_attr_node *at,
    7113                 :            :                        struct md5_ctx *ctx, int *mark)
    7114                 :            : {
    7115                 :        595 :   dw_loc_descr_ref loc;
    7116                 :        595 :   rtx r;
    7117                 :            : 
    7118                 :        595 :   if (AT_class (at) == dw_val_class_die_ref)
    7119                 :            :     {
    7120                 :        108 :       dw_die_ref target_die = AT_ref (at);
    7121                 :            : 
    7122                 :            :       /* For pointer and reference types, we checksum only the (qualified)
    7123                 :            :          name of the target type (if there is a name).  For friend entries,
    7124                 :            :          we checksum only the (qualified) name of the target type or function.
    7125                 :            :          This allows the checksum to remain the same whether the target type
    7126                 :            :          is complete or not.  */
    7127                 :        108 :       if ((at->dw_attr == DW_AT_type
    7128                 :        100 :            && (tag == DW_TAG_pointer_type
    7129                 :        100 :                || tag == DW_TAG_reference_type
    7130                 :        100 :                || tag == DW_TAG_rvalue_reference_type
    7131                 :         92 :                || tag == DW_TAG_ptr_to_member_type))
    7132                 :         96 :           || (at->dw_attr == DW_AT_friend
    7133                 :          0 :               && tag == DW_TAG_friend))
    7134                 :            :         {
    7135                 :         12 :           dw_attr_node *name_attr = get_AT (target_die, DW_AT_name);
    7136                 :            : 
    7137                 :         12 :           if (name_attr != NULL)
    7138                 :            :             {
    7139                 :          0 :               dw_die_ref decl = get_AT_ref (target_die, DW_AT_specification);
    7140                 :            : 
    7141                 :          0 :               if (decl == NULL)
    7142                 :          0 :                 decl = target_die;
    7143                 :          0 :               CHECKSUM_ULEB128 ('N');
    7144                 :          0 :               CHECKSUM_ULEB128 (at->dw_attr);
    7145                 :          0 :               if (decl->die_parent != NULL)
    7146                 :          0 :                 checksum_die_context (decl->die_parent, ctx);
    7147                 :          0 :               CHECKSUM_ULEB128 ('E');
    7148                 :          0 :               CHECKSUM_STRING (AT_string (name_attr));
    7149                 :          0 :               return;
    7150                 :            :             }
    7151                 :            :         }
    7152                 :            : 
    7153                 :            :       /* For all other references to another DIE, we check to see if the
    7154                 :            :          target DIE has already been visited.  If it has, we emit a
    7155                 :            :          backward reference; if not, we descend recursively.  */
    7156                 :        108 :       if (target_die->die_mark > 0)
    7157                 :            :         {
    7158                 :         22 :           CHECKSUM_ULEB128 ('R');
    7159                 :         22 :           CHECKSUM_ULEB128 (at->dw_attr);
    7160                 :         22 :           CHECKSUM_ULEB128 (target_die->die_mark);
    7161                 :            :         }
    7162                 :            :       else
    7163                 :            :         {
    7164                 :         86 :           dw_die_ref decl = get_AT_ref (target_die, DW_AT_specification);
    7165                 :            : 
    7166                 :         86 :           if (decl == NULL)
    7167                 :         83 :             decl = target_die;
    7168                 :         86 :           target_die->die_mark = ++(*mark);
    7169                 :         86 :           CHECKSUM_ULEB128 ('T');
    7170                 :         86 :           CHECKSUM_ULEB128 (at->dw_attr);
    7171                 :         86 :           if (decl->die_parent != NULL)
    7172                 :         86 :             checksum_die_context (decl->die_parent, ctx);
    7173                 :         86 :           die_checksum_ordered (target_die, ctx, mark);
    7174                 :            :         }
    7175                 :        108 :       return;
    7176                 :            :     }
    7177                 :            : 
    7178                 :        487 :   CHECKSUM_ULEB128 ('A');
    7179                 :        487 :   CHECKSUM_ULEB128 (at->dw_attr);
    7180                 :            : 
    7181                 :        487 :   switch (AT_class (at))
    7182                 :            :     {
    7183                 :          0 :     case dw_val_class_const:
    7184                 :          0 :     case dw_val_class_const_implicit:
    7185                 :          0 :       CHECKSUM_ULEB128 (DW_FORM_sdata);
    7186                 :          0 :       CHECKSUM_SLEB128 (at->dw_attr_val.v.val_int);
    7187                 :          0 :       break;
    7188                 :            : 
    7189                 :        270 :     case dw_val_class_unsigned_const:
    7190                 :        270 :     case dw_val_class_unsigned_const_implicit:
    7191                 :        270 :       CHECKSUM_ULEB128 (DW_FORM_sdata);
    7192                 :        270 :       CHECKSUM_SLEB128 ((int) at->dw_attr_val.v.val_unsigned);
    7193                 :        270 :       break;
    7194                 :            : 
    7195                 :          0 :     case dw_val_class_const_double:
    7196                 :          0 :       CHECKSUM_ULEB128 (DW_FORM_block);
    7197                 :          0 :       CHECKSUM_ULEB128 (sizeof (at->dw_attr_val.v.val_double));
    7198                 :          0 :       CHECKSUM (at->dw_attr_val.v.val_double);
    7199                 :          0 :       break;
    7200                 :            : 
    7201                 :          0 :     case dw_val_class_wide_int:
    7202                 :          0 :       CHECKSUM_ULEB128 (DW_FORM_block);
    7203                 :          0 :       CHECKSUM_ULEB128 (get_full_len (*at->dw_attr_val.v.val_wide)
    7204                 :            :                         * HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT);
    7205                 :          0 :       CHECKSUM_BLOCK (at->dw_attr_val.v.val_wide->get_val (),
    7206                 :            :                       get_full_len (*at->dw_attr_val.v.val_wide)
    7207                 :            :                       * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR);
    7208                 :          0 :       break;
    7209                 :            : 
    7210                 :          0 :     case dw_val_class_vec:
    7211                 :          0 :       CHECKSUM_ULEB128 (DW_FORM_block);
    7212                 :          0 :       CHECKSUM_ULEB128 (at->dw_attr_val.v.val_vec.length
    7213                 :            :                         * at->dw_attr_val.v.val_vec.elt_size);
    7214                 :          0 :       CHECKSUM_BLOCK (at->dw_attr_val.v.val_vec.array,
    7215                 :            :                       (at->dw_attr_val.v.val_vec.length
    7216                 :            :                        * at->dw_attr_val.v.val_vec.elt_size));
    7217                 :          0 :       break;
    7218                 :            : 
    7219                 :          4 :     case dw_val_class_flag:
    7220                 :          4 :       CHECKSUM_ULEB128 (DW_FORM_flag);
    7221                 :          4 :       CHECKSUM_ULEB128 (at->dw_attr_val.v.val_flag ? 1 : 0);
    7222                 :          4 :       break;
    7223                 :            : 
    7224                 :        213 :     case dw_val_class_str:
    7225                 :        213 :       CHECKSUM_ULEB128 (DW_FORM_string);
    7226                 :        213 :       CHECKSUM_STRING (AT_string (at));
    7227                 :        213 :       break;
    7228                 :            : 
    7229                 :          0 :     case dw_val_class_addr:
    7230                 :          0 :       r = AT_addr (at);
    7231                 :          0 :       gcc_assert (GET_CODE (r) == SYMBOL_REF);
    7232                 :          0 :       CHECKSUM_ULEB128 (DW_FORM_string);
    7233                 :          0 :       CHECKSUM_STRING (XSTR (r, 0));
    7234                 :          0 :       break;
    7235                 :            : 
    7236                 :          0 :     case dw_val_class_offset:
    7237                 :          0 :       CHECKSUM_ULEB128 (DW_FORM_sdata);
    7238                 :          0 :       CHECKSUM_ULEB128 (at->dw_attr_val.v.val_offset);
    7239                 :          0 :       break;
    7240                 :            : 
    7241                 :          0 :     case dw_val_class_loc:
    7242                 :          0 :       for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
    7243                 :          0 :         loc_checksum_ordered (loc, ctx);
    7244                 :            :       break;
    7245                 :            : 
    7246                 :            :     case dw_val_class_fde_ref:
    7247                 :            :     case dw_val_class_symview:
    7248                 :            :     case dw_val_class_lbl_id:
    7249                 :            :     case dw_val_class_lineptr:
    7250                 :            :     case dw_val_class_macptr:
    7251                 :            :     case dw_val_class_loclistsptr:
    7252                 :            :     case dw_val_class_high_pc:
    7253                 :            :       break;
    7254                 :            : 
    7255                 :          0 :     case dw_val_class_file:
    7256                 :          0 :     case dw_val_class_file_implicit:
    7257                 :          0 :       CHECKSUM_ULEB128 (DW_FORM_string);
    7258                 :          0 :       CHECKSUM_STRING (AT_file (at)->filename);
    7259                 :          0 :       break;
    7260                 :            : 
    7261                 :          0 :     case dw_val_class_data8:
    7262                 :          0 :       CHECKSUM (at->dw_attr_val.v.val_data8);
    7263                 :          0 :       break;
    7264                 :            : 
    7265                 :            :     default:
    7266                 :            :       break;
    7267                 :            :     }
    7268                 :            : }
    7269                 :            : 
    7270                 :            : struct checksum_attributes
    7271                 :            : {
    7272                 :            :   dw_attr_node *at_name;
    7273                 :            :   dw_attr_node *at_type;
    7274                 :            :   dw_attr_node *at_friend;
    7275                 :            :   dw_attr_node *at_accessibility;
    7276                 :            :   dw_attr_node *at_address_class;
    7277                 :            :   dw_attr_node *at_alignment;
    7278                 :            :   dw_attr_node *at_allocated;
    7279                 :            :   dw_attr_node *at_artificial;
    7280                 :            :   dw_attr_node *at_associated;
    7281                 :            :   dw_attr_node *at_binary_scale;
    7282                 :            :   dw_attr_node *at_bit_offset;
    7283                 :            :   dw_attr_node *at_bit_size;
    7284                 :            :   dw_attr_node *at_bit_stride;
    7285                 :            :   dw_attr_node *at_byte_size;
    7286                 :            :   dw_attr_node *at_byte_stride;
    7287                 :            :   dw_attr_node *at_const_value;
    7288                 :            :   dw_attr_node *at_containing_type;
    7289                 :            :   dw_attr_node *at_count;
    7290                 :            :   dw_attr_node *at_data_location;
    7291                 :            :   dw_attr_node *at_data_member_location;
    7292                 :            :   dw_attr_node *at_decimal_scale;
    7293                 :            :   dw_attr_node *at_decimal_sign;
    7294                 :            :   dw_attr_node *at_default_value;
    7295                 :            :   dw_attr_node *at_digit_count;
    7296                 :            :   dw_attr_node *at_discr;
    7297                 :            :   dw_attr_node *at_discr_list;
    7298                 :            :   dw_attr_node *at_discr_value;
    7299                 :            :   dw_attr_node *at_encoding;
    7300                 :            :   dw_attr_node *at_endianity;
    7301                 :            :   dw_attr_node *at_explicit;
    7302                 :            :   dw_attr_node *at_is_optional;
    7303                 :            :   dw_attr_node *at_location;
    7304                 :            :   dw_attr_node *at_lower_bound;
    7305                 :            :   dw_attr_node *at_mutable;
    7306                 :            :   dw_attr_node *at_ordering;
    7307                 :            :   dw_attr_node *at_picture_string;
    7308                 :            :   dw_attr_node *at_prototyped;
    7309                 :            :   dw_attr_node *at_small;
    7310                 :            :   dw_attr_node *at_segment;
    7311                 :            :   dw_attr_node *at_string_length;
    7312                 :            :   dw_attr_node *at_string_length_bit_size;
    7313                 :            :   dw_attr_node *at_string_length_byte_size;
    7314                 :            :   dw_attr_node *at_threads_scaled;
    7315                 :            :   dw_attr_node *at_upper_bound;
    7316                 :            :   dw_attr_node *at_use_location;
    7317                 :            :   dw_attr_node *at_use_UTF8;
    7318                 :            :   dw_attr_node *at_variable_parameter;
    7319                 :            :   dw_attr_node *at_virtuality;
    7320                 :            :   dw_attr_node *at_visibility;
    7321                 :            :   dw_attr_node *at_vtable_elem_location;
    7322                 :            : };
    7323                 :            : 
    7324                 :            : /* Collect the attributes that we will want to use for the checksum.  */
    7325                 :            : 
    7326                 :            : static void
    7327                 :        265 : collect_checksum_attributes (struct checksum_attributes *attrs, dw_die_ref die)
    7328                 :            : {
    7329                 :        265 :   dw_attr_node *a;
    7330                 :        265 :   unsigned ix;
    7331                 :            : 
    7332                 :       1264 :   FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
    7333                 :            :     {
    7334                 :        999 :       switch (a->dw_attr)
    7335                 :            :         {
    7336                 :        213 :         case DW_AT_name:
    7337                 :        213 :           attrs->at_name = a;
    7338                 :        213 :           break;
    7339                 :        100 :         case DW_AT_type:
    7340                 :        100 :           attrs->at_type = a;
    7341                 :        100 :           break;
    7342                 :          0 :         case DW_AT_friend:
    7343                 :          0 :           attrs->at_friend = a;
    7344                 :          0 :           break;
    7345                 :         15 :         case DW_AT_accessibility:
    7346                 :         15 :           attrs->at_accessibility = a;
    7347                 :         15 :           break;
    7348                 :          0 :         case DW_AT_address_class:
    7349                 :          0 :           attrs->at_address_class = a;
    7350                 :          0 :           break;
    7351                 :          0 :         case DW_AT_alignment:
    7352                 :          0 :           attrs->at_alignment = a;
    7353                 :          0 :           break;
    7354                 :          0 :         case DW_AT_allocated:
    7355                 :          0 :           attrs->at_allocated = a;
    7356                 :          0 :           break;
    7357                 :          4 :         case DW_AT_artificial:
    7358                 :          4 :           attrs->at_artificial = a;
    7359                 :          4 :           break;
    7360                 :          0 :         case DW_AT_associated:
    7361                 :          0 :           attrs->at_associated = a;
    7362                 :          0 :           break;
    7363                 :          0 :         case DW_AT_binary_scale:
    7364                 :          0 :           attrs->at_binary_scale = a;
    7365                 :          0 :           break;
    7366                 :          0 :         case DW_AT_bit_offset:
    7367                 :          0 :           attrs->at_bit_offset = a;
    7368                 :          0 :           break;
    7369                 :          0 :         case DW_AT_bit_size:
    7370                 :          0 :           attrs->at_bit_size = a;
    7371                 :          0 :           break;
    7372                 :          0 :         case DW_AT_bit_stride:
    7373                 :          0 :           attrs->at_bit_stride = a;
    7374                 :          0 :           break;
    7375                 :        145 :         case DW_AT_byte_size:
    7376                 :        145 :           attrs->at_byte_size = a;
    7377                 :        145 :           break;
    7378                 :          0 :         case DW_AT_byte_stride:
    7379                 :          0 :           attrs->at_byte_stride = a;
    7380                 :          0 :           break;
    7381                 :         27 :         case DW_AT_const_value:
    7382                 :         27 :           attrs->at_const_value = a;
    7383                 :         27 :           break;
    7384                 :          8 :         case DW_AT_containing_type:
    7385                 :          8 :           attrs->at_containing_type = a;
    7386                 :          8 :           break;
    7387                 :          0 :         case DW_AT_count:
    7388                 :          0 :           attrs->at_count = a;
    7389                 :          0 :           break;
    7390                 :          0 :         case DW_AT_data_location:
    7391                 :          0 :           attrs->at_data_location = a;
    7392                 :          0 :           break;
    7393                 :         27 :         case DW_AT_data_member_location:
    7394                 :         27 :           attrs->at_data_member_location = a;
    7395                 :         27 :           break;
    7396                 :          0 :         case DW_AT_decimal_scale:
    7397                 :          0 :           attrs->at_decimal_scale = a;
    7398                 :          0 :           break;
    7399                 :          0 :         case DW_AT_decimal_sign:
    7400                 :          0 :           attrs->at_decimal_sign = a;
    7401                 :          0 :           break;
    7402                 :          0 :         case DW_AT_default_value:
    7403                 :          0 :           attrs->at_default_value = a;
    7404                 :          0 :           break;
    7405                 :          0 :         case DW_AT_digit_count:
    7406                 :          0 :           attrs->at_digit_count = a;
    7407                 :          0 :           break;
    7408                 :          0 :         case DW_AT_discr:
    7409                 :          0 :           attrs->at_discr = a;
    7410                 :          0 :           break;
    7411                 :          0 :         case DW_AT_discr_list:
    7412                 :          0 :           attrs->at_discr_list = a;
    7413                 :          0 :           break;
    7414                 :          0 :         case DW_AT_discr_value:
    7415                 :          0 :           attrs->at_discr_value = a;
    7416                 :          0 :           break;
    7417                 :         52 :         case DW_AT_encoding:
    7418                 :         52 :           attrs->at_encoding = a;
    7419                 :         52 :           break;
    7420                 :          0 :         case DW_AT_endianity:
    7421                 :          0 :           attrs->at_endianity = a;
    7422                 :          0 :           break;
    7423                 :          0 :         case DW_AT_explicit:
    7424                 :          0 :           attrs->at_explicit = a;
    7425                 :          0 :           break;
    7426                 :          0 :         case DW_AT_is_optional:
    7427                 :          0 :           attrs->at_is_optional = a;
    7428                 :          0 :           break;
    7429                 :          0 :         case DW_AT_location:
    7430                 :          0 :           attrs->at_location = a;
    7431                 :          0 :           break;
    7432                 :          0 :         case DW_AT_lower_bound:
    7433                 :          0 :           attrs->at_lower_bound = a;
    7434                 :          0 :           break;
    7435                 :          0 :         case DW_AT_mutable:
    7436                 :          0 :           attrs->at_mutable = a;
    7437                 :          0 :           break;
    7438                 :          0 :         case DW_AT_ordering:
    7439                 :          0 :           attrs->at_ordering = a;
    7440                 :          0 :           break;
    7441                 :          0 :         case DW_AT_picture_string:
    7442                 :          0 :           attrs->at_picture_string = a;
    7443                 :          0 :           break;
    7444                 :          0 :         case DW_AT_prototyped:
    7445                 :          0 :           attrs->at_prototyped = a;
    7446                 :          0 :           break;
    7447                 :          0 :         case DW_AT_small:
    7448                 :          0 :           attrs->at_small = a;
    7449                 :          0 :           break;
    7450                 :          0 :         case DW_AT_segment:
    7451                 :          0 :           attrs->at_segment = a;
    7452                 :          0 :           break;
    7453                 :          0 :         case DW_AT_string_length:
    7454                 :          0 :           attrs->at_string_length = a;
    7455                 :          0 :           break;
    7456                 :          0 :         case DW_AT_string_length_bit_size:
    7457                 :          0 :           attrs->at_string_length_bit_size = a;
    7458                 :          0 :           break;
    7459                 :          0 :         case DW_AT_string_length_byte_size:
    7460                 :          0 :           attrs->at_string_length_byte_size = a;
    7461                 :          0 :           break;
    7462                 :          0 :         case DW_AT_threads_scaled:
    7463                 :          0 :           attrs->at_threads_scaled = a;
    7464                 :          0 :           break;
    7465                 :          4 :         case DW_AT_upper_bound:
    7466                 :          4 :           attrs->at_upper_bound = a;
    7467                 :          4 :           break;
    7468                 :          0 :         case DW_AT_use_location:
    7469                 :          0 :           attrs->at_use_location = a;
    7470                 :          0 :           break;
    7471                 :          0 :         case DW_AT_use_UTF8:
    7472                 :          0 :           attrs->at_use_UTF8 = a;
    7473                 :          0 :           break;
    7474                 :          0 :         case DW_AT_variable_parameter:
    7475                 :          0 :           attrs->at_variable_parameter = a;
    7476                 :          0 :           break;
    7477                 :          0 :         case DW_AT_virtuality:
    7478                 :          0 :           attrs->at_virtuality = a;
    7479                 :          0 :           break;
    7480                 :          0 :         case DW_AT_visibility:
    7481                 :          0 :           attrs->at_visibility = a;
    7482                 :          0 :           break;
    7483                 :          0 :         case DW_AT_vtable_elem_location:
    7484                 :          0 :           attrs->at_vtable_elem_location = a;
    7485                 :          0 :           break;
    7486                 :            :         default:
    7487                 :            :           break;
    7488                 :            :         }
    7489                 :            :     }
    7490                 :        265 : }
    7491                 :            : 
    7492                 :            : /* Calculate the checksum of a DIE, using an ordered subset of attributes.  */
    7493                 :            : 
    7494                 :            : static void
    7495                 :        262 : die_checksum_ordered (dw_die_ref die, struct md5_ctx *ctx, int *mark)
    7496                 :            : {
    7497                 :        262 :   dw_die_ref c;
    7498                 :        262 :   dw_die_ref decl;
    7499                 :        262 :   struct checksum_attributes attrs;
    7500                 :            : 
    7501                 :        262 :   CHECKSUM_ULEB128 ('D');
    7502                 :        262 :   CHECKSUM_ULEB128 (die->die_tag);
    7503                 :            : 
    7504                 :        262 :   memset (&attrs, 0, sizeof (attrs));
    7505                 :            : 
    7506                 :        262 :   decl = get_AT_ref (die, DW_AT_specification);
    7507                 :        262 :   if (decl != NULL)
    7508                 :          3 :     collect_checksum_attributes (&attrs, decl);
    7509                 :        262 :   collect_checksum_attributes (&attrs, die);
    7510                 :            : 
    7511                 :        262 :   CHECKSUM_ATTR (attrs.at_name);
    7512                 :        262 :   CHECKSUM_ATTR (attrs.at_accessibility);
    7513                 :        262 :   CHECKSUM_ATTR (attrs.at_address_class);
    7514                 :        262 :   CHECKSUM_ATTR (attrs.at_allocated);
    7515                 :        262 :   CHECKSUM_ATTR (attrs.at_artificial);
    7516                 :        262 :   CHECKSUM_ATTR (attrs.at_associated);
    7517                 :        262 :   CHECKSUM_ATTR (attrs.at_binary_scale);
    7518                 :        262 :   CHECKSUM_ATTR (attrs.at_bit_offset);
    7519                 :        262 :   CHECKSUM_ATTR (attrs.at_bit_size);
    7520                 :        262 :   CHECKSUM_ATTR (attrs.at_bit_stride);
    7521                 :        262 :   CHECKSUM_ATTR (attrs.at_byte_size);
    7522                 :        262 :   CHECKSUM_ATTR (attrs.at_byte_stride);
    7523                 :        262 :   CHECKSUM_ATTR (attrs.at_const_value);
    7524                 :        262 :   CHECKSUM_ATTR (attrs.at_containing_type);
    7525                 :        262 :   CHECKSUM_ATTR (attrs.at_count);
    7526                 :        262 :   CHECKSUM_ATTR (attrs.at_data_location);
    7527                 :        262 :   CHECKSUM_ATTR (attrs.at_data_member_location);
    7528                 :        262 :   CHECKSUM_ATTR (attrs.at_decimal_scale);
    7529                 :        262 :   CHECKSUM_ATTR (attrs.at_decimal_sign);
    7530                 :        262 :   CHECKSUM_ATTR (attrs.at_default_value);
    7531                 :        262 :   CHECKSUM_ATTR (attrs.at_digit_count);
    7532                 :        262 :   CHECKSUM_ATTR (attrs.at_discr);
    7533                 :        262 :   CHECKSUM_ATTR (attrs.at_discr_list);
    7534                 :        262 :   CHECKSUM_ATTR (attrs.at_discr_value);
    7535                 :        262 :   CHECKSUM_ATTR (attrs.at_encoding);
    7536                 :        262 :   CHECKSUM_ATTR (attrs.at_endianity);
    7537                 :        262 :   CHECKSUM_ATTR (attrs.at_explicit);
    7538                 :        262 :   CHECKSUM_ATTR (attrs.at_is_optional);
    7539                 :        262 :   CHECKSUM_ATTR (attrs.at_location);
    7540                 :        262 :   CHECKSUM_ATTR (attrs.at_lower_bound);
    7541                 :        262 :   CHECKSUM_ATTR (attrs.at_mutable);
    7542                 :        262 :   CHECKSUM_ATTR (attrs.at_ordering);
    7543                 :        262 :   CHECKSUM_ATTR (attrs.at_picture_string);
    7544                 :        262 :   CHECKSUM_ATTR (attrs.at_prototyped);
    7545                 :        262 :   CHECKSUM_ATTR (attrs.at_small);
    7546                 :        262 :   CHECKSUM_ATTR (attrs.at_segment);
    7547                 :        262 :   CHECKSUM_ATTR (attrs.at_string_length);
    7548                 :        262 :   CHECKSUM_ATTR (attrs.at_string_length_bit_size);
    7549                 :        262 :   CHECKSUM_ATTR (attrs.at_string_length_byte_size);
    7550                 :        262 :   CHECKSUM_ATTR (attrs.at_threads_scaled);
    7551                 :        262 :   CHECKSUM_ATTR (attrs.at_upper_bound);
    7552                 :        262 :   CHECKSUM_ATTR (attrs.at_use_location);
    7553                 :        262 :   CHECKSUM_ATTR (attrs.at_use_UTF8);
    7554                 :        262 :   CHECKSUM_ATTR (attrs.at_variable_parameter);
    7555                 :        262 :   CHECKSUM_ATTR (attrs.at_virtuality);
    7556                 :        262 :   CHECKSUM_ATTR (attrs.at_visibility);
    7557                 :        262 :   CHECKSUM_ATTR (attrs.at_vtable_elem_location);
    7558                 :        262 :   CHECKSUM_ATTR (attrs.at_type);
    7559                 :        262 :   CHECKSUM_ATTR (attrs.at_friend);
    7560                 :        262 :   CHECKSUM_ATTR (attrs.at_alignment);
    7561                 :            : 
    7562                 :            :   /* Checksum the child DIEs.  */
    7563                 :        262 :   c = die->die_child;
    7564                 :        262 :   if (c) do {
    7565                 :        218 :     dw_attr_node *name_attr;
    7566                 :            : 
    7567                 :        218 :     c = c->die_sib;
    7568                 :        218 :     name_attr = get_AT (c, DW_AT_name);
    7569                 :        218 :     if (is_template_instantiation (c))
    7570                 :            :       {
    7571                 :            :         /* Ignore instantiations of member type and function templates.  */
    7572                 :            :       }
    7573                 :        213 :     else if (name_attr != NULL
    7574                 :        213 :              && (is_type_die (c) || c->die_tag == DW_TAG_subprogram))
    7575                 :            :       {
    7576                 :            :         /* Use a shallow checksum for named nested types and member
    7577                 :            :            functions.  */
    7578                 :        120 :         CHECKSUM_ULEB128 ('S');
    7579                 :        120 :         CHECKSUM_ULEB128 (c->die_tag);
    7580                 :        120 :         CHECKSUM_STRING (AT_string (name_attr));
    7581                 :            :       }
    7582                 :            :     else
    7583                 :            :       {
    7584                 :            :         /* Use a deep checksum for other children.  */
    7585                 :            :         /* Mark this DIE so it gets processed when unmarking.  */
    7586                 :         93 :         if (c->die_mark == 0)
    7587                 :         93 :           c->die_mark = -1;
    7588                 :         93 :         die_checksum_ordered (c, ctx, mark);
    7589                 :            :       }
    7590                 :        218 :   } while (c != die->die_child);
    7591                 :            : 
    7592                 :        262 :   CHECKSUM_ULEB128 (0);
    7593                 :        262 : }
    7594                 :            : 
    7595                 :            : /* Add a type name and tag to a hash.  */
    7596                 :            : static void
    7597                 :         80 : die_odr_checksum (int tag, const char *name, md5_ctx *ctx)
    7598                 :            : {
    7599                 :         80 :   CHECKSUM_ULEB128 (tag);
    7600                 :         80 :   CHECKSUM_STRING (name);
    7601                 :         80 : }
    7602                 :            : 
    7603                 :            : #undef CHECKSUM
    7604                 :            : #undef CHECKSUM_STRING
    7605                 :            : #undef CHECKSUM_ATTR
    7606                 :            : #undef CHECKSUM_LEB128
    7607                 :            : #undef CHECKSUM_ULEB128
    7608                 :            : 
    7609                 :            : /* Generate the type signature for DIE.  This is computed by generating an
    7610                 :            :    MD5 checksum over the DIE's tag, its relevant attributes, and its
    7611                 :            :    children.  Attributes that are references to other DIEs are processed
    7612                 :            :    by recursion, using the MARK field to prevent infinite recursion.
    7613                 :            :    If the DIE is nested inside a namespace or another type, we also
    7614                 :            :    need to include that context in the signature.  The lower 64 bits
    7615                 :            :    of the resulting MD5 checksum comprise the signature.  */
    7616                 :            : 
    7617                 :            : static void
    7618                 :         83 : generate_type_signature (dw_die_ref die, comdat_type_node *type_node)
    7619                 :            : {
    7620                 :         83 :   int mark;
    7621                 :         83 :   const char *name;
    7622                 :         83 :   unsigned char checksum[16];
    7623                 :         83 :   struct md5_ctx ctx;
    7624                 :         83 :   dw_die_ref decl;
    7625                 :         83 :   dw_die_ref parent;
    7626                 :            : 
    7627                 :         83 :   name = get_AT_string (die, DW_AT_name);
    7628                 :         83 :   decl = get_AT_ref (die, DW_AT_specification);
    7629                 :         83 :   parent = get_die_parent (die);
    7630                 :            : 
    7631                 :            :   /* First, compute a signature for just the type name (and its surrounding
    7632                 :            :      context, if any.  This is stored in the type unit DIE for link-time
    7633                 :            :      ODR (one-definition rule) checking.  */
    7634                 :            : 
    7635                 :         83 :   if (is_cxx () && name != NULL)
    7636                 :            :     {
    7637                 :         80 :       md5_init_ctx (&ctx);
    7638                 :            : 
    7639                 :            :       /* Checksum the names of surrounding namespaces and structures.  */
    7640                 :         80 :       if (parent != NULL)
    7641                 :         80 :         checksum_die_context (parent, &ctx);
    7642                 :            : 
    7643                 :            :       /* Checksum the current DIE. */
    7644                 :         80 :       die_odr_checksum (die->die_tag, name, &ctx);
    7645                 :         80 :       md5_finish_ctx (&ctx, checksum);
    7646                 :            : 
    7647                 :         80 :       add_AT_data8 (type_node->root_die, DW_AT_GNU_odr_signature, &checksum[8]);
    7648                 :            :     }
    7649                 :            : 
    7650                 :            :   /* Next, compute the complete type signature.  */
    7651                 :            : 
    7652                 :         83 :   md5_init_ctx (&ctx);
    7653                 :         83 :   mark = 1;
    7654                 :         83 :   die->die_mark = mark;
    7655                 :            : 
    7656                 :            :   /* Checksum the names of surrounding namespaces and structures.  */
    7657                 :         83 :   if (parent != NULL)
    7658                 :         83 :     checksum_die_context (parent, &ctx);
    7659                 :            : 
    7660                 :            :   /* Checksum the DIE and its children.  */
    7661                 :         83 :   die_checksum_ordered (die, &ctx, &mark);
    7662                 :         83 :   unmark_all_dies (die);
    7663                 :         83 :   md5_finish_ctx (&ctx, checksum);
    7664                 :            : 
    7665                 :            :   /* Store the signature in the type node and link the type DIE and the
    7666                 :            :      type node together.  */
    7667                 :         83 :   memcpy (type_node->signature, &checksum[16 - DWARF_TYPE_SIGNATURE_SIZE],
    7668                 :            :           DWARF_TYPE_SIGNATURE_SIZE);
    7669                 :         83 :   die->comdat_type_p = true;
    7670                 :         83 :   die->die_id.die_type_node = type_node;
    7671                 :         83 :   type_node->type_die = die;
    7672                 :            : 
    7673                 :            :   /* If the DIE is a specification, link its declaration to the type node
    7674                 :            :      as well.  */
    7675                 :         83 :   if (decl != NULL)
    7676                 :            :     {
    7677                 :          0 :       decl->comdat_type_p = true;
    7678                 :          0 :       decl->die_id.die_type_node = type_node;
    7679                 :            :     }
    7680                 :         83 : }
    7681                 :            : 
    7682                 :            : /* Do the location expressions look same?  */
    7683                 :            : static inline int
    7684                 :          0 : same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
    7685                 :            : {
    7686                 :          0 :   return loc1->dw_loc_opc == loc2->dw_loc_opc
    7687                 :          0 :          && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
    7688                 :          0 :          && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
    7689                 :            : }
    7690                 :            : 
    7691                 :            : /* Do the values look the same?  */
    7692                 :            : static int
    7693                 :          0 : same_dw_val_p (const dw_val_node *v1, const dw_val_node *v2, int *mark)
    7694                 :            : {
    7695                 :          0 :   dw_loc_descr_ref loc1, loc2;
    7696                 :          0 :   rtx r1, r2;
    7697                 :            : 
    7698                 :          0 :   if (v1->val_class != v2->val_class)
    7699                 :            :     return 0;
    7700                 :            : 
    7701                 :          0 :   switch (v1->val_class)
    7702                 :            :     {
    7703                 :          0 :     case dw_val_class_const:
    7704                 :          0 :     case dw_val_class_const_implicit:
    7705                 :          0 :       return v1->v.val_int == v2->v.val_int;
    7706                 :          0 :     case dw_val_class_unsigned_const:
    7707                 :          0 :     case dw_val_class_unsigned_const_implicit:
    7708                 :          0 :       return v1->v.val_unsigned == v2->v.val_unsigned;
    7709                 :          0 :     case dw_val_class_const_double:
    7710                 :          0 :       return v1->v.val_double.high == v2->v.val_double.high
    7711                 :          0 :              && v1->v.val_double.low == v2->v.val_double.low;
    7712                 :          0 :     case dw_val_class_wide_int:
    7713                 :          0 :       return *v1->v.val_wide == *v2->v.val_wide;
    7714                 :          0 :     case dw_val_class_vec:
    7715                 :          0 :       if (v1->v.val_vec.length != v2->v.val_vec.length
    7716                 :          0 :           || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size)
    7717                 :            :         return 0;
    7718                 :          0 :       if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array,
    7719                 :          0 :                   v1->v.val_vec.length * v1->v.val_vec.elt_size))
    7720                 :          0 :         return 0;
    7721                 :            :       return 1;
    7722                 :          0 :     case dw_val_class_flag:
    7723                 :          0 :       return v1->v.val_flag == v2->v.val_flag;
    7724                 :          0 :     case dw_val_class_str:
    7725                 :          0 :       return !strcmp (v1->v.val_str->str, v2->v.val_str->str);
    7726                 :            : 
    7727                 :          0 :     case dw_val_class_addr:
    7728                 :          0 :       r1 = v1->v.val_addr;
    7729                 :          0 :       r2 = v2->v.val_addr;
    7730                 :          0 :       if (GET_CODE (r1) != GET_CODE (r2))
    7731                 :            :         return 0;
    7732                 :          0 :       return !rtx_equal_p (r1, r2);
    7733                 :            : 
    7734                 :          0 :     case dw_val_class_offset:
    7735                 :          0 :       return v1->v.val_offset == v2->v.val_offset;
    7736                 :            : 
    7737                 :          0 :     case dw_val_class_loc:
    7738                 :          0 :       for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
    7739                 :          0 :            loc1 && loc2;
    7740                 :          0 :            loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
    7741                 :          0 :         if (!same_loc_p (loc1, loc2, mark))
    7742                 :            :           return 0;
    7743                 :          0 :       return !loc1 && !loc2;
    7744                 :            : 
    7745                 :          0 :     case dw_val_class_die_ref:
    7746                 :          0 :       return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
    7747                 :            : 
    7748                 :          0 :     case dw_val_class_symview:
    7749                 :          0 :       return strcmp (v1->v.val_symbolic_view, v2->v.val_symbolic_view) == 0;
    7750                 :            : 
    7751                 :            :     case dw_val_class_fde_ref:
    7752                 :            :     case dw_val_class_vms_delta:
    7753                 :            :     case dw_val_class_lbl_id:
    7754                 :            :     case dw_val_class_lineptr:
    7755                 :            :     case dw_val_class_macptr:
    7756                 :            :     case dw_val_class_loclistsptr:
    7757                 :            :     case dw_val_class_high_pc:
    7758                 :            :       return 1;
    7759                 :            : 
    7760                 :          0 :     case dw_val_class_file:
    7761                 :          0 :     case dw_val_class_file_implicit:
    7762                 :          0 :       return v1->v.val_file == v2->v.val_file;
    7763                 :            : 
    7764                 :          0 :     case dw_val_class_data8:
    7765                 :          0 :       return !memcmp (v1->v.val_data8, v2->v.val_data8, 8);
    7766                 :            : 
    7767                 :            :     default:
    7768                 :            :       return 1;
    7769                 :            :     }
    7770                 :            : }
    7771                 :            : 
    7772                 :            : /* Do the attributes look the same?  */
    7773                 :            : 
    7774                 :            : static int
    7775                 :          0 : same_attr_p (dw_attr_node *at1, dw_attr_node *at2, int *mark)
    7776                 :            : {
    7777                 :          0 :   if (at1->dw_attr != at2->dw_attr)
    7778                 :            :     return 0;
    7779                 :            : 
    7780                 :            :   /* We don't care that this was compiled with a different compiler
    7781                 :            :      snapshot; if the output is the same, that's what matters. */
    7782                 :          0 :   if (at1->dw_attr == DW_AT_producer)
    7783                 :            :     return 1;
    7784                 :            : 
    7785                 :          0 :   return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
    7786                 :            : }
    7787                 :            : 
    7788                 :            : /* Do the dies look the same?  */
    7789                 :            : 
    7790                 :            : static int
    7791                 :          0 : same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
    7792                 :            : {
    7793                 :          0 :   dw_die_ref c1, c2;
    7794                 :          0 :   dw_attr_node *a1;
    7795                 :          0 :   unsigned ix;
    7796                 :            : 
    7797                 :            :   /* To avoid infinite recursion.  */
    7798                 :          0 :   if (die1->die_mark)
    7799                 :          0 :     return die1->die_mark == die2->die_mark;
    7800                 :          0 :   die1->die_mark = die2->die_mark = ++(*mark);
    7801                 :            : 
    7802                 :          0 :   if (die1->die_tag != die2->die_tag)
    7803                 :            :     return 0;
    7804                 :            : 
    7805                 :          0 :   if (vec_safe_length (die1->die_attr) != vec_safe_length (die2->die_attr))
    7806                 :            :     return 0;
    7807                 :            : 
    7808                 :          0 :   FOR_EACH_VEC_SAFE_ELT (die1->die_attr, ix, a1)
    7809                 :          0 :     if (!same_attr_p (a1, &(*die2->die_attr)[ix], mark))
    7810                 :          0 :       return 0;
    7811                 :            : 
    7812                 :          0 :   c1 = die1->die_child;
    7813                 :          0 :   c2 = die2->die_child;
    7814                 :          0 :   if (! c1)
    7815                 :            :     {
    7816                 :          0 :       if (c2)
    7817                 :          0 :         return 0;
    7818                 :            :     }
    7819                 :            :   else
    7820                 :          0 :     for (;;)
    7821                 :            :       {
    7822                 :          0 :         if (!same_die_p (c1, c2, mark))
    7823                 :            :           return 0;
    7824                 :          0 :         c1 = c1->die_sib;
    7825                 :          0 :         c2 = c2->die_sib;
    7826                 :          0 :         if (c1 == die1->die_child)
    7827                 :            :           {
    7828                 :          0 :             if (c2 == die2->die_child)
    7829                 :            :               break;
    7830                 :            :             else
    7831                 :          0 :               return 0;
    7832                 :            :           }
    7833                 :            :     }
    7834                 :            : 
    7835                 :            :   return 1;
    7836                 :            : }
    7837                 :            : 
    7838                 :            : /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
    7839                 :            :    children, and set die_symbol.  */
    7840                 :            : 
    7841                 :            : static void
    7842                 :        904 : compute_comp_unit_symbol (dw_die_ref unit_die)
    7843                 :            : {
    7844                 :        904 :   const char *die_name = get_AT_string (unit_die, DW_AT_name);
    7845                 :        904 :   const char *base = die_name ? lbasename (die_name) : "anonymous";
    7846                 :        904 :   char *name = XALLOCAVEC (char, strlen (base) + 64);
    7847                 :        904 :   char *p;
    7848                 :        904 :   int i, mark;
    7849                 :        904 :   unsigned char checksum[16];
    7850                 :        904 :   struct md5_ctx ctx;
    7851                 :            : 
    7852                 :            :   /* Compute the checksum of the DIE, then append part of it as hex digits to
    7853                 :            :      the name filename of the unit.  */
    7854                 :            : 
    7855                 :        904 :   md5_init_ctx (&ctx);
    7856                 :        904 :   mark = 0;
    7857                 :        904 :   die_checksum (unit_die, &ctx, &mark);
    7858                 :        904 :   unmark_all_dies (unit_die);
    7859                 :        904 :   md5_finish_ctx (&ctx, checksum);
    7860                 :            : 
    7861                 :            :   /* When we this for comp_unit_die () we have a DW_AT_name that might
    7862                 :            :      not start with a letter but with anything valid for filenames and
    7863                 :            :      clean_symbol_name doesn't fix that up.  Prepend 'g' if the first
    7864                 :            :      character is not a letter.  */
    7865                 :        904 :   sprintf (name, "%s%s.", ISALPHA (*base) ? "" : "g", base);
    7866                 :        904 :   clean_symbol_name (name);
    7867                 :            : 
    7868                 :        904 :   p = name + strlen (name);
    7869                 :       4520 :   for (i = 0; i < 4; i++)
    7870                 :            :     {
    7871                 :       3616 :       sprintf (p, "%.2x", checksum[i]);
    7872                 :       3616 :       p += 2;
    7873                 :            :     }
    7874                 :            : 
    7875                 :        904 :   unit_die->die_id.die_symbol = xstrdup (name);
    7876                 :        904 : }
    7877                 :            : 
    7878                 :            : /* Returns nonzero if DIE represents a type, in the sense of TYPE_P.  */
    7879                 :            : 
    7880                 :            : static int
    7881                 :   45542600 : is_type_die (dw_die_ref die)
    7882                 :            : {
    7883                 :   45542600 :   switch (die->die_tag)
    7884                 :            :     {
    7885                 :            :     case DW_TAG_array_type:
    7886                 :            :     case DW_TAG_class_type:
    7887                 :            :     case DW_TAG_interface_type:
    7888                 :            :     case DW_TAG_enumeration_type:
    7889                 :            :     case DW_TAG_pointer_type:
    7890                 :            :     case DW_TAG_reference_type:
    7891                 :            :     case DW_TAG_rvalue_reference_type:
    7892                 :            :     case DW_TAG_string_type:
    7893                 :            :     case DW_TAG_structure_type:
    7894                 :            :     case DW_TAG_subroutine_type:
    7895                 :            :     case DW_TAG_union_type:
    7896                 :            :     case DW_TAG_ptr_to_member_type:
    7897                 :            :     case DW_TAG_set_type:
    7898                 :            :     case DW_TAG_subrange_type:
    7899                 :            :     case DW_TAG_base_type:
    7900                 :            :     case DW_TAG_const_type:
    7901                 :            :     case DW_TAG_file_type:
    7902                 :            :     case DW_TAG_packed_type:
    7903                 :            :     case DW_TAG_volatile_type:
    7904                 :            :     case DW_TAG_typedef:
    7905                 :            :       return 1;
    7906                 :   40347700 :     default:
    7907                 :   40347700 :       return 0;
    7908                 :            :     }
    7909                 :            : }
    7910                 :            : 
    7911                 :            : /* Returns true iff C is a compile-unit DIE.  */
    7912                 :            : 
    7913                 :            : static inline bool
    7914                 :   10976100 : is_cu_die (dw_die_ref c)
    7915                 :            : {
    7916                 :   10936000 :   return c && (c->die_tag == DW_TAG_compile_unit
    7917                 :   10936200 :                || c->die_tag == DW_TAG_skeleton_unit);
    7918                 :            : }
    7919                 :            : 
    7920                 :            : /* Returns true iff C is a unit DIE of some sort.  */
    79