1 //===- BTFDebug.cpp - BTF Generator ---------------------------------------===//
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
7 //===----------------------------------------------------------------------===//
9 // This file contains support for writing BTF debug info.
11 //===----------------------------------------------------------------------===//
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"
28 static const char *BTFKindStr[] = {
29 #define HANDLE_BTF_KIND(ID, NAME) "BTF_KIND_" #NAME,
33 /// Emit a BTF common type.
34 void BTFTypeBase::emitType(MCStreamer &OS) {
35 OS.AddComment(std::string(BTFKindStr[Kind]) + "(id = " + std::to_string(Id) +
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);
43 BTFTypeDerived::BTFTypeDerived(const DIDerivedType *DTy, unsigned Tag,
45 : DTy(DTy), NeedsFixup(NeedsFixup) {
47 case dwarf::DW_TAG_pointer_type:
48 Kind = BTF::BTF_KIND_PTR;
50 case dwarf::DW_TAG_const_type:
51 Kind = BTF::BTF_KIND_CONST;
53 case dwarf::DW_TAG_volatile_type:
54 Kind = BTF::BTF_KIND_VOLATILE;
56 case dwarf::DW_TAG_typedef:
57 Kind = BTF::BTF_KIND_TYPEDEF;
59 case dwarf::DW_TAG_restrict_type:
60 Kind = BTF::BTF_KIND_RESTRICT;
63 llvm_unreachable("Unknown DIDerivedType Tag");
65 BTFType.Info = Kind << 24;
68 void BTFTypeDerived::completeType(BTFDebug &BDebug) {
73 BTFType.NameOff = BDebug.addString(DTy->getName());
78 // The base type for PTR/CONST/VOLATILE could be void.
79 const DIType *ResolvedType = DTy->getBaseType();
81 assert((Kind == BTF::BTF_KIND_PTR || Kind == BTF::BTF_KIND_CONST ||
82 Kind == BTF::BTF_KIND_VOLATILE) &&
83 "Invalid null basetype");
86 BTFType.Type = BDebug.getTypeId(ResolvedType);
90 void BTFTypeDerived::emitType(MCStreamer &OS) { BTFTypeBase::emitType(OS); }
92 void BTFTypeDerived::setPointeeType(uint32_t PointeeType) {
93 BTFType.Type = PointeeType;
96 /// Represent a struct/union forward declaration.
97 BTFTypeFwd::BTFTypeFwd(StringRef Name, bool IsUnion) : Name(Name) {
98 Kind = BTF::BTF_KIND_FWD;
99 BTFType.Info = IsUnion << 31 | Kind << 24;
103 void BTFTypeFwd::completeType(BTFDebug &BDebug) {
108 BTFType.NameOff = BDebug.addString(Name);
111 void BTFTypeFwd::emitType(MCStreamer &OS) { BTFTypeBase::emitType(OS); }
113 BTFTypeInt::BTFTypeInt(uint32_t Encoding, uint32_t SizeInBits,
114 uint32_t OffsetInBits, StringRef TypeName)
116 // Translate IR int encoding to BTF int encoding.
119 case dwarf::DW_ATE_boolean:
120 BTFEncoding = BTF::INT_BOOL;
122 case dwarf::DW_ATE_signed:
123 case dwarf::DW_ATE_signed_char:
124 BTFEncoding = BTF::INT_SIGNED;
126 case dwarf::DW_ATE_unsigned:
127 case dwarf::DW_ATE_unsigned_char:
131 llvm_unreachable("Unknown BTFTypeInt Encoding");
134 Kind = BTF::BTF_KIND_INT;
135 BTFType.Info = Kind << 24;
136 BTFType.Size = roundupToBytes(SizeInBits);
137 IntVal = (BTFEncoding << 24) | OffsetInBits << 16 | SizeInBits;
140 void BTFTypeInt::completeType(BTFDebug &BDebug) {
145 BTFType.NameOff = BDebug.addString(Name);
148 void BTFTypeInt::emitType(MCStreamer &OS) {
149 BTFTypeBase::emitType(OS);
150 OS.AddComment("0x" + Twine::utohexstr(IntVal));
151 OS.EmitIntValue(IntVal, 4);
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());
160 void BTFTypeEnum::completeType(BTFDebug &BDebug) {
165 BTFType.NameOff = BDebug.addString(ETy->getName());
167 DINodeArray Elements = ETy->getElements();
168 for (const auto Element : Elements) {
169 const auto *Enum = cast<DIEnumerator>(Element);
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);
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);
187 BTFTypeArray::BTFTypeArray(uint32_t ElemTypeId, uint32_t NumElems) {
188 Kind = BTF::BTF_KIND_ARRAY;
190 BTFType.Info = Kind << 24;
193 ArrayInfo.ElemType = ElemTypeId;
194 ArrayInfo.Nelems = NumElems;
197 /// Represent a BTF array.
198 void BTFTypeArray::completeType(BTFDebug &BDebug) {
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();
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);
217 /// Represent either a struct or a union.
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;
226 void BTFTypeStruct::completeType(BTFDebug &BDebug) {
231 BTFType.NameOff = BDebug.addString(STy->getName());
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);
239 BTFMember.NameOff = BDebug.addString(DDTy->getName());
241 uint8_t BitFieldSize = DDTy->isBitField() ? DDTy->getSizeInBits() : 0;
242 BTFMember.Offset = BitFieldSize << 24 | DDTy->getOffsetInBits();
244 BTFMember.Offset = DDTy->getOffsetInBits();
246 const auto *BaseTy = DDTy->getBaseType();
247 BTFMember.Type = BDebug.getTypeId(BaseTy);
248 Members.push_back(BTFMember);
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);
262 std::string BTFTypeStruct::getName() { return STy->getName(); }
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
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;
277 void BTFTypeFuncProto::completeType(BTFDebug &BDebug) {
282 DITypeRefArray Elements = STy->getTypeArray();
283 auto RetType = Elements[0];
284 BTFType.Type = RetType ? BDebug.getTypeId(RetType) : 0;
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];
293 Param.NameOff = BDebug.addString(FuncArgNames[I]);
294 Param.Type = BDebug.getTypeId(Element);
299 Parameters.push_back(Param);
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);
311 BTFTypeFunc::BTFTypeFunc(StringRef FuncName, uint32_t ProtoTypeId,
314 Kind = BTF::BTF_KIND_FUNC;
315 BTFType.Info = (Kind << 24) | Scope;
316 BTFType.Type = ProtoTypeId;
319 void BTFTypeFunc::completeType(BTFDebug &BDebug) {
324 BTFType.NameOff = BDebug.addString(Name);
327 void BTFTypeFunc::emitType(MCStreamer &OS) { BTFTypeBase::emitType(OS); }
329 BTFKindVar::BTFKindVar(StringRef VarName, uint32_t TypeId, uint32_t VarInfo)
331 Kind = BTF::BTF_KIND_VAR;
332 BTFType.Info = Kind << 24;
333 BTFType.Type = TypeId;
337 void BTFKindVar::completeType(BTFDebug &BDebug) {
338 BTFType.NameOff = BDebug.addString(Name);
341 void BTFKindVar::emitType(MCStreamer &OS) {
342 BTFTypeBase::emitType(OS);
343 OS.EmitIntValue(Info, 4);
346 BTFKindDataSec::BTFKindDataSec(AsmPrinter *AsmPrt, std::string SecName)
347 : Asm(AsmPrt), Name(SecName) {
348 Kind = BTF::BTF_KIND_DATASEC;
349 BTFType.Info = Kind << 24;
353 void BTFKindDataSec::completeType(BTFDebug &BDebug) {
354 BTFType.NameOff = BDebug.addString(Name);
355 BTFType.Info |= Vars.size();
358 void BTFKindDataSec::emitType(MCStreamer &OS) {
359 BTFTypeBase::emitType(OS);
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);
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;
374 // Not find, add to the string table.
375 uint32_t Offset = Size;
376 OffsetToIdMap[Offset] = Table.size();
378 Size += S.size() + 1;
382 BTFDebug::BTFDebug(AsmPrinter *AP)
383 : DebugHandlerBase(AP), OS(*Asm->OutStreamer), SkipInstruction(false),
384 LineInfoGenerated(false), SecNameOff(0), ArrayIndexTypeId(0),
385 MapDefNotCollected(true) {
389 uint32_t BTFDebug::addType(std::unique_ptr<BTFTypeBase> TypeEntry,
391 TypeEntry->setId(TypeEntries.size() + 1);
392 uint32_t Id = TypeEntry->getId();
394 TypeEntries.push_back(std::move(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));
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)
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);
421 /// Handle subprogram or subroutine types.
422 void BTFDebug::visitSubroutineType(
423 const DISubroutineType *STy, bool ForSubprog,
424 const std::unordered_map<uint32_t, StringRef> &FuncArgNames,
426 DITypeRefArray Elements = STy->getTypeArray();
427 uint32_t VLen = Elements.size() - 1;
428 if (VLen > BTF::MAX_VLEN)
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
435 auto TypeEntry = std::make_unique<BTFTypeFuncProto>(STy, VLen, FuncArgNames);
437 TypeId = addType(std::move(TypeEntry)); // For subprogram
439 TypeId = addType(std::move(TypeEntry), STy); // For func ptr
441 // Visit return type and func arg types.
442 for (const auto Element : Elements) {
443 visitTypeEntry(Element);
447 /// Handle structure/union types.
448 void BTFDebug::visitStructType(const DICompositeType *CTy, bool IsStruct,
450 const DINodeArray Elements = CTy->getElements();
451 uint32_t VLen = Elements.size();
452 if (VLen > BTF::MAX_VLEN)
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()) {
466 std::make_unique<BTFTypeStruct>(CTy, IsStruct, HasBitField, VLen);
467 StructTypes.push_back(TypeEntry.get());
468 TypeId = addType(std::move(TypeEntry), CTy);
470 // Visit all struct members.
471 for (const auto *Element : Elements)
472 visitTypeEntry(cast<DIDerivedType>(Element));
475 void BTFDebug::visitArrayType(const DICompositeType *CTy, uint32_t &TypeId) {
476 // Visit array element type.
478 const DIType *ElemType = CTy->getBaseType();
479 visitTypeEntry(ElemType, ElemTypeId, false, false);
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();
490 // For struct s { int b; char c[]; }, the c[] will be represented
491 // as an array with Count = -1.
493 std::make_unique<BTFTypeArray>(ElemTypeId,
494 Count >= 0 ? Count : 0);
496 ElemTypeId = addType(std::move(TypeEntry), CTy);
498 ElemTypeId = addType(std::move(TypeEntry));
502 // The array TypeId is the type id of the outermost dimension.
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));
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)
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.
525 /// Handle structure/union forward declarations.
526 void BTFDebug::visitFwdDeclType(const DICompositeType *CTy, bool IsUnion,
528 auto TypeEntry = std::make_unique<BTFTypeFwd>(CTy->getName(), IsUnion);
529 TypeId = addType(std::move(TypeEntry), CTy);
532 /// Handle structure, union, array and enumeration types.
533 void BTFDebug::visitCompositeType(const DICompositeType *CTy,
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);
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);
548 /// Handle pointer, typedef, const, volatile, restrict and member types.
549 void BTFDebug::visitDerivedType(const DIDerivedType *DTy, uint32_t &TypeId,
550 bool CheckPointer, bool SeenPointer) {
551 unsigned Tag = DTy->getTag();
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;
559 if (CheckPointer && SeenPointer) {
560 const DIType *Base = DTy->getBaseType();
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);
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) {
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);
596 visitTypeEntry(DTy->getBaseType(), TempTypeId, CheckPointer, 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];
606 if (const auto *BTy = dyn_cast<DIBasicType>(Ty))
607 visitBasicType(BTy, TypeId);
608 else if (const auto *STy = dyn_cast<DISubroutineType>(Ty))
609 visitSubroutineType(STy, false, std::unordered_map<uint32_t, StringRef>(),
611 else if (const auto *CTy = dyn_cast<DICompositeType>(Ty))
612 visitCompositeType(CTy, TypeId);
613 else if (const auto *DTy = dyn_cast<DIDerivedType>(Ty))
614 visitDerivedType(DTy, TypeId, CheckPointer, SeenPointer);
616 llvm_unreachable("Unknown DIType");
619 void BTFDebug::visitTypeEntry(const DIType *Ty) {
621 visitTypeEntry(Ty, TypeId, false, false);
624 void BTFDebug::visitMapDefType(const DIType *Ty, uint32_t &TypeId) {
625 if (!Ty || DIToIdMap.find(Ty) != DIToIdMap.end()) {
626 TypeId = DIToIdMap[Ty];
630 // MapDef type is a struct type
631 const auto *CTy = dyn_cast<DICompositeType>(Ty);
635 auto Tag = CTy->getTag();
636 if (Tag != dwarf::DW_TAG_structure_type || CTy->isForwardDecl())
640 const DINodeArray Elements = CTy->getElements();
641 bool HasBitField = false;
642 for (const auto *Element : Elements) {
643 auto E = cast<DIDerivedType>(Element);
644 if (E->isBitField()) {
651 std::make_unique<BTFTypeStruct>(CTy, true, HasBitField, Elements.size());
652 StructTypes.push_back(TypeEntry.get());
653 TypeId = addType(std::move(TypeEntry), CTy);
655 // Visit all struct members
656 for (const auto *Element : Elements) {
657 const auto *MemberType = cast<DIDerivedType>(Element);
658 visitTypeEntry(MemberType->getBaseType());
662 /// Read file contents from the actual file or from the source
663 std::string BTFDebug::populateFileContent(const DISubprogram *SP) {
664 auto File = SP->getFile();
665 std::string FileName;
667 if (!File->getFilename().startswith("/") && File->getDirectory().size())
668 FileName = File->getDirectory().str() + "/" + File->getFilename().str();
670 FileName = File->getFilename();
672 // No need to populate the contends if it has been populated!
673 if (FileContent.find(FileName) != FileContent.end())
676 std::vector<std::string> Content;
678 Content.push_back(Line); // Line 0 for empty string
680 std::unique_ptr<MemoryBuffer> Buf;
681 auto Source = File->getSource();
683 Buf = MemoryBuffer::getMemBufferCopy(*Source);
684 else if (ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
685 MemoryBuffer::getFile(FileName))
686 Buf = std::move(*BufOrErr);
688 for (line_iterator I(*Buf, false), E; I != E; ++I)
689 Content.push_back(*I);
691 FileContent[FileName] = Content;
695 void BTFDebug::constructLineInfo(const DISubprogram *SP, MCSymbol *Label,
696 uint32_t Line, uint32_t Column) {
697 std::string FileName = populateFileContent(SP);
698 BTFLineInfo LineInfo;
700 LineInfo.Label = Label;
701 LineInfo.FileNameOff = addString(FileName);
702 // If file content is not available, let LineOff = 0.
703 if (Line < FileContent[FileName].size())
704 LineInfo.LineOff = addString(FileContent[FileName][Line]);
706 LineInfo.LineOff = 0;
707 LineInfo.LineNum = Line;
708 LineInfo.ColumnNum = Column;
709 LineInfoTable[SecNameOff].push_back(LineInfo);
712 void BTFDebug::emitCommonHeader() {
713 OS.AddComment("0x" + Twine::utohexstr(BTF::MAGIC));
714 OS.EmitIntValue(BTF::MAGIC, 2);
715 OS.EmitIntValue(BTF::VERSION, 1);
716 OS.EmitIntValue(0, 1);
719 void BTFDebug::emitBTFSection() {
720 // Do not emit section if no types and only "" string.
721 if (!TypeEntries.size() && StringTable.getSize() == 1)
724 MCContext &Ctx = OS.getContext();
725 OS.SwitchSection(Ctx.getELFSection(".BTF", ELF::SHT_PROGBITS, 0));
729 OS.EmitIntValue(BTF::HeaderSize, 4);
731 uint32_t TypeLen = 0, StrLen;
732 for (const auto &TypeEntry : TypeEntries)
733 TypeLen += TypeEntry->getSize();
734 StrLen = StringTable.getSize();
736 OS.EmitIntValue(0, 4);
737 OS.EmitIntValue(TypeLen, 4);
738 OS.EmitIntValue(TypeLen, 4);
739 OS.EmitIntValue(StrLen, 4);
742 for (const auto &TypeEntry : TypeEntries)
743 TypeEntry->emitType(OS);
745 // Emit string table.
746 uint32_t StringOffset = 0;
747 for (const auto &S : StringTable.getTable()) {
748 OS.AddComment("string offset=" + std::to_string(StringOffset));
750 OS.EmitBytes(StringRef("\0", 1));
751 StringOffset += S.size() + 1;
755 void BTFDebug::emitBTFExtSection() {
756 // Do not emit section if empty FuncInfoTable and LineInfoTable
757 // and FieldRelocTable.
758 if (!FuncInfoTable.size() && !LineInfoTable.size() &&
759 !FieldRelocTable.size())
762 MCContext &Ctx = OS.getContext();
763 OS.SwitchSection(Ctx.getELFSection(".BTF.ext", ELF::SHT_PROGBITS, 0));
767 OS.EmitIntValue(BTF::ExtHeaderSize, 4);
769 // Account for FuncInfo/LineInfo record size as well.
770 uint32_t FuncLen = 4, LineLen = 4;
771 // Do not account for optional FieldReloc.
772 uint32_t FieldRelocLen = 0;
773 for (const auto &FuncSec : FuncInfoTable) {
774 FuncLen += BTF::SecFuncInfoSize;
775 FuncLen += FuncSec.second.size() * BTF::BPFFuncInfoSize;
777 for (const auto &LineSec : LineInfoTable) {
778 LineLen += BTF::SecLineInfoSize;
779 LineLen += LineSec.second.size() * BTF::BPFLineInfoSize;
781 for (const auto &FieldRelocSec : FieldRelocTable) {
782 FieldRelocLen += BTF::SecFieldRelocSize;
783 FieldRelocLen += FieldRelocSec.second.size() * BTF::BPFFieldRelocSize;
789 OS.EmitIntValue(0, 4);
790 OS.EmitIntValue(FuncLen, 4);
791 OS.EmitIntValue(FuncLen, 4);
792 OS.EmitIntValue(LineLen, 4);
793 OS.EmitIntValue(FuncLen + LineLen, 4);
794 OS.EmitIntValue(FieldRelocLen, 4);
796 // Emit func_info table.
797 OS.AddComment("FuncInfo");
798 OS.EmitIntValue(BTF::BPFFuncInfoSize, 4);
799 for (const auto &FuncSec : FuncInfoTable) {
800 OS.AddComment("FuncInfo section string offset=" +
801 std::to_string(FuncSec.first));
802 OS.EmitIntValue(FuncSec.first, 4);
803 OS.EmitIntValue(FuncSec.second.size(), 4);
804 for (const auto &FuncInfo : FuncSec.second) {
805 Asm->EmitLabelReference(FuncInfo.Label, 4);
806 OS.EmitIntValue(FuncInfo.TypeId, 4);
810 // Emit line_info table.
811 OS.AddComment("LineInfo");
812 OS.EmitIntValue(BTF::BPFLineInfoSize, 4);
813 for (const auto &LineSec : LineInfoTable) {
814 OS.AddComment("LineInfo section string offset=" +
815 std::to_string(LineSec.first));
816 OS.EmitIntValue(LineSec.first, 4);
817 OS.EmitIntValue(LineSec.second.size(), 4);
818 for (const auto &LineInfo : LineSec.second) {
819 Asm->EmitLabelReference(LineInfo.Label, 4);
820 OS.EmitIntValue(LineInfo.FileNameOff, 4);
821 OS.EmitIntValue(LineInfo.LineOff, 4);
822 OS.AddComment("Line " + std::to_string(LineInfo.LineNum) + " Col " +
823 std::to_string(LineInfo.ColumnNum));
824 OS.EmitIntValue(LineInfo.LineNum << 10 | LineInfo.ColumnNum, 4);
828 // Emit field reloc table.
830 OS.AddComment("FieldReloc");
831 OS.EmitIntValue(BTF::BPFFieldRelocSize, 4);
832 for (const auto &FieldRelocSec : FieldRelocTable) {
833 OS.AddComment("Field reloc section string offset=" +
834 std::to_string(FieldRelocSec.first));
835 OS.EmitIntValue(FieldRelocSec.first, 4);
836 OS.EmitIntValue(FieldRelocSec.second.size(), 4);
837 for (const auto &FieldRelocInfo : FieldRelocSec.second) {
838 Asm->EmitLabelReference(FieldRelocInfo.Label, 4);
839 OS.EmitIntValue(FieldRelocInfo.TypeID, 4);
840 OS.EmitIntValue(FieldRelocInfo.OffsetNameOff, 4);
841 OS.EmitIntValue(FieldRelocInfo.RelocKind, 4);
847 void BTFDebug::beginFunctionImpl(const MachineFunction *MF) {
848 auto *SP = MF->getFunction().getSubprogram();
849 auto *Unit = SP->getUnit();
851 if (Unit->getEmissionKind() == DICompileUnit::NoDebug) {
852 SkipInstruction = true;
855 SkipInstruction = false;
857 // Collect MapDef types. Map definition needs to collect
858 // pointee types. Do it first. Otherwise, for the following
864 // foo(struct t *arg);
870 // } __attribute__((section(".maps"))) hash_map;
872 // If subroutine foo is traversed first, a type chain
873 // "ptr->struct m(fwd)" will be created and later on
874 // when traversing mapdef, since "ptr->struct m" exists,
875 // the traversal of "struct m" will be omitted.
876 if (MapDefNotCollected) {
877 processGlobals(true);
878 MapDefNotCollected = false;
881 // Collect all types locally referenced in this function.
882 // Use RetainedNodes so we can collect all argument names
883 // even if the argument is not used.
884 std::unordered_map<uint32_t, StringRef> FuncArgNames;
885 for (const DINode *DN : SP->getRetainedNodes()) {
886 if (const auto *DV = dyn_cast<DILocalVariable>(DN)) {
887 // Collect function arguments for subprogram func type.
888 uint32_t Arg = DV->getArg();
890 visitTypeEntry(DV->getType());
891 FuncArgNames[Arg] = DV->getName();
896 // Construct subprogram func proto type.
897 uint32_t ProtoTypeId;
898 visitSubroutineType(SP->getType(), true, FuncArgNames, ProtoTypeId);
900 // Construct subprogram func type
901 uint8_t Scope = SP->isLocalToUnit() ? BTF::FUNC_STATIC : BTF::FUNC_GLOBAL;
903 std::make_unique<BTFTypeFunc>(SP->getName(), ProtoTypeId, Scope);
904 uint32_t FuncTypeId = addType(std::move(FuncTypeEntry));
906 for (const auto &TypeEntry : TypeEntries)
907 TypeEntry->completeType(*this);
909 // Construct funcinfo and the first lineinfo for the function.
910 MCSymbol *FuncLabel = Asm->getFunctionBegin();
911 BTFFuncInfo FuncInfo;
912 FuncInfo.Label = FuncLabel;
913 FuncInfo.TypeId = FuncTypeId;
914 if (FuncLabel->isInSection()) {
915 MCSection &Section = FuncLabel->getSection();
916 const MCSectionELF *SectionELF = dyn_cast<MCSectionELF>(&Section);
917 assert(SectionELF && "Null section for Function Label");
918 SecNameOff = addString(SectionELF->getSectionName());
920 SecNameOff = addString(".text");
922 FuncInfoTable[SecNameOff].push_back(FuncInfo);
925 void BTFDebug::endFunctionImpl(const MachineFunction *MF) {
926 SkipInstruction = false;
927 LineInfoGenerated = false;
931 /// On-demand populate struct types as requested from abstract member
933 unsigned BTFDebug::populateStructType(const DIType *Ty) {
935 visitTypeEntry(Ty, Id, false, false);
936 for (const auto &TypeEntry : TypeEntries)
937 TypeEntry->completeType(*this);
941 /// Generate a struct member field relocation.
942 void BTFDebug::generateFieldReloc(const MCSymbol *ORSym, DIType *RootTy,
943 StringRef AccessPattern) {
944 unsigned RootId = populateStructType(RootTy);
945 size_t FirstDollar = AccessPattern.find_first_of('$');
946 size_t FirstColon = AccessPattern.find_first_of(':');
947 size_t SecondColon = AccessPattern.find_first_of(':', FirstColon + 1);
948 StringRef IndexPattern = AccessPattern.substr(FirstDollar + 1);
949 StringRef RelocKindStr = AccessPattern.substr(FirstColon + 1,
950 SecondColon - FirstColon);
951 StringRef PatchImmStr = AccessPattern.substr(SecondColon + 1,
952 FirstDollar - SecondColon);
954 BTFFieldReloc FieldReloc;
955 FieldReloc.Label = ORSym;
956 FieldReloc.OffsetNameOff = addString(IndexPattern);
957 FieldReloc.TypeID = RootId;
958 FieldReloc.RelocKind = std::stoull(RelocKindStr);
959 PatchImms[AccessPattern.str()] = std::stoul(PatchImmStr);
960 FieldRelocTable[SecNameOff].push_back(FieldReloc);
963 void BTFDebug::processReloc(const MachineOperand &MO) {
964 // check whether this is a candidate or not
966 const GlobalValue *GVal = MO.getGlobal();
967 auto *GVar = dyn_cast<GlobalVariable>(GVal);
968 if (GVar && GVar->hasAttribute(BPFCoreSharedInfo::AmaAttr)) {
969 MCSymbol *ORSym = OS.getContext().createTempSymbol();
972 MDNode *MDN = GVar->getMetadata(LLVMContext::MD_preserve_access_index);
973 DIType *Ty = dyn_cast<DIType>(MDN);
974 generateFieldReloc(ORSym, Ty, GVar->getName());
979 void BTFDebug::beginInstruction(const MachineInstr *MI) {
980 DebugHandlerBase::beginInstruction(MI);
982 if (SkipInstruction || MI->isMetaInstruction() ||
983 MI->getFlag(MachineInstr::FrameSetup))
986 if (MI->isInlineAsm()) {
987 // Count the number of register definitions to find the asm string.
988 unsigned NumDefs = 0;
989 for (; MI->getOperand(NumDefs).isReg() && MI->getOperand(NumDefs).isDef();
993 // Skip this inline asm instruction if the asmstr is empty.
994 const char *AsmStr = MI->getOperand(NumDefs).getSymbolName();
999 if (MI->getOpcode() == BPF::LD_imm64) {
1000 // If the insn is "r2 = LD_imm64 @<an AmaAttr global>",
1001 // add this insn into the .BTF.ext FieldReloc subsection.
1002 // Relocation looks like:
1008 // Later, the insn is replaced with "r2 = <offset>"
1009 // where "<offset>" equals to the offset based on current
1010 // type definitions.
1011 processReloc(MI->getOperand(1));
1012 } else if (MI->getOpcode() == BPF::CORE_MEM ||
1013 MI->getOpcode() == BPF::CORE_ALU32_MEM ||
1014 MI->getOpcode() == BPF::CORE_SHIFT) {
1015 // relocation insn is a load, store or shift insn.
1016 processReloc(MI->getOperand(3));
1017 } else if (MI->getOpcode() == BPF::JAL) {
1018 // check extern function references
1019 const MachineOperand &MO = MI->getOperand(0);
1020 if (MO.isGlobal()) {
1021 processFuncPrototypes(dyn_cast<Function>(MO.getGlobal()));
1025 // Skip this instruction if no DebugLoc or the DebugLoc
1026 // is the same as the previous instruction.
1027 const DebugLoc &DL = MI->getDebugLoc();
1028 if (!DL || PrevInstLoc == DL) {
1029 // This instruction will be skipped, no LineInfo has
1030 // been generated, construct one based on function signature.
1031 if (LineInfoGenerated == false) {
1032 auto *S = MI->getMF()->getFunction().getSubprogram();
1033 MCSymbol *FuncLabel = Asm->getFunctionBegin();
1034 constructLineInfo(S, FuncLabel, S->getLine(), 0);
1035 LineInfoGenerated = true;
1041 // Create a temporary label to remember the insn for lineinfo.
1042 MCSymbol *LineSym = OS.getContext().createTempSymbol();
1043 OS.EmitLabel(LineSym);
1045 // Construct the lineinfo.
1046 auto SP = DL.get()->getScope()->getSubprogram();
1047 constructLineInfo(SP, LineSym, DL.getLine(), DL.getCol());
1049 LineInfoGenerated = true;
1053 void BTFDebug::processGlobals(bool ProcessingMapDef) {
1054 // Collect all types referenced by globals.
1055 const Module *M = MMI->getModule();
1056 for (const GlobalVariable &Global : M->globals()) {
1057 // Decide the section name.
1059 if (Global.hasSection()) {
1060 SecName = Global.getSection();
1061 } else if (Global.hasInitializer()) {
1062 // data, bss, or readonly sections
1063 if (Global.isConstant())
1064 SecName = ".rodata";
1066 SecName = Global.getInitializer()->isZeroValue() ? ".bss" : ".data";
1068 // extern variables without explicit section,
1069 // put them into ".extern" section.
1070 SecName = ".extern";
1073 if (ProcessingMapDef != SecName.startswith(".maps"))
1076 SmallVector<DIGlobalVariableExpression *, 1> GVs;
1077 Global.getDebugInfo(GVs);
1079 // No type information, mostly internal, skip it.
1080 if (GVs.size() == 0)
1083 uint32_t GVTypeId = 0;
1084 for (auto *GVE : GVs) {
1085 if (SecName.startswith(".maps"))
1086 visitMapDefType(GVE->getVariable()->getType(), GVTypeId);
1088 visitTypeEntry(GVE->getVariable()->getType(), GVTypeId, false, false);
1092 // Only support the following globals:
1093 // . static variables
1094 // . non-static weak or non-weak global variables
1095 // . weak or non-weak extern global variables
1096 // Whether DataSec is readonly or not can be found from corresponding ELF
1097 // section flags. Whether a BTF_KIND_VAR is a weak symbol or not
1098 // can be found from the corresponding ELF symbol table.
1099 auto Linkage = Global.getLinkage();
1100 if (Linkage != GlobalValue::InternalLinkage &&
1101 Linkage != GlobalValue::ExternalLinkage &&
1102 Linkage != GlobalValue::WeakAnyLinkage &&
1103 Linkage != GlobalValue::ExternalWeakLinkage)
1107 if (Linkage == GlobalValue::InternalLinkage) {
1108 GVarInfo = BTF::VAR_STATIC;
1109 } else if (Global.hasInitializer()) {
1110 GVarInfo = BTF::VAR_GLOBAL_ALLOCATED;
1112 GVarInfo = BTF::VAR_GLOBAL_EXTERNAL;
1116 std::make_unique<BTFKindVar>(Global.getName(), GVTypeId, GVarInfo);
1117 uint32_t VarId = addType(std::move(VarEntry));
1119 assert(!SecName.empty());
1121 // Find or create a DataSec
1122 if (DataSecEntries.find(SecName) == DataSecEntries.end()) {
1123 DataSecEntries[SecName] = std::make_unique<BTFKindDataSec>(Asm, SecName);
1126 // Calculate symbol size
1127 const DataLayout &DL = Global.getParent()->getDataLayout();
1128 uint32_t Size = DL.getTypeAllocSize(Global.getType()->getElementType());
1130 DataSecEntries[SecName]->addVar(VarId, Asm->getSymbol(&Global), Size);
1134 /// Emit proper patchable instructions.
1135 bool BTFDebug::InstLower(const MachineInstr *MI, MCInst &OutMI) {
1136 if (MI->getOpcode() == BPF::LD_imm64) {
1137 const MachineOperand &MO = MI->getOperand(1);
1138 if (MO.isGlobal()) {
1139 const GlobalValue *GVal = MO.getGlobal();
1140 auto *GVar = dyn_cast<GlobalVariable>(GVal);
1141 if (GVar && GVar->hasAttribute(BPFCoreSharedInfo::AmaAttr)) {
1142 // Emit "mov ri, <imm>" for patched immediate.
1143 uint32_t Imm = PatchImms[GVar->getName().str()];
1144 OutMI.setOpcode(BPF::MOV_ri);
1145 OutMI.addOperand(MCOperand::createReg(MI->getOperand(0).getReg()));
1146 OutMI.addOperand(MCOperand::createImm(Imm));
1150 } else if (MI->getOpcode() == BPF::CORE_MEM ||
1151 MI->getOpcode() == BPF::CORE_ALU32_MEM ||
1152 MI->getOpcode() == BPF::CORE_SHIFT) {
1153 const MachineOperand &MO = MI->getOperand(3);
1154 if (MO.isGlobal()) {
1155 const GlobalValue *GVal = MO.getGlobal();
1156 auto *GVar = dyn_cast<GlobalVariable>(GVal);
1157 if (GVar && GVar->hasAttribute(BPFCoreSharedInfo::AmaAttr)) {
1158 uint32_t Imm = PatchImms[GVar->getName().str()];
1159 OutMI.setOpcode(MI->getOperand(1).getImm());
1160 if (MI->getOperand(0).isImm())
1161 OutMI.addOperand(MCOperand::createImm(MI->getOperand(0).getImm()));
1163 OutMI.addOperand(MCOperand::createReg(MI->getOperand(0).getReg()));
1164 OutMI.addOperand(MCOperand::createReg(MI->getOperand(2).getReg()));
1165 OutMI.addOperand(MCOperand::createImm(Imm));
1173 void BTFDebug::processFuncPrototypes(const Function *F) {
1177 const DISubprogram *SP = F->getSubprogram();
1178 if (!SP || SP->isDefinition())
1181 // Do not emit again if already emitted.
1182 if (ProtoFunctions.find(F) != ProtoFunctions.end())
1184 ProtoFunctions.insert(F);
1186 uint32_t ProtoTypeId;
1187 const std::unordered_map<uint32_t, StringRef> FuncArgNames;
1188 visitSubroutineType(SP->getType(), false, FuncArgNames, ProtoTypeId);
1190 uint8_t Scope = BTF::FUNC_EXTERN;
1191 auto FuncTypeEntry =
1192 std::make_unique<BTFTypeFunc>(SP->getName(), ProtoTypeId, Scope);
1193 addType(std::move(FuncTypeEntry));
1196 void BTFDebug::endModule() {
1197 // Collect MapDef globals if not collected yet.
1198 if (MapDefNotCollected) {
1199 processGlobals(true);
1200 MapDefNotCollected = false;
1203 // Collect global types/variables except MapDef globals.
1204 processGlobals(false);
1206 for (auto &DataSec : DataSecEntries)
1207 addType(std::move(DataSec.second));
1210 for (auto &Fixup : FixupDerivedTypes) {
1211 StringRef TypeName = Fixup.first;
1212 bool IsUnion = Fixup.second.first;
1214 // Search through struct types
1215 uint32_t StructTypeId = 0;
1216 for (const auto &StructType : StructTypes) {
1217 if (StructType->getName() == TypeName) {
1218 StructTypeId = StructType->getId();
1223 if (StructTypeId == 0) {
1224 auto FwdTypeEntry = std::make_unique<BTFTypeFwd>(TypeName, IsUnion);
1225 StructTypeId = addType(std::move(FwdTypeEntry));
1228 for (auto &DType : Fixup.second.second) {
1229 DType->setPointeeType(StructTypeId);
1233 // Complete BTF type cross refereences.
1234 for (const auto &TypeEntry : TypeEntries)
1235 TypeEntry->completeType(*this);
1237 // Emit BTF sections.
1239 emitBTFExtSection();