gcc/ctfout.c

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