LLVM  10.0.0svn
BTFDebug.cpp
Go to the documentation of this file.
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"
17 #include "llvm/BinaryFormat/ELF.h"
20 #include "llvm/MC/MCContext.h"
22 #include "llvm/MC/MCSectionELF.h"
23 #include "llvm/MC/MCStreamer.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.
35  OS.AddComment(std::string(BTFKindStr[Kind]) + "(id = " + std::to_string(Id) +
36  ")");
39  OS.EmitIntValue(BTFType.Info, 4);
40  OS.EmitIntValue(BTFType.Size, 4);
41 }
42 
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 
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 
91 
93  BTFType.Type = PointeeType;
94 }
95 
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;
100  BTFType.Type = 0;
101 }
102 
104  if (IsCompleted)
105  return;
106  IsCompleted = true;
107 
108  BTFType.NameOff = BDebug.addString(Name);
109 }
110 
112 
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 
141  if (IsCompleted)
142  return;
143  IsCompleted = true;
144 
145  BTFType.NameOff = BDebug.addString(Name);
146 }
147 
150  OS.AddComment("0x" + Twine::utohexstr(IntVal));
151  OS.EmitIntValue(IntVal, 4);
152 }
153 
154 BTFTypeEnum::BTFTypeEnum(const DICompositeType *ETy, uint32_t VLen) : ETy(ETy) {
155  Kind = BTF::BTF_KIND_ENUM;
156  BTFType.Info = Kind << 24 | VLen;
158 }
159 
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 
181  for (const auto &Enum : EnumValues) {
182  OS.EmitIntValue(Enum.NameOff, 4);
183  OS.EmitIntValue(Enum.Val, 4);
184  }
185 }
186 
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.
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 
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.
219  bool HasBitField, uint32_t Vlen)
220  : STy(STy), HasBitField(HasBitField) {
221  Kind = IsStruct ? BTF::BTF_KIND_STRUCT : BTF::BTF_KIND_UNION;
223  BTFType.Info = (HasBitField << 31) | (Kind << 24) | Vlen;
224 }
225 
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 
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 
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.
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 
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 
305  for (const auto &Param : Parameters) {
306  OS.EmitIntValue(Param.NameOff, 4);
307  OS.EmitIntValue(Param.Type, 4);
308  }
309 }
310 
312  : Name(FuncName) {
313  Kind = BTF::BTF_KIND_FUNC;
314  BTFType.Info = Kind << 24;
315  BTFType.Type = ProtoTypeId;
316 }
317 
319  if (IsCompleted)
320  return;
321  IsCompleted = true;
322 
323  BTFType.NameOff = BDebug.addString(Name);
324 }
325 
327 
329  : Name(VarName) {
330  Kind = BTF::BTF_KIND_VAR;
331  BTFType.Info = Kind << 24;
332  BTFType.Type = TypeId;
333  Info = VarInfo;
334 }
335 
337  BTFType.NameOff = BDebug.addString(Name);
338 }
339 
342  OS.EmitIntValue(Info, 4);
343 }
344 
345 BTFKindDataSec::BTFKindDataSec(AsmPrinter *AsmPrt, std::string SecName)
346  : Asm(AsmPrt), Name(SecName) {
347  Kind = BTF::BTF_KIND_DATASEC;
348  BTFType.Info = Kind << 24;
349  BTFType.Size = 0;
350 }
351 
353  BTFType.NameOff = BDebug.addString(Name);
354  BTFType.Info |= Vars.size();
355 }
356 
359 
360  for (const auto &V : Vars) {
361  OS.EmitIntValue(std::get<0>(V), 4);
362  Asm->EmitLabelReference(std::get<1>(V), 4);
363  OS.EmitIntValue(std::get<2>(V), 4);
364  }
365 }
366 
368  // Check whether the string already exists.
369  for (auto &OffsetM : OffsetToIdMap) {
370  if (Table[OffsetM.second] == S)
371  return OffsetM.first;
372  }
373  // Not find, add to the string table.
374  uint32_t Offset = Size;
375  OffsetToIdMap[Offset] = Table.size();
376  Table.push_back(S);
377  Size += S.size() + 1;
378  return Offset;
379 }
380 
382  : DebugHandlerBase(AP), OS(*Asm->OutStreamer), SkipInstruction(false),
383  LineInfoGenerated(false), SecNameOff(0), ArrayIndexTypeId(0),
384  MapDefNotCollected(true) {
385  addString("\0");
386 }
387 
388 uint32_t BTFDebug::addType(std::unique_ptr<BTFTypeBase> TypeEntry,
389  const DIType *Ty) {
390  TypeEntry->setId(TypeEntries.size() + 1);
391  uint32_t Id = TypeEntry->getId();
392  DIToIdMap[Ty] = Id;
393  TypeEntries.push_back(std::move(TypeEntry));
394  return Id;
395 }
396 
397 uint32_t BTFDebug::addType(std::unique_ptr<BTFTypeBase> TypeEntry) {
398  TypeEntry->setId(TypeEntries.size() + 1);
399  uint32_t Id = TypeEntry->getId();
400  TypeEntries.push_back(std::move(TypeEntry));
401  return Id;
402 }
403 
404 void BTFDebug::visitBasicType(const DIBasicType *BTy, uint32_t &TypeId) {
405  // Only int types are supported in BTF.
406  uint32_t Encoding = BTy->getEncoding();
407  if (Encoding != dwarf::DW_ATE_boolean && Encoding != dwarf::DW_ATE_signed &&
408  Encoding != dwarf::DW_ATE_signed_char &&
409  Encoding != dwarf::DW_ATE_unsigned &&
410  Encoding != dwarf::DW_ATE_unsigned_char)
411  return;
412 
413  // Create a BTF type instance for this DIBasicType and put it into
414  // DIToIdMap for cross-type reference check.
415  auto TypeEntry = std::make_unique<BTFTypeInt>(
416  Encoding, BTy->getSizeInBits(), BTy->getOffsetInBits(), BTy->getName());
417  TypeId = addType(std::move(TypeEntry), BTy);
418 }
419 
420 /// Handle subprogram or subroutine types.
421 void BTFDebug::visitSubroutineType(
422  const DISubroutineType *STy, bool ForSubprog,
423  const std::unordered_map<uint32_t, StringRef> &FuncArgNames,
424  uint32_t &TypeId) {
425  DITypeRefArray Elements = STy->getTypeArray();
426  uint32_t VLen = Elements.size() - 1;
427  if (VLen > BTF::MAX_VLEN)
428  return;
429 
430  // Subprogram has a valid non-zero-length name, and the pointee of
431  // a function pointer has an empty name. The subprogram type will
432  // not be added to DIToIdMap as it should not be referenced by
433  // any other types.
434  auto TypeEntry = std::make_unique<BTFTypeFuncProto>(STy, VLen, FuncArgNames);
435  if (ForSubprog)
436  TypeId = addType(std::move(TypeEntry)); // For subprogram
437  else
438  TypeId = addType(std::move(TypeEntry), STy); // For func ptr
439 
440  // Visit return type and func arg types.
441  for (const auto Element : Elements) {
442  visitTypeEntry(Element);
443  }
444 }
445 
446 /// Handle structure/union types.
447 void BTFDebug::visitStructType(const DICompositeType *CTy, bool IsStruct,
448  uint32_t &TypeId) {
449  const DINodeArray Elements = CTy->getElements();
450  uint32_t VLen = Elements.size();
451  if (VLen > BTF::MAX_VLEN)
452  return;
453 
454  // Check whether we have any bitfield members or not
455  bool HasBitField = false;
456  for (const auto *Element : Elements) {
457  auto E = cast<DIDerivedType>(Element);
458  if (E->isBitField()) {
459  HasBitField = true;
460  break;
461  }
462  }
463 
464  auto TypeEntry =
465  std::make_unique<BTFTypeStruct>(CTy, IsStruct, HasBitField, VLen);
466  StructTypes.push_back(TypeEntry.get());
467  TypeId = addType(std::move(TypeEntry), CTy);
468 
469  // Visit all struct members.
470  for (const auto *Element : Elements)
471  visitTypeEntry(cast<DIDerivedType>(Element));
472 }
473 
474 void BTFDebug::visitArrayType(const DICompositeType *CTy, uint32_t &TypeId) {
475  // Visit array element type.
476  uint32_t ElemTypeId, ElemSize;
477  const DIType *ElemType = CTy->getBaseType();
478  visitTypeEntry(ElemType, ElemTypeId, false, false);
479 
480  // Strip qualifiers from element type to get accurate element size.
481  ElemSize = ElemType->getSizeInBits() >> 3;
482 
483  if (!CTy->getSizeInBits()) {
484  auto TypeEntry = std::make_unique<BTFTypeArray>(ElemTypeId, 0);
485  ElemTypeId = addType(std::move(TypeEntry), CTy);
486  } else {
487  // Visit array dimensions.
488  DINodeArray Elements = CTy->getElements();
489  for (int I = Elements.size() - 1; I >= 0; --I) {
490  if (auto *Element = dyn_cast_or_null<DINode>(Elements[I]))
491  if (Element->getTag() == dwarf::DW_TAG_subrange_type) {
492  const DISubrange *SR = cast<DISubrange>(Element);
493  auto *CI = SR->getCount().dyn_cast<ConstantInt *>();
494  int64_t Count = CI->getSExtValue();
495 
496  auto TypeEntry =
497  std::make_unique<BTFTypeArray>(ElemTypeId, Count);
498  if (I == 0)
499  ElemTypeId = addType(std::move(TypeEntry), CTy);
500  else
501  ElemTypeId = addType(std::move(TypeEntry));
502  ElemSize = ElemSize * Count;
503  }
504  }
505  }
506 
507  // The array TypeId is the type id of the outermost dimension.
508  TypeId = ElemTypeId;
509 
510  // The IR does not have a type for array index while BTF wants one.
511  // So create an array index type if there is none.
512  if (!ArrayIndexTypeId) {
513  auto TypeEntry = std::make_unique<BTFTypeInt>(dwarf::DW_ATE_unsigned, 32,
514  0, "__ARRAY_SIZE_TYPE__");
515  ArrayIndexTypeId = addType(std::move(TypeEntry));
516  }
517 }
518 
519 void BTFDebug::visitEnumType(const DICompositeType *CTy, uint32_t &TypeId) {
520  DINodeArray Elements = CTy->getElements();
521  uint32_t VLen = Elements.size();
522  if (VLen > BTF::MAX_VLEN)
523  return;
524 
525  auto TypeEntry = std::make_unique<BTFTypeEnum>(CTy, VLen);
526  TypeId = addType(std::move(TypeEntry), CTy);
527  // No need to visit base type as BTF does not encode it.
528 }
529 
530 /// Handle structure/union forward declarations.
531 void BTFDebug::visitFwdDeclType(const DICompositeType *CTy, bool IsUnion,
532  uint32_t &TypeId) {
533  auto TypeEntry = std::make_unique<BTFTypeFwd>(CTy->getName(), IsUnion);
534  TypeId = addType(std::move(TypeEntry), CTy);
535 }
536 
537 /// Handle structure, union, array and enumeration types.
538 void BTFDebug::visitCompositeType(const DICompositeType *CTy,
539  uint32_t &TypeId) {
540  auto Tag = CTy->getTag();
541  if (Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
542  // Handle forward declaration differently as it does not have members.
543  if (CTy->isForwardDecl())
544  visitFwdDeclType(CTy, Tag == dwarf::DW_TAG_union_type, TypeId);
545  else
546  visitStructType(CTy, Tag == dwarf::DW_TAG_structure_type, TypeId);
547  } else if (Tag == dwarf::DW_TAG_array_type)
548  visitArrayType(CTy, TypeId);
549  else if (Tag == dwarf::DW_TAG_enumeration_type)
550  visitEnumType(CTy, TypeId);
551 }
552 
553 /// Handle pointer, typedef, const, volatile, restrict and member types.
554 void BTFDebug::visitDerivedType(const DIDerivedType *DTy, uint32_t &TypeId,
555  bool CheckPointer, bool SeenPointer) {
556  unsigned Tag = DTy->getTag();
557 
558  /// Try to avoid chasing pointees, esp. structure pointees which may
559  /// unnecessary bring in a lot of types.
560  if (CheckPointer && !SeenPointer) {
561  SeenPointer = Tag == dwarf::DW_TAG_pointer_type;
562  }
563 
564  if (CheckPointer && SeenPointer) {
565  const DIType *Base = DTy->getBaseType();
566  if (Base) {
567  if (const auto *CTy = dyn_cast<DICompositeType>(Base)) {
568  auto CTag = CTy->getTag();
569  if ((CTag == dwarf::DW_TAG_structure_type ||
570  CTag == dwarf::DW_TAG_union_type) &&
571  !CTy->isForwardDecl()) {
572  /// Find a candidate, generate a fixup. Later on the struct/union
573  /// pointee type will be replaced with either a real type or
574  /// a forward declaration.
575  auto TypeEntry = std::make_unique<BTFTypeDerived>(DTy, Tag, true);
576  auto &Fixup = FixupDerivedTypes[CTy->getName()];
577  Fixup.first = CTag == dwarf::DW_TAG_union_type;
578  Fixup.second.push_back(TypeEntry.get());
579  TypeId = addType(std::move(TypeEntry), DTy);
580  return;
581  }
582  }
583  }
584  }
585 
586  if (Tag == dwarf::DW_TAG_pointer_type || Tag == dwarf::DW_TAG_typedef ||
587  Tag == dwarf::DW_TAG_const_type || Tag == dwarf::DW_TAG_volatile_type ||
588  Tag == dwarf::DW_TAG_restrict_type) {
589  auto TypeEntry = std::make_unique<BTFTypeDerived>(DTy, Tag, false);
590  TypeId = addType(std::move(TypeEntry), DTy);
591  } else if (Tag != dwarf::DW_TAG_member) {
592  return;
593  }
594 
595  // Visit base type of pointer, typedef, const, volatile, restrict or
596  // struct/union member.
597  uint32_t TempTypeId = 0;
598  if (Tag == dwarf::DW_TAG_member)
599  visitTypeEntry(DTy->getBaseType(), TempTypeId, true, false);
600  else
601  visitTypeEntry(DTy->getBaseType(), TempTypeId, CheckPointer, SeenPointer);
602 }
603 
604 void BTFDebug::visitTypeEntry(const DIType *Ty, uint32_t &TypeId,
605  bool CheckPointer, bool SeenPointer) {
606  if (!Ty || DIToIdMap.find(Ty) != DIToIdMap.end()) {
607  TypeId = DIToIdMap[Ty];
608  return;
609  }
610 
611  if (const auto *BTy = dyn_cast<DIBasicType>(Ty))
612  visitBasicType(BTy, TypeId);
613  else if (const auto *STy = dyn_cast<DISubroutineType>(Ty))
614  visitSubroutineType(STy, false, std::unordered_map<uint32_t, StringRef>(),
615  TypeId);
616  else if (const auto *CTy = dyn_cast<DICompositeType>(Ty))
617  visitCompositeType(CTy, TypeId);
618  else if (const auto *DTy = dyn_cast<DIDerivedType>(Ty))
619  visitDerivedType(DTy, TypeId, CheckPointer, SeenPointer);
620  else
621  llvm_unreachable("Unknown DIType");
622 }
623 
624 void BTFDebug::visitTypeEntry(const DIType *Ty) {
625  uint32_t TypeId;
626  visitTypeEntry(Ty, TypeId, false, false);
627 }
628 
629 void BTFDebug::visitMapDefType(const DIType *Ty, uint32_t &TypeId) {
630  if (!Ty || DIToIdMap.find(Ty) != DIToIdMap.end()) {
631  TypeId = DIToIdMap[Ty];
632  return;
633  }
634 
635  // MapDef type is a struct type
636  const auto *CTy = dyn_cast<DICompositeType>(Ty);
637  if (!CTy)
638  return;
639 
640  auto Tag = CTy->getTag();
641  if (Tag != dwarf::DW_TAG_structure_type || CTy->isForwardDecl())
642  return;
643 
644  // Record this type
645  const DINodeArray Elements = CTy->getElements();
646  bool HasBitField = false;
647  for (const auto *Element : Elements) {
648  auto E = cast<DIDerivedType>(Element);
649  if (E->isBitField()) {
650  HasBitField = true;
651  break;
652  }
653  }
654 
655  auto TypeEntry =
656  std::make_unique<BTFTypeStruct>(CTy, true, HasBitField, Elements.size());
657  StructTypes.push_back(TypeEntry.get());
658  TypeId = addType(std::move(TypeEntry), CTy);
659 
660  // Visit all struct members
661  for (const auto *Element : Elements) {
662  const auto *MemberType = cast<DIDerivedType>(Element);
663  visitTypeEntry(MemberType->getBaseType());
664  }
665 }
666 
667 /// Read file contents from the actual file or from the source
668 std::string BTFDebug::populateFileContent(const DISubprogram *SP) {
669  auto File = SP->getFile();
670  std::string FileName;
671 
672  if (!File->getFilename().startswith("/") && File->getDirectory().size())
673  FileName = File->getDirectory().str() + "/" + File->getFilename().str();
674  else
675  FileName = File->getFilename();
676 
677  // No need to populate the contends if it has been populated!
678  if (FileContent.find(FileName) != FileContent.end())
679  return FileName;
680 
681  std::vector<std::string> Content;
682  std::string Line;
683  Content.push_back(Line); // Line 0 for empty string
684 
685  std::unique_ptr<MemoryBuffer> Buf;
686  auto Source = File->getSource();
687  if (Source)
689  else if (ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
690  MemoryBuffer::getFile(FileName))
691  Buf = std::move(*BufOrErr);
692  if (Buf)
693  for (line_iterator I(*Buf, false), E; I != E; ++I)
694  Content.push_back(*I);
695 
696  FileContent[FileName] = Content;
697  return FileName;
698 }
699 
700 void BTFDebug::constructLineInfo(const DISubprogram *SP, MCSymbol *Label,
701  uint32_t Line, uint32_t Column) {
702  std::string FileName = populateFileContent(SP);
703  BTFLineInfo LineInfo;
704 
705  LineInfo.Label = Label;
706  LineInfo.FileNameOff = addString(FileName);
707  // If file content is not available, let LineOff = 0.
708  if (Line < FileContent[FileName].size())
709  LineInfo.LineOff = addString(FileContent[FileName][Line]);
710  else
711  LineInfo.LineOff = 0;
712  LineInfo.LineNum = Line;
713  LineInfo.ColumnNum = Column;
714  LineInfoTable[SecNameOff].push_back(LineInfo);
715 }
716 
717 void BTFDebug::emitCommonHeader() {
719  OS.EmitIntValue(BTF::MAGIC, 2);
720  OS.EmitIntValue(BTF::VERSION, 1);
721  OS.EmitIntValue(0, 1);
722 }
723 
724 void BTFDebug::emitBTFSection() {
725  // Do not emit section if no types and only "" string.
726  if (!TypeEntries.size() && StringTable.getSize() == 1)
727  return;
728 
729  MCContext &Ctx = OS.getContext();
730  OS.SwitchSection(Ctx.getELFSection(".BTF", ELF::SHT_PROGBITS, 0));
731 
732  // Emit header.
733  emitCommonHeader();
735 
736  uint32_t TypeLen = 0, StrLen;
737  for (const auto &TypeEntry : TypeEntries)
738  TypeLen += TypeEntry->getSize();
739  StrLen = StringTable.getSize();
740 
741  OS.EmitIntValue(0, 4);
742  OS.EmitIntValue(TypeLen, 4);
743  OS.EmitIntValue(TypeLen, 4);
744  OS.EmitIntValue(StrLen, 4);
745 
746  // Emit type table.
747  for (const auto &TypeEntry : TypeEntries)
748  TypeEntry->emitType(OS);
749 
750  // Emit string table.
751  uint32_t StringOffset = 0;
752  for (const auto &S : StringTable.getTable()) {
753  OS.AddComment("string offset=" + std::to_string(StringOffset));
754  OS.EmitBytes(S);
755  OS.EmitBytes(StringRef("\0", 1));
756  StringOffset += S.size() + 1;
757  }
758 }
759 
760 void BTFDebug::emitBTFExtSection() {
761  // Do not emit section if empty FuncInfoTable and LineInfoTable.
762  if (!FuncInfoTable.size() && !LineInfoTable.size() &&
763  !OffsetRelocTable.size() && !ExternRelocTable.size())
764  return;
765 
766  MCContext &Ctx = OS.getContext();
767  OS.SwitchSection(Ctx.getELFSection(".BTF.ext", ELF::SHT_PROGBITS, 0));
768 
769  // Emit header.
770  emitCommonHeader();
772 
773  // Account for FuncInfo/LineInfo record size as well.
774  uint32_t FuncLen = 4, LineLen = 4;
775  // Do not account for optional OffsetReloc/ExternReloc.
776  uint32_t OffsetRelocLen = 0, ExternRelocLen = 0;
777  for (const auto &FuncSec : FuncInfoTable) {
778  FuncLen += BTF::SecFuncInfoSize;
779  FuncLen += FuncSec.second.size() * BTF::BPFFuncInfoSize;
780  }
781  for (const auto &LineSec : LineInfoTable) {
782  LineLen += BTF::SecLineInfoSize;
783  LineLen += LineSec.second.size() * BTF::BPFLineInfoSize;
784  }
785  for (const auto &OffsetRelocSec : OffsetRelocTable) {
786  OffsetRelocLen += BTF::SecOffsetRelocSize;
787  OffsetRelocLen += OffsetRelocSec.second.size() * BTF::BPFOffsetRelocSize;
788  }
789  for (const auto &ExternRelocSec : ExternRelocTable) {
790  ExternRelocLen += BTF::SecExternRelocSize;
791  ExternRelocLen += ExternRelocSec.second.size() * BTF::BPFExternRelocSize;
792  }
793 
794  if (OffsetRelocLen)
795  OffsetRelocLen += 4;
796  if (ExternRelocLen)
797  ExternRelocLen += 4;
798 
799  OS.EmitIntValue(0, 4);
800  OS.EmitIntValue(FuncLen, 4);
801  OS.EmitIntValue(FuncLen, 4);
802  OS.EmitIntValue(LineLen, 4);
803  OS.EmitIntValue(FuncLen + LineLen, 4);
804  OS.EmitIntValue(OffsetRelocLen, 4);
805  OS.EmitIntValue(FuncLen + LineLen + OffsetRelocLen, 4);
806  OS.EmitIntValue(ExternRelocLen, 4);
807 
808  // Emit func_info table.
809  OS.AddComment("FuncInfo");
811  for (const auto &FuncSec : FuncInfoTable) {
812  OS.AddComment("FuncInfo section string offset=" +
813  std::to_string(FuncSec.first));
814  OS.EmitIntValue(FuncSec.first, 4);
815  OS.EmitIntValue(FuncSec.second.size(), 4);
816  for (const auto &FuncInfo : FuncSec.second) {
817  Asm->EmitLabelReference(FuncInfo.Label, 4);
818  OS.EmitIntValue(FuncInfo.TypeId, 4);
819  }
820  }
821 
822  // Emit line_info table.
823  OS.AddComment("LineInfo");
825  for (const auto &LineSec : LineInfoTable) {
826  OS.AddComment("LineInfo section string offset=" +
827  std::to_string(LineSec.first));
828  OS.EmitIntValue(LineSec.first, 4);
829  OS.EmitIntValue(LineSec.second.size(), 4);
830  for (const auto &LineInfo : LineSec.second) {
831  Asm->EmitLabelReference(LineInfo.Label, 4);
832  OS.EmitIntValue(LineInfo.FileNameOff, 4);
833  OS.EmitIntValue(LineInfo.LineOff, 4);
834  OS.AddComment("Line " + std::to_string(LineInfo.LineNum) + " Col " +
835  std::to_string(LineInfo.ColumnNum));
836  OS.EmitIntValue(LineInfo.LineNum << 10 | LineInfo.ColumnNum, 4);
837  }
838  }
839 
840  // Emit offset reloc table.
841  if (OffsetRelocLen) {
842  OS.AddComment("OffsetReloc");
844  for (const auto &OffsetRelocSec : OffsetRelocTable) {
845  OS.AddComment("Offset reloc section string offset=" +
846  std::to_string(OffsetRelocSec.first));
847  OS.EmitIntValue(OffsetRelocSec.first, 4);
848  OS.EmitIntValue(OffsetRelocSec.second.size(), 4);
849  for (const auto &OffsetRelocInfo : OffsetRelocSec.second) {
850  Asm->EmitLabelReference(OffsetRelocInfo.Label, 4);
851  OS.EmitIntValue(OffsetRelocInfo.TypeID, 4);
852  OS.EmitIntValue(OffsetRelocInfo.OffsetNameOff, 4);
853  }
854  }
855  }
856 
857  // Emit extern reloc table.
858  if (ExternRelocLen) {
859  OS.AddComment("ExternReloc");
861  for (const auto &ExternRelocSec : ExternRelocTable) {
862  OS.AddComment("Extern reloc section string offset=" +
863  std::to_string(ExternRelocSec.first));
864  OS.EmitIntValue(ExternRelocSec.first, 4);
865  OS.EmitIntValue(ExternRelocSec.second.size(), 4);
866  for (const auto &ExternRelocInfo : ExternRelocSec.second) {
867  Asm->EmitLabelReference(ExternRelocInfo.Label, 4);
868  OS.EmitIntValue(ExternRelocInfo.ExternNameOff, 4);
869  }
870  }
871  }
872 }
873 
875  auto *SP = MF->getFunction().getSubprogram();
876  auto *Unit = SP->getUnit();
877 
878  if (Unit->getEmissionKind() == DICompileUnit::NoDebug) {
879  SkipInstruction = true;
880  return;
881  }
882  SkipInstruction = false;
883 
884  // Collect MapDef types. Map definition needs to collect
885  // pointee types. Do it first. Otherwise, for the following
886  // case:
887  // struct m { ...};
888  // struct t {
889  // struct m *key;
890  // };
891  // foo(struct t *arg);
892  //
893  // struct mapdef {
894  // ...
895  // struct m *key;
896  // ...
897  // } __attribute__((section(".maps"))) hash_map;
898  //
899  // If subroutine foo is traversed first, a type chain
900  // "ptr->struct m(fwd)" will be created and later on
901  // when traversing mapdef, since "ptr->struct m" exists,
902  // the traversal of "struct m" will be omitted.
903  if (MapDefNotCollected) {
904  processGlobals(true);
905  MapDefNotCollected = false;
906  }
907 
908  // Collect all types locally referenced in this function.
909  // Use RetainedNodes so we can collect all argument names
910  // even if the argument is not used.
911  std::unordered_map<uint32_t, StringRef> FuncArgNames;
912  for (const DINode *DN : SP->getRetainedNodes()) {
913  if (const auto *DV = dyn_cast<DILocalVariable>(DN)) {
914  // Collect function arguments for subprogram func type.
915  uint32_t Arg = DV->getArg();
916  if (Arg) {
917  visitTypeEntry(DV->getType());
918  FuncArgNames[Arg] = DV->getName();
919  }
920  }
921  }
922 
923  // Construct subprogram func proto type.
924  uint32_t ProtoTypeId;
925  visitSubroutineType(SP->getType(), true, FuncArgNames, ProtoTypeId);
926 
927  // Construct subprogram func type
928  auto FuncTypeEntry =
929  std::make_unique<BTFTypeFunc>(SP->getName(), ProtoTypeId);
930  uint32_t FuncTypeId = addType(std::move(FuncTypeEntry));
931 
932  for (const auto &TypeEntry : TypeEntries)
933  TypeEntry->completeType(*this);
934 
935  // Construct funcinfo and the first lineinfo for the function.
936  MCSymbol *FuncLabel = Asm->getFunctionBegin();
937  BTFFuncInfo FuncInfo;
938  FuncInfo.Label = FuncLabel;
939  FuncInfo.TypeId = FuncTypeId;
940  if (FuncLabel->isInSection()) {
941  MCSection &Section = FuncLabel->getSection();
942  const MCSectionELF *SectionELF = dyn_cast<MCSectionELF>(&Section);
943  assert(SectionELF && "Null section for Function Label");
944  SecNameOff = addString(SectionELF->getSectionName());
945  } else {
946  SecNameOff = addString(".text");
947  }
948  FuncInfoTable[SecNameOff].push_back(FuncInfo);
949 }
950 
952  SkipInstruction = false;
953  LineInfoGenerated = false;
954  SecNameOff = 0;
955 }
956 
957 /// On-demand populate struct types as requested from abstract member
958 /// accessing.
959 unsigned BTFDebug::populateStructType(const DIType *Ty) {
960  unsigned Id;
961  visitTypeEntry(Ty, Id, false, false);
962  for (const auto &TypeEntry : TypeEntries)
963  TypeEntry->completeType(*this);
964  return Id;
965 }
966 
967 /// Generate a struct member offset relocation.
968 void BTFDebug::generateOffsetReloc(const MachineInstr *MI,
969  const MCSymbol *ORSym, DIType *RootTy,
970  StringRef AccessPattern) {
971  unsigned RootId = populateStructType(RootTy);
972  size_t FirstDollar = AccessPattern.find_first_of('$');
973  size_t FirstColon = AccessPattern.find_first_of(':');
974  StringRef IndexPattern = AccessPattern.substr(FirstDollar + 1);
975  StringRef OffsetStr = AccessPattern.substr(FirstColon + 1,
976  FirstDollar - FirstColon);
977 
978  BTFOffsetReloc OffsetReloc;
979  OffsetReloc.Label = ORSym;
980  OffsetReloc.OffsetNameOff = addString(IndexPattern);
981  OffsetReloc.TypeID = RootId;
982  AccessOffsets[AccessPattern.str()] = std::stoi(OffsetStr);
983  OffsetRelocTable[SecNameOff].push_back(OffsetReloc);
984 }
985 
986 void BTFDebug::processLDimm64(const MachineInstr *MI) {
987  // If the insn is an LD_imm64, the following two cases
988  // will generate an .BTF.ext record.
989  //
990  // If the insn is "r2 = LD_imm64 @__BTF_...",
991  // add this insn into the .BTF.ext OffsetReloc subsection.
992  // Relocation looks like:
993  // . SecName:
994  // . InstOffset
995  // . TypeID
996  // . OffSetNameOff
997  // Later, the insn is replaced with "r2 = <offset>"
998  // where "<offset>" equals to the offset based on current
999  // type definitions.
1000  //
1001  // If the insn is "r2 = LD_imm64 @VAR" and VAR is
1002  // a patchable external global, add this insn into the .BTF.ext
1003  // ExternReloc subsection.
1004  // Relocation looks like:
1005  // . SecName:
1006  // . InstOffset
1007  // . ExternNameOff
1008  // Later, the insn is replaced with "r2 = <value>" or
1009  // "LD_imm64 r2, <value>" where "<value>" = 0.
1010 
1011  // check whether this is a candidate or not
1012  const MachineOperand &MO = MI->getOperand(1);
1013  if (MO.isGlobal()) {
1014  const GlobalValue *GVal = MO.getGlobal();
1015  auto *GVar = dyn_cast<GlobalVariable>(GVal);
1016  if (GVar && GVar->hasAttribute(BPFCoreSharedInfo::AmaAttr)) {
1017  MCSymbol *ORSym = OS.getContext().createTempSymbol();
1018  OS.EmitLabel(ORSym);
1019 
1020  MDNode *MDN = GVar->getMetadata(LLVMContext::MD_preserve_access_index);
1021  DIType *Ty = dyn_cast<DIType>(MDN);
1022  generateOffsetReloc(MI, ORSym, Ty, GVar->getName());
1023  } else if (GVar && !GVar->hasInitializer() && GVar->hasExternalLinkage() &&
1024  GVar->getSection() == BPFCoreSharedInfo::PatchableExtSecName) {
1025  MCSymbol *ORSym = OS.getContext().createTempSymbol();
1026  OS.EmitLabel(ORSym);
1027 
1028  BTFExternReloc ExternReloc;
1029  ExternReloc.Label = ORSym;
1030  ExternReloc.ExternNameOff = addString(GVar->getName());
1031  ExternRelocTable[SecNameOff].push_back(ExternReloc);
1032  }
1033  }
1034 }
1035 
1038 
1039  if (SkipInstruction || MI->isMetaInstruction() ||
1041  return;
1042 
1043  if (MI->isInlineAsm()) {
1044  // Count the number of register definitions to find the asm string.
1045  unsigned NumDefs = 0;
1046  for (; MI->getOperand(NumDefs).isReg() && MI->getOperand(NumDefs).isDef();
1047  ++NumDefs)
1048  ;
1049 
1050  // Skip this inline asm instruction if the asmstr is empty.
1051  const char *AsmStr = MI->getOperand(NumDefs).getSymbolName();
1052  if (AsmStr[0] == 0)
1053  return;
1054  }
1055 
1056  if (MI->getOpcode() == BPF::LD_imm64)
1057  processLDimm64(MI);
1058 
1059  // Skip this instruction if no DebugLoc or the DebugLoc
1060  // is the same as the previous instruction.
1061  const DebugLoc &DL = MI->getDebugLoc();
1062  if (!DL || PrevInstLoc == DL) {
1063  // This instruction will be skipped, no LineInfo has
1064  // been generated, construct one based on function signature.
1065  if (LineInfoGenerated == false) {
1066  auto *S = MI->getMF()->getFunction().getSubprogram();
1067  MCSymbol *FuncLabel = Asm->getFunctionBegin();
1068  constructLineInfo(S, FuncLabel, S->getLine(), 0);
1069  LineInfoGenerated = true;
1070  }
1071 
1072  return;
1073  }
1074 
1075  // Create a temporary label to remember the insn for lineinfo.
1076  MCSymbol *LineSym = OS.getContext().createTempSymbol();
1077  OS.EmitLabel(LineSym);
1078 
1079  // Construct the lineinfo.
1080  auto SP = DL.get()->getScope()->getSubprogram();
1081  constructLineInfo(SP, LineSym, DL.getLine(), DL.getCol());
1082 
1083  LineInfoGenerated = true;
1084  PrevInstLoc = DL;
1085 }
1086 
1087 void BTFDebug::processGlobals(bool ProcessingMapDef) {
1088  // Collect all types referenced by globals.
1089  const Module *M = MMI->getModule();
1090  for (const GlobalVariable &Global : M->globals()) {
1091  // Ignore external globals for now.
1092  if (!Global.hasInitializer() && Global.hasExternalLinkage())
1093  continue;
1094 
1095  // Decide the section name.
1096  StringRef SecName;
1097  if (Global.hasSection()) {
1098  SecName = Global.getSection();
1099  } else {
1100  // data, bss, or readonly sections
1101  if (Global.isConstant())
1102  SecName = ".rodata";
1103  else
1104  SecName = Global.getInitializer()->isZeroValue() ? ".bss" : ".data";
1105  }
1106 
1107  if (ProcessingMapDef != SecName.startswith(".maps"))
1108  continue;
1109 
1111  Global.getDebugInfo(GVs);
1112  uint32_t GVTypeId = 0;
1113  for (auto *GVE : GVs) {
1114  if (SecName.startswith(".maps"))
1115  visitMapDefType(GVE->getVariable()->getType(), GVTypeId);
1116  else
1117  visitTypeEntry(GVE->getVariable()->getType(), GVTypeId, false, false);
1118  break;
1119  }
1120 
1121  // Only support the following globals:
1122  // . static variables
1123  // . non-static global variables with section attributes
1124  // Essentially means:
1125  // . .bcc/.data/.rodata DataSec entities only contain static data
1126  // . Other DataSec entities contain static or initialized global data.
1127  // Initialized global data are mostly used for finding map key/value type
1128  // id's. Whether DataSec is readonly or not can be found from
1129  // corresponding ELF section flags.
1130  auto Linkage = Global.getLinkage();
1131  if (Linkage != GlobalValue::InternalLinkage &&
1132  (Linkage != GlobalValue::ExternalLinkage || !Global.hasSection()))
1133  continue;
1134 
1135  uint32_t GVarInfo = Linkage == GlobalValue::ExternalLinkage
1137  : BTF::VAR_STATIC;
1138  auto VarEntry =
1139  std::make_unique<BTFKindVar>(Global.getName(), GVTypeId, GVarInfo);
1140  uint32_t VarId = addType(std::move(VarEntry));
1141 
1142  // Find or create a DataSec
1143  if (DataSecEntries.find(SecName) == DataSecEntries.end()) {
1144  DataSecEntries[SecName] = std::make_unique<BTFKindDataSec>(Asm, SecName);
1145  }
1146 
1147  // Calculate symbol size
1148  const DataLayout &DL = Global.getParent()->getDataLayout();
1149  uint32_t Size = DL.getTypeAllocSize(Global.getType()->getElementType());
1150 
1151  DataSecEntries[SecName]->addVar(VarId, Asm->getSymbol(&Global), Size);
1152  }
1153 }
1154 
1155 /// Emit proper patchable instructions.
1156 bool BTFDebug::InstLower(const MachineInstr *MI, MCInst &OutMI) {
1157  if (MI->getOpcode() == BPF::LD_imm64) {
1158  const MachineOperand &MO = MI->getOperand(1);
1159  if (MO.isGlobal()) {
1160  const GlobalValue *GVal = MO.getGlobal();
1161  auto *GVar = dyn_cast<GlobalVariable>(GVal);
1162  if (GVar && GVar->hasAttribute(BPFCoreSharedInfo::AmaAttr)) {
1163  MDNode *MDN = GVar->getMetadata(LLVMContext::MD_preserve_access_index);
1164  DIType *Ty = dyn_cast<DIType>(MDN);
1165  std::string TypeName = Ty->getName();
1166  int64_t Imm = AccessOffsets[GVar->getName().str()];
1167 
1168  // Emit "mov ri, <imm>" for abstract member accesses.
1169  OutMI.setOpcode(BPF::MOV_ri);
1171  OutMI.addOperand(MCOperand::createImm(Imm));
1172  return true;
1173  } else if (GVar && !GVar->hasInitializer() &&
1174  GVar->hasExternalLinkage() &&
1175  GVar->getSection() == BPFCoreSharedInfo::PatchableExtSecName) {
1176  const IntegerType *IntTy = dyn_cast<IntegerType>(GVar->getValueType());
1177  assert(IntTy);
1178  // For patchable externals, emit "LD_imm64, ri, 0" if the external
1179  // variable is 64bit width, emit "mov ri, 0" otherwise.
1180  if (IntTy->getBitWidth() == 64)
1181  OutMI.setOpcode(BPF::LD_imm64);
1182  else
1183  OutMI.setOpcode(BPF::MOV_ri);
1185  OutMI.addOperand(MCOperand::createImm(0));
1186  return true;
1187  }
1188  }
1189  }
1190  return false;
1191 }
1192 
1194  // Collect MapDef globals if not collected yet.
1195  if (MapDefNotCollected) {
1196  processGlobals(true);
1197  MapDefNotCollected = false;
1198  }
1199 
1200  // Collect global types/variables except MapDef globals.
1201  processGlobals(false);
1202  for (auto &DataSec : DataSecEntries)
1203  addType(std::move(DataSec.second));
1204 
1205  // Fixups
1206  for (auto &Fixup : FixupDerivedTypes) {
1207  StringRef TypeName = Fixup.first;
1208  bool IsUnion = Fixup.second.first;
1209 
1210  // Search through struct types
1211  uint32_t StructTypeId = 0;
1212  for (const auto &StructType : StructTypes) {
1213  if (StructType->getName() == TypeName) {
1214  StructTypeId = StructType->getId();
1215  break;
1216  }
1217  }
1218 
1219  if (StructTypeId == 0) {
1220  auto FwdTypeEntry = std::make_unique<BTFTypeFwd>(TypeName, IsUnion);
1221  StructTypeId = addType(std::move(FwdTypeEntry));
1222  }
1223 
1224  for (auto &DType : Fixup.second.second) {
1225  DType->setPointeeType(StructTypeId);
1226  }
1227  }
1228 
1229  // Complete BTF type cross refereences.
1230  for (const auto &TypeEntry : TypeEntries)
1231  TypeEntry->completeType(*this);
1232 
1233  // Emit BTF sections.
1234  emitBTFSection();
1235  emitBTFExtSection();
1236 }
Instances of this class represent a uniqued identifier for a section in the current translation unit...
Definition: MCSection.h:38
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:111
BTFTypeArray(uint32_t ElemTypeId, uint32_t NumElems)
Definition: BTFDebug.cpp:187
Represents either an error or a value T.
Definition: ErrorOr.h:56
uint32_t Type
Definition: BTF.h:185
uint64_t getOffsetInBits() const
void endFunctionImpl(const MachineFunction *MF) override
Post process after all instructions in this function are processed.
Definition: BTFDebug.cpp:951
DILocation * get() const
Get the underlying DILocation.
Definition: DebugLoc.cpp:21
Represent one func and its type id.
Definition: BTFDebug.h:212
LLVM_NODISCARD std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:218
BTFKindDataSec(AsmPrinter *AsmPrt, std::string SecName)
Definition: BTFDebug.cpp:345
BTFTypeFunc(StringRef FuncName, uint32_t ProtoTypeId)
Definition: BTFDebug.cpp:311
Linkage: InternalLinkage.
Definition: BTF.h:190
uint32_t OffsetNameOff
The string to traverse types.
Definition: BTFDebug.h:230
uint32_t ColumnNum
the column number
Definition: BTFDebug.h:223
const MachineFunction * getMF() const
Return the function that contains the basic block that this instruction belongs to.
This class represents lattice values for constants.
Definition: AllocatorList.h:23
uint32_t NameOff
Definition: BTF.h:184
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:65
unsigned size() const
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
LLVM_NODISCARD bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:256
DIFile * getFile() const
const DebugLoc & getDebugLoc() const
Returns the debug location id of this MachineInstr.
Definition: MachineInstr.h:385
Linkage: ExternalLinkage.
Definition: BTF.h:191
uint32_t getArrayIndexTypeId()
Get the special array index type id.
Definition: BTFDebug.h:335
virtual void EmitBytes(StringRef Data)
Emit the bytes in Data into the output.
bool isInlineAsm() const
uint32_t getSize()
Definition: BTFDebug.h:204
BTFTypeEnum(const DICompositeType *ETy, uint32_t NumValues)
Definition: BTFDebug.cpp:154
iterator find(StringRef Key)
Definition: StringMap.h:332
Externally visible function.
Definition: GlobalValue.h:48
BTFTypeInt(uint32_t Encoding, uint32_t SizeInBits, uint32_t OffsetInBits, StringRef TypeName)
Definition: BTFDebug.cpp:113
A forward iterator which reads text lines from a buffer.
Definition: LineIterator.h:31
void completeType(BTFDebug &BDebug)
Represent a BTF array.
Definition: BTFDebug.cpp:198
unsigned getLine() const
Definition: DebugLoc.cpp:25
uint32_t Size
Definition: BTF.h:128
A debug info location.
Definition: DebugLoc.h:33
Metadata node.
Definition: Metadata.h:863
block Block Frequency true
bool isMetaInstruction() const
Return true if this instruction doesn&#39;t produce any output in the form of executable instructions...
bool isForwardDecl() const
static const char * BTFKindStr[]
Definition: BTFDebug.cpp:28
uint32_t Offset
BitOffset or BitFieldSize+BitOffset.
Definition: BTF.h:177
std::string getName()
Definition: BTFDebug.cpp:262
StringRef getName() const
Tagged DWARF-like metadata node.
DINodeArray getElements() const
uint32_t Type
Member type.
Definition: BTF.h:176
MCContext & getContext() const
Definition: MCStreamer.h:251
DebugLoc PrevInstLoc
Previous instruction&#39;s location information.
void emitType(MCStreamer &OS)
Emit types for this BTF type entry.
Definition: BTFDebug.cpp:326
BTFTypeDerived(const DIDerivedType *Ty, unsigned Tag, bool NeedsFixup)
Definition: BTFDebug.cpp:43
static MCOperand createReg(unsigned Reg)
Definition: MCInst.h:115
void emitType(MCStreamer &OS)
Emit types for this BTF type entry.
Definition: BTFDebug.cpp:303
unsigned getTag() const
Class to represent struct types.
Definition: DerivedTypes.h:233
Array subrange.
virtual void emitType(MCStreamer &OS)
Emit types for this BTF type entry.
Definition: BTFDebug.cpp:34
bool isInSection() const
isInSection - Check if this symbol is defined in some section (i.e., it is defined but not absolute)...
Definition: MCSymbol.h:253
void completeType(BTFDebug &BDebug)
Complete BTF type generation after all related DebugInfo types have been visited so their BTF type id...
Definition: BTFDebug.cpp:140
BTF_KIND_ENUM is followed by multiple "struct BTFEnum".
Definition: BTF.h:152
BTFKindVar(StringRef VarName, uint32_t TypeId, uint32_t VarInfo)
Definition: BTFDebug.cpp:328
unsigned getOpcode() const
Returns the opcode of this MachineInstr.
Definition: MachineInstr.h:411
uint32_t roundupToBytes(uint32_t NumBits)
Definition: BTFDebug.h:44
uint64_t getSizeInBits() const
const char * getSymbolName() const
LLVM_NODISCARD StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:578
void beginFunctionImpl(const MachineFunction *MF) override
Gather pre-function debug information.
Definition: BTFDebug.cpp:874
Context object for machine code objects.
Definition: MCContext.h:65
Subprogram description.
virtual void AddComment(const Twine &T, bool EOL=true)
Add a textual comment.
Definition: MCStreamer.h:310
DIType * getBaseType() const
void completeType(BTFDebug &BDebug)
Complete BTF type generation after all related DebugInfo types have been visited so their BTF type id...
Definition: BTFDebug.cpp:160
MCSymbol * getFunctionBegin() const
Definition: AsmPrinter.h:208
uint32_t Type
Definition: BTF.h:129
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:130
void emitType(MCStreamer &OS)
Emit types for this BTF type entry.
Definition: BTFDebug.cpp:357
unsigned getBitWidth() const
Get the number of bits in this IntegerType.
Definition: DerivedTypes.h:66
virtual void EmitIntValue(uint64_t Value, unsigned Size)
Special case of EmitValue that avoids the client having to pass in a MCExpr for constant integers...
Definition: MCStreamer.cpp:128
BTF_KIND_FUNC_PROTO are followed by multiple "struct BTFParam".
Definition: BTF.h:183
static const std::string PatchableExtSecName
The section name to identify a patchable external global.
Definition: BPFCORE.h:19
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:158
Analysis containing CSE Info
Definition: CSEInfo.cpp:20
void endModule() override
Complete all the types and emit the BTF sections.
Definition: BTFDebug.cpp:1193
Represent one extern relocation.
Definition: BTFDebug.h:234
uint8_t Kind
Definition: BTFDebug.h:34
BTFTypeStruct(const DICompositeType *STy, bool IsStruct, bool HasBitField, uint32_t NumMembers)
Represent either a struct or a union.
Definition: BTFDebug.cpp:218
Streaming machine code generation interface.
Definition: MCStreamer.h:189
MCSymbol * createTempSymbol(bool CanBeUnnamed=true)
Create and return a new assembler temporary symbol with a unique but unspecified name.
Definition: MCContext.cpp:225
void completeType(BTFDebug &BDebug)
Complete BTF type generation after all related DebugInfo types have been visited so their BTF type id...
Definition: BTFDebug.cpp:103
void completeType(BTFDebug &BDebug)
Complete BTF type generation after all related DebugInfo types have been visited so their BTF type id...
Definition: BTFDebug.cpp:352
DISubprogram * getSubprogram() const
Get the attached subprogram.
Definition: Metadata.cpp:1504
Instrumentation for Order File
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
virtual void SwitchSection(MCSection *Section, const MCExpr *Subsection=nullptr)
Set the current section where code is being emitted to Section.
CountType getCount() const
struct BTF::CommonType BTFType
Definition: BTFDebug.h:37
void beginInstruction(const MachineInstr *MI) override
Process beginning of an instruction.
Definition: BTFDebug.cpp:1036
const GlobalValue * getGlobal() const
AsmPrinter * Asm
Target of debug info emission.
const MCSymbol * Label
MCSymbol identifying insn for the reloc.
Definition: BTFDebug.h:235
uint32_t ExternNameOff
The extern variable name.
Definition: BTFDebug.h:236
Collect and emit BTF information.
Definition: BTFDebug.h:240
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:78
uint32_t NameOff
Member name offset in the string table.
Definition: BTF.h:175
void emitType(MCStreamer &OS)
Emit types for this BTF type entry.
Definition: BTFDebug.cpp:148
bool InstLower(const MachineInstr *MI, MCInst &OutMI)
Emit proper patchable instructions.
Definition: BTFDebug.cpp:1156
StringRef getName() const
Return the name for this struct type if it has an identity.
Definition: Type.cpp:499
constexpr char TypeName[]
Key for Kernel::Arg::Metadata::mTypeName.
void completeType(BTFDebug &BDebug)
Complete BTF type generation after all related DebugInfo types have been visited so their BTF type id...
Definition: BTFDebug.cpp:336
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
void EmitLabelReference(const MCSymbol *Label, unsigned Size, bool IsSectionRelative=false) const
Emit something like ".long Label" where the size in bytes of the directive is specified by Size and L...
Definition: AsmPrinter.h:499
Represent one line info.
Definition: BTFDebug.h:218
Class to represent integer types.
Definition: DerivedTypes.h:40
void beginInstruction(const MachineInstr *MI) override
Process beginning of an instruction.
Represent one offset relocation.
Definition: BTFDebug.h:227
BTF_KIND_STRUCT and BTF_KIND_UNION are followed by multiple "struct BTFMember".
Definition: BTF.h:174
uint32_t NameOff
Type name offset in the string table.
Definition: BTF.h:110
void emitType(MCStreamer &OS)
Emit types for this BTF type entry.
Definition: BTFDebug.cpp:179
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
PowerPC TLS Dynamic Call Fixup
std::vector< std::string > & getTable()
Definition: BTFDebug.h:205
void setOpcode(unsigned Op)
Definition: MCInst.h:170
Base class for types.
This is the shared class of boolean and integer constants.
Definition: Constants.h:83
uint32_t LineNum
the line number
Definition: BTFDebug.h:222
auto size(R &&Range, typename std::enable_if< std::is_same< typename std::iterator_traits< decltype(Range.begin())>::iterator_category, std::random_access_iterator_tag >::value, void >::type *=nullptr) -> decltype(std::distance(Range.begin(), Range.end()))
Get the size of a range.
Definition: STLExtras.h:1158
bool isGlobal() const
isGlobal - Tests if this is a MO_GlobalAddress operand.
uint32_t Id
Definition: BTFDebug.h:36
StringRef getName() const
MCSymbol * getSymbol(const GlobalValue *GV) const
Definition: AsmPrinter.cpp:443
MachineOperand class - Representation of each machine instruction operand.
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:837
int32_t Val
Enum member value.
Definition: BTF.h:154
uint32_t NameOff
Enum name offset in the string table.
Definition: BTF.h:153
void setPointeeType(uint32_t PointeeType)
Definition: BTFDebug.cpp:92
void completeType(BTFDebug &BDebug)
Complete BTF type generation after all related DebugInfo types have been visited so their BTF type id...
Definition: BTFDebug.cpp:226
MCSymbol * Label
MCSymbol identifying insn for the lineinfo.
Definition: BTFDebug.h:219
static Twine utohexstr(const uint64_t &Val)
Definition: Twine.h:387
uint32_t getTypeId(const DIType *Ty)
Get the type id for a particular DIType.
Definition: BTFDebug.h:344
void completeType(BTFDebug &BDebug)
Complete BTF type generation after all related DebugInfo types have been visited so their BTF type id...
Definition: BTFDebug.cpp:277
const Function & getFunction() const
Return the LLVM function that this machine code represents.
static std::unique_ptr< MemoryBuffer > getMemBufferCopy(StringRef InputData, const Twine &BufferName="")
Open the specified memory range as a MemoryBuffer, copying the contents and taking ownership of it...
Max # of struct/union/enum members or func args.
Definition: BTF.h:98
MCSection & getSection() const
Get the section associated with a defined, non-absolute symbol.
Definition: MCSymbol.h:268
This file contains support for writing BTF debug info.
void emitType(MCStreamer &OS)
Emit types for this BTF type entry.
Definition: BTFDebug.cpp:210
void completeType(BTFDebug &BDebug)
Complete BTF type generation after all related DebugInfo types have been visited so their BTF type id...
Definition: BTFDebug.cpp:68
BTFDebug(AsmPrinter *AP)
Definition: BTFDebug.cpp:381
Type array for a subprogram.
Representation of each machine instruction.
Definition: MachineInstr.h:64
uint32_t addString(StringRef S)
Add a string to the string table and returns its offset in the table.
Definition: BTFDebug.cpp:367
unsigned getEncoding() const
BTFTypeFwd(StringRef Name, bool IsUnion)
Represent a struct/union forward declaration.
Definition: BTFDebug.cpp:97
LLVM_NODISCARD size_t find_first_of(char C, size_t From=0) const
Find the first character in the string that is C, or npos if not found.
Definition: StringRef.h:380
void emitType(MCStreamer &OS)
Emit types for this BTF type entry.
Definition: BTFDebug.cpp:111
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
This represents a section on linux, lots of unix variants and some bare metal systems.
Definition: MCSectionELF.h:27
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:332
Base class for debug information backends.
BTFTypeFuncProto(const DISubroutineType *STy, uint32_t NumParams, const std::unordered_map< uint32_t, StringRef > &FuncArgNames)
The Func kind represents both subprogram and pointee of function pointers.
Definition: BTFDebug.cpp:269
uint32_t Size
Definition: Profile.cpp:46
Rename collisions when linking (static functions).
Definition: GlobalValue.h:55
static const std::string AmaAttr
The attribute attached to globals representing a member offset.
Definition: BPFCORE.h:17
const MCSymbol * Label
Func MCSymbol.
Definition: BTFDebug.h:213
const Module * getModule() const
uint32_t FileNameOff
file name offset in the .BTF string table
Definition: BTFDebug.h:220
size_t addString(StringRef S)
Add string to the string table.
Definition: BTFDebug.h:341
bool isReg() const
isReg - Tests if this is a MO_Register operand.
const std::string to_string(const T &Value)
Definition: ScopedPrinter.h:61
unsigned getCol() const
Definition: DebugLoc.cpp:30
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFile(const Twine &Filename, int64_t FileSize=-1, bool RequiresNullTerminator=true, bool IsVolatile=false)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful, otherwise returning null.
void completeType(BTFDebug &BDebug)
Complete BTF type generation after all related DebugInfo types have been visited so their BTF type id...
Definition: BTFDebug.cpp:318
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
MCSectionELF * getELFSection(const Twine &Section, unsigned Type, unsigned Flags)
Definition: MCContext.h:424
void emitType(MCStreamer &OS)
Emit types for this BTF type entry.
Definition: BTFDebug.cpp:90
virtual void EmitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc())
Emit a label for Symbol into the current section.
Definition: MCStreamer.cpp:397
DITypeRefArray getTypeArray() const
MachineModuleInfo * MMI
Collected machine module information.
iterator_range< global_iterator > globals()
Definition: Module.h:587
IRTranslator LLVM IR MI
void addOperand(const MCOperand &Op)
Definition: MCInst.h:183
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
uint32_t Info
"Info" bits arrangement: Bits 0-15: vlen (e.g.
Definition: BTF.h:119
Register getReg() const
getReg - Returns the register number.
int64_t getSExtValue() const
Return the constant as a 64-bit integer value after it has been sign extended as appropriate for the ...
Definition: Constants.h:156
void emitType(MCStreamer &OS)
Emit types for this BTF type entry.
Definition: BTFDebug.cpp:340
const MCSymbol * Label
MCSymbol identifying insn for the reloc.
Definition: BTFDebug.h:228
const MachineOperand & getOperand(unsigned i) const
Definition: MachineInstr.h:416
static MCOperand createImm(int64_t Val)
Definition: MCInst.h:122
void emitType(MCStreamer &OS)
Emit types for this BTF type entry.
Definition: BTFDebug.cpp:252
bool getFlag(MIFlag Flag) const
Return whether an MI flag is set.
Definition: MachineInstr.h:297
iterator end()
Definition: StringMap.h:317
uint32_t TypeId
Type id referring to .BTF type section.
Definition: BTFDebug.h:214
StringRef getSectionName() const
Definition: MCSectionELF.h:70
uint32_t LineOff
line offset in the .BTF string table
Definition: BTFDebug.h:221
uint32_t TypeID
Type ID.
Definition: BTFDebug.h:229
Basic type, like &#39;int&#39; or &#39;float&#39;.