1 //===- BTFDebug.cpp - BTF Generator ---------------------------------------===//
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 // This file contains support for writing BTF debug info.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "BTFDebug.h"
14 #include "BPF.h"
15 #include "BPFCORE.h"
16 #include "MCTargetDesc/BPFMCTargetDesc.h"
17 #include "llvm/BinaryFormat/ELF.h"
18 #include "llvm/CodeGen/AsmPrinter.h"
19 #include "llvm/CodeGen/MachineModuleInfo.h"
20 #include "llvm/MC/MCContext.h"
21 #include "llvm/MC/MCObjectFileInfo.h"
22 #include "llvm/MC/MCSectionELF.h"
23 #include "llvm/MC/MCStreamer.h"
24 #include "llvm/Support/LineIterator.h"
25
26 using namespace llvm;
27
28 static const char *BTFKindStr[] = {
29 #define HANDLE_BTF_KIND(ID, NAME) "BTF_KIND_" #NAME,
30 #include "BTF.def"
31 };
32
33 /// Emit a BTF common type.
emitType(MCStreamer & OS)34 void BTFTypeBase::emitType(MCStreamer &OS) {
35 OS.AddComment(std::string(BTFKindStr[Kind]) + "(id = " + std::to_string(Id) +
36 ")");
37 OS.EmitIntValue(BTFType.NameOff, 4);
38 OS.AddComment("0x" + Twine::utohexstr(BTFType.Info));
39 OS.EmitIntValue(BTFType.Info, 4);
40 OS.EmitIntValue(BTFType.Size, 4);
41 }
42
BTFTypeDerived(const DIDerivedType * DTy,unsigned Tag,bool NeedsFixup)43 BTFTypeDerived::BTFTypeDerived(const DIDerivedType *DTy, unsigned Tag,
44 bool NeedsFixup)
45 : DTy(DTy), NeedsFixup(NeedsFixup) {
46 switch (Tag) {
47 case dwarf::DW_TAG_pointer_type:
48 Kind = BTF::BTF_KIND_PTR;
49 break;
50 case dwarf::DW_TAG_const_type:
51 Kind = BTF::BTF_KIND_CONST;
52 break;
53 case dwarf::DW_TAG_volatile_type:
54 Kind = BTF::BTF_KIND_VOLATILE;
55 break;
56 case dwarf::DW_TAG_typedef:
57 Kind = BTF::BTF_KIND_TYPEDEF;
58 break;
59 case dwarf::DW_TAG_restrict_type:
60 Kind = BTF::BTF_KIND_RESTRICT;
61 break;
62 default:
63 llvm_unreachable("Unknown DIDerivedType Tag");
64 }
65 BTFType.Info = Kind << 24;
66 }
67
completeType(BTFDebug & BDebug)68 void BTFTypeDerived::completeType(BTFDebug &BDebug) {
69 if (IsCompleted)
70 return;
71 IsCompleted = true;
72
73 BTFType.NameOff = BDebug.addString(DTy->getName());
74
75 if (NeedsFixup)
76 return;
77
78 // The base type for PTR/CONST/VOLATILE could be void.
79 const DIType *ResolvedType = DTy->getBaseType();
80 if (!ResolvedType) {
81 assert((Kind == BTF::BTF_KIND_PTR || Kind == BTF::BTF_KIND_CONST ||
82 Kind == BTF::BTF_KIND_VOLATILE) &&
83 "Invalid null basetype");
84 BTFType.Type = 0;
85 } else {
86 BTFType.Type = BDebug.getTypeId(ResolvedType);
87 }
88 }
89
emitType(MCStreamer & OS)90 void BTFTypeDerived::emitType(MCStreamer &OS) { BTFTypeBase::emitType(OS); }
91
setPointeeType(uint32_t PointeeType)92 void BTFTypeDerived::setPointeeType(uint32_t PointeeType) {
93 BTFType.Type = PointeeType;
94 }
95
96 /// Represent a struct/union forward declaration.
BTFTypeFwd(StringRef Name,bool IsUnion)97 BTFTypeFwd::BTFTypeFwd(StringRef Name, bool IsUnion) : Name(Name) {
98 Kind = BTF::BTF_KIND_FWD;
99 BTFType.Info = IsUnion << 31 | Kind << 24;
100 BTFType.Type = 0;
101 }
102
completeType(BTFDebug & BDebug)103 void BTFTypeFwd::completeType(BTFDebug &BDebug) {
104 if (IsCompleted)
105 return;
106 IsCompleted = true;
107
108 BTFType.NameOff = BDebug.addString(Name);
109 }
110
emitType(MCStreamer & OS)111 void BTFTypeFwd::emitType(MCStreamer &OS) { BTFTypeBase::emitType(OS); }
112
BTFTypeInt(uint32_t Encoding,uint32_t SizeInBits,uint32_t OffsetInBits,StringRef TypeName)113 BTFTypeInt::BTFTypeInt(uint32_t Encoding, uint32_t SizeInBits,
114 uint32_t OffsetInBits, StringRef TypeName)
115 : Name(TypeName) {
116 // Translate IR int encoding to BTF int encoding.
117 uint8_t BTFEncoding;
118 switch (Encoding) {
119 case dwarf::DW_ATE_boolean:
120 BTFEncoding = BTF::INT_BOOL;
121 break;
122 case dwarf::DW_ATE_signed:
123 case dwarf::DW_ATE_signed_char:
124 BTFEncoding = BTF::INT_SIGNED;
125 break;
126 case dwarf::DW_ATE_unsigned:
127 case dwarf::DW_ATE_unsigned_char:
128 BTFEncoding = 0;
129 break;
130 default:
131 llvm_unreachable("Unknown BTFTypeInt Encoding");
132 }
133
134 Kind = BTF::BTF_KIND_INT;
135 BTFType.Info = Kind << 24;
136 BTFType.Size = roundupToBytes(SizeInBits);
137 IntVal = (BTFEncoding << 24) | OffsetInBits << 16 | SizeInBits;
138 }
139
completeType(BTFDebug & BDebug)140 void BTFTypeInt::completeType(BTFDebug &BDebug) {
141 if (IsCompleted)
142 return;
143 IsCompleted = true;
144
145 BTFType.NameOff = BDebug.addString(Name);
146 }
147
emitType(MCStreamer & OS)148 void BTFTypeInt::emitType(MCStreamer &OS) {
149 BTFTypeBase::emitType(OS);
150 OS.AddComment("0x" + Twine::utohexstr(IntVal));
151 OS.EmitIntValue(IntVal, 4);
152 }
153
BTFTypeEnum(const DICompositeType * ETy,uint32_t VLen)154 BTFTypeEnum::BTFTypeEnum(const DICompositeType *ETy, uint32_t VLen) : ETy(ETy) {
155 Kind = BTF::BTF_KIND_ENUM;
156 BTFType.Info = Kind << 24 | VLen;
157 BTFType.Size = roundupToBytes(ETy->getSizeInBits());
158 }
159
completeType(BTFDebug & BDebug)160 void BTFTypeEnum::completeType(BTFDebug &BDebug) {
161 if (IsCompleted)
162 return;
163 IsCompleted = true;
164
165 BTFType.NameOff = BDebug.addString(ETy->getName());
166
167 DINodeArray Elements = ETy->getElements();
168 for (const auto Element : Elements) {
169 const auto *Enum = cast<DIEnumerator>(Element);
170
171 struct BTF::BTFEnum BTFEnum;
172 BTFEnum.NameOff = BDebug.addString(Enum->getName());
173 // BTF enum value is 32bit, enforce it.
174 BTFEnum.Val = static_cast<uint32_t>(Enum->getValue());
175 EnumValues.push_back(BTFEnum);
176 }
177 }
178
emitType(MCStreamer & OS)179 void BTFTypeEnum::emitType(MCStreamer &OS) {
180 BTFTypeBase::emitType(OS);
181 for (const auto &Enum : EnumValues) {
182 OS.EmitIntValue(Enum.NameOff, 4);
183 OS.EmitIntValue(Enum.Val, 4);
184 }
185 }
186
BTFTypeArray(uint32_t ElemTypeId,uint32_t NumElems)187 BTFTypeArray::BTFTypeArray(uint32_t ElemTypeId, uint32_t NumElems) {
188 Kind = BTF::BTF_KIND_ARRAY;
189 BTFType.NameOff = 0;
190 BTFType.Info = Kind << 24;
191 BTFType.Size = 0;
192
193 ArrayInfo.ElemType = ElemTypeId;
194 ArrayInfo.Nelems = NumElems;
195 }
196
197 /// Represent a BTF array.
completeType(BTFDebug & BDebug)198 void BTFTypeArray::completeType(BTFDebug &BDebug) {
199 if (IsCompleted)
200 return;
201 IsCompleted = true;
202
203 // The IR does not really have a type for the index.
204 // A special type for array index should have been
205 // created during initial type traversal. Just
206 // retrieve that type id.
207 ArrayInfo.IndexType = BDebug.getArrayIndexTypeId();
208 }
209
emitType(MCStreamer & OS)210 void BTFTypeArray::emitType(MCStreamer &OS) {
211 BTFTypeBase::emitType(OS);
212 OS.EmitIntValue(ArrayInfo.ElemType, 4);
213 OS.EmitIntValue(ArrayInfo.IndexType, 4);
214 OS.EmitIntValue(ArrayInfo.Nelems, 4);
215 }
216
217 /// Represent either a struct or a union.
BTFTypeStruct(const DICompositeType * STy,bool IsStruct,bool HasBitField,uint32_t Vlen)218 BTFTypeStruct::BTFTypeStruct(const DICompositeType *STy, bool IsStruct,
219 bool HasBitField, uint32_t Vlen)
220 : STy(STy), HasBitField(HasBitField) {
221 Kind = IsStruct ? BTF::BTF_KIND_STRUCT : BTF::BTF_KIND_UNION;
222 BTFType.Size = roundupToBytes(STy->getSizeInBits());
223 BTFType.Info = (HasBitField << 31) | (Kind << 24) | Vlen;
224 }
225
completeType(BTFDebug & BDebug)226 void BTFTypeStruct::completeType(BTFDebug &BDebug) {
227 if (IsCompleted)
228 return;
229 IsCompleted = true;
230
231 BTFType.NameOff = BDebug.addString(STy->getName());
232
233 // Add struct/union members.
234 const DINodeArray Elements = STy->getElements();
235 for (const auto *Element : Elements) {
236 struct BTF::BTFMember BTFMember;
237 const auto *DDTy = cast<DIDerivedType>(Element);
238
239 BTFMember.NameOff = BDebug.addString(DDTy->getName());
240 if (HasBitField) {
241 uint8_t BitFieldSize = DDTy->isBitField() ? DDTy->getSizeInBits() : 0;
242 BTFMember.Offset = BitFieldSize << 24 | DDTy->getOffsetInBits();
243 } else {
244 BTFMember.Offset = DDTy->getOffsetInBits();
245 }
246 const auto *BaseTy = DDTy->getBaseType();
247 BTFMember.Type = BDebug.getTypeId(BaseTy);
248 Members.push_back(BTFMember);
249 }
250 }
251
emitType(MCStreamer & OS)252 void BTFTypeStruct::emitType(MCStreamer &OS) {
253 BTFTypeBase::emitType(OS);
254 for (const auto &Member : Members) {
255 OS.EmitIntValue(Member.NameOff, 4);
256 OS.EmitIntValue(Member.Type, 4);
257 OS.AddComment("0x" + Twine::utohexstr(Member.Offset));
258 OS.EmitIntValue(Member.Offset, 4);
259 }
260 }
261
getName()262 std::string BTFTypeStruct::getName() { return STy->getName(); }
263
264 /// The Func kind represents both subprogram and pointee of function
265 /// pointers. If the FuncName is empty, it represents a pointee of function
266 /// pointer. Otherwise, it represents a subprogram. The func arg names
267 /// are empty for pointee of function pointer case, and are valid names
268 /// for subprogram.
BTFTypeFuncProto(const DISubroutineType * STy,uint32_t VLen,const std::unordered_map<uint32_t,StringRef> & FuncArgNames)269 BTFTypeFuncProto::BTFTypeFuncProto(
270 const DISubroutineType *STy, uint32_t VLen,
271 const std::unordered_map<uint32_t, StringRef> &FuncArgNames)
272 : STy(STy), FuncArgNames(FuncArgNames) {
273 Kind = BTF::BTF_KIND_FUNC_PROTO;
274 BTFType.Info = (Kind << 24) | VLen;
275 }
276
completeType(BTFDebug & BDebug)277 void BTFTypeFuncProto::completeType(BTFDebug &BDebug) {
278 if (IsCompleted)
279 return;
280 IsCompleted = true;
281
282 DITypeRefArray Elements = STy->getTypeArray();
283 auto RetType = Elements[0];
284 BTFType.Type = RetType ? BDebug.getTypeId(RetType) : 0;
285 BTFType.NameOff = 0;
286
287 // For null parameter which is typically the last one
288 // to represent the vararg, encode the NameOff/Type to be 0.
289 for (unsigned I = 1, N = Elements.size(); I < N; ++I) {
290 struct BTF::BTFParam Param;
291 auto Element = Elements[I];
292 if (Element) {
293 Param.NameOff = BDebug.addString(FuncArgNames[I]);
294 Param.Type = BDebug.getTypeId(Element);
295 } else {
296 Param.NameOff = 0;
297 Param.Type = 0;
298 }
299 Parameters.push_back(Param);
300 }
301 }
302
emitType(MCStreamer & OS)303 void BTFTypeFuncProto::emitType(MCStreamer &OS) {
304 BTFTypeBase::emitType(OS);
305 for (const auto &Param : Parameters) {
306 OS.EmitIntValue(Param.NameOff, 4);
307 OS.EmitIntValue(Param.Type, 4);
308 }
309 }
310
BTFTypeFunc(StringRef FuncName,uint32_t ProtoTypeId,uint32_t Scope)311 BTFTypeFunc::BTFTypeFunc(StringRef FuncName, uint32_t ProtoTypeId,
312 uint32_t Scope)
313 : Name(FuncName) {
314 Kind = BTF::BTF_KIND_FUNC;
315 BTFType.Info = (Kind << 24) | Scope;
316 BTFType.Type = ProtoTypeId;
317 }
318
completeType(BTFDebug & BDebug)319 void BTFTypeFunc::completeType(BTFDebug &BDebug) {
320 if (IsCompleted)
321 return;
322 IsCompleted = true;
323
324 BTFType.NameOff = BDebug.addString(Name);
325 }
326
emitType(MCStreamer & OS)327 void BTFTypeFunc::emitType(MCStreamer &OS) { BTFTypeBase::emitType(OS); }
328
BTFKindVar(StringRef VarName,uint32_t TypeId,uint32_t VarInfo)329 BTFKindVar::BTFKindVar(StringRef VarName, uint32_t TypeId, uint32_t VarInfo)
330 : Name(VarName) {
331 Kind = BTF::BTF_KIND_VAR;
332 BTFType.Info = Kind << 24;
333 BTFType.Type = TypeId;
334 Info = VarInfo;
335 }
336
completeType(BTFDebug & BDebug)337 void BTFKindVar::completeType(BTFDebug &BDebug) {
338 BTFType.NameOff = BDebug.addString(Name);
339 }
340
emitType(MCStreamer & OS)341 void BTFKindVar::emitType(MCStreamer &OS) {
342 BTFTypeBase::emitType(OS);
343 OS.EmitIntValue(Info, 4);
344 }
345
BTFKindDataSec(AsmPrinter * AsmPrt,std::string SecName)346 BTFKindDataSec::BTFKindDataSec(AsmPrinter *AsmPrt, std::string SecName)
347 : Asm(AsmPrt), Name(SecName) {
348 Kind = BTF::BTF_KIND_DATASEC;
349 BTFType.Info = Kind << 24;
350 BTFType.Size = 0;
351 }
352
completeType(BTFDebug & BDebug)353 void BTFKindDataSec::completeType(BTFDebug &BDebug) {
354 BTFType.NameOff = BDebug.addString(Name);
355 BTFType.Info |= Vars.size();
356 }
357
emitType(MCStreamer & OS)358 void BTFKindDataSec::emitType(MCStreamer &OS) {
359 BTFTypeBase::emitType(OS);
360
361 for (const auto &V : Vars) {
362 OS.EmitIntValue(std::get<0>(V), 4);
363 Asm->EmitLabelReference(std::get<1>(V), 4);
364 OS.EmitIntValue(std::get<2>(V), 4);
365 }
366 }
367
addString(StringRef S)368 uint32_t BTFStringTable::addString(StringRef S) {
369 // Check whether the string already exists.
370 for (auto &OffsetM : OffsetToIdMap) {
371 if (Table[OffsetM.second] == S)
372 return OffsetM.first;
373 }
374 // Not find, add to the string table.
375 uint32_t Offset = Size;
376 OffsetToIdMap[Offset] = Table.size();
377 Table.push_back(S);
378 Size += S.size() + 1;
379 return Offset;
380 }
381
BTFDebug(AsmPrinter * AP)382 BTFDebug::BTFDebug(AsmPrinter *AP)
383 : DebugHandlerBase(AP), OS(*Asm->OutStreamer), SkipInstruction(false),
384 LineInfoGenerated(false), SecNameOff(0), ArrayIndexTypeId(0),
385 MapDefNotCollected(true) {
386 addString("\0");
387 }
388
addType(std::unique_ptr<BTFTypeBase> TypeEntry,const DIType * Ty)389 uint32_t BTFDebug::addType(std::unique_ptr<BTFTypeBase> TypeEntry,
390 const DIType *Ty) {
391 TypeEntry->setId(TypeEntries.size() + 1);
392 uint32_t Id = TypeEntry->getId();
393 DIToIdMap[Ty] = Id;
394 TypeEntries.push_back(std::move(TypeEntry));
395 return Id;
396 }
397
addType(std::unique_ptr<BTFTypeBase> TypeEntry)398 uint32_t BTFDebug::addType(std::unique_ptr<BTFTypeBase> TypeEntry) {
399 TypeEntry->setId(TypeEntries.size() + 1);
400 uint32_t Id = TypeEntry->getId();
401 TypeEntries.push_back(std::move(TypeEntry));
402 return Id;
403 }
404
visitBasicType(const DIBasicType * BTy,uint32_t & TypeId)405 void BTFDebug::visitBasicType(const DIBasicType *BTy, uint32_t &TypeId) {
406 // Only int types are supported in BTF.
407 uint32_t Encoding = BTy->getEncoding();
408 if (Encoding != dwarf::DW_ATE_boolean && Encoding != dwarf::DW_ATE_signed &&
409 Encoding != dwarf::DW_ATE_signed_char &&
410 Encoding != dwarf::DW_ATE_unsigned &&
411 Encoding != dwarf::DW_ATE_unsigned_char)
412 return;
413
414 // Create a BTF type instance for this DIBasicType and put it into
415 // DIToIdMap for cross-type reference check.
416 auto TypeEntry = std::make_unique<BTFTypeInt>(
417 Encoding, BTy->getSizeInBits(), BTy->getOffsetInBits(), BTy->getName());
418 TypeId = addType(std::move(TypeEntry), BTy);
419 }
420
421 /// Handle subprogram or subroutine types.
visitSubroutineType(const DISubroutineType * STy,bool ForSubprog,const std::unordered_map<uint32_t,StringRef> & FuncArgNames,uint32_t & TypeId)422 void BTFDebug::visitSubroutineType(
423 const DISubroutineType *STy, bool ForSubprog,
424 const std::unordered_map<uint32_t, StringRef> &FuncArgNames,
425 uint32_t &TypeId) {
426 DITypeRefArray Elements = STy->getTypeArray();
427 uint32_t VLen = Elements.size() - 1;
428 if (VLen > BTF::MAX_VLEN)
429 return;
430
431 // Subprogram has a valid non-zero-length name, and the pointee of
432 // a function pointer has an empty name. The subprogram type will
433 // not be added to DIToIdMap as it should not be referenced by
434 // any other types.
435 auto TypeEntry = std::make_unique<BTFTypeFuncProto>(STy, VLen, FuncArgNames);
436 if (ForSubprog)
437 TypeId = addType(std::move(TypeEntry)); // For subprogram
438 else
439 TypeId = addType(std::move(TypeEntry), STy); // For func ptr
440
441 // Visit return type and func arg types.
442 for (const auto Element : Elements) {
443 visitTypeEntry(Element);
444 }
445 }
446
447 /// Handle structure/union types.
visitStructType(const DICompositeType * CTy,bool IsStruct,uint32_t & TypeId)448 void BTFDebug::visitStructType(const DICompositeType *CTy, bool IsStruct,
449 uint32_t &TypeId) {
450 const DINodeArray Elements = CTy->getElements();
451 uint32_t VLen = Elements.size();
452 if (VLen > BTF::MAX_VLEN)
453 return;
454
455 // Check whether we have any bitfield members or not
456 bool HasBitField = false;
457 for (const auto *Element : Elements) {
458 auto E = cast<DIDerivedType>(Element);
459 if (E->isBitField()) {
460 HasBitField = true;
461 break;
462 }
463 }
464
465 auto TypeEntry =
466 std::make_unique<BTFTypeStruct>(CTy, IsStruct, HasBitField, VLen);
467 StructTypes.push_back(TypeEntry.get());
468 TypeId = addType(std::move(TypeEntry), CTy);
469
470 // Visit all struct members.
471 for (const auto *Element : Elements)
472 visitTypeEntry(cast<DIDerivedType>(Element));
473 }
474
visitArrayType(const DICompositeType * CTy,uint32_t & TypeId)475 void BTFDebug::visitArrayType(const DICompositeType *CTy, uint32_t &TypeId) {
476 // Visit array element type.
477 uint32_t ElemTypeId;
478 const DIType *ElemType = CTy->getBaseType();
479 visitTypeEntry(ElemType, ElemTypeId, false, false);
480
481 // Visit array dimensions.
482 DINodeArray Elements = CTy->getElements();
483 for (int I = Elements.size() - 1; I >= 0; --I) {
484 if (auto *Element = dyn_cast_or_null<DINode>(Elements[I]))
485 if (Element->getTag() == dwarf::DW_TAG_subrange_type) {
486 const DISubrange *SR = cast<DISubrange>(Element);
487 auto *CI = SR->getCount().dyn_cast<ConstantInt *>();
488 int64_t Count = CI->getSExtValue();
489
490 // For struct s { int b; char c[]; }, the c[] will be represented
491 // as an array with Count = -1.
492 auto TypeEntry =
493 std::make_unique<BTFTypeArray>(ElemTypeId,
494 Count >= 0 ? Count : 0);
495 if (I == 0)
496 ElemTypeId = addType(std::move(TypeEntry), CTy);
497 else
498 ElemTypeId = addType(std::move(TypeEntry));
499 }
500 }
501
502 // The array TypeId is the type id of the outermost dimension.
503 TypeId = ElemTypeId;
504
505 // The IR does not have a type for array index while BTF wants one.
506 // So create an array index type if there is none.
507 if (!ArrayIndexTypeId) {
508 auto TypeEntry = std::make_unique<BTFTypeInt>(dwarf::DW_ATE_unsigned, 32,
509 0, "__ARRAY_SIZE_TYPE__");
510 ArrayIndexTypeId = addType(std::move(TypeEntry));
511 }
512 }
513
visitEnumType(const DICompositeType * CTy,uint32_t & TypeId)514 void BTFDebug::visitEnumType(const DICompositeType *CTy, uint32_t &TypeId) {
515 DINodeArray Elements = CTy->getElements();
516 uint32_t VLen = Elements.size();
517 if (VLen > BTF::MAX_VLEN)
518 return;
519
520 auto TypeEntry = std::make_unique<BTFTypeEnum>(CTy, VLen);
521 TypeId = addType(std::move(TypeEntry), CTy);
522 // No need to visit base type as BTF does not encode it.
523 }
524
525 /// Handle structure/union forward declarations.
visitFwdDeclType(const DICompositeType * CTy,bool IsUnion,uint32_t & TypeId)526 void BTFDebug::visitFwdDeclType(const DICompositeType *CTy, bool IsUnion,
527 uint32_t &TypeId) {
528 auto TypeEntry = std::make_unique<BTFTypeFwd>(CTy->getName(), IsUnion);
529 TypeId = addType(std::move(TypeEntry), CTy);
530 }
531
532 /// Handle structure, union, array and enumeration types.
visitCompositeType(const DICompositeType * CTy,uint32_t & TypeId)533 void BTFDebug::visitCompositeType(const DICompositeType *CTy,
534 uint32_t &TypeId) {
535 auto Tag = CTy->getTag();
536 if (Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
537 // Handle forward declaration differently as it does not have members.
538 if (CTy->isForwardDecl())
539 visitFwdDeclType(CTy, Tag == dwarf::DW_TAG_union_type, TypeId);
540 else
541 visitStructType(CTy, Tag == dwarf::DW_TAG_structure_type, TypeId);
542 } else if (Tag == dwarf::DW_TAG_array_type)
543 visitArrayType(CTy, TypeId);
544 else if (Tag == dwarf::DW_TAG_enumeration_type)
545 visitEnumType(CTy, TypeId);
546 }
547
548 /// Handle pointer, typedef, const, volatile, restrict and member types.
visitDerivedType(const DIDerivedType * DTy,uint32_t & TypeId,bool CheckPointer,bool SeenPointer)549 void BTFDebug::visitDerivedType(const DIDerivedType *DTy, uint32_t &TypeId,
550 bool CheckPointer, bool SeenPointer) {
551 unsigned Tag = DTy->getTag();
552
553 /// Try to avoid chasing pointees, esp. structure pointees which may
554 /// unnecessary bring in a lot of types.
555 if (CheckPointer && !SeenPointer) {
556 SeenPointer = Tag == dwarf::DW_TAG_pointer_type;
557 }
558
559 if (CheckPointer && SeenPointer) {
560 const DIType *Base = DTy->getBaseType();
561 if (Base) {
562 if (const auto *CTy = dyn_cast<DICompositeType>(Base)) {
563 auto CTag = CTy->getTag();
564 if ((CTag == dwarf::DW_TAG_structure_type ||
565 CTag == dwarf::DW_TAG_union_type) &&
566 !CTy->isForwardDecl()) {
567 /// Find a candidate, generate a fixup. Later on the struct/union
568 /// pointee type will be replaced with either a real type or
569 /// a forward declaration.
570 auto TypeEntry = std::make_unique<BTFTypeDerived>(DTy, Tag, true);
571 auto &Fixup = FixupDerivedTypes[CTy->getName()];
572 Fixup.first = CTag == dwarf::DW_TAG_union_type;
573 Fixup.second.push_back(TypeEntry.get());
574 TypeId = addType(std::move(TypeEntry), DTy);
575 return;
576 }
577 }
578 }
579 }
580
581 if (Tag == dwarf::DW_TAG_pointer_type || Tag == dwarf::DW_TAG_typedef ||
582 Tag == dwarf::DW_TAG_const_type || Tag == dwarf::DW_TAG_volatile_type ||
583 Tag == dwarf::DW_TAG_restrict_type) {
584 auto TypeEntry = std::make_unique<BTFTypeDerived>(DTy, Tag, false);
585 TypeId = addType(std::move(TypeEntry), DTy);
586 } else if (Tag != dwarf::DW_TAG_member) {
587 return;
588 }
589
590 // Visit base type of pointer, typedef, const, volatile, restrict or
591 // struct/union member.
592 uint32_t TempTypeId = 0;
593 if (Tag == dwarf::DW_TAG_member)
594 visitTypeEntry(DTy->getBaseType(), TempTypeId, true, false);
595 else
596 visitTypeEntry(DTy->getBaseType(), TempTypeId, CheckPointer, SeenPointer);
597 }
598
visitTypeEntry(const DIType * Ty,uint32_t & TypeId,bool CheckPointer,bool SeenPointer)599 void BTFDebug::visitTypeEntry(const DIType *Ty, uint32_t &TypeId,
600 bool CheckPointer, bool SeenPointer) {
601 if (!Ty || DIToIdMap.find(Ty) != DIToIdMap.end()) {
602 TypeId = DIToIdMap[Ty];
603
604 // To handle the case like the following:
605 // struct t;
606 // typedef struct t _t;
607 // struct s1 { _t *c; };
608 // int test1(struct s1 *arg) { ... }
609 //
610 // struct t { int a; int b; };
611 // struct s2 { _t c; }
612 // int test2(struct s2 *arg) { ... }
613 //
614 // During traversing test1() argument, "_t" is recorded
615 // in DIToIdMap and a forward declaration fixup is created
616 // for "struct t" to avoid pointee type traversal.
617 //
618 // During traversing test2() argument, even if we see "_t" is
619 // already defined, we should keep moving to eventually
620 // bring in types for "struct t". Otherwise, the "struct s2"
621 // definition won't be correct.
622 if (Ty && (!CheckPointer || !SeenPointer)) {
623 if (const auto *DTy = dyn_cast<DIDerivedType>(Ty)) {
624 unsigned Tag = DTy->getTag();
625 if (Tag == dwarf::DW_TAG_typedef || Tag == dwarf::DW_TAG_const_type ||
626 Tag == dwarf::DW_TAG_volatile_type ||
627 Tag == dwarf::DW_TAG_restrict_type) {
628 uint32_t TmpTypeId;
629 visitTypeEntry(DTy->getBaseType(), TmpTypeId, CheckPointer,
630 SeenPointer);
631 }
632 }
633 }
634
635 return;
636 }
637
638 if (const auto *BTy = dyn_cast<DIBasicType>(Ty))
639 visitBasicType(BTy, TypeId);
640 else if (const auto *STy = dyn_cast<DISubroutineType>(Ty))
641 visitSubroutineType(STy, false, std::unordered_map<uint32_t, StringRef>(),
642 TypeId);
643 else if (const auto *CTy = dyn_cast<DICompositeType>(Ty))
644 visitCompositeType(CTy, TypeId);
645 else if (const auto *DTy = dyn_cast<DIDerivedType>(Ty))
646 visitDerivedType(DTy, TypeId, CheckPointer, SeenPointer);
647 else
648 llvm_unreachable("Unknown DIType");
649 }
650
visitTypeEntry(const DIType * Ty)651 void BTFDebug::visitTypeEntry(const DIType *Ty) {
652 uint32_t TypeId;
653 visitTypeEntry(Ty, TypeId, false, false);
654 }
655
visitMapDefType(const DIType * Ty,uint32_t & TypeId)656 void BTFDebug::visitMapDefType(const DIType *Ty, uint32_t &TypeId) {
657 if (!Ty || DIToIdMap.find(Ty) != DIToIdMap.end()) {
658 TypeId = DIToIdMap[Ty];
659 return;
660 }
661
662 // MapDef type is a struct type
663 const auto *CTy = dyn_cast<DICompositeType>(Ty);
664 if (!CTy)
665 return;
666
667 auto Tag = CTy->getTag();
668 if (Tag != dwarf::DW_TAG_structure_type || CTy->isForwardDecl())
669 return;
670
671 // Record this type
672 const DINodeArray Elements = CTy->getElements();
673 bool HasBitField = false;
674 for (const auto *Element : Elements) {
675 auto E = cast<DIDerivedType>(Element);
676 if (E->isBitField()) {
677 HasBitField = true;
678 break;
679 }
680 }
681
682 auto TypeEntry =
683 std::make_unique<BTFTypeStruct>(CTy, true, HasBitField, Elements.size());
684 StructTypes.push_back(TypeEntry.get());
685 TypeId = addType(std::move(TypeEntry), CTy);
686
687 // Visit all struct members
688 for (const auto *Element : Elements) {
689 const auto *MemberType = cast<DIDerivedType>(Element);
690 visitTypeEntry(MemberType->getBaseType());
691 }
692 }
693
694 /// Read file contents from the actual file or from the source
populateFileContent(const DISubprogram * SP)695 std::string BTFDebug::populateFileContent(const DISubprogram *SP) {
696 auto File = SP->getFile();
697 std::string FileName;
698
699 if (!File->getFilename().startswith("/") && File->getDirectory().size())
700 FileName = File->getDirectory().str() + "/" + File->getFilename().str();
701 else
702 FileName = File->getFilename();
703
704 // No need to populate the contends if it has been populated!
705 if (FileContent.find(FileName) != FileContent.end())
706 return FileName;
707
708 std::vector<std::string> Content;
709 std::string Line;
710 Content.push_back(Line); // Line 0 for empty string
711
712 std::unique_ptr<MemoryBuffer> Buf;
713 auto Source = File->getSource();
714 if (Source)
715 Buf = MemoryBuffer::getMemBufferCopy(*Source);
716 else if (ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
717 MemoryBuffer::getFile(FileName))
718 Buf = std::move(*BufOrErr);
719 if (Buf)
720 for (line_iterator I(*Buf, false), E; I != E; ++I)
721 Content.push_back(*I);
722
723 FileContent[FileName] = Content;
724 return FileName;
725 }
726
constructLineInfo(const DISubprogram * SP,MCSymbol * Label,uint32_t Line,uint32_t Column)727 void BTFDebug::constructLineInfo(const DISubprogram *SP, MCSymbol *Label,
728 uint32_t Line, uint32_t Column) {
729 std::string FileName = populateFileContent(SP);
730 BTFLineInfo LineInfo;
731
732 LineInfo.Label = Label;
733 LineInfo.FileNameOff = addString(FileName);
734 // If file content is not available, let LineOff = 0.
735 if (Line < FileContent[FileName].size())
736 LineInfo.LineOff = addString(FileContent[FileName][Line]);
737 else
738 LineInfo.LineOff = 0;
739 LineInfo.LineNum = Line;
740 LineInfo.ColumnNum = Column;
741 LineInfoTable[SecNameOff].push_back(LineInfo);
742 }
743
emitCommonHeader()744 void BTFDebug::emitCommonHeader() {
745 OS.AddComment("0x" + Twine::utohexstr(BTF::MAGIC));
746 OS.EmitIntValue(BTF::MAGIC, 2);
747 OS.EmitIntValue(BTF::VERSION, 1);
748 OS.EmitIntValue(0, 1);
749 }
750
emitBTFSection()751 void BTFDebug::emitBTFSection() {
752 // Do not emit section if no types and only "" string.
753 if (!TypeEntries.size() && StringTable.getSize() == 1)
754 return;
755
756 MCContext &Ctx = OS.getContext();
757 OS.SwitchSection(Ctx.getELFSection(".BTF", ELF::SHT_PROGBITS, 0));
758
759 // Emit header.
760 emitCommonHeader();
761 OS.EmitIntValue(BTF::HeaderSize, 4);
762
763 uint32_t TypeLen = 0, StrLen;
764 for (const auto &TypeEntry : TypeEntries)
765 TypeLen += TypeEntry->getSize();
766 StrLen = StringTable.getSize();
767
768 OS.EmitIntValue(0, 4);
769 OS.EmitIntValue(TypeLen, 4);
770 OS.EmitIntValue(TypeLen, 4);
771 OS.EmitIntValue(StrLen, 4);
772
773 // Emit type table.
774 for (const auto &TypeEntry : TypeEntries)
775 TypeEntry->emitType(OS);
776
777 // Emit string table.
778 uint32_t StringOffset = 0;
779 for (const auto &S : StringTable.getTable()) {
780 OS.AddComment("string offset=" + std::to_string(StringOffset));
781 OS.EmitBytes(S);
782 OS.EmitBytes(StringRef("\0", 1));
783 StringOffset += S.size() + 1;
784 }
785 }
786
emitBTFExtSection()787 void BTFDebug::emitBTFExtSection() {
788 // Do not emit section if empty FuncInfoTable and LineInfoTable
789 // and FieldRelocTable.
790 if (!FuncInfoTable.size() && !LineInfoTable.size() &&
791 !FieldRelocTable.size())
792 return;
793
794 MCContext &Ctx = OS.getContext();
795 OS.SwitchSection(Ctx.getELFSection(".BTF.ext", ELF::SHT_PROGBITS, 0));
796
797 // Emit header.
798 emitCommonHeader();
799 OS.EmitIntValue(BTF::ExtHeaderSize, 4);
800
801 // Account for FuncInfo/LineInfo record size as well.
802 uint32_t FuncLen = 4, LineLen = 4;
803 // Do not account for optional FieldReloc.
804 uint32_t FieldRelocLen = 0;
805 for (const auto &FuncSec : FuncInfoTable) {
806 FuncLen += BTF::SecFuncInfoSize;
807 FuncLen += FuncSec.second.size() * BTF::BPFFuncInfoSize;
808 }
809 for (const auto &LineSec : LineInfoTable) {
810 LineLen += BTF::SecLineInfoSize;
811 LineLen += LineSec.second.size() * BTF::BPFLineInfoSize;
812 }
813 for (const auto &FieldRelocSec : FieldRelocTable) {
814 FieldRelocLen += BTF::SecFieldRelocSize;
815 FieldRelocLen += FieldRelocSec.second.size() * BTF::BPFFieldRelocSize;
816 }
817
818 if (FieldRelocLen)
819 FieldRelocLen += 4;
820
821 OS.EmitIntValue(0, 4);
822 OS.EmitIntValue(FuncLen, 4);
823 OS.EmitIntValue(FuncLen, 4);
824 OS.EmitIntValue(LineLen, 4);
825 OS.EmitIntValue(FuncLen + LineLen, 4);
826 OS.EmitIntValue(FieldRelocLen, 4);
827
828 // Emit func_info table.
829 OS.AddComment("FuncInfo");
830 OS.EmitIntValue(BTF::BPFFuncInfoSize, 4);
831 for (const auto &FuncSec : FuncInfoTable) {
832 OS.AddComment("FuncInfo section string offset=" +
833 std::to_string(FuncSec.first));
834 OS.EmitIntValue(FuncSec.first, 4);
835 OS.EmitIntValue(FuncSec.second.size(), 4);
836 for (const auto &FuncInfo : FuncSec.second) {
837 Asm->EmitLabelReference(FuncInfo.Label, 4);
838 OS.EmitIntValue(FuncInfo.TypeId, 4);
839 }
840 }
841
842 // Emit line_info table.
843 OS.AddComment("LineInfo");
844 OS.EmitIntValue(BTF::BPFLineInfoSize, 4);
845 for (const auto &LineSec : LineInfoTable) {
846 OS.AddComment("LineInfo section string offset=" +
847 std::to_string(LineSec.first));
848 OS.EmitIntValue(LineSec.first, 4);
849 OS.EmitIntValue(LineSec.second.size(), 4);
850 for (const auto &LineInfo : LineSec.second) {
851 Asm->EmitLabelReference(LineInfo.Label, 4);
852 OS.EmitIntValue(LineInfo.FileNameOff, 4);
853 OS.EmitIntValue(LineInfo.LineOff, 4);
854 OS.AddComment("Line " + std::to_string(LineInfo.LineNum) + " Col " +
855 std::to_string(LineInfo.ColumnNum));
856 OS.EmitIntValue(LineInfo.LineNum << 10 | LineInfo.ColumnNum, 4);
857 }
858 }
859
860 // Emit field reloc table.
861 if (FieldRelocLen) {
862 OS.AddComment("FieldReloc");
863 OS.EmitIntValue(BTF::BPFFieldRelocSize, 4);
864 for (const auto &FieldRelocSec : FieldRelocTable) {
865 OS.AddComment("Field reloc section string offset=" +
866 std::to_string(FieldRelocSec.first));
867 OS.EmitIntValue(FieldRelocSec.first, 4);
868 OS.EmitIntValue(FieldRelocSec.second.size(), 4);
869 for (const auto &FieldRelocInfo : FieldRelocSec.second) {
870 Asm->EmitLabelReference(FieldRelocInfo.Label, 4);
871 OS.EmitIntValue(FieldRelocInfo.TypeID, 4);
872 OS.EmitIntValue(FieldRelocInfo.OffsetNameOff, 4);
873 OS.EmitIntValue(FieldRelocInfo.RelocKind, 4);
874 }
875 }
876 }
877 }
878
beginFunctionImpl(const MachineFunction * MF)879 void BTFDebug::beginFunctionImpl(const MachineFunction *MF) {
880 auto *SP = MF->getFunction().getSubprogram();
881 auto *Unit = SP->getUnit();
882
883 if (Unit->getEmissionKind() == DICompileUnit::NoDebug) {
884 SkipInstruction = true;
885 return;
886 }
887 SkipInstruction = false;
888
889 // Collect MapDef types. Map definition needs to collect
890 // pointee types. Do it first. Otherwise, for the following
891 // case:
892 // struct m { ...};
893 // struct t {
894 // struct m *key;
895 // };
896 // foo(struct t *arg);
897 //
898 // struct mapdef {
899 // ...
900 // struct m *key;
901 // ...
902 // } __attribute__((section(".maps"))) hash_map;
903 //
904 // If subroutine foo is traversed first, a type chain
905 // "ptr->struct m(fwd)" will be created and later on
906 // when traversing mapdef, since "ptr->struct m" exists,
907 // the traversal of "struct m" will be omitted.
908 if (MapDefNotCollected) {
909 processGlobals(true);
910 MapDefNotCollected = false;
911 }
912
913 // Collect all types locally referenced in this function.
914 // Use RetainedNodes so we can collect all argument names
915 // even if the argument is not used.
916 std::unordered_map<uint32_t, StringRef> FuncArgNames;
917 for (const DINode *DN : SP->getRetainedNodes()) {
918 if (const auto *DV = dyn_cast<DILocalVariable>(DN)) {
919 // Collect function arguments for subprogram func type.
920 uint32_t Arg = DV->getArg();
921 if (Arg) {
922 visitTypeEntry(DV->getType());
923 FuncArgNames[Arg] = DV->getName();
924 }
925 }
926 }
927
928 // Construct subprogram func proto type.
929 uint32_t ProtoTypeId;
930 visitSubroutineType(SP->getType(), true, FuncArgNames, ProtoTypeId);
931
932 // Construct subprogram func type
933 uint8_t Scope = SP->isLocalToUnit() ? BTF::FUNC_STATIC : BTF::FUNC_GLOBAL;
934 auto FuncTypeEntry =
935 std::make_unique<BTFTypeFunc>(SP->getName(), ProtoTypeId, Scope);
936 uint32_t FuncTypeId = addType(std::move(FuncTypeEntry));
937
938 for (const auto &TypeEntry : TypeEntries)
939 TypeEntry->completeType(*this);
940
941 // Construct funcinfo and the first lineinfo for the function.
942 MCSymbol *FuncLabel = Asm->getFunctionBegin();
943 BTFFuncInfo FuncInfo;
944 FuncInfo.Label = FuncLabel;
945 FuncInfo.TypeId = FuncTypeId;
946 if (FuncLabel->isInSection()) {
947 MCSection &Section = FuncLabel->getSection();
948 const MCSectionELF *SectionELF = dyn_cast<MCSectionELF>(&Section);
949 assert(SectionELF && "Null section for Function Label");
950 SecNameOff = addString(SectionELF->getSectionName());
951 } else {
952 SecNameOff = addString(".text");
953 }
954 FuncInfoTable[SecNameOff].push_back(FuncInfo);
955 }
956
endFunctionImpl(const MachineFunction * MF)957 void BTFDebug::endFunctionImpl(const MachineFunction *MF) {
958 SkipInstruction = false;
959 LineInfoGenerated = false;
960 SecNameOff = 0;
961 }
962
963 /// On-demand populate struct types as requested from abstract member
964 /// accessing.
populateStructType(const DIType * Ty)965 unsigned BTFDebug::populateStructType(const DIType *Ty) {
966 unsigned Id;
967 visitTypeEntry(Ty, Id, false, false);
968 for (const auto &TypeEntry : TypeEntries)
969 TypeEntry->completeType(*this);
970 return Id;
971 }
972
973 /// Generate a struct member field relocation.
generateFieldReloc(const MCSymbol * ORSym,DIType * RootTy,StringRef AccessPattern)974 void BTFDebug::generateFieldReloc(const MCSymbol *ORSym, DIType *RootTy,
975 StringRef AccessPattern) {
976 unsigned RootId = populateStructType(RootTy);
977 size_t FirstDollar = AccessPattern.find_first_of('$');
978 size_t FirstColon = AccessPattern.find_first_of(':');
979 size_t SecondColon = AccessPattern.find_first_of(':', FirstColon + 1);
980 StringRef IndexPattern = AccessPattern.substr(FirstDollar + 1);
981 StringRef RelocKindStr = AccessPattern.substr(FirstColon + 1,
982 SecondColon - FirstColon);
983 StringRef PatchImmStr = AccessPattern.substr(SecondColon + 1,
984 FirstDollar - SecondColon);
985
986 BTFFieldReloc FieldReloc;
987 FieldReloc.Label = ORSym;
988 FieldReloc.OffsetNameOff = addString(IndexPattern);
989 FieldReloc.TypeID = RootId;
990 FieldReloc.RelocKind = std::stoull(RelocKindStr);
991 PatchImms[AccessPattern.str()] = std::stoul(PatchImmStr);
992 FieldRelocTable[SecNameOff].push_back(FieldReloc);
993 }
994
processReloc(const MachineOperand & MO)995 void BTFDebug::processReloc(const MachineOperand &MO) {
996 // check whether this is a candidate or not
997 if (MO.isGlobal()) {
998 const GlobalValue *GVal = MO.getGlobal();
999 auto *GVar = dyn_cast<GlobalVariable>(GVal);
1000 if (GVar && GVar->hasAttribute(BPFCoreSharedInfo::AmaAttr)) {
1001 MCSymbol *ORSym = OS.getContext().createTempSymbol();
1002 OS.EmitLabel(ORSym);
1003
1004 MDNode *MDN = GVar->getMetadata(LLVMContext::MD_preserve_access_index);
1005 DIType *Ty = dyn_cast<DIType>(MDN);
1006 generateFieldReloc(ORSym, Ty, GVar->getName());
1007 }
1008 }
1009 }
1010
beginInstruction(const MachineInstr * MI)1011 void BTFDebug::beginInstruction(const MachineInstr *MI) {
1012 DebugHandlerBase::beginInstruction(MI);
1013
1014 if (SkipInstruction || MI->isMetaInstruction() ||
1015 MI->getFlag(MachineInstr::FrameSetup))
1016 return;
1017
1018 if (MI->isInlineAsm()) {
1019 // Count the number of register definitions to find the asm string.
1020 unsigned NumDefs = 0;
1021 for (; MI->getOperand(NumDefs).isReg() && MI->getOperand(NumDefs).isDef();
1022 ++NumDefs)
1023 ;
1024
1025 // Skip this inline asm instruction if the asmstr is empty.
1026 const char *AsmStr = MI->getOperand(NumDefs).getSymbolName();
1027 if (AsmStr[0] == 0)
1028 return;
1029 }
1030
1031 if (MI->getOpcode() == BPF::LD_imm64) {
1032 // If the insn is "r2 = LD_imm64 @<an AmaAttr global>",
1033 // add this insn into the .BTF.ext FieldReloc subsection.
1034 // Relocation looks like:
1035 // . SecName:
1036 // . InstOffset
1037 // . TypeID
1038 // . OffSetNameOff
1039 // . RelocType
1040 // Later, the insn is replaced with "r2 = <offset>"
1041 // where "<offset>" equals to the offset based on current
1042 // type definitions.
1043 processReloc(MI->getOperand(1));
1044 } else if (MI->getOpcode() == BPF::CORE_MEM ||
1045 MI->getOpcode() == BPF::CORE_ALU32_MEM ||
1046 MI->getOpcode() == BPF::CORE_SHIFT) {
1047 // relocation insn is a load, store or shift insn.
1048 processReloc(MI->getOperand(3));
1049 } else if (MI->getOpcode() == BPF::JAL) {
1050 // check extern function references
1051 const MachineOperand &MO = MI->getOperand(0);
1052 if (MO.isGlobal()) {
1053 processFuncPrototypes(dyn_cast<Function>(MO.getGlobal()));
1054 }
1055 }
1056
1057 // Skip this instruction if no DebugLoc or the DebugLoc
1058 // is the same as the previous instruction.
1059 const DebugLoc &DL = MI->getDebugLoc();
1060 if (!DL || PrevInstLoc == DL) {
1061 // This instruction will be skipped, no LineInfo has
1062 // been generated, construct one based on function signature.
1063 if (LineInfoGenerated == false) {
1064 auto *S = MI->getMF()->getFunction().getSubprogram();
1065 MCSymbol *FuncLabel = Asm->getFunctionBegin();
1066 constructLineInfo(S, FuncLabel, S->getLine(), 0);
1067 LineInfoGenerated = true;
1068 }
1069
1070 return;
1071 }
1072
1073 // Create a temporary label to remember the insn for lineinfo.
1074 MCSymbol *LineSym = OS.getContext().createTempSymbol();
1075 OS.EmitLabel(LineSym);
1076
1077 // Construct the lineinfo.
1078 auto SP = DL.get()->getScope()->getSubprogram();
1079 constructLineInfo(SP, LineSym, DL.getLine(), DL.getCol());
1080
1081 LineInfoGenerated = true;
1082 PrevInstLoc = DL;
1083 }
1084
processGlobals(bool ProcessingMapDef)1085 void BTFDebug::processGlobals(bool ProcessingMapDef) {
1086 // Collect all types referenced by globals.
1087 const Module *M = MMI->getModule();
1088 for (const GlobalVariable &Global : M->globals()) {
1089 // Decide the section name.
1090 StringRef SecName;
1091 if (Global.hasSection()) {
1092 SecName = Global.getSection();
1093 } else if (Global.hasInitializer()) {
1094 // data, bss, or readonly sections
1095 if (Global.isConstant())
1096 SecName = ".rodata";
1097 else
1098 SecName = Global.getInitializer()->isZeroValue() ? ".bss" : ".data";
1099 } else {
1100 // extern variables without explicit section,
1101 // put them into ".extern" section.
1102 SecName = ".extern";
1103 }
1104
1105 if (ProcessingMapDef != SecName.startswith(".maps"))
1106 continue;
1107
1108 SmallVector<DIGlobalVariableExpression *, 1> GVs;
1109 Global.getDebugInfo(GVs);
1110
1111 // No type information, mostly internal, skip it.
1112 if (GVs.size() == 0)
1113 continue;
1114
1115 uint32_t GVTypeId = 0;
1116 for (auto *GVE : GVs) {
1117 if (SecName.startswith(".maps"))
1118 visitMapDefType(GVE->getVariable()->getType(), GVTypeId);
1119 else
1120 visitTypeEntry(GVE->getVariable()->getType(), GVTypeId, false, false);
1121 break;
1122 }
1123
1124 // Only support the following globals:
1125 // . static variables
1126 // . non-static weak or non-weak global variables
1127 // . weak or non-weak extern global variables
1128 // Whether DataSec is readonly or not can be found from corresponding ELF
1129 // section flags. Whether a BTF_KIND_VAR is a weak symbol or not
1130 // can be found from the corresponding ELF symbol table.
1131 auto Linkage = Global.getLinkage();
1132 if (Linkage != GlobalValue::InternalLinkage &&
1133 Linkage != GlobalValue::ExternalLinkage &&
1134 Linkage != GlobalValue::WeakAnyLinkage &&
1135 Linkage != GlobalValue::ExternalWeakLinkage)
1136 continue;
1137
1138 uint32_t GVarInfo;
1139 if (Linkage == GlobalValue::InternalLinkage) {
1140 GVarInfo = BTF::VAR_STATIC;
1141 } else if (Global.hasInitializer()) {
1142 GVarInfo = BTF::VAR_GLOBAL_ALLOCATED;
1143 } else {
1144 GVarInfo = BTF::VAR_GLOBAL_EXTERNAL;
1145 }
1146
1147 auto VarEntry =
1148 std::make_unique<BTFKindVar>(Global.getName(), GVTypeId, GVarInfo);
1149 uint32_t VarId = addType(std::move(VarEntry));
1150
1151 assert(!SecName.empty());
1152
1153 // Find or create a DataSec
1154 if (DataSecEntries.find(SecName) == DataSecEntries.end()) {
1155 DataSecEntries[SecName] = std::make_unique<BTFKindDataSec>(Asm, SecName);
1156 }
1157
1158 // Calculate symbol size
1159 const DataLayout &DL = Global.getParent()->getDataLayout();
1160 uint32_t Size = DL.getTypeAllocSize(Global.getType()->getElementType());
1161
1162 DataSecEntries[SecName]->addVar(VarId, Asm->getSymbol(&Global), Size);
1163 }
1164 }
1165
1166 /// Emit proper patchable instructions.
InstLower(const MachineInstr * MI,MCInst & OutMI)1167 bool BTFDebug::InstLower(const MachineInstr *MI, MCInst &OutMI) {
1168 if (MI->getOpcode() == BPF::LD_imm64) {
1169 const MachineOperand &MO = MI->getOperand(1);
1170 if (MO.isGlobal()) {
1171 const GlobalValue *GVal = MO.getGlobal();
1172 auto *GVar = dyn_cast<GlobalVariable>(GVal);
1173 if (GVar && GVar->hasAttribute(BPFCoreSharedInfo::AmaAttr)) {
1174 // Emit "mov ri, <imm>" for patched immediate.
1175 uint32_t Imm = PatchImms[GVar->getName().str()];
1176 OutMI.setOpcode(BPF::MOV_ri);
1177 OutMI.addOperand(MCOperand::createReg(MI->getOperand(0).getReg()));
1178 OutMI.addOperand(MCOperand::createImm(Imm));
1179 return true;
1180 }
1181 }
1182 } else if (MI->getOpcode() == BPF::CORE_MEM ||
1183 MI->getOpcode() == BPF::CORE_ALU32_MEM ||
1184 MI->getOpcode() == BPF::CORE_SHIFT) {
1185 const MachineOperand &MO = MI->getOperand(3);
1186 if (MO.isGlobal()) {
1187 const GlobalValue *GVal = MO.getGlobal();
1188 auto *GVar = dyn_cast<GlobalVariable>(GVal);
1189 if (GVar && GVar->hasAttribute(BPFCoreSharedInfo::AmaAttr)) {
1190 uint32_t Imm = PatchImms[GVar->getName().str()];
1191 OutMI.setOpcode(MI->getOperand(1).getImm());
1192 if (MI->getOperand(0).isImm())
1193 OutMI.addOperand(MCOperand::createImm(MI->getOperand(0).getImm()));
1194 else
1195 OutMI.addOperand(MCOperand::createReg(MI->getOperand(0).getReg()));
1196 OutMI.addOperand(MCOperand::createReg(MI->getOperand(2).getReg()));
1197 OutMI.addOperand(MCOperand::createImm(Imm));
1198 return true;
1199 }
1200 }
1201 }
1202 return false;
1203 }
1204
processFuncPrototypes(const Function * F)1205 void BTFDebug::processFuncPrototypes(const Function *F) {
1206 if (!F)
1207 return;
1208
1209 const DISubprogram *SP = F->getSubprogram();
1210 if (!SP || SP->isDefinition())
1211 return;
1212
1213 // Do not emit again if already emitted.
1214 if (ProtoFunctions.find(F) != ProtoFunctions.end())
1215 return;
1216 ProtoFunctions.insert(F);
1217
1218 uint32_t ProtoTypeId;
1219 const std::unordered_map<uint32_t, StringRef> FuncArgNames;
1220 visitSubroutineType(SP->getType(), false, FuncArgNames, ProtoTypeId);
1221
1222 uint8_t Scope = BTF::FUNC_EXTERN;
1223 auto FuncTypeEntry =
1224 std::make_unique<BTFTypeFunc>(SP->getName(), ProtoTypeId, Scope);
1225 addType(std::move(FuncTypeEntry));
1226 }
1227
endModule()1228 void BTFDebug::endModule() {
1229 // Collect MapDef globals if not collected yet.
1230 if (MapDefNotCollected) {
1231 processGlobals(true);
1232 MapDefNotCollected = false;
1233 }
1234
1235 // Collect global types/variables except MapDef globals.
1236 processGlobals(false);
1237
1238 for (auto &DataSec : DataSecEntries)
1239 addType(std::move(DataSec.second));
1240
1241 // Fixups
1242 for (auto &Fixup : FixupDerivedTypes) {
1243 StringRef TypeName = Fixup.first;
1244 bool IsUnion = Fixup.second.first;
1245
1246 // Search through struct types
1247 uint32_t StructTypeId = 0;
1248 for (const auto &StructType : StructTypes) {
1249 if (StructType->getName() == TypeName) {
1250 StructTypeId = StructType->getId();
1251 break;
1252 }
1253 }
1254
1255 if (StructTypeId == 0) {
1256 auto FwdTypeEntry = std::make_unique<BTFTypeFwd>(TypeName, IsUnion);
1257 StructTypeId = addType(std::move(FwdTypeEntry));
1258 }
1259
1260 for (auto &DType : Fixup.second.second) {
1261 DType->setPointeeType(StructTypeId);
1262 }
1263 }
1264
1265 // Complete BTF type cross refereences.
1266 for (const auto &TypeEntry : TypeEntries)
1267 TypeEntry->completeType(*this);
1268
1269 // Emit BTF sections.
1270 emitBTFSection();
1271 emitBTFExtSection();
1272 }
1273