LCOV - code coverage report
Current view: top level - gcc - ctfout.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 93.9 % 329 309
Test Date: 2024-11-30 13:30:02 Functions: 81.8 % 33 27
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: - 0 0

             Branch data     Line data    Source code
       1                 :             : /* Output CTF format from GCC.
       2                 :             :    Copyright (C) 2019-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 "memmodel.h"
      25                 :             : #include "tm_p.h"
      26                 :             : #include "output.h"
      27                 :             : #include "dwarf2asm.h"
      28                 :             : #include "debug.h"
      29                 :             : #include "ctfc.h"
      30                 :             : #include "diagnostic-core.h"
      31                 :             : 
      32                 :             : static int ctf_label_num;
      33                 :             : 
      34                 :             : /* Pointers to various CTF sections.  */
      35                 :             : 
      36                 :             : static GTY (()) section * ctf_info_section;
      37                 :             : 
      38                 :             : /* Section names used to hold CTF debugging information.  */
      39                 :             : 
      40                 :             : /* CTF debug info section.  */
      41                 :             : 
      42                 :             : #ifndef CTF_INFO_SECTION_NAME
      43                 :             : #define CTF_INFO_SECTION_NAME  ".ctf"
      44                 :             : #endif
      45                 :             : 
      46                 :             : /* Section flags for the CTF debug info section.  */
      47                 :             : 
      48                 :             : #define CTF_INFO_SECTION_FLAGS (SECTION_DEBUG)
      49                 :             : 
      50                 :             : /* Maximum size (in bytes) of an artificially generated CTF label.  */
      51                 :             : 
      52                 :             : #define MAX_CTF_LABEL_BYTES 40
      53                 :             : 
      54                 :             : static char ctf_info_section_label[MAX_CTF_LABEL_BYTES];
      55                 :             : 
      56                 :             : #ifndef CTF_INFO_SECTION_LABEL
      57                 :             : #define CTF_INFO_SECTION_LABEL                  "Lctf"
      58                 :             : #endif
      59                 :             : 
      60                 :             : /* CTF preprocess callback arguments.  */
      61                 :             : 
      62                 :             : typedef struct ctf_dtd_preprocess_arg
      63                 :             : {
      64                 :             :   uint64_t dtd_global_func_idx;
      65                 :             :   ctf_container_ref dtd_arg_ctfc;
      66                 :             : } ctf_dtd_preprocess_arg_t;
      67                 :             : 
      68                 :             : typedef struct ctf_dvd_preprocess_arg
      69                 :             : {
      70                 :             :   uint64_t dvd_global_obj_idx;
      71                 :             :   ctf_container_ref dvd_arg_ctfc;
      72                 :             : } ctf_dvd_preprocess_arg_t;
      73                 :             : 
      74                 :             : /* Compare two CTF variable definition entries.  Currently used for sorting
      75                 :             :    by name.  */
      76                 :             : 
      77                 :             : static int
      78                 :         727 : ctf_varent_compare (const void * entry1, const void * entry2)
      79                 :             : {
      80                 :         727 :   int result;
      81                 :         727 :   const ctf_dvdef_t * e1 = *(const ctf_dvdef_t * const*) entry1;
      82                 :         727 :   const ctf_dvdef_t * e2 = *(const ctf_dvdef_t * const*) entry2;
      83                 :             : 
      84                 :         727 :   result = strcmp (e1->dvd_name, e2->dvd_name);
      85                 :             : 
      86                 :         727 :   return result;
      87                 :             : }
      88                 :             : 
      89                 :             : /* A CTF type record may be followed by variable-length of bytes to encode the
      90                 :             :    CTF type completely.  This routine calculates the number of bytes, in the
      91                 :             :    final binary CTF format, which are used to encode information about the type
      92                 :             :    completely.
      93                 :             : 
      94                 :             :    This function must always be in sync with the CTF header.  */
      95                 :             : 
      96                 :             : static uint64_t
      97                 :        1249 : ctf_calc_num_vbytes (ctf_dtdef_ref ctftype)
      98                 :             : {
      99                 :        1249 :   uint32_t size;
     100                 :        1249 :   uint64_t vlen_bytes = 0;
     101                 :             : 
     102                 :        1249 :   uint32_t kind = CTF_V2_INFO_KIND (ctftype->dtd_data.ctti_info);
     103                 :        1249 :   uint32_t vlen = CTF_V2_INFO_VLEN (ctftype->dtd_data.ctti_info);
     104                 :             : 
     105                 :        1249 :   ctf_dmdef_t * dmd;
     106                 :        1249 :   ctf_func_arg_t * farg;
     107                 :        1249 :   uint32_t size_per_member = 0;
     108                 :        1249 :   unsigned int num_members = 0;
     109                 :        1249 :   unsigned int num_fargs = 0;
     110                 :             : 
     111                 :        1249 :   switch (kind)
     112                 :             :     {
     113                 :             :       case CTF_K_FORWARD:
     114                 :             :       case CTF_K_UNKNOWN:
     115                 :             :       case CTF_K_POINTER:
     116                 :             :       case CTF_K_TYPEDEF:
     117                 :             :       case CTF_K_VOLATILE:
     118                 :             :       case CTF_K_CONST:
     119                 :             :       case CTF_K_RESTRICT:
     120                 :             :         /* These types have no vlen data.  */
     121                 :             :         break;
     122                 :             : 
     123                 :         508 :       case CTF_K_INTEGER:
     124                 :         508 :       case CTF_K_FLOAT:
     125                 :             :         /* 4 bytes to represent encoding CTF_INT_DATA, CTF_FP_DATA.  */
     126                 :         508 :         vlen_bytes += sizeof (uint32_t);
     127                 :         508 :         break;
     128                 :         381 :       case CTF_K_FUNCTION:
     129                 :             :         /* Sanity check - number of function args must be the same as
     130                 :             :            vlen.  */
     131                 :         381 :         for (farg = ctftype->dtd_u.dtu_argv;
     132                 :         489 :              farg != NULL; farg = (ctf_func_arg_t *) ctf_farg_list_next (farg))
     133                 :         108 :           num_fargs++;
     134                 :         381 :         gcc_assert (vlen == num_fargs);
     135                 :             : 
     136                 :             :         /* FIXME - CTF_PADDING_FOR_ALIGNMENT.  */
     137                 :         381 :         vlen_bytes += (vlen + (vlen & 1)) * sizeof (uint32_t);
     138                 :         381 :         break;
     139                 :          67 :       case CTF_K_ARRAY:
     140                 :             :         /* This has a single ctf_array_t.  */
     141                 :          67 :         vlen_bytes += sizeof (ctf_array_t);
     142                 :          67 :         break;
     143                 :          13 :       case CTF_K_SLICE:
     144                 :          13 :         vlen_bytes += sizeof (ctf_slice_t);
     145                 :          13 :         break;
     146                 :          72 :       case CTF_K_STRUCT:
     147                 :          72 :       case CTF_K_UNION:
     148                 :             :         /* Count the number and type of members.  */
     149                 :          72 :         size = ctftype->dtd_data.ctti_size;
     150                 :          72 :         size_per_member = size >= CTF_LSTRUCT_THRESH
     151                 :             :                           ? sizeof (ctf_lmember_t) : sizeof (ctf_member_t);
     152                 :             : 
     153                 :             :         /* Sanity check - number of members of struct must be the same as
     154                 :             :            vlen.  */
     155                 :          72 :         for (dmd = ctftype->dtd_u.dtu_members;
     156                 :         217 :              dmd != NULL; dmd = (ctf_dmdef_t *) ctf_dmd_list_next (dmd))
     157                 :         145 :           num_members++;
     158                 :          72 :         gcc_assert (vlen == num_members);
     159                 :             : 
     160                 :          72 :         vlen_bytes += (num_members * size_per_member);
     161                 :          72 :         break;
     162                 :           6 :       case CTF_K_ENUM:
     163                 :           6 :         vlen_bytes += vlen * sizeof (ctf_enum_t);
     164                 :           6 :         break;
     165                 :             :       default :
     166                 :             :         break;
     167                 :             :     }
     168                 :        1249 :   return vlen_bytes;
     169                 :             : }
     170                 :             : 
     171                 :             : /* Add a CTF variable to the end of the list.  */
     172                 :             : 
     173                 :             : static void
     174                 :         163 : ctf_list_add_ctf_vars (ctf_container_ref ctfc, ctf_dvdef_ref var)
     175                 :             : {
     176                 :         163 :   ctfc->ctfc_vars_list[ctfc->ctfc_vars_list_count++] = var;
     177                 :           0 : }
     178                 :             : 
     179                 :             : /* Initialize the various sections and labels for CTF output.  */
     180                 :             : 
     181                 :             : void
     182                 :         332 : init_ctf_sections (void)
     183                 :             : {
     184                 :             :   /* Note : Even in case of LTO, the compiler continues to generate a single
     185                 :             :      CTF section for each compilation unit "early".  Unlike other debug
     186                 :             :      sections, CTF sections are non-LTO sections, and do not take the
     187                 :             :      .gnu.debuglto_ prefix.  The linker will de-duplicate the types in the CTF
     188                 :             :      sections, in case of LTO or  otherwise.  */
     189                 :         332 :   ctf_info_section = get_section (CTF_INFO_SECTION_NAME, CTF_INFO_SECTION_FLAGS,
     190                 :             :                                   NULL);
     191                 :             : 
     192                 :         332 :   ASM_GENERATE_INTERNAL_LABEL (ctf_info_section_label,
     193                 :             :                                CTF_INFO_SECTION_LABEL, ctf_label_num++);
     194                 :         332 : }
     195                 :             : 
     196                 :             : /* Routines for CTF pre-processing.  */
     197                 :             : 
     198                 :             : static void
     199                 :         163 : ctf_preprocess_var (ctf_container_ref ctfc, ctf_dvdef_ref var)
     200                 :             : {
     201                 :             :   /* Add it to the list of types.  This array of types will be sorted before
     202                 :             :      assembling into output.  */
     203                 :         163 :   ctf_list_add_ctf_vars (ctfc, var);
     204                 :           0 : }
     205                 :             : 
     206                 :             : /* CTF preprocess callback routine for CTF variables.  */
     207                 :             : 
     208                 :             : int
     209                 :         164 : ctf_dvd_preprocess_cb (ctf_dvdef_ref * slot, void * arg)
     210                 :             : {
     211                 :         164 :   ctf_dvd_preprocess_arg_t * dvd_arg =  (ctf_dvd_preprocess_arg_t *)arg;
     212                 :         164 :   ctf_dvdef_ref var = (ctf_dvdef_ref) *slot;
     213                 :         164 :   ctf_container_ref arg_ctfc = dvd_arg->dvd_arg_ctfc;
     214                 :             : 
     215                 :             :   /* If the CTF variable corresponds to an extern variable declaration with
     216                 :             :      a defining declaration later on, skip it.  Only CTF variable
     217                 :             :      corresponding to the defining declaration for the extern variable is
     218                 :             :      desirable.  */
     219                 :         164 :   if (ctf_dvd_ignore_lookup (arg_ctfc, var->dvd_key))
     220                 :             :     return 1;
     221                 :             : 
     222                 :         163 :   ctf_preprocess_var (arg_ctfc, var);
     223                 :             : 
     224                 :             :   /* Keep track of global objts.  */
     225                 :         163 :   arg_ctfc->ctfc_gobjts_list[dvd_arg->dvd_global_obj_idx] = var;
     226                 :         163 :   dvd_arg->dvd_global_obj_idx++;
     227                 :             : 
     228                 :         163 :   return 1;
     229                 :             : }
     230                 :             : 
     231                 :             : /* CTF preprocess callback routine for CTF types.  */
     232                 :             : 
     233                 :             : int
     234                 :        1249 : ctf_dtd_preprocess_cb (ctf_dtdef_ref * slot, void * arg)
     235                 :             : {
     236                 :        1249 :   uint32_t kind;
     237                 :             : 
     238                 :        1249 :   ctf_dtdef_ref ctftype = (ctf_dtdef_ref) *slot;
     239                 :        1249 :   ctf_dtd_preprocess_arg_t * dtd_arg = (ctf_dtd_preprocess_arg_t *)arg;
     240                 :        1249 :   ctf_container_ref arg_ctfc = dtd_arg->dtd_arg_ctfc;
     241                 :             : 
     242                 :        1249 :   size_t index = ctftype->dtd_type;
     243                 :        1249 :   gcc_assert (index <= arg_ctfc->ctfc_types->elements ());
     244                 :             : 
     245                 :             :   /* CTF types need to be output in the order of their type IDs.  In other
     246                 :             :      words, if type A is used to define type B, type ID of type A must
     247                 :             :      appear before type ID of type B.  */
     248                 :        1249 :   arg_ctfc->ctfc_types_list[index] = ctftype;
     249                 :             : 
     250                 :             :   /* Keep track of the CTF type if it's a function type and the type
     251                 :             :      was generated from a function object.  */
     252                 :        1249 :   kind = CTF_V2_INFO_KIND (ctftype->dtd_data.ctti_info);
     253                 :        1249 :   if (kind == CTF_K_FUNCTION && ctftype->from_global_func)
     254                 :             :     {
     255                 :         371 :       arg_ctfc->ctfc_gfuncs_list[dtd_arg->dtd_global_func_idx] = ctftype;
     256                 :         371 :       dtd_arg->dtd_global_func_idx++;
     257                 :             :     }
     258                 :             : 
     259                 :             :   /* Calculate the vlen bytes.  */
     260                 :        1249 :   arg_ctfc->ctfc_num_vlen_bytes += ctf_calc_num_vbytes (ctftype);
     261                 :             : 
     262                 :        1249 :   return 1;
     263                 :             : }
     264                 :             : 
     265                 :             : /* CTF preprocessing.
     266                 :             :    After the CTF types for the compilation unit have been generated fully, the
     267                 :             :    compiler writes out the asm for the CTF types.
     268                 :             : 
     269                 :             :    CTF writeout in the compiler requires two passes over the CTF types.  In the
     270                 :             :    first pass, the CTF preprocess pass:
     271                 :             :      1.  CTF types are sorted in the order of their type IDs.
     272                 :             :      2.  The variable number of bytes after each CTF type record are calculated.
     273                 :             :          This is used to calculate the offsets in the ctf_header_t.
     274                 :             :      3.  If the CTF type is of CTF_K_FUNCTION, the number of bytes in the
     275                 :             :          funcinfo sub-section are calculated.  This is used to calculate the
     276                 :             :          offsets in the ctf_header_t.
     277                 :             :      4.  Keep the list of CTF variables in ASCIIbetical order of their names.
     278                 :             : 
     279                 :             :    In the second pass, the CTF writeout pass, asm tags are written out using
     280                 :             :    the compiler's afore-generated internal pre-processed CTF types.  */
     281                 :             : 
     282                 :             : static void
     283                 :         332 : ctf_preprocess (ctf_container_ref ctfc)
     284                 :             : {
     285                 :         332 :   size_t num_ctf_types = ctfc->ctfc_types->elements ();
     286                 :         332 :   size_t num_ctf_vars = ctfc_get_num_ctf_vars (ctfc);
     287                 :             : 
     288                 :             :   /* Initialize an array to keep track of the CTF variables at global
     289                 :             :      scope.  At this time, size it conservatively.  */
     290                 :         332 :   size_t num_global_objts = num_ctf_vars;
     291                 :         332 :   if (num_global_objts)
     292                 :             :     {
     293                 :          78 :       ctfc->ctfc_gobjts_list = ggc_vec_alloc<ctf_dvdef_t*>(num_global_objts);
     294                 :             :     }
     295                 :             : 
     296                 :          78 :   if (num_ctf_vars)
     297                 :             :     {
     298                 :          78 :       ctf_dvd_preprocess_arg_t dvd_arg;
     299                 :          78 :       dvd_arg.dvd_global_obj_idx = 0;
     300                 :          78 :       dvd_arg.dvd_arg_ctfc = ctfc;
     301                 :             : 
     302                 :             :       /* Allocate CTF var list.  */
     303                 :          78 :       ctfc->ctfc_vars_list = ggc_vec_alloc<ctf_dvdef_ref>(num_ctf_vars);
     304                 :             :       /* Variables appear in the sort ASCIIbetical order of their names.  This
     305                 :             :          permits binary searching in the CTF reader.  Add the variables to a
     306                 :             :          list for sorting.  */
     307                 :         242 :       ctfc->ctfc_vars->traverse<void *, ctf_dvd_preprocess_cb> (&dvd_arg);
     308                 :             :       /* Sort the list.  */
     309                 :          78 :       qsort (ctfc->ctfc_vars_list, ctfc->ctfc_vars_list_count,
     310                 :             :              sizeof (ctf_dvdef_ref), ctf_varent_compare);
     311                 :             :       /* Update the actual number of the generated CTF variables at global
     312                 :             :          scope.  */
     313                 :          78 :       ctfc->ctfc_num_global_objts = dvd_arg.dvd_global_obj_idx;
     314                 :             :     }
     315                 :             : 
     316                 :             :   /* Initialize an array to keep track of the CTF functions types for global
     317                 :             :      functions in the CTF data section.  */
     318                 :         332 :   size_t num_global_funcs = ctfc->ctfc_num_global_funcs;
     319                 :         332 :   if (num_global_funcs)
     320                 :             :     {
     321                 :         278 :       ctfc->ctfc_gfuncs_list = ggc_vec_alloc<ctf_dtdef_t*>(num_global_funcs);
     322                 :         278 :       gcc_assert (num_ctf_types);
     323                 :             :     }
     324                 :             : 
     325                 :          54 :   if (num_ctf_types)
     326                 :             :     {
     327                 :         332 :       ctf_dtd_preprocess_arg_t dtd_arg;
     328                 :         332 :       dtd_arg.dtd_global_func_idx = 0;
     329                 :         332 :       dtd_arg.dtd_arg_ctfc = ctfc;
     330                 :             :       /* Allocate the CTF types list.  Add 1 because type ID 0 is never a valid
     331                 :             :          CTF type ID.  No CTF type record should appear at that offset, this
     332                 :             :          eases debugging and readability.  */
     333                 :         332 :       ctfc->ctfc_types_list = ggc_vec_alloc<ctf_dtdef_ref>(num_ctf_types + 1);
     334                 :             :       /* Pre-process CTF types.  */
     335                 :        1581 :       ctfc->ctfc_types->traverse<void *, ctf_dtd_preprocess_cb> (&dtd_arg);
     336                 :             : 
     337                 :         332 :       gcc_assert (dtd_arg.dtd_global_func_idx == num_global_funcs);
     338                 :             :     }
     339                 :         332 : }
     340                 :             : 
     341                 :             : /* CTF asm helper routines.  */
     342                 :             : 
     343                 :             : /* Asm'out the CTF preamble.  */
     344                 :             : 
     345                 :             : static void
     346                 :         332 : ctf_asm_preamble (ctf_container_ref ctfc)
     347                 :             : {
     348                 :         332 :   dw2_asm_output_data (2, ctfc->ctfc_magic,
     349                 :             :                        "CTF preamble magic number");
     350                 :         332 :   dw2_asm_output_data (1, ctfc->ctfc_version, "CTF preamble version");
     351                 :         332 :   dw2_asm_output_data (1, ctfc->ctfc_flags, "CTF preamble flags");
     352                 :         332 : }
     353                 :             : 
     354                 :             : /* Asm'out a CTF type which is represented by ctf_stype_t.  */
     355                 :             : 
     356                 :             : static void
     357                 :        1249 : ctf_asm_stype (ctf_dtdef_ref type)
     358                 :             : {
     359                 :        1249 :   dw2_asm_output_data (4, type->dtd_data.ctti_name, "ctt_name");
     360                 :        1249 :   dw2_asm_output_data (4, type->dtd_data.ctti_info, "ctt_info");
     361                 :             :   /* union.  */
     362                 :        1249 :   dw2_asm_output_data (4, type->dtd_data.ctti_size, "ctt_size or ctt_type");
     363                 :        1249 : }
     364                 :             : 
     365                 :             : /* Asm'out a CTF type which is represented by ctf_type_t.  */
     366                 :             : 
     367                 :             : static void
     368                 :           0 : ctf_asm_type (ctf_dtdef_ref type)
     369                 :             : {
     370                 :           0 :   dw2_asm_output_data (4, type->dtd_data.ctti_name, "ctt_name");
     371                 :           0 :   dw2_asm_output_data (4, type->dtd_data.ctti_info, "ctt_info");
     372                 :             :   /* union.  */
     373                 :           0 :   dw2_asm_output_data (4, type->dtd_data.ctti_size, "ctt_size");
     374                 :           0 :   dw2_asm_output_data (4, type->dtd_data.ctti_lsizehi, "ctt_lsizehi");
     375                 :           0 :   dw2_asm_output_data (4, type->dtd_data.ctti_lsizelo, "ctt_lsizelo");
     376                 :           0 : }
     377                 :             : 
     378                 :             : /* Asm'out a CTF type of kind CTF_K_SLICE.  */
     379                 :             : 
     380                 :             : static void
     381                 :          13 : ctf_asm_slice (ctf_dtdef_ref type)
     382                 :             : {
     383                 :          13 :   dw2_asm_output_data (4, ctf_type_id (type->dtd_u.dtu_slice.cts_type),
     384                 :             :                        "cts_type");
     385                 :          13 :   dw2_asm_output_data (2, type->dtd_u.dtu_slice.cts_offset, "cts_offset");
     386                 :          13 :   dw2_asm_output_data (2, type->dtd_u.dtu_slice.cts_bits, "cts_bits");
     387                 :          13 : }
     388                 :             : 
     389                 :             : /* Asm'out a CTF type of kind CTF_K_ARRAY.  */
     390                 :             : 
     391                 :             : static void
     392                 :          67 : ctf_asm_array (ctf_dtdef_ref dtd)
     393                 :             : {
     394                 :          67 :   dw2_asm_output_data (4, ctf_type_id (dtd->dtd_u.dtu_arr.ctr_contents),
     395                 :             :                        "cta_contents");
     396                 :          67 :   dw2_asm_output_data (4, ctf_type_id (dtd->dtd_u.dtu_arr.ctr_index),
     397                 :             :                        "cta_index");
     398                 :          67 :   dw2_asm_output_data (4, dtd->dtd_u.dtu_arr.ctr_nelems, "cta_nelems");
     399                 :          67 : }
     400                 :             : 
     401                 :             : /* Asm'out a CTF variable.  */
     402                 :             : 
     403                 :             : static void
     404                 :         163 : ctf_asm_varent (ctf_dvdef_ref var)
     405                 :             : {
     406                 :             :   /* Output the reference to the name in the string table.  */
     407                 :         163 :   dw2_asm_output_data (4, var->dvd_name_offset, "ctv_name");
     408                 :             :   /* Output the type index.  */
     409                 :         163 :   dw2_asm_output_data (4, ctf_type_id (var->dvd_type), "ctv_typeidx");
     410                 :         163 : }
     411                 :             : 
     412                 :             : /* Asm'out a member of CTF struct or union, represented by ctf_lmember_t.  */
     413                 :             : 
     414                 :             : static void
     415                 :           0 : ctf_asm_sou_lmember (ctf_dmdef_t * dmd)
     416                 :             : {
     417                 :           0 :   dw2_asm_output_data (4, dmd->dmd_name_offset, "ctlm_name");
     418                 :           0 :   dw2_asm_output_data (4, CTF_OFFSET_TO_LMEMHI (dmd->dmd_offset),
     419                 :             :                        "ctlm_offsethi");
     420                 :           0 :   dw2_asm_output_data (4, ctf_type_id (dmd->dmd_type), "ctlm_type");
     421                 :           0 :   dw2_asm_output_data (4, CTF_OFFSET_TO_LMEMLO (dmd->dmd_offset),
     422                 :             :                        "ctlm_offsetlo");
     423                 :           0 : }
     424                 :             : 
     425                 :             : /* Asm'out a member of a CTF sruct or union, represented by ctf_member_t.  */
     426                 :             : 
     427                 :             : static void
     428                 :         145 : ctf_asm_sou_member (ctf_dmdef_t * dmd)
     429                 :             : {
     430                 :         145 :   dw2_asm_output_data (4, dmd->dmd_name_offset, "ctm_name");
     431                 :         145 :   dw2_asm_output_data (4, dmd->dmd_offset, "ctm_offset");
     432                 :         145 :   dw2_asm_output_data (4, ctf_type_id (dmd->dmd_type), "ctm_type");
     433                 :         145 : }
     434                 :             : 
     435                 :             : /* Asm'out an enumerator constant.  */
     436                 :             : 
     437                 :             : static void
     438                 :          18 : ctf_asm_enum_const (ctf_dmdef_t * dmd)
     439                 :             : {
     440                 :          18 :   dw2_asm_output_data (4, dmd->dmd_name_offset, "cte_name");
     441                 :          18 :   dw2_asm_output_data (4, dmd->dmd_value, "cte_value");
     442                 :          18 : }
     443                 :             : 
     444                 :             : /* Asm'out a function argument.  */
     445                 :             : 
     446                 :             : static void
     447                 :         108 : ctf_asm_func_arg (ctf_func_arg_t * farg)
     448                 :             : {
     449                 :             :   /* farg_type may be NULL, indicating varargs.  */
     450                 :         215 :   dw2_asm_output_data (4, farg->farg_type
     451                 :         107 :                        ? ctf_type_id (farg->farg_type)
     452                 :             :                        : 0, "dtu_argv");
     453                 :         108 : }
     454                 :             : 
     455                 :             : /* CTF writeout to asm file.  */
     456                 :             : 
     457                 :             : static void
     458                 :         332 : output_ctf_header (ctf_container_ref ctfc)
     459                 :             : {
     460                 :         332 :   switch_to_section (ctf_info_section);
     461                 :         332 :   ASM_OUTPUT_LABEL (asm_out_file, ctf_info_section_label);
     462                 :             : 
     463                 :         332 :   ctf_asm_preamble (ctfc);
     464                 :             : 
     465                 :             :   /* For a single compilation unit, the parent container's name and label are
     466                 :             :      NULL.  */
     467                 :         332 :   dw2_asm_output_data (4, 0, "cth_parlabel");
     468                 :         332 :   dw2_asm_output_data (4, 0, "cth_parname");
     469                 :         332 :   dw2_asm_output_data (4, ctfc->ctfc_cuname_offset, "cth_cuname");
     470                 :             : 
     471                 :         332 :   int typeslen = 0;
     472                 :             :   /* Initialize the offsets.  The offsets are from after the CTF header.  */
     473                 :         332 :   uint32_t lbloff = 0;
     474                 :         332 :   uint32_t objtoff = 0;
     475                 :         332 :   uint32_t funcoff = 0;
     476                 :         332 :   uint32_t objtidxoff = 0;
     477                 :         332 :   uint32_t funcidxoff = 0;
     478                 :         332 :   uint32_t varoff = 0;
     479                 :         332 :   uint32_t typeoff = 0;
     480                 :         332 :   uint32_t stroff = 0;
     481                 :             : 
     482                 :         332 :   if (!ctfc_is_empty_container (ctfc))
     483                 :             :     {
     484                 :         332 :       gcc_assert (ctfc_get_num_ctf_types (ctfc)
     485                 :             :                   == (ctfc->ctfc_num_types + ctfc->ctfc_num_stypes));
     486                 :             : 
     487                 :         332 :       funcoff = objtoff + ctfc->ctfc_num_global_objts * sizeof (uint32_t);
     488                 :             :       /* Object index appears after function info.  */
     489                 :         332 :       objtidxoff = funcoff + ctfc->ctfc_num_global_funcs * sizeof (uint32_t);
     490                 :             :       /* Funxtion index goes next.  */
     491                 :         332 :       funcidxoff = objtidxoff + ctfc->ctfc_num_global_objts * sizeof (uint32_t);
     492                 :             :       /* Vars appear after function index.  */
     493                 :         332 :       varoff = funcidxoff + ctfc->ctfc_num_global_funcs * sizeof (uint32_t);
     494                 :             :       /* CTF types appear after vars.  */
     495                 :         332 :       typeoff = varoff + (ctfc->ctfc_vars_list_count) * sizeof (ctf_varent_t);
     496                 :             :       /* The total number of bytes for CTF types is the sum of the number of
     497                 :             :          times struct ctf_type_t, struct ctf_stype_t are written, plus the
     498                 :             :          amount of variable length data after each one of these.  */
     499                 :         664 :       typeslen = ctfc->ctfc_num_types * sizeof (ctf_type_t)
     500                 :         332 :                 + ctfc->ctfc_num_stypes * (sizeof (ctf_stype_t))
     501                 :         332 :                 + ctfc_get_num_vlen_bytes (ctfc);
     502                 :             : 
     503                 :             :       /* Strings appear after types.  */
     504                 :         332 :       stroff = typeoff + typeslen;
     505                 :             :     }
     506                 :             : 
     507                 :             :     /* Offset of label section.  */
     508                 :         332 :     dw2_asm_output_data (4, lbloff, "cth_lbloff");
     509                 :             :     /* Offset of object section.  */
     510                 :         332 :     dw2_asm_output_data (4, objtoff, "cth_objtoff");
     511                 :             :     /* Offset of function section.  */
     512                 :         332 :     dw2_asm_output_data (4, funcoff, "cth_funcoff");
     513                 :             :     /* Offset of object index section.  */
     514                 :         332 :     dw2_asm_output_data (4, objtidxoff, "cth_objtidxoff");
     515                 :             :     /* Offset of function index section.  */
     516                 :         332 :     dw2_asm_output_data (4, funcidxoff, "cth_funcidxoff");
     517                 :             : 
     518                 :             :     /* Offset of variable section.  */
     519                 :         332 :     dw2_asm_output_data (4, varoff, "cth_varoff");
     520                 :             :     /* Offset of type section.  */
     521                 :         332 :     dw2_asm_output_data (4, typeoff, "cth_typeoff");
     522                 :             :     /* Offset of string section.  */
     523                 :         332 :     dw2_asm_output_data (4, stroff, "cth_stroff");
     524                 :             :     /* Length of string section in bytes.  */
     525                 :         332 :     dw2_asm_output_data (4, ctfc->ctfc_strlen, "cth_strlen");
     526                 :         332 : }
     527                 :             : 
     528                 :             : /* Output the CTF object info section.  */
     529                 :             : 
     530                 :             : static void
     531                 :         332 : output_ctf_obj_info (ctf_container_ref ctfc)
     532                 :             : {
     533                 :         332 :   uint64_t i;
     534                 :         332 :   ctf_dvdef_ref var;
     535                 :             : 
     536                 :         332 :   if (!ctfc->ctfc_num_global_objts) return;
     537                 :             : 
     538                 :             :   /* Compiler spits out the objts (at global scope) in the CTF obj info section.
     539                 :             :      In no specific order.  In an object file, the CTF object index section is
     540                 :             :      used to associate the objts to their corresponding names.  */
     541                 :         241 :   for (i = 0; i < ctfc->ctfc_num_global_objts; i++)
     542                 :             :     {
     543                 :         163 :       var = ctfc->ctfc_gobjts_list[i];
     544                 :             : 
     545                 :             :       /* CTF type ID corresponding to the type of the variable.  */
     546                 :         163 :       dw2_asm_output_data (4, ctf_type_id (var->dvd_type), "objtinfo_var_type");
     547                 :             :     }
     548                 :             : 
     549                 :             : }
     550                 :             : 
     551                 :             : /* Output the CTF function info section.  */
     552                 :             : 
     553                 :             : static void
     554                 :         332 : output_ctf_func_info (ctf_container_ref ctfc)
     555                 :             : {
     556                 :         332 :   uint64_t i;
     557                 :         332 :   ctf_dtdef_ref ctftype;
     558                 :             : 
     559                 :         332 :   if (!ctfc->ctfc_num_global_funcs) return;
     560                 :             : 
     561                 :             :   /* The CTF funcinfo section is simply an array of CTF_K_FUNCTION type IDs in
     562                 :             :      the type section.  In an object file, the CTF function index section is
     563                 :             :      used to associate functions to their corresponding names.  */
     564                 :         649 :   for (i = 0; i < ctfc->ctfc_num_global_funcs; i++)
     565                 :             :     {
     566                 :         371 :       ctftype = ctfc->ctfc_gfuncs_list[i];
     567                 :         371 :       dw2_asm_output_data (4, ctftype->dtd_type, "funcinfo_func_type");
     568                 :             :     }
     569                 :             : }
     570                 :             : 
     571                 :             : /* Output the CTF object index section.  */
     572                 :             : 
     573                 :             : static void
     574                 :         332 : output_ctf_objtidx (ctf_container_ref ctfc)
     575                 :             : {
     576                 :         332 :   uint64_t i;
     577                 :         332 :   ctf_dvdef_ref var;
     578                 :             : 
     579                 :         332 :   if (!ctfc->ctfc_num_global_objts) return;
     580                 :             : 
     581                 :         241 :   for (i = 0; i < ctfc->ctfc_num_global_objts; i++)
     582                 :             :     {
     583                 :         163 :       var = ctfc->ctfc_gobjts_list[i];
     584                 :             :       /* Offset to the name in CTF string table.  */
     585                 :         163 :       dw2_asm_output_data (4, var->dvd_name_offset, "objtinfo_name");
     586                 :             :     }
     587                 :             : }
     588                 :             : 
     589                 :             : /* Output the CTF function index section.  */
     590                 :             : 
     591                 :             : static void
     592                 :         332 : output_ctf_funcidx (ctf_container_ref ctfc)
     593                 :             : {
     594                 :         332 :   uint64_t i;
     595                 :         332 :   ctf_dtdef_ref ctftype;
     596                 :             : 
     597                 :         332 :   if (!ctfc->ctfc_num_global_funcs) return;
     598                 :             : 
     599                 :         649 :   for (i = 0; i < ctfc->ctfc_num_global_funcs; i++)
     600                 :             :     {
     601                 :         371 :       ctftype = ctfc->ctfc_gfuncs_list[i];
     602                 :             :       /* Offset to the name in CTF string table.  */
     603                 :         371 :       dw2_asm_output_data (4, ctftype->dtd_data.ctti_name, "funcinfo_name");
     604                 :             :     }
     605                 :             : }
     606                 :             : 
     607                 :             : /* Output the CTF variables.  Variables appear in the sorted ASCIIbetical
     608                 :             :    order of their names.  This permits binary searching in the CTF reader.  */
     609                 :             : 
     610                 :             : static void
     611                 :         332 : output_ctf_vars (ctf_container_ref ctfc)
     612                 :             : {
     613                 :         332 :   size_t i;
     614                 :         332 :   unsigned int num_ctf_vars = ctfc->ctfc_vars_list_count;
     615                 :         332 :   if (num_ctf_vars)
     616                 :             :     {
     617                 :             :       /* Iterate over the list of sorted vars and output the asm.  */
     618                 :         241 :       for (i = 0; i < num_ctf_vars; i++)
     619                 :             :         {
     620                 :         163 :           ctf_asm_varent (ctfc->ctfc_vars_list[i]);
     621                 :             :           /* The type of variable must be a valid one.  */
     622                 :         163 :           gcc_assert (ctfc->ctfc_vars_list[i]->dvd_type != CTF_NULL_TYPEID);
     623                 :             :         }
     624                 :             :     }
     625                 :         332 : }
     626                 :             : 
     627                 :             : /* Output the CTF string records.  */
     628                 :             : 
     629                 :             : static void
     630                 :         332 : output_ctf_strs (ctf_container_ref ctfc)
     631                 :             : {
     632                 :         332 :   ctf_string_t * ctf_string = ctfc->ctfc_strtable.ctstab_head;
     633                 :             : 
     634                 :        2323 :   while (ctf_string)
     635                 :             :     {
     636                 :        1991 :       dw2_asm_output_nstring (ctf_string->cts_str, -1, "ctf_string");
     637                 :        1991 :       ctf_string = ctf_string->cts_next;
     638                 :             :     }
     639                 :         332 : }
     640                 :             : 
     641                 :             : /* Output the members of the CTF struct or union.  */
     642                 :             : 
     643                 :             : static void
     644                 :          72 : output_asm_ctf_sou_fields (ctf_container_ref ARG_UNUSED (ctfc),
     645                 :             :                            ctf_dtdef_ref dtd)
     646                 :             : {
     647                 :          72 :   ctf_dmdef_t * dmd;
     648                 :             : 
     649                 :             :   /* Function pointer to dump struct/union members.  */
     650                 :          72 :   void (*ctf_asm_sou_field_func) (ctf_dmdef_t *);
     651                 :             : 
     652                 :          72 :   uint32_t size = dtd->dtd_data.ctti_size;
     653                 :             : 
     654                 :             :   /* The variable length data struct/union CTF types is an array of
     655                 :             :      ctf_member or ctf_lmember, depending on size of the member.  */
     656                 :          72 :   if (size >= CTF_LSTRUCT_THRESH)
     657                 :             :     ctf_asm_sou_field_func = ctf_asm_sou_lmember;
     658                 :             :   else
     659                 :          72 :     ctf_asm_sou_field_func = ctf_asm_sou_member;
     660                 :             : 
     661                 :          72 :   for (dmd = dtd->dtd_u.dtu_members;
     662                 :         217 :        dmd != NULL; dmd = (ctf_dmdef_t *) ctf_dmd_list_next (dmd))
     663                 :             :     {
     664                 :         145 :       ctf_asm_sou_field_func (dmd);
     665                 :             :       /* Sanity Check - Unrepresented types appear as explicit types.  */
     666                 :         145 :       gcc_assert (dmd->dmd_type != CTF_NULL_TYPEID);
     667                 :             :     }
     668                 :          72 : }
     669                 :             : 
     670                 :             : /* Output the list of enumerator constants of the CTF enum type.  */
     671                 :             : 
     672                 :             : static void
     673                 :           6 : output_asm_ctf_enum_list (ctf_container_ref ARG_UNUSED (ctfc),
     674                 :             :                           ctf_dtdef_ref dtd)
     675                 :             : {
     676                 :           6 :   ctf_dmdef_t * dmd;
     677                 :             : 
     678                 :           0 :   for (dmd = dtd->dtd_u.dtu_members;
     679                 :          24 :        dmd != NULL; dmd = (ctf_dmdef_t *) ctf_dmd_list_next (dmd))
     680                 :          18 :     ctf_asm_enum_const (dmd);
     681                 :           0 : }
     682                 :             : 
     683                 :             : /* Output the list of function arguments of the CTF function type.  */
     684                 :             : 
     685                 :             : static void
     686                 :         381 : output_asm_func_args_list (ctf_container_ref ARG_UNUSED (ctfc),
     687                 :             :                           ctf_dtdef_ref dtd)
     688                 :             : {
     689                 :         381 :   ctf_func_arg_t * farg;
     690                 :             : 
     691                 :           0 :   for (farg = dtd->dtd_u.dtu_argv;
     692                 :         489 :        farg != NULL; farg = (ctf_func_arg_t *) ctf_farg_list_next (farg))
     693                 :         108 :     ctf_asm_func_arg (farg);
     694                 :           0 : }
     695                 :             : 
     696                 :             : /* Output the variable length portion of the CTF type record.  */
     697                 :             : 
     698                 :             : static void
     699                 :        1249 : output_asm_ctf_vlen_bytes (ctf_container_ref ctfc, ctf_dtdef_ref ctftype)
     700                 :             : {
     701                 :        1249 :   uint32_t encoding;
     702                 :        1249 :   uint32_t kind = CTF_V2_INFO_KIND (ctftype->dtd_data.ctti_info);
     703                 :        1249 :   uint32_t vlen = CTF_V2_INFO_VLEN (ctftype->dtd_data.ctti_info);
     704                 :             : 
     705                 :        1249 :   switch (kind)
     706                 :             :     {
     707                 :         508 :       case CTF_K_INTEGER:
     708                 :         508 :       case CTF_K_FLOAT:
     709                 :         508 :         if (kind == CTF_K_INTEGER)
     710                 :             :           {
     711                 :         480 :             encoding = CTF_INT_DATA (ctftype->dtd_u.dtu_enc.cte_format,
     712                 :             :                                      ctftype->dtd_u.dtu_enc.cte_offset,
     713                 :             :                                      ctftype->dtd_u.dtu_enc.cte_bits);
     714                 :             :           }
     715                 :             :         else
     716                 :             :           {
     717                 :          28 :             encoding = CTF_FP_DATA (ctftype->dtd_u.dtu_enc.cte_format,
     718                 :             :                                     ctftype->dtd_u.dtu_enc.cte_offset,
     719                 :             :                                     ctftype->dtd_u.dtu_enc.cte_bits);
     720                 :             :           }
     721                 :         508 :         dw2_asm_output_data (4, encoding, "ctf_encoding_data");
     722                 :         508 :         break;
     723                 :         381 :       case CTF_K_FUNCTION:
     724                 :         381 :           {
     725                 :         381 :             output_asm_func_args_list (ctfc, ctftype);
     726                 :             :             /* FIXME - CTF_PADDING_FOR_ALIGNMENT.
     727                 :             :                libctf expects this padding for alignment reasons.  Expected to
     728                 :             :                be redundant in CTF_VERSION_4.  */
     729                 :         381 :             if (vlen & 1)
     730                 :          48 :               dw2_asm_output_data (4, 0, "dtu_argv_padding");
     731                 :             : 
     732                 :             :             break;
     733                 :             :           }
     734                 :          67 :       case CTF_K_ARRAY:
     735                 :          67 :         ctf_asm_array (ctftype);
     736                 :          67 :         break;
     737                 :          13 :       case CTF_K_SLICE:
     738                 :          13 :           {
     739                 :          13 :             ctf_asm_slice (ctftype);
     740                 :             :             /* Type of the slice must be a valid CTF type.  */
     741                 :          13 :             gcc_assert (ctftype->dtd_u.dtu_slice.cts_type != CTF_NULL_TYPEID);
     742                 :             :             break;
     743                 :             :           }
     744                 :          72 :       case CTF_K_STRUCT:
     745                 :          72 :       case CTF_K_UNION:
     746                 :          72 :         output_asm_ctf_sou_fields (ctfc, ctftype);
     747                 :          72 :         break;
     748                 :           6 :       case CTF_K_ENUM:
     749                 :           6 :         output_asm_ctf_enum_list (ctfc, ctftype);
     750                 :             :         break;
     751                 :             : 
     752                 :             :       default:
     753                 :             :         /* CTF types of kind CTF_K_VOLATILE, CTF_K_CONST, CTF_K_RESTRICT,
     754                 :             :            etc have no vlen data to write.  */
     755                 :             :         break;
     756                 :             :     }
     757                 :        1249 : }
     758                 :             : 
     759                 :             : /* Output a CTF Type.  */
     760                 :             : 
     761                 :             : static void
     762                 :        1249 : output_asm_ctf_type (ctf_container_ref ctfc, ctf_dtdef_ref type)
     763                 :             : {
     764                 :        1249 :   if (type->dtd_data.ctti_size <= CTF_MAX_SIZE)
     765                 :        1249 :     ctf_asm_stype (type);
     766                 :             :   else
     767                 :           0 :     ctf_asm_type (type);
     768                 :             :   /* Now comes the variable-length portion for defining types completely.
     769                 :             :      E.g., encoding follows CTF_INT_DATA, CTF_FP_DATA types,
     770                 :             :      struct ctf_array_t follows CTF_K_ARRAY types, or a bunch of
     771                 :             :      struct ctf_member / ctf_lmember ctf_enum sit in there for CTF_K_STRUCT or
     772                 :             :      CTF_K_UNION.  */
     773                 :        1249 :   output_asm_ctf_vlen_bytes (ctfc, type);
     774                 :             : 
     775                 :        1249 :   uint32_t kind = CTF_V2_INFO_KIND (type->dtd_data.ctti_info);
     776                 :             :   /* The underlying type must be a valid CTF type.  */
     777                 :        1249 :   if (kind == CTF_K_POINTER || kind == CTF_K_TYPEDEF
     778                 :        1105 :       || kind == CTF_K_VOLATILE || kind == CTF_K_CONST
     779                 :        1063 :       || kind == CTF_K_RESTRICT)
     780                 :         188 :     gcc_assert (type->dtd_data.ctti_type != CTF_NULL_TYPEID);
     781                 :        1249 : }
     782                 :             : 
     783                 :             : /* Output all CTF type records.  */
     784                 :             : 
     785                 :             : static void
     786                 :         332 : output_ctf_types (ctf_container_ref ctfc)
     787                 :             : {
     788                 :         332 :   size_t i;
     789                 :         332 :   size_t num_ctf_types = ctfc->ctfc_types->elements ();
     790                 :         332 :   if (num_ctf_types)
     791                 :             :     {
     792                 :             :       /* Type ID = 0 is used as sentinel value; not a valid type.  */
     793                 :        1581 :       for (i = 1; i <= num_ctf_types; i++)
     794                 :        1249 :         output_asm_ctf_type (ctfc, ctfc->ctfc_types_list[i]);
     795                 :             :     }
     796                 :         332 : }
     797                 :             : 
     798                 :             : /* CTF routines interfacing to the compiler.  */
     799                 :             : 
     800                 :             : /* Prepare and output the CTF section.  */
     801                 :             : 
     802                 :             : void
     803                 :         332 : ctf_output (const char * filename)
     804                 :             : {
     805                 :         332 :   if (ctf_debug_info_level == CTFINFO_LEVEL_NONE)
     806                 :             :     return;
     807                 :             : 
     808                 :             :   /* Get the CTF container for the current translation unit.  */
     809                 :         332 :   ctf_container_ref tu_ctfc = ctf_get_tu_ctfc ();
     810                 :             : 
     811                 :         332 :   init_ctf_sections ();
     812                 :             : 
     813                 :         332 :   ctf_add_cuname (tu_ctfc, filename);
     814                 :             : 
     815                 :             :   /* Pre-process CTF before generating assembly.  */
     816                 :         332 :   ctf_preprocess (tu_ctfc);
     817                 :         332 :   output_ctf_header (tu_ctfc);
     818                 :         332 :   output_ctf_obj_info (tu_ctfc);
     819                 :         332 :   output_ctf_func_info (tu_ctfc);
     820                 :         332 :   output_ctf_objtidx (tu_ctfc);
     821                 :         332 :   output_ctf_funcidx (tu_ctfc);
     822                 :         332 :   output_ctf_vars (tu_ctfc);
     823                 :         332 :   output_ctf_types (tu_ctfc);
     824                 :         332 :   output_ctf_strs (tu_ctfc);
     825                 :             : 
     826                 :             :   /* The total number of string bytes must be equal to those processed out to
     827                 :             :      the str subsection.  */
     828                 :         332 :   gcc_assert (tu_ctfc->ctfc_strlen
     829                 :             :               == ctfc_get_strtab_len (tu_ctfc, CTF_STRTAB));
     830                 :             : 
     831                 :             : }
     832                 :             : 
     833                 :             : /* Reset all state for CTF generation so that we can rerun the compiler within
     834                 :             :    the same process.  */
     835                 :             : 
     836                 :             : void
     837                 :         332 : ctf_finalize (void)
     838                 :             : {
     839                 :         332 :   ctf_info_section = NULL;
     840                 :             : 
     841                 :         332 :   ctf_container_ref tu_ctfc = ctf_get_tu_ctfc ();
     842                 :         332 :   ctfc_delete_container (tu_ctfc);
     843                 :         332 :   tu_ctfc = NULL;
     844                 :         332 : }
     845                 :             : 
     846                 :             : #include "gt-ctfout.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.