1134 lines
33 KiB
C++
1134 lines
33 KiB
C++
/* Output BTF format from GCC.
|
|
Copyright (C) 2021-2022 Free Software Foundation, Inc.
|
|
|
|
This file is part of GCC.
|
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
|
the terms of the GNU General Public License as published by the Free
|
|
Software Foundation; either version 3, or (at your option) any later
|
|
version.
|
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GCC; see the file COPYING3. If not see
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
/* This file contains routines to output the BPF Type Format (BTF). The BTF
|
|
debug format is very similar to CTF; as a result, the structure of this file
|
|
closely resembles that of ctfout.cc, and the same CTF container objects are
|
|
used. */
|
|
|
|
#include "config.h"
|
|
#include "system.h"
|
|
#include "coretypes.h"
|
|
#include "target.h"
|
|
#include "memmodel.h"
|
|
#include "tm_p.h"
|
|
#include "output.h"
|
|
#include "dwarf2asm.h"
|
|
#include "debug.h"
|
|
#include "ctfc.h"
|
|
#include "diagnostic-core.h"
|
|
#include "cgraph.h"
|
|
#include "varasm.h"
|
|
#include "dwarf2out.h" /* For lookup_decl_die. */
|
|
|
|
static int btf_label_num;
|
|
|
|
static GTY (()) section * btf_info_section;
|
|
|
|
/* BTF debug info section. */
|
|
|
|
#ifndef BTF_INFO_SECTION_NAME
|
|
#define BTF_INFO_SECTION_NAME ".BTF"
|
|
#endif
|
|
|
|
#define BTF_INFO_SECTION_FLAGS (SECTION_DEBUG)
|
|
|
|
/* Maximum size (in bytes) for an artifically generated BTF label. */
|
|
|
|
#define MAX_BTF_LABEL_BYTES 40
|
|
|
|
static char btf_info_section_label[MAX_BTF_LABEL_BYTES];
|
|
|
|
#ifndef BTF_INFO_SECTION_LABEL
|
|
#define BTF_INFO_SECTION_LABEL "Lbtf"
|
|
#endif
|
|
|
|
/* BTF encodes void as type id 0. */
|
|
|
|
#define BTF_VOID_TYPEID 0
|
|
#define BTF_INIT_TYPEID 1
|
|
|
|
#define BTF_INVALID_TYPEID 0xFFFFFFFF
|
|
|
|
/* Mapping of CTF variables to the IDs they will be assigned when they are
|
|
converted to BTF_KIND_VAR type records. Strictly accounts for the index
|
|
from the start of the variable type entries, does not include the number
|
|
of types emitted prior to the variable records. */
|
|
static GTY (()) hash_map <ctf_dvdef_ref, unsigned> *btf_var_ids;
|
|
|
|
/* Mapping of type IDs from original CTF ID to BTF ID. Types do not map
|
|
1-to-1 from CTF to BTF. To avoid polluting the CTF container when updating
|
|
type references-by-ID, we use this map instead. */
|
|
static ctf_id_t * btf_id_map = NULL;
|
|
|
|
/* Information for creating the BTF_KIND_DATASEC records. */
|
|
typedef struct btf_datasec
|
|
{
|
|
const char *name; /* Section name, e.g. ".bss". */
|
|
uint32_t name_offset; /* Offset to name in string table. */
|
|
vec<struct btf_var_secinfo> entries; /* Variable entries in this section. */
|
|
} btf_datasec_t;
|
|
|
|
/* One BTF_KIND_DATASEC record is created for each output data section which
|
|
will hold at least one variable. */
|
|
static vec<btf_datasec_t> datasecs;
|
|
|
|
/* Holes occur for types which are present in the CTF container, but are either
|
|
non-representable or redundant in BTF. */
|
|
static vec<ctf_id_t> holes;
|
|
|
|
/* CTF definition(s) of void. Only one definition of void should be generated.
|
|
We should not encounter more than one definition of void, but use a vector
|
|
to be safe. */
|
|
static vec<ctf_id_t> voids;
|
|
|
|
/* Functions in BTF have two separate type records - one for the prototype
|
|
(BTF_KIND_FUNC_PROTO), as well as a BTF_KIND_FUNC. CTF_K_FUNCTION types
|
|
map closely to BTF_KIND_FUNC_PROTO, but the BTF_KIND_FUNC records must be
|
|
created. This vector holds them. */
|
|
static GTY (()) vec<ctf_dtdef_ref, va_gc> *funcs;
|
|
|
|
/* The number of BTF variables added to the TU CTF container. */
|
|
static unsigned int num_vars_added = 0;
|
|
|
|
/* The number of BTF types added to the TU CTF container. */
|
|
static unsigned int num_types_added = 0;
|
|
|
|
/* The number of types synthesized for BTF that do not correspond to
|
|
CTF types. */
|
|
static unsigned int num_types_created = 0;
|
|
|
|
/* Map a CTF type kind to the corresponding BTF type kind. */
|
|
|
|
static uint32_t
|
|
get_btf_kind (uint32_t ctf_kind)
|
|
{
|
|
/* N.B. the values encoding kinds are not in general the same for the
|
|
same kind between CTF and BTF. e.g. CTF_K_CONST != BTF_KIND_CONST. */
|
|
switch (ctf_kind)
|
|
{
|
|
case CTF_K_INTEGER: return BTF_KIND_INT;
|
|
case CTF_K_FLOAT: return BTF_KIND_FLOAT;
|
|
case CTF_K_POINTER: return BTF_KIND_PTR;
|
|
case CTF_K_ARRAY: return BTF_KIND_ARRAY;
|
|
case CTF_K_FUNCTION: return BTF_KIND_FUNC_PROTO;
|
|
case CTF_K_STRUCT: return BTF_KIND_STRUCT;
|
|
case CTF_K_UNION: return BTF_KIND_UNION;
|
|
case CTF_K_ENUM: return BTF_KIND_ENUM;
|
|
case CTF_K_FORWARD: return BTF_KIND_FWD;
|
|
case CTF_K_TYPEDEF: return BTF_KIND_TYPEDEF;
|
|
case CTF_K_VOLATILE: return BTF_KIND_VOLATILE;
|
|
case CTF_K_CONST: return BTF_KIND_CONST;
|
|
case CTF_K_RESTRICT: return BTF_KIND_RESTRICT;
|
|
default:;
|
|
}
|
|
return BTF_KIND_UNKN;
|
|
}
|
|
|
|
/* Allocate the btf_id_map, and initialize elements to BTF_INVALID_TYPEID. */
|
|
|
|
static void
|
|
init_btf_id_map (size_t len)
|
|
{
|
|
btf_id_map = XNEWVEC (ctf_id_t, len);
|
|
|
|
btf_id_map[0] = BTF_VOID_TYPEID;
|
|
for (size_t i = 1; i < len; i++)
|
|
btf_id_map[i] = BTF_INVALID_TYPEID;
|
|
}
|
|
|
|
/* Return the BTF type ID of CTF type ID KEY, or BTF_INVALID_TYPEID if the CTF
|
|
type with ID KEY does not map to a BTF type. */
|
|
|
|
ctf_id_t
|
|
get_btf_id (ctf_id_t key)
|
|
{
|
|
return btf_id_map[key];
|
|
}
|
|
|
|
/* Set the CTF type ID KEY to map to BTF type ID VAL. */
|
|
|
|
static inline void
|
|
set_btf_id (ctf_id_t key, ctf_id_t val)
|
|
{
|
|
btf_id_map[key] = val;
|
|
}
|
|
|
|
/* Return TRUE iff the given CTF type ID maps to a BTF type which will
|
|
be emitted. */
|
|
static inline bool
|
|
btf_emit_id_p (ctf_id_t id)
|
|
{
|
|
return ((btf_id_map[id] != BTF_VOID_TYPEID)
|
|
&& (btf_id_map[id] <= BTF_MAX_TYPE));
|
|
}
|
|
|
|
/* Each BTF type can be followed additional, variable-length information
|
|
completing the description of the type. Calculate the number of bytes
|
|
of variable information required to encode a given type. */
|
|
|
|
static uint64_t
|
|
btf_calc_num_vbytes (ctf_dtdef_ref dtd)
|
|
{
|
|
uint64_t vlen_bytes = 0;
|
|
|
|
uint32_t kind = get_btf_kind (CTF_V2_INFO_KIND (dtd->dtd_data.ctti_info));
|
|
uint32_t vlen = CTF_V2_INFO_VLEN (dtd->dtd_data.ctti_info);
|
|
|
|
switch (kind)
|
|
{
|
|
case BTF_KIND_UNKN:
|
|
case BTF_KIND_PTR:
|
|
case BTF_KIND_FWD:
|
|
case BTF_KIND_TYPEDEF:
|
|
case BTF_KIND_VOLATILE:
|
|
case BTF_KIND_CONST:
|
|
case BTF_KIND_RESTRICT:
|
|
case BTF_KIND_FUNC:
|
|
/* These kinds have no vlen data. */
|
|
break;
|
|
|
|
case BTF_KIND_INT:
|
|
/* Size 0 integers represent redundant definitions of void that will
|
|
not be emitted. Don't allocate space for them. */
|
|
if (dtd->dtd_data.ctti_size == 0)
|
|
break;
|
|
|
|
vlen_bytes += sizeof (uint32_t);
|
|
break;
|
|
|
|
case BTF_KIND_ARRAY:
|
|
vlen_bytes += sizeof (struct btf_array);
|
|
break;
|
|
|
|
case BTF_KIND_STRUCT:
|
|
case BTF_KIND_UNION:
|
|
vlen_bytes += vlen * sizeof (struct btf_member);
|
|
break;
|
|
|
|
case BTF_KIND_ENUM:
|
|
vlen_bytes += vlen * sizeof (struct btf_enum);
|
|
break;
|
|
|
|
case BTF_KIND_FUNC_PROTO:
|
|
vlen_bytes += vlen * sizeof (struct btf_param);
|
|
break;
|
|
|
|
case BTF_KIND_VAR:
|
|
vlen_bytes += sizeof (struct btf_var);
|
|
break;
|
|
|
|
case BTF_KIND_DATASEC:
|
|
vlen_bytes += vlen * sizeof (struct btf_var_secinfo);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return vlen_bytes;
|
|
}
|
|
|
|
/* Initialize BTF section (.BTF) for output. */
|
|
|
|
void
|
|
init_btf_sections (void)
|
|
{
|
|
btf_info_section = get_section (BTF_INFO_SECTION_NAME, BTF_INFO_SECTION_FLAGS,
|
|
NULL);
|
|
|
|
ASM_GENERATE_INTERNAL_LABEL (btf_info_section_label,
|
|
BTF_INFO_SECTION_LABEL, btf_label_num++);
|
|
}
|
|
|
|
/* Push a BTF datasec variable entry INFO into the datasec named SECNAME,
|
|
creating the datasec if it does not already exist. */
|
|
|
|
static void
|
|
btf_datasec_push_entry (ctf_container_ref ctfc, const char *secname,
|
|
struct btf_var_secinfo info)
|
|
{
|
|
if (secname == NULL)
|
|
return;
|
|
|
|
for (size_t i = 0; i < datasecs.length (); i++)
|
|
if (strcmp (datasecs[i].name, secname) == 0)
|
|
{
|
|
datasecs[i].entries.safe_push (info);
|
|
return;
|
|
}
|
|
|
|
/* If we don't already have a datasec record for secname, make one. */
|
|
|
|
uint32_t str_off;
|
|
ctf_add_string (ctfc, secname, &str_off, CTF_AUX_STRTAB);
|
|
if (strcmp (secname, ""))
|
|
ctfc->ctfc_aux_strlen += strlen (secname) + 1;
|
|
|
|
btf_datasec_t ds;
|
|
ds.name = secname;
|
|
ds.name_offset = str_off;
|
|
|
|
ds.entries.create (0);
|
|
ds.entries.safe_push (info);
|
|
|
|
datasecs.safe_push (ds);
|
|
num_types_created++;
|
|
}
|
|
|
|
/* Construct all BTF_KIND_DATASEC records for CTFC. One such record is created
|
|
for each non-empty data-containing section in the output. Each record is
|
|
followed by a variable number of entries describing the variables stored
|
|
in that section. */
|
|
|
|
static void
|
|
btf_collect_datasec (ctf_container_ref ctfc)
|
|
{
|
|
/* See cgraph.h struct symtab_node, which varpool_node extends. */
|
|
varpool_node *node;
|
|
FOR_EACH_VARIABLE (node)
|
|
{
|
|
dw_die_ref die = lookup_decl_die (node->decl);
|
|
if (die == NULL)
|
|
continue;
|
|
|
|
ctf_dvdef_ref dvd = ctf_dvd_lookup (ctfc, die);
|
|
if (dvd == NULL)
|
|
continue;
|
|
|
|
const char *section_name = node->get_section ();
|
|
|
|
if (section_name == NULL)
|
|
{
|
|
switch (categorize_decl_for_section (node->decl, 0))
|
|
{
|
|
case SECCAT_BSS:
|
|
section_name = ".bss";
|
|
break;
|
|
case SECCAT_DATA:
|
|
section_name = ".data";
|
|
break;
|
|
case SECCAT_RODATA:
|
|
section_name = ".rodata";
|
|
break;
|
|
default:
|
|
continue;
|
|
}
|
|
}
|
|
|
|
struct btf_var_secinfo info;
|
|
|
|
info.type = 0;
|
|
unsigned int *var_id = btf_var_ids->get (dvd);
|
|
if (var_id)
|
|
/* +1 for the sentinel type not in the types map. */
|
|
info.type = *var_id + num_types_added + 1;
|
|
else
|
|
continue;
|
|
|
|
info.size = 0;
|
|
tree size = DECL_SIZE_UNIT (node->decl);
|
|
if (tree_fits_uhwi_p (size))
|
|
info.size = tree_to_uhwi (size);
|
|
|
|
/* Offset is left as 0 at compile time, to be filled in by loaders such
|
|
as libbpf. */
|
|
info.offset = 0;
|
|
|
|
btf_datasec_push_entry (ctfc, section_name, info);
|
|
}
|
|
}
|
|
|
|
/* Return true if the type ID is that of a type which will not be emitted (for
|
|
example, if it is not representable in BTF). */
|
|
|
|
static bool
|
|
btf_removed_type_p (ctf_id_t id)
|
|
{
|
|
return holes.contains (id);
|
|
}
|
|
|
|
/* Adjust the given type ID to account for holes and duplicate definitions of
|
|
void. */
|
|
|
|
static ctf_id_t
|
|
btf_adjust_type_id (ctf_id_t id)
|
|
{
|
|
size_t n;
|
|
ctf_id_t i = 0;
|
|
|
|
/* Do not adjust invalid type markers. */
|
|
if (id == BTF_INVALID_TYPEID)
|
|
return id;
|
|
|
|
for (n = 0; n < voids.length (); n++)
|
|
if (id == voids[n])
|
|
return BTF_VOID_TYPEID;
|
|
|
|
for (n = 0; n < holes.length (); n++)
|
|
{
|
|
if (holes[n] < id)
|
|
i++;
|
|
else if (holes[n] == id)
|
|
return BTF_VOID_TYPEID;
|
|
}
|
|
|
|
return id - i;
|
|
}
|
|
|
|
/* Postprocessing callback routine for types. */
|
|
|
|
int
|
|
btf_dtd_postprocess_cb (ctf_dtdef_ref *slot, ctf_container_ref arg_ctfc)
|
|
{
|
|
ctf_dtdef_ref ctftype = (ctf_dtdef_ref) * slot;
|
|
|
|
size_t index = ctftype->dtd_type;
|
|
gcc_assert (index <= arg_ctfc->ctfc_types->elements ());
|
|
|
|
uint32_t ctf_kind, btf_kind;
|
|
|
|
ctf_kind = CTF_V2_INFO_KIND (ctftype->dtd_data.ctti_info);
|
|
btf_kind = get_btf_kind (ctf_kind);
|
|
|
|
if (btf_kind == BTF_KIND_UNKN)
|
|
/* This type is not representable in BTF. Create a hole. */
|
|
holes.safe_push (ctftype->dtd_type);
|
|
|
|
else if (btf_kind == BTF_KIND_INT && ctftype->dtd_data.ctti_size == 0)
|
|
{
|
|
/* This is a (redundant) definition of void. */
|
|
voids.safe_push (ctftype->dtd_type);
|
|
holes.safe_push (ctftype->dtd_type);
|
|
}
|
|
|
|
arg_ctfc->ctfc_types_list[index] = ctftype;
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* Preprocessing callback routine for variables. */
|
|
|
|
int
|
|
btf_dvd_emit_preprocess_cb (ctf_dvdef_ref *slot, ctf_container_ref arg_ctfc)
|
|
{
|
|
ctf_dvdef_ref var = (ctf_dvdef_ref) * slot;
|
|
|
|
/* Do not add variables which refer to unsupported types. */
|
|
if (btf_removed_type_p (var->dvd_type))
|
|
return 1;
|
|
|
|
arg_ctfc->ctfc_vars_list[num_vars_added] = var;
|
|
btf_var_ids->put (var, num_vars_added);
|
|
|
|
num_vars_added++;
|
|
num_types_created++;
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* Preprocessing callback routine for types. */
|
|
|
|
static void
|
|
btf_dtd_emit_preprocess_cb (ctf_container_ref ctfc, ctf_dtdef_ref dtd)
|
|
{
|
|
if (!btf_emit_id_p (dtd->dtd_type))
|
|
return;
|
|
|
|
uint32_t btf_kind
|
|
= get_btf_kind (CTF_V2_INFO_KIND (dtd->dtd_data.ctti_info));
|
|
|
|
if (btf_kind == BTF_KIND_FUNC_PROTO)
|
|
{
|
|
/* Functions actually get two types: a BTF_KIND_FUNC_PROTO, and
|
|
also a BTF_KIND_FUNC. But the CTF container only allocates one
|
|
type per function, which matches closely with BTF_KIND_FUNC_PROTO.
|
|
For each such function, also allocate a BTF_KIND_FUNC entry.
|
|
These will be output later. */
|
|
ctf_dtdef_ref func_dtd = ggc_cleared_alloc<ctf_dtdef_t> ();
|
|
func_dtd->dtd_data = dtd->dtd_data;
|
|
func_dtd->dtd_data.ctti_type = dtd->dtd_type;
|
|
|
|
vec_safe_push (funcs, func_dtd);
|
|
num_types_created++;
|
|
|
|
/* Only the BTF_KIND_FUNC type actually references the name. The
|
|
BTF_KIND_FUNC_PROTO is always anonymous. */
|
|
dtd->dtd_data.ctti_name = 0;
|
|
}
|
|
|
|
ctfc->ctfc_num_vlen_bytes += btf_calc_num_vbytes (dtd);
|
|
}
|
|
|
|
/* Preprocess the CTF information to prepare for BTF output. BTF is almost a
|
|
subset of CTF, with many small differences in encoding, and lacking support
|
|
for some types (notably floating point formats).
|
|
|
|
During the preprocessing pass:
|
|
- Ascertain that the sorted list of types has been prepared. For the BTF
|
|
generation process, this is taken care of by the btf_init_postprocess ().
|
|
|
|
- BTF_KIND_FUNC and BTF_KIND_DATASEC records are constructed. These types do
|
|
not have analogues in CTF (the analogous type to CTF_K_FUNCTION is
|
|
BTF_KIND_FUNC_PROTO), but can be relatively easily deduced from CTF
|
|
information.
|
|
|
|
- Construct BTF_KIND_VAR records, representing variables.
|
|
|
|
- Calculate the total size in bytes of variable-length information following
|
|
BTF type records. This is used for outputting the BTF header.
|
|
|
|
After preprocessing, all BTF information is ready to be output:
|
|
- ctfc->ctfc_types_list holdstypes converted from CTF types. This does not
|
|
include KIND_VAR, KIND_FUNC, nor KIND_DATASEC types. These types have been
|
|
re-encoded to the appropriate representation in BTF.
|
|
- ctfc->ctfc_vars_list holds all variables which should be output.
|
|
Variables of unsupported types are not present in this list.
|
|
- Vector 'funcs' holds all BTF_KIND_FUNC types, one to match each
|
|
BTF_KIND_FUNC_PROTO.
|
|
- Vector 'datasecs' holds all BTF_KIND_DATASEC types. */
|
|
|
|
static void
|
|
btf_emit_preprocess (ctf_container_ref ctfc)
|
|
{
|
|
size_t num_ctf_types = ctfc->ctfc_types->elements ();
|
|
size_t num_ctf_vars = ctfc->ctfc_vars->elements ();
|
|
size_t i;
|
|
|
|
if (num_ctf_types)
|
|
{
|
|
gcc_assert (ctfc->ctfc_types_list);
|
|
/* Preprocess the types. */
|
|
for (i = 1; i <= num_ctf_types; i++)
|
|
btf_dtd_emit_preprocess_cb (ctfc, ctfc->ctfc_types_list[i]);
|
|
}
|
|
|
|
btf_var_ids = hash_map<ctf_dvdef_ref, unsigned int>::create_ggc (100);
|
|
|
|
if (num_ctf_vars)
|
|
{
|
|
/* Allocate and construct the list of variables. While BTF variables are
|
|
not distinct from types (in that variables are simply types with
|
|
BTF_KIND_VAR), it is simpler to maintain a separate list of variables
|
|
and append them to the types list during output. */
|
|
ctfc->ctfc_vars_list = ggc_vec_alloc<ctf_dvdef_ref>(num_ctf_vars);
|
|
ctfc->ctfc_vars->traverse<ctf_container_ref, btf_dvd_emit_preprocess_cb>
|
|
(ctfc);
|
|
|
|
ctfc->ctfc_num_vlen_bytes += (num_vars_added * sizeof (struct btf_var));
|
|
}
|
|
|
|
btf_collect_datasec (ctfc);
|
|
}
|
|
|
|
/* Return true iff DMD is a member description of a bit-field which can be
|
|
validly represented in BTF. */
|
|
|
|
static bool
|
|
btf_dmd_representable_bitfield_p (ctf_container_ref ctfc, ctf_dmdef_t *dmd)
|
|
{
|
|
ctf_dtdef_ref ref_type = ctfc->ctfc_types_list[dmd->dmd_type];
|
|
|
|
if (CTF_V2_INFO_KIND (ref_type->dtd_data.ctti_info) == CTF_K_SLICE)
|
|
{
|
|
unsigned short word_offset = ref_type->dtd_u.dtu_slice.cts_offset;
|
|
unsigned short bits = ref_type->dtd_u.dtu_slice.cts_bits;
|
|
uint64_t sou_offset = dmd->dmd_offset;
|
|
|
|
if ((bits > 0xff) || ((sou_offset + word_offset) > 0xffffff))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/* BTF asm helper routines. */
|
|
|
|
/* Asm'out a BTF type. This routine is responsible for the bulk of the task
|
|
of converting CTF types to their BTF representation. */
|
|
|
|
static void
|
|
btf_asm_type (ctf_container_ref ctfc, ctf_dtdef_ref dtd)
|
|
{
|
|
uint32_t btf_kind, btf_kflag, btf_vlen, btf_size_type;
|
|
uint32_t ctf_info = dtd->dtd_data.ctti_info;
|
|
|
|
btf_kind = get_btf_kind (CTF_V2_INFO_KIND (ctf_info));
|
|
btf_size_type = dtd->dtd_data.ctti_type;
|
|
btf_vlen = CTF_V2_INFO_VLEN (ctf_info);
|
|
|
|
/* By now any unrepresentable types have been removed. */
|
|
gcc_assert (btf_kind != BTF_KIND_UNKN);
|
|
|
|
/* Size 0 integers are redundant definitions of void. None should remain
|
|
in the types list by this point. */
|
|
gcc_assert (btf_kind != BTF_KIND_INT || btf_size_type >= 1);
|
|
|
|
/* Re-encode the ctti_info to BTF. */
|
|
/* kflag is 1 for structs/unions with a bitfield member.
|
|
kflag is 1 for forwards to unions.
|
|
kflag is 0 in all other cases. */
|
|
btf_kflag = 0;
|
|
|
|
if (btf_kind == BTF_KIND_STRUCT || btf_kind == BTF_KIND_UNION)
|
|
{
|
|
/* If a struct/union has ANY bitfield members, set kflag=1.
|
|
Note that we must also change the encoding of every member to encode
|
|
both member bitfield size (stealing most-significant 8 bits) and bit
|
|
offset (LS 24 bits). This is done during preprocessing. */
|
|
ctf_dmdef_t *dmd;
|
|
for (dmd = dtd->dtd_u.dtu_members;
|
|
dmd != NULL; dmd = (ctf_dmdef_t *) ctf_dmd_list_next (dmd))
|
|
{
|
|
/* Set kflag if this member is a representable bitfield. */
|
|
if (btf_dmd_representable_bitfield_p (ctfc, dmd))
|
|
btf_kflag = 1;
|
|
|
|
/* Struct members that refer to unsupported types or bitfield formats
|
|
shall be skipped. These are marked during preprocessing. */
|
|
else if (!btf_emit_id_p (dmd->dmd_type))
|
|
btf_vlen -= 1;
|
|
}
|
|
}
|
|
|
|
/* BTF forwards make use of KIND_FLAG to distinguish between forwards to
|
|
structs and forwards to unions. The dwarf2ctf conversion process stores
|
|
the kind of the forward in ctti_type, but for BTF this must be 0 for
|
|
forwards, with only the KIND_FLAG to distinguish.
|
|
At time of writing, BTF forwards to enums are unspecified. */
|
|
if (btf_kind == BTF_KIND_FWD)
|
|
{
|
|
if (dtd->dtd_data.ctti_type == CTF_K_UNION)
|
|
btf_kflag = 1;
|
|
|
|
btf_size_type = 0;
|
|
}
|
|
|
|
dw2_asm_output_data (4, dtd->dtd_data.ctti_name, "btt_name");
|
|
dw2_asm_output_data (4, BTF_TYPE_INFO (btf_kind, btf_kflag, btf_vlen),
|
|
"btt_info: kind=%u, kflag=%u, vlen=%u",
|
|
btf_kind, btf_kflag, btf_vlen);
|
|
switch (btf_kind)
|
|
{
|
|
case BTF_KIND_INT:
|
|
case BTF_KIND_FLOAT:
|
|
case BTF_KIND_STRUCT:
|
|
case BTF_KIND_UNION:
|
|
case BTF_KIND_ENUM:
|
|
case BTF_KIND_DATASEC:
|
|
dw2_asm_output_data (4, dtd->dtd_data.ctti_size, "btt_size: %uB",
|
|
dtd->dtd_data.ctti_size);
|
|
return;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
dw2_asm_output_data (4, get_btf_id (dtd->dtd_data.ctti_type), "btt_type");
|
|
}
|
|
|
|
/* Asm'out the variable information following a BTF_KIND_ARRAY. */
|
|
|
|
static void
|
|
btf_asm_array (ctf_dtdef_ref dtd)
|
|
{
|
|
dw2_asm_output_data (4, get_btf_id (dtd->dtd_u.dtu_arr.ctr_contents),
|
|
"bta_contents");
|
|
dw2_asm_output_data (4, get_btf_id (dtd->dtd_u.dtu_arr.ctr_index),
|
|
"bta_index");
|
|
dw2_asm_output_data (4, dtd->dtd_u.dtu_arr.ctr_nelems, "bta_nelems");
|
|
}
|
|
|
|
/* Asm'out a BTF_KIND_VAR. */
|
|
|
|
static void
|
|
btf_asm_varent (ctf_dvdef_ref var)
|
|
{
|
|
dw2_asm_output_data (4, var->dvd_name_offset, "btv_name");
|
|
dw2_asm_output_data (4, BTF_TYPE_INFO (BTF_KIND_VAR, 0, 0), "btv_info");
|
|
dw2_asm_output_data (4, get_btf_id (var->dvd_type), "btv_type");
|
|
dw2_asm_output_data (4, (var->dvd_visibility ? 1 : 0), "btv_linkage");
|
|
}
|
|
|
|
/* Asm'out a member description following a BTF_KIND_STRUCT or
|
|
BTF_KIND_UNION. */
|
|
|
|
static void
|
|
btf_asm_sou_member (ctf_container_ref ctfc, ctf_dmdef_t * dmd)
|
|
{
|
|
ctf_dtdef_ref ref_type = ctfc->ctfc_types_list[dmd->dmd_type];
|
|
|
|
/* Re-encode bitfields to BTF representation. */
|
|
if (CTF_V2_INFO_KIND (ref_type->dtd_data.ctti_info) == CTF_K_SLICE)
|
|
{
|
|
ctf_id_t base_type = ref_type->dtd_u.dtu_slice.cts_type;
|
|
unsigned short word_offset = ref_type->dtd_u.dtu_slice.cts_offset;
|
|
unsigned short bits = ref_type->dtd_u.dtu_slice.cts_bits;
|
|
uint64_t sou_offset = dmd->dmd_offset;
|
|
|
|
/* Pack the bit offset and bitfield size together. */
|
|
sou_offset += word_offset;
|
|
|
|
/* If this bitfield cannot be represented, do not output anything.
|
|
The parent struct/union 'vlen' field has already been updated. */
|
|
if ((bits > 0xff) || (sou_offset > 0xffffff))
|
|
return;
|
|
|
|
sou_offset &= 0x00ffffff;
|
|
sou_offset |= ((bits & 0xff) << 24);
|
|
|
|
/* Refer to the base type of the slice. */
|
|
dw2_asm_output_data (4, dmd->dmd_name_offset, "btm_name_off");
|
|
dw2_asm_output_data (4, get_btf_id (base_type), "btm_type");
|
|
dw2_asm_output_data (4, sou_offset, "btm_offset");
|
|
}
|
|
else
|
|
{
|
|
dw2_asm_output_data (4, dmd->dmd_name_offset, "btm_name_off");
|
|
dw2_asm_output_data (4, get_btf_id (dmd->dmd_type), "btm_type");
|
|
dw2_asm_output_data (4, dmd->dmd_offset, "btm_offset");
|
|
}
|
|
}
|
|
|
|
/* Asm'out an enum constant following a BTF_KIND_ENUM. */
|
|
|
|
static void
|
|
btf_asm_enum_const (ctf_dmdef_t * dmd)
|
|
{
|
|
dw2_asm_output_data (4, dmd->dmd_name_offset, "bte_name");
|
|
dw2_asm_output_data (4, dmd->dmd_value, "bte_value");
|
|
}
|
|
|
|
/* Asm'out a function parameter description following a BTF_KIND_FUNC_PROTO. */
|
|
|
|
static void
|
|
btf_asm_func_arg (ctf_func_arg_t * farg, size_t stroffset)
|
|
{
|
|
/* If the function arg does not have a name, refer to the null string at
|
|
the start of the string table. This ensures correct encoding for varargs
|
|
'...' arguments. */
|
|
if ((farg->farg_name != NULL) && strcmp (farg->farg_name, ""))
|
|
dw2_asm_output_data (4, farg->farg_name_offset + stroffset, "farg_name");
|
|
else
|
|
dw2_asm_output_data (4, 0, "farg_name");
|
|
|
|
dw2_asm_output_data (4, (btf_removed_type_p (farg->farg_type)
|
|
? BTF_VOID_TYPEID
|
|
: get_btf_id (farg->farg_type)),
|
|
"farg_type");
|
|
}
|
|
|
|
/* Asm'out a BTF_KIND_FUNC type. */
|
|
|
|
static void
|
|
btf_asm_func_type (ctf_dtdef_ref dtd)
|
|
{
|
|
dw2_asm_output_data (4, dtd->dtd_data.ctti_name, "btt_name");
|
|
dw2_asm_output_data (4, BTF_TYPE_INFO (BTF_KIND_FUNC, 0, 0), "btt_info");
|
|
dw2_asm_output_data (4, get_btf_id (dtd->dtd_data.ctti_type), "btt_type");
|
|
}
|
|
|
|
/* Asm'out a variable entry following a BTF_KIND_DATASEC. */
|
|
|
|
static void
|
|
btf_asm_datasec_entry (struct btf_var_secinfo info)
|
|
{
|
|
dw2_asm_output_data (4, info.type, "bts_type");
|
|
dw2_asm_output_data (4, info.offset, "bts_offset");
|
|
dw2_asm_output_data (4, info.size, "bts_size");
|
|
}
|
|
|
|
/* Asm'out a whole BTF_KIND_DATASEC, including its variable entries. */
|
|
|
|
static void
|
|
btf_asm_datasec_type (btf_datasec_t ds, size_t stroffset)
|
|
{
|
|
dw2_asm_output_data (4, ds.name_offset + stroffset, "btt_name");
|
|
dw2_asm_output_data (4, BTF_TYPE_INFO (BTF_KIND_DATASEC, 0,
|
|
ds.entries.length ()),
|
|
"btt_info");
|
|
/* Note: the "total section size in bytes" is emitted as 0 and patched by
|
|
loaders such as libbpf. */
|
|
dw2_asm_output_data (4, 0, "btt_size");
|
|
for (size_t i = 0; i < ds.entries.length (); i++)
|
|
btf_asm_datasec_entry (ds.entries[i]);
|
|
}
|
|
|
|
/* Compute and output the header information for a .BTF section. */
|
|
|
|
static void
|
|
output_btf_header (ctf_container_ref ctfc)
|
|
{
|
|
switch_to_section (btf_info_section);
|
|
ASM_OUTPUT_LABEL (asm_out_file, btf_info_section_label);
|
|
|
|
/* BTF magic number, version, flags, and header length. */
|
|
dw2_asm_output_data (2, BTF_MAGIC, "btf_magic");
|
|
dw2_asm_output_data (1, BTF_VERSION, "btf_version");
|
|
dw2_asm_output_data (1, 0, "btf_flags");
|
|
dw2_asm_output_data (4, sizeof (struct btf_header), "btf_hdr_len");
|
|
|
|
uint32_t type_off = 0, type_len = 0;
|
|
uint32_t str_off = 0, str_len = 0;
|
|
uint32_t datasec_vlen_bytes = 0;
|
|
|
|
if (!ctfc_is_empty_container (ctfc))
|
|
{
|
|
for (size_t i = 0; i < datasecs.length (); i++)
|
|
{
|
|
datasec_vlen_bytes += ((datasecs[i].entries.length ())
|
|
* sizeof (struct btf_var_secinfo));
|
|
}
|
|
|
|
/* Total length (bytes) of the types section. */
|
|
type_len = (num_types_added * sizeof (struct btf_type))
|
|
+ (num_types_created * sizeof (struct btf_type))
|
|
+ datasec_vlen_bytes
|
|
+ ctfc->ctfc_num_vlen_bytes;
|
|
|
|
str_off = type_off + type_len;
|
|
|
|
str_len = ctfc->ctfc_strtable.ctstab_len
|
|
+ ctfc->ctfc_aux_strtable.ctstab_len;
|
|
}
|
|
|
|
/* Offset of type section. */
|
|
dw2_asm_output_data (4, type_off, "type_off");
|
|
/* Length of type section in bytes. */
|
|
dw2_asm_output_data (4, type_len, "type_len");
|
|
/* Offset of string section. */
|
|
dw2_asm_output_data (4, str_off, "str_off");
|
|
/* Length of string section in bytes. */
|
|
dw2_asm_output_data (4, str_len, "str_len");
|
|
}
|
|
|
|
/* Output all BTF_KIND_VARs in CTFC. */
|
|
|
|
static void
|
|
output_btf_vars (ctf_container_ref ctfc)
|
|
{
|
|
size_t i;
|
|
size_t num_ctf_vars = num_vars_added;
|
|
if (num_ctf_vars)
|
|
{
|
|
for (i = 0; i < num_ctf_vars; i++)
|
|
btf_asm_varent (ctfc->ctfc_vars_list[i]);
|
|
}
|
|
}
|
|
|
|
/* Output BTF string records. The BTF strings section is a concatenation
|
|
of the standard and auxilliary string tables in the ctf container. */
|
|
|
|
static void
|
|
output_btf_strs (ctf_container_ref ctfc)
|
|
{
|
|
ctf_string_t * ctf_string = ctfc->ctfc_strtable.ctstab_head;
|
|
|
|
while (ctf_string)
|
|
{
|
|
dw2_asm_output_nstring (ctf_string->cts_str, -1, "btf_string");
|
|
ctf_string = ctf_string->cts_next;
|
|
}
|
|
|
|
ctf_string = ctfc->ctfc_aux_strtable.ctstab_head;
|
|
while (ctf_string)
|
|
{
|
|
dw2_asm_output_nstring (ctf_string->cts_str, -1, "btf_aux_string");
|
|
ctf_string = ctf_string->cts_next;
|
|
}
|
|
}
|
|
|
|
/* Output all (representable) members of a BTF_KIND_STRUCT or
|
|
BTF_KIND_UNION type. */
|
|
|
|
static void
|
|
output_asm_btf_sou_fields (ctf_container_ref ctfc, ctf_dtdef_ref dtd)
|
|
{
|
|
ctf_dmdef_t * dmd;
|
|
|
|
for (dmd = dtd->dtd_u.dtu_members;
|
|
dmd != NULL; dmd = (ctf_dmdef_t *) ctf_dmd_list_next (dmd))
|
|
btf_asm_sou_member (ctfc, dmd);
|
|
}
|
|
|
|
/* Output all enumerator constants following a BTF_KIND_ENUM. */
|
|
|
|
static void
|
|
output_asm_btf_enum_list (ctf_container_ref ARG_UNUSED (ctfc),
|
|
ctf_dtdef_ref dtd)
|
|
{
|
|
ctf_dmdef_t * dmd;
|
|
|
|
for (dmd = dtd->dtd_u.dtu_members;
|
|
dmd != NULL; dmd = (ctf_dmdef_t *) ctf_dmd_list_next (dmd))
|
|
btf_asm_enum_const (dmd);
|
|
}
|
|
|
|
/* Output all function arguments following a BTF_KIND_FUNC_PROTO. */
|
|
|
|
static void
|
|
output_asm_btf_func_args_list (ctf_container_ref ctfc,
|
|
ctf_dtdef_ref dtd)
|
|
{
|
|
size_t farg_name_offset = ctfc_get_strtab_len (ctfc, CTF_STRTAB);
|
|
ctf_func_arg_t * farg;
|
|
for (farg = dtd->dtd_u.dtu_argv;
|
|
farg != NULL; farg = (ctf_func_arg_t *) ctf_farg_list_next (farg))
|
|
btf_asm_func_arg (farg, farg_name_offset);
|
|
}
|
|
|
|
/* Output the variable portion of a BTF type record. The information depends
|
|
on the kind of the type. */
|
|
|
|
static void
|
|
output_asm_btf_vlen_bytes (ctf_container_ref ctfc, ctf_dtdef_ref dtd)
|
|
{
|
|
uint32_t btf_kind, encoding;
|
|
|
|
btf_kind = get_btf_kind (CTF_V2_INFO_KIND (dtd->dtd_data.ctti_info));
|
|
|
|
if (btf_kind == BTF_KIND_UNKN)
|
|
return;
|
|
|
|
switch (btf_kind)
|
|
{
|
|
case BTF_KIND_INT:
|
|
/* Redundant definitions of void may still be hanging around in the type
|
|
list as size 0 integers. Skip emitting them. */
|
|
if (dtd->dtd_data.ctti_size < 1)
|
|
break;
|
|
|
|
encoding = BTF_INT_DATA (dtd->dtd_u.dtu_enc.cte_format,
|
|
dtd->dtd_u.dtu_enc.cte_offset,
|
|
dtd->dtd_u.dtu_enc.cte_bits);
|
|
|
|
dw2_asm_output_data (4, encoding, "bti_encoding");
|
|
break;
|
|
|
|
case BTF_KIND_ARRAY:
|
|
btf_asm_array (dtd);
|
|
break;
|
|
|
|
case BTF_KIND_STRUCT:
|
|
case BTF_KIND_UNION:
|
|
output_asm_btf_sou_fields (ctfc, dtd);
|
|
break;
|
|
|
|
case BTF_KIND_ENUM:
|
|
output_asm_btf_enum_list (ctfc, dtd);
|
|
break;
|
|
|
|
case BTF_KIND_FUNC_PROTO:
|
|
output_asm_btf_func_args_list (ctfc, dtd);
|
|
break;
|
|
|
|
case BTF_KIND_VAR:
|
|
/* BTF Variables are handled by output_btf_vars and btf_asm_varent.
|
|
There should be no BTF_KIND_VAR types at this point. */
|
|
gcc_unreachable ();
|
|
|
|
case BTF_KIND_DATASEC:
|
|
/* The BTF_KIND_DATASEC records are handled by output_btf_datasec_types
|
|
and btf_asm_datasec_type. There should be no BTF_KIND_DATASEC types
|
|
at this point. */
|
|
gcc_unreachable ();
|
|
|
|
default:
|
|
/* All other BTF type kinds have no variable length data. */
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Output a whole BTF type record for TYPE, including the fixed and variable
|
|
data portions. */
|
|
|
|
static void
|
|
output_asm_btf_type (ctf_container_ref ctfc, ctf_dtdef_ref type)
|
|
{
|
|
if (btf_emit_id_p (type->dtd_type))
|
|
{
|
|
btf_asm_type (ctfc, type);
|
|
output_asm_btf_vlen_bytes (ctfc, type);
|
|
}
|
|
}
|
|
|
|
/* Output all BTF types in the container. This does not include synthesized
|
|
types: BTF_KIND_VAR, BTF_KIND_FUNC, nor BTF_KIND_DATASEC. */
|
|
|
|
static void
|
|
output_btf_types (ctf_container_ref ctfc)
|
|
{
|
|
size_t i;
|
|
size_t num_types = ctfc->ctfc_types->elements ();
|
|
if (num_types)
|
|
{
|
|
for (i = 1; i <= num_types; i++)
|
|
output_asm_btf_type (ctfc, ctfc->ctfc_types_list[i]);
|
|
}
|
|
}
|
|
|
|
/* Output all BTF_KIND_FUNC type records. */
|
|
|
|
static void
|
|
output_btf_func_types (void)
|
|
{
|
|
for (size_t i = 0; i < vec_safe_length (funcs); i++)
|
|
btf_asm_func_type ((*funcs)[i]);
|
|
}
|
|
|
|
/* Output all BTF_KIND_DATASEC records. */
|
|
|
|
static void
|
|
output_btf_datasec_types (ctf_container_ref ctfc)
|
|
{
|
|
size_t name_offset = ctfc_get_strtab_len (ctfc, CTF_STRTAB);
|
|
|
|
for (size_t i = 0; i < datasecs.length(); i++)
|
|
btf_asm_datasec_type (datasecs[i], name_offset);
|
|
}
|
|
|
|
/* Postprocess the CTF debug data post initialization.
|
|
|
|
During the postprocess pass:
|
|
|
|
- Prepare the sorted list of BTF types.
|
|
|
|
The sorted list of BTF types is, firstly, used for lookup (during the BTF
|
|
generation process) of CTF/BTF types given a typeID.
|
|
|
|
Secondly, in the emitted BTF section, BTF Types need to be in the sorted
|
|
order of their type IDs. The BTF types section is viewed as an array,
|
|
with type IDs used to index into that array. It is essential that every
|
|
type be placed at the exact index corresponding to its ID, or else
|
|
references to that type from other types will no longer be correct.
|
|
|
|
- References to void types are converted to reference BTF_VOID_TYPEID. In
|
|
CTF, a distinct type is used to encode void.
|
|
|
|
- Bitfield struct/union members are converted to BTF encoding. CTF uses
|
|
slices to encode bitfields, but BTF does not have slices and encodes
|
|
bitfield information directly in the variable-length btf_member
|
|
descriptions following the struct or union type.
|
|
|
|
- Unrepresentable types are removed. We cannot have any invalid BTF types
|
|
appearing in the output so they must be removed, and type ids of other
|
|
types and references adjust accordingly. This also involves ensuring that
|
|
BTF descriptions of struct members referring to unrepresentable types are
|
|
not emitted, as they would be nonsensical.
|
|
|
|
- Adjust inner- and inter-type references-by-ID to account for removed
|
|
types, and construct the types list. */
|
|
|
|
void
|
|
btf_init_postprocess (void)
|
|
{
|
|
ctf_container_ref tu_ctfc = ctf_get_tu_ctfc ();
|
|
|
|
size_t i;
|
|
size_t num_ctf_types = tu_ctfc->ctfc_types->elements ();
|
|
|
|
holes.create (0);
|
|
voids.create (0);
|
|
|
|
num_types_added = 0;
|
|
num_types_created = 0;
|
|
|
|
if (num_ctf_types)
|
|
{
|
|
init_btf_id_map (num_ctf_types + 1);
|
|
|
|
/* Allocate the types list and traverse all types, placing each type
|
|
at the index according to its ID. Add 1 because type ID 0 always
|
|
represents VOID. */
|
|
tu_ctfc->ctfc_types_list
|
|
= ggc_vec_alloc<ctf_dtdef_ref>(num_ctf_types + 1);
|
|
tu_ctfc->ctfc_types->traverse<ctf_container_ref, btf_dtd_postprocess_cb>
|
|
(tu_ctfc);
|
|
|
|
/* Build mapping of CTF type ID -> BTF type ID, and count total number
|
|
of valid BTF types added. */
|
|
for (i = 1; i <= num_ctf_types; i++)
|
|
{
|
|
ctf_dtdef_ref dtd = tu_ctfc->ctfc_types_list[i];
|
|
ctf_id_t btfid = btf_adjust_type_id (dtd->dtd_type);
|
|
set_btf_id (dtd->dtd_type, btfid);
|
|
if (btfid < BTF_MAX_TYPE && (btfid != BTF_VOID_TYPEID))
|
|
num_types_added ++;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Process and output all BTF data. Entry point of btfout. */
|
|
|
|
void
|
|
btf_output (const char * filename)
|
|
{
|
|
ctf_container_ref tu_ctfc = ctf_get_tu_ctfc ();
|
|
|
|
init_btf_sections ();
|
|
|
|
datasecs.create (0);
|
|
vec_alloc (funcs, 16);
|
|
|
|
ctf_add_cuname (tu_ctfc, filename);
|
|
|
|
btf_emit_preprocess (tu_ctfc);
|
|
|
|
output_btf_header (tu_ctfc);
|
|
output_btf_types (tu_ctfc);
|
|
output_btf_vars (tu_ctfc);
|
|
output_btf_func_types ();
|
|
output_btf_datasec_types (tu_ctfc);
|
|
output_btf_strs (tu_ctfc);
|
|
}
|
|
|
|
/* Reset all state for BTF generation so that we can rerun the compiler within
|
|
the same process. */
|
|
|
|
void
|
|
btf_finalize (void)
|
|
{
|
|
btf_info_section = NULL;
|
|
|
|
/* Clear preprocessing state. */
|
|
num_vars_added = 0;
|
|
num_types_added = 0;
|
|
num_types_created = 0;
|
|
|
|
holes.release ();
|
|
voids.release ();
|
|
for (size_t i = 0; i < datasecs.length (); i++)
|
|
datasecs[i].entries.release ();
|
|
datasecs.release ();
|
|
|
|
funcs = NULL;
|
|
|
|
btf_var_ids->empty ();
|
|
btf_var_ids = NULL;
|
|
|
|
free (btf_id_map);
|
|
btf_id_map = NULL;
|
|
|
|
ctf_container_ref tu_ctfc = ctf_get_tu_ctfc ();
|
|
ctfc_delete_container (tu_ctfc);
|
|
tu_ctfc = NULL;
|
|
}
|
|
|
|
#include "gt-btfout.h"
|