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