LCOV - code coverage report
Current view: top level - gcc - dwarf2ctf.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 90.4 % 415 375
Test Date: 2024-12-14 13:15:07 Functions: 87.5 % 24 21
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: - 0 0

             Branch data     Line data    Source code
       1                 :             : /* Generate CTF types and objects from the GCC DWARF.
       2                 :             :    Copyright (C) 2021-2024 Free Software Foundation, Inc.
       3                 :             : 
       4                 :             : This file is part of GCC.
       5                 :             : 
       6                 :             : GCC is free software; you can redistribute it and/or modify it under
       7                 :             : the terms of the GNU General Public License as published by the Free
       8                 :             : Software Foundation; either version 3, or (at your option) any later
       9                 :             : version.
      10                 :             : 
      11                 :             : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      12                 :             : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13                 :             : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14                 :             : for more details.
      15                 :             : 
      16                 :             : You should have received a copy of the GNU General Public License
      17                 :             : along with GCC; see the file COPYING3.  If not see
      18                 :             : <http://www.gnu.org/licenses/>.  */
      19                 :             : 
      20                 :             : #include "config.h"
      21                 :             : #include "system.h"
      22                 :             : #include "coretypes.h"
      23                 :             : #include "target.h"
      24                 :             : #include "dwarf2out.h"
      25                 :             : #include "dwarf2out.h"
      26                 :             : 
      27                 :             : #include "dwarf2ctf.h"
      28                 :             : #include "ctfc.h"
      29                 :             : 
      30                 :             : /* Forward declarations for some routines defined in this file.  */
      31                 :             : 
      32                 :             : static ctf_dtdef_ref
      33                 :             : gen_ctf_type (ctf_container_ref, dw_die_ref);
      34                 :             : 
      35                 :             : /* All the DIE structures we handle come from the DWARF information
      36                 :             :    generated by GCC.  However, there are three situations where we need
      37                 :             :    to create our own created DIE structures because GCC doesn't
      38                 :             :    provide them.
      39                 :             : 
      40                 :             :    The DWARF spec suggests using a DIE with DW_TAG_unspecified_type
      41                 :             :    and name "void" in order to denote the void type.  But GCC doesn't
      42                 :             :    follow this advice.  Still we need a DIE to act as a key for void
      43                 :             :    types, we use ctf_void_die.
      44                 :             : 
      45                 :             :    Also, if a subrange type corresponding to an array index does not
      46                 :             :    specify a type then we assume it is `int'.
      47                 :             : 
      48                 :             :    Finally, for types unrepresentable in CTF, we need a DIE to anchor
      49                 :             :    them to a CTF type of kind unknown.
      50                 :             : 
      51                 :             :    The variables below are initialized in ctf_debug_init and hold
      52                 :             :    references to the proper DIEs.  */
      53                 :             : 
      54                 :             : static GTY (()) dw_die_ref ctf_void_die;
      55                 :             : static GTY (()) dw_die_ref ctf_array_index_die;
      56                 :             : static GTY (()) dw_die_ref ctf_unknown_die;
      57                 :             : 
      58                 :             : /* Some DIEs have a type description attribute, stored in a DW_AT_type
      59                 :             :    attribute.  However, GCC generates no attribute to signify a `void'
      60                 :             :    type.
      61                 :             : 
      62                 :             :    This can happen in many contexts (return type of a function,
      63                 :             :    pointed or qualified type, etc) so we use the `ctf_get_AT_type'
      64                 :             :    function below abstracts this.  */
      65                 :             : 
      66                 :             : static dw_die_ref
      67                 :        1453 : ctf_get_AT_type (dw_die_ref die)
      68                 :             : {
      69                 :        1453 :   dw_die_ref type_die = get_AT_ref (die, DW_AT_type);
      70                 :        1453 :   return (type_die ? type_die : ctf_void_die);
      71                 :             : }
      72                 :             : 
      73                 :             : /* Some data member DIEs have location specified as a DWARF expression
      74                 :             :    (specifically in DWARF2).  Luckily, the expression is a simple
      75                 :             :    DW_OP_plus_uconst with one operand set to zero.
      76                 :             : 
      77                 :             :    Sometimes the data member location may also be negative.  In yet some other
      78                 :             :    cases (specifically union data members), the data member location is
      79                 :             :    non-existent.  Handle all these scenarios here to abstract this.  */
      80                 :             : 
      81                 :             : static HOST_WIDE_INT
      82                 :         221 : ctf_get_AT_data_member_location (dw_die_ref die)
      83                 :             : {
      84                 :         221 :   HOST_WIDE_INT field_location = 0;
      85                 :         221 :   dw_attr_node * attr;
      86                 :             : 
      87                 :             :   /* The field location (in bits) can be determined from
      88                 :             :      either a DW_AT_data_member_location attribute or a
      89                 :             :      DW_AT_data_bit_offset attribute.  */
      90                 :         221 :   if (get_AT (die, DW_AT_data_bit_offset))
      91                 :          23 :     field_location = get_AT_unsigned (die, DW_AT_data_bit_offset);
      92                 :             :   else
      93                 :             :     {
      94                 :         198 :       attr = get_AT (die, DW_AT_data_member_location);
      95                 :         198 :       if (attr && AT_class (attr) == dw_val_class_loc)
      96                 :             :         {
      97                 :           2 :           dw_loc_descr_ref descr = AT_loc (attr);
      98                 :             :           /* Operand 2 must be zero; the structure is assumed to be on the
      99                 :             :              stack in DWARF2.  */
     100                 :           2 :           gcc_assert (!descr->dw_loc_oprnd2.v.val_unsigned);
     101                 :           2 :           gcc_assert (descr->dw_loc_oprnd2.val_class
     102                 :             :                       == dw_val_class_unsigned_const);
     103                 :           2 :           field_location = descr->dw_loc_oprnd1.v.val_unsigned * 8;
     104                 :             :         }
     105                 :             :       else
     106                 :             :         {
     107                 :         196 :           attr = get_AT (die, DW_AT_data_member_location);
     108                 :         196 :           if (attr && AT_class (attr) == dw_val_class_const)
     109                 :           0 :             field_location = AT_int (attr) * 8;
     110                 :             :           else
     111                 :         196 :             field_location = (get_AT_unsigned (die,
     112                 :             :                                            DW_AT_data_member_location)
     113                 :         196 :                               * 8);
     114                 :             :         }
     115                 :             :     }
     116                 :             : 
     117                 :         221 :   return field_location;
     118                 :             : }
     119                 :             : 
     120                 :             : /* CTF Types' and CTF Variables' Location Information.  CTF section does not
     121                 :             :    emit location information, this is provided for BTF CO-RE use-cases.  These
     122                 :             :    functions fetch information from DWARF Die directly, as such the location
     123                 :             :    information is not buffered in the CTF container.  */
     124                 :             : 
     125                 :             : const char *
     126                 :           0 : ctf_get_die_loc_file (dw_die_ref die)
     127                 :             : {
     128                 :           0 :   if (!die)
     129                 :             :     return NULL;
     130                 :             : 
     131                 :           0 :   struct dwarf_file_data * file;
     132                 :           0 :   file = get_AT_file (die, DW_AT_decl_file);
     133                 :           0 :   if (!file)
     134                 :             :     return NULL;
     135                 :             : 
     136                 :           0 :   return file->filename;
     137                 :             : }
     138                 :             : 
     139                 :             : unsigned int
     140                 :           0 : ctf_get_die_loc_line (dw_die_ref die)
     141                 :             : {
     142                 :           0 :   if (!die)
     143                 :             :     return 0;
     144                 :             : 
     145                 :           0 :   return get_AT_unsigned (die, DW_AT_decl_line);
     146                 :             : }
     147                 :             : 
     148                 :             : unsigned int
     149                 :           0 : ctf_get_die_loc_col (dw_die_ref die)
     150                 :             : {
     151                 :           0 :   if (!die)
     152                 :             :     return 0;
     153                 :             : 
     154                 :           0 :   return get_AT_unsigned (die, DW_AT_decl_column);
     155                 :             : }
     156                 :             : 
     157                 :             : /* Generate CTF for the void type.  */
     158                 :             : 
     159                 :             : static ctf_dtdef_ref
     160                 :          75 : gen_ctf_void_type (ctf_container_ref ctfc)
     161                 :             : {
     162                 :          75 :   ctf_encoding_t ctf_encoding = {0, 0, 0};
     163                 :             : 
     164                 :             :   /* In CTF the void type is encoded as a 0-byte signed integer
     165                 :             :      type.  */
     166                 :             : 
     167                 :          75 :   ctf_encoding.cte_bits = 0;
     168                 :          75 :   ctf_encoding.cte_format = CTF_INT_SIGNED;
     169                 :             : 
     170                 :          75 :   gcc_assert (ctf_void_die != NULL);
     171                 :          75 :   return ctf_add_integer (ctfc, CTF_ADD_ROOT, "void",
     172                 :          75 :                           &ctf_encoding, ctf_void_die);
     173                 :             : }
     174                 :             : 
     175                 :             : /* Generate CTF type of unknown kind.  */
     176                 :             : 
     177                 :             : static ctf_dtdef_ref
     178                 :          43 : gen_ctf_unknown_type (ctf_container_ref ctfc)
     179                 :             : {
     180                 :          43 :   ctf_dtdef_ref dtd;
     181                 :             : 
     182                 :             :   /* In CTF, the unknown type is encoded as a 0 byte sized type with kind
     183                 :             :      CTF_K_UNKNOWN.  Create an encoding object merely to reuse the underlying
     184                 :             :      ctf_add_encoded interface; the CTF encoding object is not 'used' any more
     185                 :             :      than just the generation of size from.  */
     186                 :          43 :   ctf_encoding_t ctf_encoding = {0, 0, 0};
     187                 :             : 
     188                 :          43 :   gcc_assert (ctf_unknown_die != NULL);
     189                 :             :   /* Type de-duplication.  */
     190                 :          43 :   if (!ctf_type_exists (ctfc, ctf_unknown_die, &dtd))
     191                 :          10 :     dtd = ctf_add_unknown (ctfc, CTF_ADD_ROOT, "unknown",
     192                 :             :                            &ctf_encoding, ctf_unknown_die);
     193                 :             : 
     194                 :          43 :   return dtd;
     195                 :             : }
     196                 :             : 
     197                 :             : /* Sizes of entities can be given in bytes or bits.  This function
     198                 :             :    abstracts this by returning the size in bits of the given entity.
     199                 :             :    If no DW_AT_byte_size nor DW_AT_bit_size are defined, this function
     200                 :             :    returns 0.  */
     201                 :             : 
     202                 :             : static uint32_t
     203                 :         727 : ctf_die_bitsize (dw_die_ref die)
     204                 :             : {
     205                 :         727 :   dw_attr_node *attr_byte_size = get_AT (die, DW_AT_byte_size);
     206                 :         727 :   dw_attr_node *attr_bit_size = get_AT (die, DW_AT_bit_size);
     207                 :             : 
     208                 :         727 :   if (attr_bit_size)
     209                 :          24 :     return AT_unsigned (attr_bit_size);
     210                 :         703 :   else if (attr_byte_size)
     211                 :         690 :     return (AT_unsigned (attr_byte_size) * 8);
     212                 :             :   else
     213                 :             :     return 0;
     214                 :             : }
     215                 :             : 
     216                 :             : /* Generate CTF for base type (integer, boolean, real, fixed point and complex).
     217                 :             :    Important: the caller of this API must make sure that duplicate types are
     218                 :             :    not added.  */
     219                 :             : 
     220                 :             : static ctf_dtdef_ref
     221                 :         573 : gen_ctf_base_type (ctf_container_ref ctfc, dw_die_ref type)
     222                 :             : {
     223                 :         573 :   ctf_dtdef_ref dtd = NULL;
     224                 :             : 
     225                 :         573 :   ctf_encoding_t ctf_encoding = {0, 0, 0};
     226                 :             : 
     227                 :         573 :   unsigned int encoding = get_AT_unsigned (type, DW_AT_encoding);
     228                 :         573 :   unsigned int bit_size = ctf_die_bitsize (type);
     229                 :         573 :   const char * name_string = get_AT_string (type, DW_AT_name);
     230                 :             : 
     231                 :         573 :   switch (encoding)
     232                 :             :     {
     233                 :           0 :     case DW_ATE_void:
     234                 :             : 
     235                 :           0 :       ctf_encoding.cte_format = CTF_INT_SIGNED;
     236                 :           0 :       ctf_encoding.cte_bits = 0;
     237                 :             : 
     238                 :           0 :       gcc_assert (name_string);
     239                 :           0 :       dtd = ctf_add_integer (ctfc, CTF_ADD_ROOT, name_string,
     240                 :             :                              &ctf_encoding, type);
     241                 :             : 
     242                 :           0 :       break;
     243                 :           2 :     case DW_ATE_boolean:
     244                 :             : 
     245                 :           2 :       ctf_encoding.cte_format = CTF_INT_BOOL;
     246                 :           2 :       ctf_encoding.cte_bits = bit_size;
     247                 :             : 
     248                 :           2 :       gcc_assert (name_string);
     249                 :           2 :       dtd = ctf_add_integer (ctfc, CTF_ADD_ROOT, name_string,
     250                 :             :                              &ctf_encoding, type);
     251                 :           2 :       break;
     252                 :          31 :     case DW_ATE_float:
     253                 :          31 :       {
     254                 :          31 :         unsigned int float_bit_size
     255                 :          31 :           = tree_to_uhwi (TYPE_SIZE (float_type_node));
     256                 :          31 :         unsigned int double_bit_size
     257                 :          31 :           = tree_to_uhwi (TYPE_SIZE (double_type_node));
     258                 :          31 :         unsigned int long_double_bit_size
     259                 :          31 :           = tree_to_uhwi (TYPE_SIZE (long_double_type_node));
     260                 :             : 
     261                 :          31 :         if (bit_size == float_bit_size)
     262                 :          14 :           ctf_encoding.cte_format = CTF_FP_SINGLE;
     263                 :          17 :         else if (bit_size == double_bit_size)
     264                 :          10 :           ctf_encoding.cte_format = CTF_FP_DOUBLE;
     265                 :           7 :         else if (bit_size == long_double_bit_size)
     266                 :           5 :           ctf_encoding.cte_format = CTF_FP_LDOUBLE;
     267                 :             :         else
     268                 :             :           /* CTF does not have representation for other types.  Skip them.  */
     269                 :             :           break;
     270                 :             : 
     271                 :          29 :         ctf_encoding.cte_bits = bit_size;
     272                 :          29 :         dtd = ctf_add_float (ctfc, CTF_ADD_ROOT, name_string,
     273                 :             :                                  &ctf_encoding, type);
     274                 :             : 
     275                 :          29 :         break;
     276                 :             :       }
     277                 :         507 :     case DW_ATE_signed_char:
     278                 :             :       /* FALLTHROUGH */
     279                 :         507 :     case DW_ATE_unsigned_char:
     280                 :             :       /* FALLTHROUGH */
     281                 :         507 :     case DW_ATE_signed:
     282                 :             :       /* FALLTHROUGH */
     283                 :         507 :     case DW_ATE_unsigned:
     284                 :             : 
     285                 :         507 :       if (encoding == DW_ATE_signed_char
     286                 :         507 :           || encoding == DW_ATE_unsigned_char)
     287                 :          50 :         ctf_encoding.cte_format |= CTF_INT_CHAR;
     288                 :             : 
     289                 :         507 :       if (encoding == DW_ATE_signed
     290                 :         507 :           || encoding == DW_ATE_signed_char)
     291                 :         400 :         ctf_encoding.cte_format |= CTF_INT_SIGNED;
     292                 :             : 
     293                 :         507 :       ctf_encoding.cte_bits = bit_size;
     294                 :         507 :       dtd = ctf_add_integer (ctfc, CTF_ADD_ROOT, name_string,
     295                 :             :                                  &ctf_encoding, type);
     296                 :         507 :       break;
     297                 :             : 
     298                 :           5 :     case DW_ATE_complex_float:
     299                 :           5 :       {
     300                 :           5 :         unsigned int float_bit_size
     301                 :           5 :           = tree_to_uhwi (TYPE_SIZE (float_type_node));
     302                 :           5 :         unsigned int double_bit_size
     303                 :           5 :           = tree_to_uhwi (TYPE_SIZE (double_type_node));
     304                 :           5 :         unsigned int long_double_bit_size
     305                 :           5 :           = tree_to_uhwi (TYPE_SIZE (long_double_type_node));
     306                 :             : 
     307                 :           5 :         if (bit_size == float_bit_size * 2)
     308                 :           2 :           ctf_encoding.cte_format = CTF_FP_CPLX;
     309                 :           3 :         else if (bit_size == double_bit_size * 2)
     310                 :           1 :           ctf_encoding.cte_format = CTF_FP_DCPLX;
     311                 :           2 :         else if (bit_size == long_double_bit_size * 2)
     312                 :           2 :             ctf_encoding.cte_format = CTF_FP_LDCPLX;
     313                 :             :         else
     314                 :             :           /* CTF does not have representation for other types.  Skip them.  */
     315                 :             :           break;
     316                 :             : 
     317                 :           5 :         ctf_encoding.cte_bits = bit_size;
     318                 :           5 :         dtd = ctf_add_float (ctfc, CTF_ADD_ROOT, name_string,
     319                 :             :                                  &ctf_encoding, type);
     320                 :           5 :         break;
     321                 :             :       }
     322                 :             :     default:
     323                 :             :       /* Ignore.  */
     324                 :             :       break;
     325                 :             :     }
     326                 :             : 
     327                 :         573 :   return dtd;
     328                 :             : }
     329                 :             : 
     330                 :             : /* Generate CTF for a pointer type.  */
     331                 :             : 
     332                 :             : static ctf_dtdef_ref
     333                 :         135 : gen_ctf_pointer_type (ctf_container_ref ctfc, dw_die_ref ptr_type)
     334                 :             : {
     335                 :         135 :   ctf_dtdef_ref pointed_dtd, pointer_dtd;
     336                 :         135 :   dw_die_ref pointed_type_die = ctf_get_AT_type (ptr_type);
     337                 :             : 
     338                 :         135 :   pointed_dtd = gen_ctf_type (ctfc, pointed_type_die);
     339                 :             : 
     340                 :             :   /* Type de-duplication.
     341                 :             :      Consult the ctfc_types hash again before adding the CTF pointer type
     342                 :             :      because there can be cases where a pointer type may have been added by
     343                 :             :      the gen_ctf_type call above.  */
     344                 :         135 :   if (!ctf_type_exists (ctfc, ptr_type, &pointer_dtd))
     345                 :         132 :     pointer_dtd = ctf_add_pointer (ctfc, CTF_ADD_ROOT, pointed_dtd, ptr_type);
     346                 :             : 
     347                 :         135 :   return pointer_dtd;
     348                 :             : }
     349                 :             : 
     350                 :             : /* Recursively generate CTF for array dimensions starting at DIE C (of type
     351                 :             :    DW_TAG_subrange_type) until DIE LAST (of type DW_TAG_subrange_type) is
     352                 :             :    reached.  ARRAY_ELEMS_TYPE is the CTF type object for the type of the
     353                 :             :    array elements.  */
     354                 :             : 
     355                 :             : static ctf_dtdef_ref
     356                 :          89 : gen_ctf_subrange_type (ctf_container_ref ctfc, ctf_dtdef_ref array_elems_type,
     357                 :             :                        dw_die_ref c, dw_die_ref last)
     358                 :             : {
     359                 :          89 :   ctf_arinfo_t arinfo;
     360                 :          89 :   ctf_dtdef_ref array_dtd;
     361                 :             : 
     362                 :          89 :   dw_attr_node *upper_bound_at;
     363                 :          89 :   dw_die_ref array_index_type;
     364                 :          89 :   uint32_t array_num_elements;
     365                 :             : 
     366                 :          89 :   if (dw_get_die_tag (c) == DW_TAG_subrange_type)
     367                 :             :     {
     368                 :             :       /* When DW_AT_upper_bound is used to specify the size of an
     369                 :             :          array in DWARF, it is usually an unsigned constant
     370                 :             :          specifying the upper bound index of the array.  However,
     371                 :             :          for unsized arrays, such as foo[] or bar[0],
     372                 :             :          DW_AT_upper_bound is a signed integer constant
     373                 :             :          instead.  */
     374                 :             : 
     375                 :          89 :       upper_bound_at = get_AT (c, DW_AT_upper_bound);
     376                 :          89 :       if (upper_bound_at
     377                 :          89 :           && AT_class (upper_bound_at) == dw_val_class_unsigned_const)
     378                 :             :         /* This is the upper bound index.  */
     379                 :          67 :         array_num_elements = get_AT_unsigned (c, DW_AT_upper_bound) + 1;
     380                 :          22 :       else if (get_AT (c, DW_AT_count))
     381                 :           3 :         array_num_elements = get_AT_unsigned (c, DW_AT_count);
     382                 :             :       else
     383                 :             :         {
     384                 :             :           /* This is a VLA of some kind.  */
     385                 :             :           array_num_elements = 0;
     386                 :             :         }
     387                 :             :     }
     388                 :             :   else
     389                 :           0 :     gcc_unreachable ();
     390                 :             : 
     391                 :             :   /* Ok, mount and register the array type.  Note how the array
     392                 :             :      type we register here is the type of the elements in
     393                 :             :      subsequent "dimensions", if there are any.  */
     394                 :          89 :   arinfo.ctr_nelems = array_num_elements;
     395                 :             : 
     396                 :          89 :   array_index_type = ctf_get_AT_type (c);
     397                 :          89 :   arinfo.ctr_index = gen_ctf_type (ctfc, array_index_type);
     398                 :             : 
     399                 :          89 :   if (c == last)
     400                 :          80 :     arinfo.ctr_contents = array_elems_type;
     401                 :             :   else
     402                 :           9 :     arinfo.ctr_contents = gen_ctf_subrange_type (ctfc, array_elems_type,
     403                 :             :                                                  dw_get_die_sib (c), last);
     404                 :             : 
     405                 :          89 :   if (!ctf_type_exists (ctfc, c, &array_dtd))
     406                 :          89 :     array_dtd = ctf_add_array (ctfc, CTF_ADD_ROOT, &arinfo, c);
     407                 :             : 
     408                 :          89 :   return array_dtd;
     409                 :             : }
     410                 :             : 
     411                 :             : /* Generate CTF for an ARRAY_TYPE.  */
     412                 :             : 
     413                 :             : static ctf_dtdef_ref
     414                 :         149 : gen_ctf_array_type (ctf_container_ref ctfc,
     415                 :             :                     dw_die_ref array_type)
     416                 :             : {
     417                 :         149 :   dw_die_ref first, last, array_elems_type;
     418                 :         149 :   ctf_dtdef_ref array_dtd, elem_dtd;
     419                 :             : 
     420                 :         149 :   int vector_type_p = get_AT_flag (array_type, DW_AT_GNU_vector);
     421                 :         149 :   if (vector_type_p)
     422                 :             :     return NULL;
     423                 :             : 
     424                 :             :   /* Find the first and last array dimension DIEs.  */
     425                 :         137 :   last = dw_get_die_child (array_type);
     426                 :         137 :   first = dw_get_die_sib (last);
     427                 :             : 
     428                 :             :   /* Type de-duplication.
     429                 :             :      Consult the ctfc_types before adding CTF type for the first dimension.  */
     430                 :         137 :   if (!ctf_type_exists (ctfc, first, &array_dtd))
     431                 :             :     {
     432                 :          80 :       array_elems_type = ctf_get_AT_type (array_type);
     433                 :             :       /* First, register the type of the array elements if needed.  */
     434                 :          80 :       elem_dtd = gen_ctf_type (ctfc, array_elems_type);
     435                 :             : 
     436                 :          80 :       array_dtd = gen_ctf_subrange_type (ctfc, elem_dtd, first, last);
     437                 :             :     }
     438                 :             : 
     439                 :         137 :   return array_dtd;
     440                 :             : }
     441                 :             : 
     442                 :             : /* Generate CTF for a typedef.  */
     443                 :             : 
     444                 :             : static ctf_dtdef_ref
     445                 :          57 : gen_ctf_typedef (ctf_container_ref ctfc, dw_die_ref tdef)
     446                 :             : {
     447                 :          57 :   ctf_dtdef_ref tdef_dtd, dtd;
     448                 :          57 :   const char *tdef_name = get_AT_string (tdef, DW_AT_name);
     449                 :          57 :   dw_die_ref tdef_type = ctf_get_AT_type (tdef);
     450                 :             : 
     451                 :          57 :   dtd = gen_ctf_type (ctfc, tdef_type);
     452                 :             : 
     453                 :             :   /* Type de-duplication.
     454                 :             :      This is necessary because the ctf for the typedef may have been already
     455                 :             :      added due to the gen_ctf_type call above.  */
     456                 :          57 :   if (!ctf_type_exists (ctfc, tdef, &tdef_dtd))
     457                 :          55 :     tdef_dtd = ctf_add_typedef (ctfc, CTF_ADD_ROOT, tdef_name, dtd, tdef);
     458                 :             : 
     459                 :          57 :   return tdef_dtd;
     460                 :             : }
     461                 :             : 
     462                 :             : /* Generate CTF for a type modifier.
     463                 :             : 
     464                 :             :    If the given DIE contains a valid C modifier (like _Atomic), which is not
     465                 :             :    supported by CTF, then this function skips the modifier die and continues
     466                 :             :    with the underlying type.
     467                 :             : 
     468                 :             :    If the modifier is supported by CTF, then this function constructs and
     469                 :             :    returns an appropate CTF type representing the modifier.
     470                 :             : 
     471                 :             :    For all other cases, this function returns NULL.  */
     472                 :             : 
     473                 :             : static ctf_dtdef_ref
     474                 :          62 : gen_ctf_modifier_type (ctf_container_ref ctfc, dw_die_ref modifier)
     475                 :             : {
     476                 :          62 :   uint32_t kind = CTF_K_MAX;
     477                 :          62 :   ctf_dtdef_ref dtd, modifier_dtd;
     478                 :          62 :   dw_die_ref qual_type = ctf_get_AT_type (modifier);
     479                 :             : 
     480                 :          62 :   switch (dw_get_die_tag (modifier))
     481                 :             :     {
     482                 :          48 :     case DW_TAG_const_type: kind = CTF_K_CONST; break;
     483                 :           8 :     case DW_TAG_volatile_type: kind = CTF_K_VOLATILE; break;
     484                 :           4 :     case DW_TAG_restrict_type: kind = CTF_K_RESTRICT; break;
     485                 :             :     case DW_TAG_atomic_type: break;
     486                 :             :     default:
     487                 :             :       return NULL;
     488                 :             :     }
     489                 :             : 
     490                 :             :   /* Register the type for which this modifier applies.  */
     491                 :          62 :   dtd = gen_ctf_type (ctfc, qual_type);
     492                 :             : 
     493                 :             :   /* Skip generating a CTF modifier record for _Atomic as there is no
     494                 :             :      representation for it.  */
     495                 :          62 :   if (dw_get_die_tag (modifier) == DW_TAG_atomic_type)
     496                 :             :     return dtd;
     497                 :             : 
     498                 :          60 :   gcc_assert (kind != CTF_K_MAX);
     499                 :             :   /* Now register the modifier itself.  */
     500                 :          60 :   if (!ctf_type_exists (ctfc, modifier, &modifier_dtd))
     501                 :          60 :     modifier_dtd = ctf_add_reftype (ctfc, CTF_ADD_ROOT, dtd, kind, modifier);
     502                 :             : 
     503                 :          60 :   return modifier_dtd;
     504                 :             : }
     505                 :             : 
     506                 :             : /* Generate CTF for a struct type.  */
     507                 :             : 
     508                 :             : static ctf_dtdef_ref
     509                 :         115 : gen_ctf_sou_type (ctf_container_ref ctfc, dw_die_ref sou, uint32_t kind)
     510                 :             : {
     511                 :         115 :   uint32_t bit_size = ctf_die_bitsize (sou);
     512                 :         115 :   int declaration_p = get_AT_flag (sou, DW_AT_declaration);
     513                 :         115 :   const char *sou_name = get_AT_string (sou, DW_AT_name);
     514                 :             : 
     515                 :         115 :   ctf_dtdef_ref sou_dtd;
     516                 :             : 
     517                 :             :   /* An incomplete structure or union type is represented in DWARF by
     518                 :             :      a structure or union DIE that does not have a size attribute and
     519                 :             :      that has a DW_AT_declaration attribute.  This corresponds to a
     520                 :             :      CTF forward type with kind CTF_K_STRUCT.  */
     521                 :         115 :   if (bit_size == 0 && declaration_p)
     522                 :          10 :     return ctf_add_forward (ctfc, CTF_ADD_ROOT,
     523                 :          10 :                             sou_name, kind, sou);
     524                 :             : 
     525                 :             :   /* This is a complete struct or union type.  Generate a CTF type for
     526                 :             :      it if it doesn't exist already.  */
     527                 :         105 :   if (!ctf_type_exists (ctfc, sou, &sou_dtd))
     528                 :         105 :     sou_dtd = ctf_add_sou (ctfc, CTF_ADD_ROOT,
     529                 :         105 :                            sou_name, kind, bit_size / 8,
     530                 :             :                            sou);
     531                 :             : 
     532                 :             :   /* Now process the struct members.  */
     533                 :         105 :   {
     534                 :         105 :     dw_die_ref c;
     535                 :             : 
     536                 :         105 :     c = dw_get_die_child (sou);
     537                 :         105 :     if (c)
     538                 :         221 :       do
     539                 :             :         {
     540                 :         221 :           const char *field_name;
     541                 :         221 :           dw_die_ref field_type;
     542                 :         221 :           HOST_WIDE_INT field_location;
     543                 :         221 :           ctf_dtdef_ref field_dtd;
     544                 :             : 
     545                 :         221 :           c = dw_get_die_sib (c);
     546                 :             : 
     547                 :         221 :           field_name = get_AT_string (c, DW_AT_name);
     548                 :         221 :           field_type = ctf_get_AT_type (c);
     549                 :         221 :           field_location = ctf_get_AT_data_member_location (c);
     550                 :             : 
     551                 :             :           /* Generate the field type.  */
     552                 :         221 :           field_dtd = gen_ctf_type (ctfc, field_type);
     553                 :             : 
     554                 :             :           /* If this is a bit-field, then wrap the field type
     555                 :             :              generated above with a CTF slice.  */
     556                 :         221 :           if (get_AT (c, DW_AT_bit_offset)
     557                 :         221 :               || get_AT (c, DW_AT_data_bit_offset))
     558                 :             :             {
     559                 :          23 :               dw_attr_node *attr;
     560                 :          23 :               HOST_WIDE_INT bitpos = 0;
     561                 :          23 :               HOST_WIDE_INT bitsize = ctf_die_bitsize (c);
     562                 :          23 :               HOST_WIDE_INT bit_offset;
     563                 :             : 
     564                 :             :               /* The bit offset is given in bits and it may be
     565                 :             :                  negative.  */
     566                 :          23 :               attr = get_AT (c, DW_AT_bit_offset);
     567                 :          23 :               if (attr)
     568                 :             :                 {
     569                 :           0 :                   if (AT_class (attr) == dw_val_class_unsigned_const)
     570                 :           0 :                     bit_offset = AT_unsigned (attr);
     571                 :             :                   else
     572                 :           0 :                     bit_offset = AT_int (attr);
     573                 :             : 
     574                 :           0 :                   if (BYTES_BIG_ENDIAN)
     575                 :             :                     bitpos = field_location + bit_offset;
     576                 :             :                   else
     577                 :             :                     {
     578                 :           0 :                       HOST_WIDE_INT bit_size;
     579                 :             : 
     580                 :           0 :                       attr = get_AT (c, DW_AT_byte_size);
     581                 :           0 :                       if (attr)
     582                 :             :                         /* Explicit size given in bytes.  */
     583                 :           0 :                         bit_size = AT_unsigned (attr) * 8;
     584                 :             :                       else
     585                 :             :                         /* Infer the size from the member type.  */
     586                 :           0 :                         bit_size = ctf_die_bitsize (field_type);
     587                 :             : 
     588                 :           0 :                       bitpos = (field_location
     589                 :           0 :                                 + bit_size
     590                 :           0 :                                 - bit_offset
     591                 :             :                                 - bitsize);
     592                 :             :                     }
     593                 :             :                 }
     594                 :             : 
     595                 :             :               /* In DWARF5 a data_bit_offset attribute is given with
     596                 :             :                  the offset of the data from the beginning of the
     597                 :             :                  struct.  Acknowledge it if present.  */
     598                 :          23 :               attr = get_AT (c, DW_AT_data_bit_offset);
     599                 :          23 :               if (attr)
     600                 :          23 :                 bitpos += AT_unsigned (attr);
     601                 :             : 
     602                 :             :               /* This is not precisely a TBD_CTF_REPRESENTATION_LIMIT, but
     603                 :             :                  surely something to look at for the next format version bump
     604                 :             :                  for CTF.  */
     605                 :          23 :               if (bitsize <= 255 && (bitpos - field_location) <= 255)
     606                 :          22 :                 field_dtd = ctf_add_slice (ctfc, CTF_ADD_NONROOT,
     607                 :             :                                                field_dtd,
     608                 :             :                                                bitpos - field_location,
     609                 :             :                                                bitsize, c);
     610                 :             :               else
     611                 :           1 :                 field_dtd = gen_ctf_unknown_type (ctfc);
     612                 :             :             }
     613                 :             : 
     614                 :             :           /* Add the field type to the struct or union type.  */
     615                 :         221 :           ctf_add_member_offset (ctfc, sou,
     616                 :             :                                  field_name,
     617                 :             :                                  field_dtd,
     618                 :             :                                  field_location);
     619                 :             :         }
     620                 :         221 :       while (c != dw_get_die_child (sou));
     621                 :             :   }
     622                 :             : 
     623                 :         105 :   return sou_dtd;
     624                 :             : }
     625                 :             : 
     626                 :             : /* Generate CTF for a function type.  */
     627                 :             : 
     628                 :             : static ctf_dtdef_ref
     629                 :         418 : gen_ctf_function_type (ctf_container_ref ctfc, dw_die_ref function,
     630                 :             :                        bool from_global_func)
     631                 :             : {
     632                 :         418 :   const char *function_name = get_AT_string (function, DW_AT_name);
     633                 :         418 :   dw_die_ref return_type = ctf_get_AT_type (function);
     634                 :             : 
     635                 :         418 :   ctf_funcinfo_t func_info;
     636                 :         418 :   uint32_t num_args = 0;
     637                 :         418 :   int linkage = get_AT_flag (function, DW_AT_external);
     638                 :             : 
     639                 :         418 :   ctf_dtdef_ref return_dtd, function_dtd;
     640                 :             : 
     641                 :             :   /* First, add the return type.  */
     642                 :         418 :   return_dtd = gen_ctf_type (ctfc, return_type);
     643                 :         418 :   func_info.ctc_return = return_dtd;
     644                 :             : 
     645                 :             :   /* Type de-duplication.
     646                 :             :      Consult the ctfc_types hash before adding the CTF function type.  */
     647                 :         418 :   if (ctf_type_exists (ctfc, function, &function_dtd))
     648                 :           1 :     return function_dtd;
     649                 :             : 
     650                 :             :   /* Do a first pass on the formals to determine the number of
     651                 :             :      arguments, and whether the function type gets a varargs.  */
     652                 :         417 :   {
     653                 :         417 :     dw_die_ref c;
     654                 :             : 
     655                 :         417 :     c = dw_get_die_child (function);
     656                 :         417 :     if (c)
     657                 :         317 :       do
     658                 :             :         {
     659                 :         317 :           c = dw_get_die_sib (c);
     660                 :             : 
     661                 :         317 :           if (dw_get_die_tag (c) == DW_TAG_formal_parameter)
     662                 :         134 :             num_args += 1;
     663                 :         183 :           else if (dw_get_die_tag (c) == DW_TAG_unspecified_parameters)
     664                 :             :             {
     665                 :           2 :               func_info.ctc_flags |= CTF_FUNC_VARARG;
     666                 :           2 :               num_args += 1;
     667                 :             :             }
     668                 :             :         }
     669                 :         317 :       while (c != dw_get_die_child (function));
     670                 :             :   }
     671                 :             : 
     672                 :             :   /* Note the number of typed arguments _includes_ the vararg.  */
     673                 :         417 :   func_info.ctc_argc = num_args;
     674                 :             : 
     675                 :             :   /* Type de-duplication has already been performed by now.  */
     676                 :         417 :   function_dtd = ctf_add_function (ctfc, CTF_ADD_ROOT,
     677                 :             :                                    function_name,
     678                 :             :                                    (const ctf_funcinfo_t *)&func_info,
     679                 :             :                                    function,
     680                 :             :                                    from_global_func,
     681                 :             :                                    linkage);
     682                 :             : 
     683                 :             :   /* Second pass on formals: generate the CTF types corresponding to
     684                 :             :      them and add them as CTF function args.  */
     685                 :         417 :   {
     686                 :         417 :     dw_die_ref c;
     687                 :         417 :     unsigned int i = 0;
     688                 :         417 :     const char *arg_name;
     689                 :         417 :     ctf_dtdef_ref arg_type;
     690                 :             : 
     691                 :         417 :     c = dw_get_die_child (function);
     692                 :         417 :     if (c)
     693                 :         317 :       do
     694                 :             :         {
     695                 :         317 :           c = dw_get_die_sib (c);
     696                 :             : 
     697                 :         317 :           if (dw_get_die_tag (c) == DW_TAG_unspecified_parameters)
     698                 :             :             {
     699                 :           2 :               gcc_assert (i == num_args - 1);
     700                 :             :               /* Add an argument with type 0 and no name.  */
     701                 :           2 :               ctf_add_function_arg (ctfc, function, "", NULL);
     702                 :             :             }
     703                 :         315 :           else if (dw_get_die_tag (c) == DW_TAG_formal_parameter)
     704                 :             :             {
     705                 :         134 :               i++;
     706                 :         134 :               arg_name = get_AT_string (c, DW_AT_name);
     707                 :         134 :               arg_type = gen_ctf_type (ctfc, ctf_get_AT_type (c));
     708                 :             :               /* Add the argument to the existing CTF function type.  */
     709                 :         134 :               ctf_add_function_arg (ctfc, function, arg_name, arg_type);
     710                 :             :             }
     711                 :             :           else
     712                 :             :             /* This is a local variable.  Ignore.  */
     713                 :         181 :             continue;
     714                 :             :         }
     715                 :         317 :       while (c != dw_get_die_child (function));
     716                 :             :   }
     717                 :             : 
     718                 :         417 :   return function_dtd;
     719                 :             : }
     720                 :             : 
     721                 :             : /* Generate CTF for an enumeration type.  */
     722                 :             : 
     723                 :             : static ctf_dtdef_ref
     724                 :          16 : gen_ctf_enumeration_type (ctf_container_ref ctfc, dw_die_ref enumeration)
     725                 :             : {
     726                 :          16 :   const char *enum_name = get_AT_string (enumeration, DW_AT_name);
     727                 :          16 :   unsigned int bit_size = ctf_die_bitsize (enumeration);
     728                 :          16 :   unsigned int signedness = get_AT_unsigned (enumeration, DW_AT_encoding);
     729                 :          16 :   int declaration_p = get_AT_flag (enumeration, DW_AT_declaration);
     730                 :             : 
     731                 :          16 :   ctf_dtdef_ref enum_dtd;
     732                 :             : 
     733                 :             :   /* If this is an incomplete enum, generate a CTF forward for it and
     734                 :             :      be done.  */
     735                 :          16 :   if (declaration_p)
     736                 :             :     {
     737                 :           2 :       gcc_assert (enum_name);
     738                 :           2 :       return ctf_add_forward (ctfc, CTF_ADD_ROOT, enum_name,
     739                 :           2 :                               CTF_K_ENUM, enumeration);
     740                 :             :     }
     741                 :             : 
     742                 :             :   /* If the size the enumerators is not specified then use the size of
     743                 :             :      the underlying type, which must be a base type.  */
     744                 :          14 :   if (bit_size == 0)
     745                 :             :     {
     746                 :           0 :       dw_die_ref type = ctf_get_AT_type (enumeration);
     747                 :           0 :       bit_size = ctf_die_bitsize (type);
     748                 :             :     }
     749                 :             : 
     750                 :             :   /* Generate a CTF type for the enumeration.  */
     751                 :          28 :   enum_dtd = ctf_add_enum (ctfc, CTF_ADD_ROOT,
     752                 :          14 :                            enum_name, bit_size / 8,
     753                 :             :                            (signedness == DW_ATE_unsigned),
     754                 :             :                            enumeration);
     755                 :             : 
     756                 :             :   /* Process the enumerators.  */
     757                 :          14 :   {
     758                 :          14 :     dw_die_ref c;
     759                 :             : 
     760                 :          14 :     c = dw_get_die_child (enumeration);
     761                 :          14 :     if (c)
     762                 :          45 :       do
     763                 :             :         {
     764                 :          45 :           const char *enumerator_name;
     765                 :          45 :           dw_attr_node *enumerator_value;
     766                 :          45 :           HOST_WIDE_INT value_wide_int;
     767                 :             : 
     768                 :          45 :           c = dw_get_die_sib (c);
     769                 :             : 
     770                 :          45 :           enumerator_name = get_AT_string (c, DW_AT_name);
     771                 :          45 :           enumerator_value = get_AT (c, DW_AT_const_value);
     772                 :             : 
     773                 :             :           /* enumerator_value can be either a signed or an unsigned
     774                 :             :              constant value.  */
     775                 :          45 :           if (AT_class (enumerator_value) == dw_val_class_unsigned_const
     776                 :          45 :               || (AT_class (enumerator_value)
     777                 :             :                   == dw_val_class_unsigned_const_implicit))
     778                 :          43 :             value_wide_int = AT_unsigned (enumerator_value);
     779                 :             :           else
     780                 :           2 :             value_wide_int = AT_int (enumerator_value);
     781                 :             : 
     782                 :          45 :           ctf_add_enumerator (ctfc, enum_dtd,
     783                 :             :                               enumerator_name, value_wide_int, enumeration);
     784                 :             :         }
     785                 :          45 :       while (c != dw_get_die_child (enumeration));
     786                 :             :   }
     787                 :             : 
     788                 :             :   return enum_dtd;
     789                 :             : }
     790                 :             : 
     791                 :             : /* Add a CTF variable record for the given input DWARF DIE.  */
     792                 :             : 
     793                 :             : static void
     794                 :         257 : gen_ctf_variable (ctf_container_ref ctfc, dw_die_ref die)
     795                 :             : {
     796                 :         257 :   const char *var_name = get_AT_string (die, DW_AT_name);
     797                 :         257 :   dw_die_ref var_type = ctf_get_AT_type (die);
     798                 :         257 :   unsigned int external_vis = get_AT_flag (die, DW_AT_external);
     799                 :         257 :   ctf_dtdef_ref var_dtd;
     800                 :             : 
     801                 :             :   /* Avoid duplicates.  */
     802                 :         257 :   if (ctf_dvd_lookup (ctfc, die))
     803                 :             :     return;
     804                 :             : 
     805                 :             :   /* Do not generate CTF variable records for non-defining incomplete
     806                 :             :      declarations.  Such declarations can be known via the DWARF
     807                 :             :      DW_AT_specification attribute.  */
     808                 :         257 :   if (ctf_dvd_ignore_lookup (ctfc, die))
     809                 :             :     return;
     810                 :             : 
     811                 :             :   /* The value of the DW_AT_specification attribute, if present, is a
     812                 :             :      reference to the debugging information entry representing the
     813                 :             :      non-defining declaration.  */
     814                 :         257 :   dw_die_ref decl = get_AT_ref (die, DW_AT_specification);
     815                 :             : 
     816                 :             :   /* Add the type of the variable.  */
     817                 :         257 :   var_dtd = gen_ctf_type (ctfc, var_type);
     818                 :             : 
     819                 :             :   /* Generate the new CTF variable and update global counter.  */
     820                 :         257 :   (void) ctf_add_variable (ctfc, var_name, var_dtd, die, external_vis, decl);
     821                 :             :   /* Skip updating the number of global objects at this time.  This is updated
     822                 :             :      later after pre-processing as some CTF variable records although
     823                 :             :      generated now, will not be emitted later.  [PR105089].  */
     824                 :             : }
     825                 :             : 
     826                 :             : /* Add a CTF function record for the given input DWARF DIE.  */
     827                 :             : 
     828                 :             : static void
     829                 :         404 : gen_ctf_function (ctf_container_ref ctfc, dw_die_ref die)
     830                 :             : {
     831                 :         404 :   ctf_dtdef_ref function_dtd;
     832                 :             :   /* Type de-duplication.
     833                 :             :      Consult the ctfc_types hash before adding the CTF function type.  */
     834                 :         404 :   if (ctf_type_exists (ctfc, die, &function_dtd))
     835                 :           0 :     return;
     836                 :             : 
     837                 :             :   /* Add the type of the function and update the global functions
     838                 :             :      counter.  Note that DWARF encodes function types in both
     839                 :             :      DW_TAG_subroutine_type and DW_TAG_subprogram in exactly the same
     840                 :             :      way.  */
     841                 :         404 :   (void) gen_ctf_function_type (ctfc, die, true /* from_global_func */);
     842                 :         404 :   ctfc->ctfc_num_global_funcs += 1;
     843                 :             : }
     844                 :             : 
     845                 :             : /* Add CTF type record(s) for the given input DWARF DIE and return its type id.
     846                 :             : 
     847                 :             :    If there is already a CTF type corresponding to the given DIE, then
     848                 :             :    this function returns the type id of the existing type.
     849                 :             : 
     850                 :             :    If the given DIE is not recognized as a type, then this function
     851                 :             :    returns NULL.  */
     852                 :             : 
     853                 :             : static ctf_dtdef_ref
     854                 :        2863 : gen_ctf_type (ctf_container_ref ctfc, dw_die_ref die)
     855                 :             : {
     856                 :        2863 :   ctf_dtdef_ref dtd = NULL;
     857                 :        2863 :   int unrecog_die = false;
     858                 :             : 
     859                 :        2863 :   if (ctf_type_exists (ctfc, die, &dtd))
     860                 :        1280 :     return dtd;
     861                 :             : 
     862                 :        1583 :   switch (dw_get_die_tag (die))
     863                 :             :     {
     864                 :         573 :     case DW_TAG_base_type:
     865                 :         573 :       dtd = gen_ctf_base_type (ctfc, die);
     866                 :         573 :       break;
     867                 :         135 :     case DW_TAG_pointer_type:
     868                 :         135 :       dtd = gen_ctf_pointer_type (ctfc, die);
     869                 :         135 :       break;
     870                 :          57 :     case DW_TAG_typedef:
     871                 :          57 :       dtd = gen_ctf_typedef (ctfc, die);
     872                 :          57 :       break;
     873                 :         149 :     case DW_TAG_array_type:
     874                 :         149 :       dtd = gen_ctf_array_type (ctfc, die);
     875                 :         149 :       break;
     876                 :         102 :     case DW_TAG_structure_type:
     877                 :         102 :       dtd = gen_ctf_sou_type (ctfc, die, CTF_K_STRUCT);
     878                 :         102 :       break;
     879                 :          13 :     case DW_TAG_union_type:
     880                 :          13 :       dtd = gen_ctf_sou_type (ctfc, die, CTF_K_UNION);
     881                 :          13 :       break;
     882                 :          14 :     case DW_TAG_subroutine_type:
     883                 :          14 :       dtd = gen_ctf_function_type (ctfc, die,
     884                 :             :                                    false /* from_global_func */);
     885                 :          14 :       break;
     886                 :          16 :     case DW_TAG_enumeration_type:
     887                 :          16 :       dtd = gen_ctf_enumeration_type (ctfc, die);
     888                 :          16 :       break;
     889                 :          62 :     case DW_TAG_atomic_type:
     890                 :             :       /* FALLTHROUGH */
     891                 :          62 :     case DW_TAG_const_type:
     892                 :             :       /* FALLTHROUGH */
     893                 :          62 :     case DW_TAG_restrict_type:
     894                 :             :       /* FALLTHROUGH */
     895                 :          62 :     case DW_TAG_volatile_type:
     896                 :          62 :       dtd = gen_ctf_modifier_type (ctfc, die);
     897                 :          62 :       break;
     898                 :          75 :     case DW_TAG_unspecified_type:
     899                 :          75 :       {
     900                 :          75 :         const char *name = get_AT_string (die, DW_AT_name);
     901                 :             : 
     902                 :          75 :         if (name && strcmp (name, "void") == 0)
     903                 :          75 :           dtd = gen_ctf_void_type (ctfc);
     904                 :             :         else
     905                 :           0 :           dtd = NULL;
     906                 :             : 
     907                 :             :         break;
     908                 :             :       }
     909                 :           0 :     case DW_TAG_reference_type:
     910                 :           0 :       dtd = NULL;
     911                 :           0 :       break;
     912                 :         387 :     default:
     913                 :             :       /* Unrecognized DIE.  */
     914                 :         387 :       unrecog_die = true;
     915                 :         387 :       dtd = NULL;
     916                 :         387 :       break;
     917                 :             :     }
     918                 :             : 
     919                 :             :   /* For all types unrepresented in CTF, use an explicit CTF type of kind
     920                 :             :      CTF_K_UNKNOWN.  */
     921                 :        1583 :   if ((dtd == NULL) && (!unrecog_die))
     922                 :          42 :     dtd = gen_ctf_unknown_type (ctfc);
     923                 :             : 
     924                 :        1583 :   return dtd;
     925                 :             : }
     926                 :             : 
     927                 :             : bool
     928                 :        2071 : ctf_do_die (dw_die_ref die)
     929                 :             : {
     930                 :        2071 :   ctf_container_ref tu_ctfc = ctf_get_tu_ctfc ();
     931                 :             : 
     932                 :             :   /* Note how we tell the caller to continue traversing children DIEs
     933                 :             :      if this DIE didn't result in CTF records being added.  */
     934                 :        2071 :   if (dw_get_die_tag (die) == DW_TAG_variable)
     935                 :             :     {
     936                 :         257 :       gen_ctf_variable (tu_ctfc, die);
     937                 :         257 :       return false;
     938                 :             :     }
     939                 :        1814 :   else if (dw_get_die_tag (die) == DW_TAG_subprogram)
     940                 :             :     {
     941                 :         404 :       gen_ctf_function (tu_ctfc, die);
     942                 :         404 :       return false;
     943                 :             :     }
     944                 :             :   else
     945                 :        1410 :     return (gen_ctf_type (tu_ctfc, die) == NULL);
     946                 :             : }
     947                 :             : 
     948                 :             : /* Initialize CTF subsystem for CTF debug info generation.  */
     949                 :             : 
     950                 :             : void
     951                 :         387 : ctf_debug_init (void)
     952                 :             : {
     953                 :             :   /* First, initialize the CTF subsystem.  */
     954                 :         387 :   ctf_init ();
     955                 :             : 
     956                 :             :   /* Create a couple of DIE structures that we may need.  */
     957                 :         387 :   ctf_void_die = new_die_raw (DW_TAG_unspecified_type);
     958                 :         387 :   add_name_attribute (ctf_void_die, "void");
     959                 :         387 :   ctf_array_index_die
     960                 :         387 :     = base_type_die (integer_type_node, 0 /* reverse */);
     961                 :         387 :   add_name_attribute (ctf_array_index_die, "int");
     962                 :         387 :   ctf_unknown_die = new_die_raw (DW_TAG_unspecified_type);
     963                 :         387 :   add_name_attribute (ctf_unknown_die, "unknown");
     964                 :         387 : }
     965                 :             : 
     966                 :             : /* Early finish CTF/BTF debug info.  */
     967                 :             : 
     968                 :             : void
     969                 :         387 : ctf_debug_early_finish (const char * filename)
     970                 :             : {
     971                 :             :   /* Emit the collected CTF information.  */
     972                 :         387 :   if (ctf_debug_info_level > CTFINFO_LEVEL_NONE)
     973                 :         293 :     ctf_output (filename);
     974                 :             : 
     975                 :             :   /* If emitting BTF, start translation to BTF.  */
     976                 :         387 :   if (btf_debuginfo_p ())
     977                 :             :     {
     978                 :          94 :       btf_early_finish ();
     979                 :             : 
     980                 :             :       /* For LTO builds, also emit BTF now.  */
     981                 :          94 :       if (flag_lto && !in_lto_p)
     982                 :           0 :         btf_finish ();
     983                 :             :     }
     984                 :             :   else
     985                 :             :     /* Otherwise, done with the CTF container.  */
     986                 :         293 :     ctf_finalize ();
     987                 :         387 : }
     988                 :             : 
     989                 :             : /* Finish CTF/BTF debug info emission.  */
     990                 :             : 
     991                 :             : void
     992                 :         385 : ctf_debug_finish ()
     993                 :             : {
     994                 :             :   /* Emit BTF late, unless this is an LTO build in which case it was
     995                 :             :      already done early.  */
     996                 :         385 :   if (btf_debuginfo_p () && !flag_lto)
     997                 :          94 :     btf_finish ();
     998                 :         385 : }
     999                 :             : 
    1000                 :             : #include "gt-dwarf2ctf.h"
        

Generated by: LCOV version 2.1-beta

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