gcc/ctfc.h

   1 /* ctfc.h - Declarations and definitions related to the CTF container.
   2    Copyright (C) 2019-2022 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 /* This file defines the data structures and functions used by the compiler
  21    to generate the CTF debug info.  The definitions below are compiler internal
  22    representations and closely reflect the CTF format requirements in <ctf.h>.
  23
  24    The contents of the CTF container are used eventually for emission of both
  25    CTF (ctfout.cc) and BTF debug info (btfout.cc), as the two type debug formats
  26    are close cousins.  */
  27
  28 #ifndef GCC_CTFC_H
  29 #define GCC_CTFC_H 1
  30
  31 #include "config.h"
  32 #include "system.h"
  33 #include "tree.h"
  34 #include "fold-const.h"
  35 #include "dwarf2ctf.h"
  36 #include "ctf.h"
  37 #include "btf.h"
  38
  39 /* Invalid CTF type ID definition.  */
  40
  41 #define CTF_NULL_TYPEID 0
  42
  43 /* Value to start generating the CTF type ID from.  */
  44
  45 #define CTF_INIT_TYPEID 1
  46
  47 /* CTF type ID.  */
  48
  49 typedef uint64_t ctf_id_t;
  50
  51 /* CTF string table element (list node).  */
  52
  53 typedef struct GTY ((chain_next ("%h.cts_next"))) ctf_string
  54 {
  55   const char * cts_str;           /* CTF string.  */
  56   struct ctf_string * cts_next;   /* A list node.  */
  57 } ctf_string_t;
  58
  59 /* Internal representation of CTF string table.  */
  60
  61 typedef struct GTY (()) ctf_strtable
  62 {
  63   ctf_string_t * ctstab_head;       /* Head str ptr.  */
  64   ctf_string_t * ctstab_tail;       /* Tail.  new str appended to tail.  */
  65   int ctstab_num;                   /* Number of strings in the table.  */
  66   size_t ctstab_len;                /* Size of string table in bytes.  */
  67   const char * ctstab_estr;         /* Empty string "".  */
  68 } ctf_strtable_t;
  69
  70 /* Encoding information for integers, floating-point values etc.  The flags
  71    field will contain values appropriate for the type defined in <ctf.h>.  */
  72
  73 typedef struct GTY (()) ctf_encoding
  74 {
  75   unsigned int cte_format;  /* Data format (CTF_INT_* or CTF_FP_* flags).  */
  76   unsigned int cte_offset;  /* Offset of value in bits.  */
  77   unsigned int cte_bits;    /* Size of storage in bits.  */
  78 } ctf_encoding_t;
  79
  80 /* Array information for CTF generation.  */
  81
  82 typedef struct GTY (()) ctf_arinfo
  83 {
  84   ctf_id_t ctr_contents;        /* Type of array contents.  */
  85   ctf_id_t ctr_index;           /* Type of array index.  */
  86   unsigned int ctr_nelems;      /* Number of elements.  */
  87 } ctf_arinfo_t;
  88
  89 /* Function information for CTF generation.  */
  90
  91 typedef struct GTY (()) ctf_funcinfo
  92 {
  93   ctf_id_t ctc_return;          /* Function return type.  */
  94   unsigned int ctc_argc;        /* Number of typed arguments to function.  */
  95   unsigned int ctc_flags;       /* Function attributes (see below).  */
  96 } ctf_funcinfo_t;
  97
  98 typedef struct GTY (()) ctf_sliceinfo
  99 {
 100   unsigned int cts_type;        /* Reference CTF type.  */
 101   unsigned short cts_offset;    /* Offset in bits of the first bit.  */
 102   unsigned short cts_bits;      /* Size in bits.  */
 103 } ctf_sliceinfo_t;
 104
 105 /* CTF type representation internal to the compiler.  It closely reflects the
 106    ctf_type_t type node in <ctf.h> except the GTY (()) tags.  */
 107
 108 typedef struct GTY (()) ctf_itype
 109 {
 110   uint32_t ctti_name;           /* Reference to name in string table.  */
 111   uint32_t ctti_info;           /* Encoded kind, variant length (see below).  */
 112   union GTY ((desc ("0")))
 113   {
 114     uint32_t GTY ((tag ("0"))) _size;/* Size of entire type in bytes.  */
 115     uint32_t GTY ((tag ("1"))) _type;/* Reference to another type.  */
 116   } _u;
 117   uint32_t ctti_lsizehi;        /* High 32 bits of type size in bytes.  */
 118   uint32_t ctti_lsizelo;        /* Low 32 bits of type size in bytes.  */
 119 } ctf_itype_t;
 120
 121 #define ctti_size _u._size
 122 #define ctti_type _u._type
 123
 124 /* Function arguments end with varargs.  */
 125
 126 #define CTF_FUNC_VARARG 0x1
 127
 128 /* Struct/union/enum member definition for CTF generation.  */
 129
 130 typedef struct GTY ((chain_next ("%h.dmd_next"))) ctf_dmdef
 131 {
 132   const char * dmd_name;        /* Name of this member.  */
 133   ctf_id_t dmd_type;            /* Type of this member (for sou).  */
 134   uint32_t dmd_name_offset;     /* Offset of the name in str table.  */
 135   uint64_t dmd_offset;          /* Offset of this member in bits (for sou).  */
 136   int dmd_value;                /* Value of this member (for enum).  */
 137   struct ctf_dmdef * dmd_next;  /* A list node.  */
 138 } ctf_dmdef_t;
 139
 140 #define ctf_dmd_list_next(elem) ((ctf_dmdef_t *)((elem)->dmd_next))
 141
 142 /* Function Argument.  */
 143
 144 typedef struct GTY (()) ctf_func_arg
 145 {
 146   ctf_id_t farg_type;             /* Type identifier of the argument.  */
 147   const char * farg_name;         /* Name of the argument.  */
 148   uint32_t farg_name_offset;      /* Offset of the name in str table.  */
 149   struct ctf_func_arg * farg_next;/* A list node.  */
 150 } ctf_func_arg_t;
 151
 152 #define ctf_farg_list_next(elem) ((ctf_func_arg_t *)((elem)->farg_next))
 153
 154 /* Type definition for CTF generation.  */
 155
 156 struct GTY ((for_user)) ctf_dtdef
 157 {
 158   dw_die_ref dtd_key;         /* Type key for hashing.  */
 159   const char * dtd_name;      /* Name associated with definition (if any).  */
 160   ctf_id_t dtd_type;          /* Type identifier for this definition.  */
 161   ctf_itype_t dtd_data;       /* Type node.  */
 162   bool from_global_func; /* Whether this type was added from a global
 163                             function.  */
 164   uint32_t linkage;           /* Used in function types.  0=local, 1=global.  */
 165   union GTY ((desc ("ctf_dtu_d_union_selector (&%1)")))
 166   {
 167     /* struct, union, or enum.  */
 168     ctf_dmdef_t * GTY ((tag ("CTF_DTU_D_MEMBERS"))) dtu_members;
 169     /* array.  */
 170     ctf_arinfo_t GTY ((tag ("CTF_DTU_D_ARRAY"))) dtu_arr;
 171     /* integer or float.  */
 172     ctf_encoding_t GTY ((tag ("CTF_DTU_D_ENCODING"))) dtu_enc;
 173     /* function.  */
 174     ctf_func_arg_t * GTY ((tag ("CTF_DTU_D_ARGUMENTS"))) dtu_argv;
 175     /* slice.  */
 176     ctf_sliceinfo_t GTY ((tag ("CTF_DTU_D_SLICE"))) dtu_slice;
 177   } dtd_u;
 178 };
 179
 180 typedef struct ctf_dtdef ctf_dtdef_t;
 181
 182 /* Variable definition for CTF generation.  */
 183
 184 struct GTY ((for_user)) ctf_dvdef
 185 {
 186   dw_die_ref dvd_key;           /* DWARF DIE corresponding to the variable.  */
 187   const char * dvd_name;        /* Name associated with variable.  */
 188   uint32_t dvd_name_offset;     /* Offset of the name in str table.  */
 189   unsigned int dvd_visibility;  /* External visibility.  0=static,1=global.  */
 190   ctf_id_t dvd_type;            /* Type of variable.  */
 191 };
 192
 193 typedef struct ctf_dvdef ctf_dvdef_t;
 194
 195 typedef ctf_dvdef_t * ctf_dvdef_ref;
 196 typedef ctf_dtdef_t * ctf_dtdef_ref;
 197
 198 /* Location information for CTF Types and CTF Variables.  */
 199
 200 typedef struct GTY (()) ctf_srcloc
 201 {
 202   const char * ctsloc_file;
 203   unsigned int ctsloc_line;
 204   unsigned int ctsloc_col;
 205 } ctf_srcloc_t;
 206
 207 typedef ctf_srcloc_t * ctf_srcloc_ref;
 208
 209 /* Helper enum and api for the GTY machinery to work on union dtu_d.  */
 210
 211 enum ctf_dtu_d_union_enum {
 212   CTF_DTU_D_MEMBERS,
 213   CTF_DTU_D_ARRAY,
 214   CTF_DTU_D_ENCODING,
 215   CTF_DTU_D_ARGUMENTS,
 216   CTF_DTU_D_SLICE
 217 };
 218
 219 enum ctf_dtu_d_union_enum
 220 ctf_dtu_d_union_selector (ctf_dtdef_ref);
 221
 222 struct ctfc_dtd_hasher : ggc_ptr_hash <ctf_dtdef_t>
 223 {
 224   typedef ctf_dtdef_ref compare_type;
 225
 226   static hashval_t hash (ctf_dtdef_ref);
 227   static bool equal (ctf_dtdef_ref, ctf_dtdef_ref);
 228 };
 229
 230 inline hashval_t
 231 ctfc_dtd_hasher::hash (ctf_dtdef_ref dtd)
 232 {
 233   return htab_hash_pointer (dtd->dtd_key);
 234 }
 235
 236 inline bool
 237 ctfc_dtd_hasher::equal (ctf_dtdef_ref dtd, ctf_dtdef_ref dtd2)
 238 {
 239   return (dtd->dtd_key == dtd2->dtd_key);
 240 }
 241
 242 struct ctfc_dvd_hasher : ggc_ptr_hash <ctf_dvdef_t>
 243 {
 244   typedef ctf_dvdef_ref compare_type;
 245
 246   static hashval_t hash (ctf_dvdef_ref);
 247   static bool equal (ctf_dvdef_ref, ctf_dvdef_ref);
 248 };
 249
 250 inline hashval_t
 251 ctfc_dvd_hasher::hash (ctf_dvdef_ref dvd)
 252 {
 253   return htab_hash_pointer (dvd->dvd_key);
 254 }
 255
 256 inline bool
 257 ctfc_dvd_hasher::equal (ctf_dvdef_ref dvd, ctf_dvdef_ref dvd2)
 258 {
 259   return (dvd->dvd_key == dvd2->dvd_key);
 260 }
 261
 262 /* CTF container structure.
 263    It is the context passed around when generating ctf debug info.  There is
 264    one container per translation unit.  */
 265
 266 typedef struct GTY (()) ctf_container
 267 {
 268   /* CTF Preamble.  */
 269   unsigned short ctfc_magic;
 270   unsigned char ctfc_version;
 271   unsigned char ctfc_flags;
 272   uint32_t ctfc_cuname_offset;
 273
 274   /* CTF types.  */
 275   hash_table <ctfc_dtd_hasher> * GTY (()) ctfc_types;
 276   /* CTF variables.  */
 277   hash_table <ctfc_dvd_hasher> * GTY (()) ctfc_vars;
 278   /* CTF variables to be ignored.  */
 279   hash_table <ctfc_dvd_hasher> * GTY (()) ctfc_ignore_vars;
 280
 281   /* CTF string table.  */
 282   ctf_strtable_t ctfc_strtable;
 283   /* Auxilliary string table.  At this time, used for keeping func arg names
 284      for BTF.  */
 285   ctf_strtable_t ctfc_aux_strtable;
 286
 287   uint64_t ctfc_num_types;
 288   uint64_t ctfc_num_stypes;
 289   uint64_t ctfc_num_global_funcs;
 290   uint64_t ctfc_num_global_objts;
 291
 292   /* Number of vlen bytes - the variable length portion after ctf_type_t and
 293      ctf_stype_t in the CTF section.  This is used to calculate the offsets in
 294      the CTF header.  */
 295   uint64_t ctfc_num_vlen_bytes;
 296
 297   /* Next CTF type id to assign.  */
 298   ctf_id_t ctfc_nextid;
 299
 300   /* Specify an explicit length of 0 so that the GC marking routines steer
 301      clear of marking the CTF vars and CTF types twice. These lists below do
 302      not own the pointed to objects, they simply hold references to them.  */
 303
 304   /* List of pre-processed CTF Variables.  CTF requires that the variables
 305      appear in the sorted order of their names.  */
 306   ctf_dvdef_t ** GTY ((length ("0"))) ctfc_vars_list;
 307   /* Count of pre-processed CTF Variables in the list.  */
 308   uint64_t ctfc_vars_list_count;
 309   /* List of pre-processed CTF types.  CTF requires that a shared type must
 310      appear before the type that uses it.  For the compiler, this means types
 311      are emitted in sorted order of their type IDs.  */
 312   ctf_dtdef_t ** GTY ((length ("0"))) ctfc_types_list;
 313   /* List of CTF function types for global functions.  The order of global
 314      function entries in the CTF funcinfo section is undefined by the
 315      compiler.  */
 316   ctf_dtdef_t ** GTY ((length ("0"))) ctfc_gfuncs_list;
 317   /* List of CTF variables at global scope.  The order of global object entries
 318      in the CTF objinfo section is undefined by the  compiler.  */
 319   ctf_dvdef_t ** GTY ((length ("0"))) ctfc_gobjts_list;
 320
 321   /* Following members are for debugging only.  They do not add functional
 322      value to the task of CTF creation.  These can be cleaned up once CTF
 323      generation stabilizes.  */
 324
 325   /* Keep a count of the number of bytes dumped in asm for debugging
 326      purposes.  */
 327   uint64_t ctfc_numbytes_asm;
 328    /* Total length of all strings in CTF.  */
 329   size_t ctfc_strlen;
 330   /* Total length of all strings in aux string table.  */
 331   size_t ctfc_aux_strlen;
 332
 333 } ctf_container_t;
 334
 335 /* Markers for which string table from the CTF container to use.  */
 336
 337 #define CTF_STRTAB 0        /* CTF string table.  */
 338 #define CTF_AUX_STRTAB 1    /* CTF auxilliary string table.  */
 339
 340 typedef ctf_container_t * ctf_container_ref;
 341
 342 extern GTY (()) ctf_container_ref tu_ctfc;
 343
 344 extern void ctfc_delete_container (ctf_container_ref);
 345
 346 /* If the next ctf type id is still set to the init value, no ctf records to
 347    report.  */
 348 extern bool ctfc_is_empty_container (ctf_container_ref);
 349
 350 /* Get the total number of CTF types in the container.  */
 351
 352 extern unsigned int ctfc_get_num_ctf_types (ctf_container_ref);
 353
 354 /* Get the total number of CTF variables in the container.  */
 355
 356 extern unsigned int ctfc_get_num_ctf_vars (ctf_container_ref);
 357
 358 /* Get reference to the CTF string table or the CTF auxilliary
 359    string table.  */
 360
 361 extern ctf_strtable_t * ctfc_get_strtab (ctf_container_ref, int);
 362
 363 /* Get the length of the specified string table in the CTF container.  */
 364
 365 extern size_t ctfc_get_strtab_len (ctf_container_ref, int);
 366
 367 /* Get the number of bytes to represent the variable length portion of all CTF
 368    types in the CTF container.  */
 369
 370 extern size_t ctfc_get_num_vlen_bytes (ctf_container_ref);
 371
 372 /* The compiler demarcates whether types are visible at top-level scope or not.
 373    The only example so far of a type not visible at top-level scope is slices.
 374    CTF_ADD_NONROOT is used to indicate the latter.  */
 375 #define CTF_ADD_NONROOT 0       /* CTF type only visible in nested scope.  */
 376 #define CTF_ADD_ROOT    1       /* CTF type visible at top-level scope.  */
 377
 378 /* These APIs allow to initialize and finalize the CTF machinery and
 379    to add types to the CTF container associated to the current
 380    translation unit.  Used in dwarf2ctf.cc.  */
 381
 382 extern void ctf_init (void);
 383 extern void ctf_output (const char * filename);
 384 extern void ctf_finalize (void);
 385
 386 extern void btf_output (const char * filename);
 387 extern void btf_init_postprocess (void);
 388 extern void btf_finalize (void);
 389
 390 extern ctf_container_ref ctf_get_tu_ctfc (void);
 391
 392 extern bool ctf_type_exists (ctf_container_ref, dw_die_ref, ctf_id_t *);
 393
 394 extern void ctf_add_cuname (ctf_container_ref, const char *);
 395
 396 extern ctf_dtdef_ref ctf_dtd_lookup (const ctf_container_ref ctfc,
 397                                      dw_die_ref die);
 398 extern ctf_dvdef_ref ctf_dvd_lookup (const ctf_container_ref ctfc,
 399                                      dw_die_ref die);
 400 extern bool ctf_dvd_ignore_lookup (const ctf_container_ref ctfc,
 401                                    dw_die_ref die);
 402
 403 extern const char * ctf_add_string (ctf_container_ref, const char *,
 404                                     uint32_t *, int);
 405
 406 extern ctf_id_t ctf_add_reftype (ctf_container_ref, uint32_t, ctf_id_t,
 407                                  uint32_t, dw_die_ref);
 408 extern ctf_id_t ctf_add_enum (ctf_container_ref, uint32_t, const char *,
 409                               HOST_WIDE_INT, dw_die_ref);
 410 extern ctf_id_t ctf_add_slice (ctf_container_ref, uint32_t, ctf_id_t,
 411                                uint32_t, uint32_t, dw_die_ref);
 412 extern ctf_id_t ctf_add_float (ctf_container_ref, uint32_t, const char *,
 413                                const ctf_encoding_t *, dw_die_ref);
 414 extern ctf_id_t ctf_add_integer (ctf_container_ref, uint32_t, const char *,
 415                                  const ctf_encoding_t *, dw_die_ref);
 416 extern ctf_id_t ctf_add_unknown (ctf_container_ref, uint32_t, const char *,
 417                                  const ctf_encoding_t *, dw_die_ref);
 418 extern ctf_id_t ctf_add_pointer (ctf_container_ref, uint32_t, ctf_id_t,
 419                                  dw_die_ref);
 420 extern ctf_id_t ctf_add_array (ctf_container_ref, uint32_t,
 421                                const ctf_arinfo_t *, dw_die_ref);
 422 extern ctf_id_t ctf_add_forward (ctf_container_ref, uint32_t, const char *,
 423                                  uint32_t, dw_die_ref);
 424 extern ctf_id_t ctf_add_typedef (ctf_container_ref, uint32_t, const char *,
 425                                  ctf_id_t, dw_die_ref);
 426 extern ctf_id_t ctf_add_function (ctf_container_ref, uint32_t, const char *,
 427                                   const ctf_funcinfo_t *, dw_die_ref, bool, int);
 428 extern ctf_id_t ctf_add_sou (ctf_container_ref, uint32_t, const char *,
 429                              uint32_t, size_t, dw_die_ref);
 430
 431 extern int ctf_add_enumerator (ctf_container_ref, ctf_id_t, const char *,
 432                                HOST_WIDE_INT, dw_die_ref);
 433 extern int ctf_add_member_offset (ctf_container_ref, dw_die_ref, const char *,
 434                                   ctf_id_t, uint64_t);
 435 extern int ctf_add_function_arg (ctf_container_ref, dw_die_ref,
 436                                  const char *, ctf_id_t);
 437 extern int ctf_add_variable (ctf_container_ref, const char *, ctf_id_t,
 438                              dw_die_ref, unsigned int, dw_die_ref);
 439
 440 extern ctf_id_t ctf_lookup_tree_type (ctf_container_ref, const tree);
 441 extern ctf_id_t get_btf_id (ctf_id_t);
 442
 443 /* CTF section does not emit location information; at this time, location
 444    information is needed for BTF CO-RE use-cases.  */
 445
 446 extern int ctfc_get_dtd_srcloc (ctf_dtdef_ref, ctf_srcloc_ref);
 447 extern int ctfc_get_dvd_srcloc (ctf_dvdef_ref, ctf_srcloc_ref);
 448
 449 #endif /* GCC_CTFC_H */