1//===-- BTF.h --------------------------------------------------*- C++ -*-===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8/// 9/// \file 10/// This file contains the layout of .BTF and .BTF.ext ELF sections. 11/// 12/// The binary layout for .BTF section: 13/// struct Header 14/// Type and Str subsections 15/// The Type subsection is a collection of types with type id starting with 1. 16/// The Str subsection is simply a collection of strings. 17/// 18/// The binary layout for .BTF.ext section: 19/// struct ExtHeader 20/// FuncInfo, LineInfo, FieldReloc and ExternReloc subsections 21/// The FuncInfo subsection is defined as below: 22/// BTFFuncInfo Size 23/// struct SecFuncInfo for ELF section #1 24/// A number of struct BPFFuncInfo for ELF section #1 25/// struct SecFuncInfo for ELF section #2 26/// A number of struct BPFFuncInfo for ELF section #2 27/// ... 28/// The LineInfo subsection is defined as below: 29/// BPFLineInfo Size 30/// struct SecLineInfo for ELF section #1 31/// A number of struct BPFLineInfo for ELF section #1 32/// struct SecLineInfo for ELF section #2 33/// A number of struct BPFLineInfo for ELF section #2 34/// ... 35/// The FieldReloc subsection is defined as below: 36/// BPFFieldReloc Size 37/// struct SecFieldReloc for ELF section #1 38/// A number of struct BPFFieldReloc for ELF section #1 39/// struct SecFieldReloc for ELF section #2 40/// A number of struct BPFFieldReloc for ELF section #2 41/// ... 42/// 43/// The section formats are also defined at 44/// https://github.com/torvalds/linux/blob/master/include/uapi/linux/btf.h 45/// 46//===----------------------------------------------------------------------===// 47 48#ifndef LLVM_LIB_TARGET_BPF_BTF_H 49#define LLVM_LIB_TARGET_BPF_BTF_H 50 51namespace llvm { 52namespace BTF { 53 54enum : uint32_t { MAGIC = 0xeB9F, VERSION = 1 }; 55 56/// Sizes in bytes of various things in the BTF format. 57enum { 58 HeaderSize = 24, 59 ExtHeaderSize = 32, 60 CommonTypeSize = 12, 61 BTFArraySize = 12, 62 BTFEnumSize = 8, 63 BTFMemberSize = 12, 64 BTFParamSize = 8, 65 BTFDataSecVarSize = 12, 66 SecFuncInfoSize = 8, 67 SecLineInfoSize = 8, 68 SecFieldRelocSize = 8, 69 BPFFuncInfoSize = 8, 70 BPFLineInfoSize = 16, 71 BPFFieldRelocSize = 16, 72}; 73 74/// The .BTF section header definition. 75struct Header { 76 uint16_t Magic; ///< Magic value 77 uint8_t Version; ///< Version number 78 uint8_t Flags; ///< Extra flags 79 uint32_t HdrLen; ///< Length of this header 80 81 /// All offsets are in bytes relative to the end of this header. 82 uint32_t TypeOff; ///< Offset of type section 83 uint32_t TypeLen; ///< Length of type section 84 uint32_t StrOff; ///< Offset of string section 85 uint32_t StrLen; ///< Length of string section 86}; 87 88enum : uint32_t { 89 MAX_VLEN = 0xffff ///< Max # of struct/union/enum members or func args 90}; 91 92enum TypeKinds : uint8_t { 93#define HANDLE_BTF_KIND(ID, NAME) BTF_KIND_##NAME = ID, 94#include "BTF.def" 95}; 96 97/// The BTF common type definition. Different kinds may have 98/// additional information after this structure data. 99struct CommonType { 100 /// Type name offset in the string table. 101 uint32_t NameOff; 102 103 /// "Info" bits arrangement: 104 /// Bits 0-15: vlen (e.g. # of struct's members) 105 /// Bits 16-23: unused 106 /// Bits 24-27: kind (e.g. int, ptr, array...etc) 107 /// Bits 28-30: unused 108 /// Bit 31: kind_flag, currently used by 109 /// struct, union and fwd 110 uint32_t Info; 111 112 /// "Size" is used by INT, ENUM, STRUCT and UNION. 113 /// "Size" tells the size of the type it is describing. 114 /// 115 /// "Type" is used by PTR, TYPEDEF, VOLATILE, CONST, RESTRICT, 116 /// FUNC, FUNC_PROTO and VAR. 117 /// "Type" is a type_id referring to another type. 118 union { 119 uint32_t Size; 120 uint32_t Type; 121 }; 122}; 123 124// For some specific BTF_KIND, "struct CommonType" is immediately 125// followed by extra data. 126 127// BTF_KIND_INT is followed by a u32 and the following 128// is the 32 bits arrangement: 129// BTF_INT_ENCODING(VAL) : (((VAL) & 0x0f000000) >> 24) 130// BTF_INT_OFFSET(VAL) : (((VAL & 0x00ff0000)) >> 16) 131// BTF_INT_BITS(VAL) : ((VAL) & 0x000000ff) 132 133/// Attributes stored in the INT_ENCODING. 134enum : uint8_t { 135 INT_SIGNED = (1 << 0), 136 INT_CHAR = (1 << 1), 137 INT_BOOL = (1 << 2) 138}; 139 140/// BTF_KIND_ENUM is followed by multiple "struct BTFEnum". 141/// The exact number of btf_enum is stored in the vlen (of the 142/// info in "struct CommonType"). 143struct BTFEnum { 144 uint32_t NameOff; ///< Enum name offset in the string table 145 int32_t Val; ///< Enum member value 146}; 147 148/// BTF_KIND_ARRAY is followed by one "struct BTFArray". 149struct BTFArray { 150 uint32_t ElemType; ///< Element type 151 uint32_t IndexType; ///< Index type 152 uint32_t Nelems; ///< Number of elements for this array 153}; 154 155/// BTF_KIND_STRUCT and BTF_KIND_UNION are followed 156/// by multiple "struct BTFMember". The exact number 157/// of BTFMember is stored in the vlen (of the info in 158/// "struct CommonType"). 159/// 160/// If the struct/union contains any bitfield member, 161/// the Offset below represents BitOffset (bits 0 - 23) 162/// and BitFieldSize(bits 24 - 31) with BitFieldSize = 0 163/// for non bitfield members. Otherwise, the Offset 164/// represents the BitOffset. 165struct BTFMember { 166 uint32_t NameOff; ///< Member name offset in the string table 167 uint32_t Type; ///< Member type 168 uint32_t Offset; ///< BitOffset or BitFieldSize+BitOffset 169}; 170 171/// BTF_KIND_FUNC_PROTO are followed by multiple "struct BTFParam". 172/// The exist number of BTFParam is stored in the vlen (of the info 173/// in "struct CommonType"). 174struct BTFParam { 175 uint32_t NameOff; 176 uint32_t Type; 177}; 178 179/// BTF_KIND_FUNC can be global, static or extern. 180enum : uint8_t { 181 FUNC_STATIC = 0, 182 FUNC_GLOBAL = 1, 183 FUNC_EXTERN = 2, 184}; 185 186/// Variable scoping information. 187enum : uint8_t { 188 VAR_STATIC = 0, ///< Linkage: InternalLinkage 189 VAR_GLOBAL_ALLOCATED = 1, ///< Linkage: ExternalLinkage 190 VAR_GLOBAL_EXTERNAL = 2, ///< Linkage: ExternalLinkage 191}; 192 193/// BTF_KIND_DATASEC are followed by multiple "struct BTFDataSecVar". 194/// The exist number of BTFDataSec is stored in the vlen (of the info 195/// in "struct CommonType"). 196struct BTFDataSec { 197 uint32_t Type; ///< A BTF_KIND_VAR type 198 uint32_t Offset; ///< In-section offset 199 uint32_t Size; ///< Occupied memory size 200}; 201 202/// The .BTF.ext section header definition. 203struct ExtHeader { 204 uint16_t Magic; 205 uint8_t Version; 206 uint8_t Flags; 207 uint32_t HdrLen; 208 209 uint32_t FuncInfoOff; ///< Offset of func info section 210 uint32_t FuncInfoLen; ///< Length of func info section 211 uint32_t LineInfoOff; ///< Offset of line info section 212 uint32_t LineInfoLen; ///< Length of line info section 213 uint32_t FieldRelocOff; ///< Offset of offset reloc section 214 uint32_t FieldRelocLen; ///< Length of offset reloc section 215}; 216 217/// Specifying one function info. 218struct BPFFuncInfo { 219 uint32_t InsnOffset; ///< Byte offset in the section 220 uint32_t TypeId; ///< Type id referring to .BTF type section 221}; 222 223/// Specifying function info's in one section. 224struct SecFuncInfo { 225 uint32_t SecNameOff; ///< Section name index in the .BTF string table 226 uint32_t NumFuncInfo; ///< Number of func info's in this section 227}; 228 229/// Specifying one line info. 230struct BPFLineInfo { 231 uint32_t InsnOffset; ///< Byte offset in this section 232 uint32_t FileNameOff; ///< File name index in the .BTF string table 233 uint32_t LineOff; ///< Line index in the .BTF string table 234 uint32_t LineCol; ///< Line num: line_col >> 10, 235 /// col num: line_col & 0x3ff 236}; 237 238/// Specifying line info's in one section. 239struct SecLineInfo { 240 uint32_t SecNameOff; ///< Section name index in the .BTF string table 241 uint32_t NumLineInfo; ///< Number of line info's in this section 242}; 243 244/// Specifying one offset relocation. 245struct BPFFieldReloc { 246 uint32_t InsnOffset; ///< Byte offset in this section 247 uint32_t TypeID; ///< TypeID for the relocation 248 uint32_t OffsetNameOff; ///< The string to traverse types 249 uint32_t RelocKind; ///< What to patch the instruction 250}; 251 252/// Specifying offset relocation's in one section. 253struct SecFieldReloc { 254 uint32_t SecNameOff; ///< Section name index in the .BTF string table 255 uint32_t NumFieldReloc; ///< Number of offset reloc's in this section 256}; 257 258} // End namespace BTF. 259} // End namespace llvm. 260 261#endif 262