contrib/llvm/lib/Target/BPF/BTFDebug.cpp

   1 //===- BTFDebug.cpp - BTF Generator ---------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains support for writing BTF debug info.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "BTFDebug.h"
  15 #include "llvm/BinaryFormat/ELF.h"
  16 #include "llvm/CodeGen/AsmPrinter.h"
  17 #include "llvm/CodeGen/MachineModuleInfo.h"
  18 #include "llvm/MC/MCContext.h"
  19 #include "llvm/MC/MCObjectFileInfo.h"
  20 #include "llvm/MC/MCSectionELF.h"
  21 #include "llvm/MC/MCStreamer.h"
  22 #include <fstream>
  23 #include <sstream>
  24
  25 using namespace llvm;
  26
  27 static const char *BTFKindStr[] = {
  28 #define HANDLE_BTF_KIND(ID, NAME) "BTF_KIND_" #NAME,
  29 #include "BTF.def"
  30 };
  31
  32 /// Emit a BTF common type.
  33 void BTFTypeBase::emitType(MCStreamer &OS) {
  34   OS.AddComment(std::string(BTFKindStr[Kind]) + "(id = " + std::to_string(Id) +
  35                 ")");
  36   OS.EmitIntValue(BTFType.NameOff, 4);
  37   OS.AddComment("0x" + Twine::utohexstr(BTFType.Info));
  38   OS.EmitIntValue(BTFType.Info, 4);
  39   OS.EmitIntValue(BTFType.Size, 4);
  40 }
  41
  42 BTFTypeDerived::BTFTypeDerived(const DIDerivedType *DTy, unsigned Tag)
  43     : DTy(DTy) {
  44   switch (Tag) {
  45   case dwarf::DW_TAG_pointer_type:
  46     Kind = BTF::BTF_KIND_PTR;
  47     break;
  48   case dwarf::DW_TAG_const_type:
  49     Kind = BTF::BTF_KIND_CONST;
  50     break;
  51   case dwarf::DW_TAG_volatile_type:
  52     Kind = BTF::BTF_KIND_VOLATILE;
  53     break;
  54   case dwarf::DW_TAG_typedef:
  55     Kind = BTF::BTF_KIND_TYPEDEF;
  56     break;
  57   case dwarf::DW_TAG_restrict_type:
  58     Kind = BTF::BTF_KIND_RESTRICT;
  59     break;
  60   default:
  61     llvm_unreachable("Unknown DIDerivedType Tag");
  62   }
  63   BTFType.Info = Kind << 24;
  64 }
  65
  66 void BTFTypeDerived::completeType(BTFDebug &BDebug) {
  67   BTFType.NameOff = BDebug.addString(DTy->getName());
  68
  69   // The base type for PTR/CONST/VOLATILE could be void.
  70   const DIType *ResolvedType = DTy->getBaseType().resolve();
  71   if (!ResolvedType) {
  72     assert((Kind == BTF::BTF_KIND_PTR || Kind == BTF::BTF_KIND_CONST ||
  73             Kind == BTF::BTF_KIND_VOLATILE) &&
  74            "Invalid null basetype");
  75     BTFType.Type = 0;
  76   } else {
  77     BTFType.Type = BDebug.getTypeId(ResolvedType);
  78   }
  79 }
  80
  81 void BTFTypeDerived::emitType(MCStreamer &OS) { BTFTypeBase::emitType(OS); }
  82
  83 /// Represent a struct/union forward declaration.
  84 BTFTypeFwd::BTFTypeFwd(StringRef Name, bool IsUnion) : Name(Name) {
  85   Kind = BTF::BTF_KIND_FWD;
  86   BTFType.Info = IsUnion << 31 | Kind << 24;
  87   BTFType.Type = 0;
  88 }
  89
  90 void BTFTypeFwd::completeType(BTFDebug &BDebug) {
  91   BTFType.NameOff = BDebug.addString(Name);
  92 }
  93
  94 void BTFTypeFwd::emitType(MCStreamer &OS) { BTFTypeBase::emitType(OS); }
  95
  96 BTFTypeInt::BTFTypeInt(uint32_t Encoding, uint32_t SizeInBits,
  97                        uint32_t OffsetInBits, StringRef TypeName)
  98     : Name(TypeName) {
  99   // Translate IR int encoding to BTF int encoding.
 100   uint8_t BTFEncoding;
 101   switch (Encoding) {
 102   case dwarf::DW_ATE_boolean:
 103     BTFEncoding = BTF::INT_BOOL;
 104     break;
 105   case dwarf::DW_ATE_signed:
 106   case dwarf::DW_ATE_signed_char:
 107     BTFEncoding = BTF::INT_SIGNED;
 108     break;
 109   case dwarf::DW_ATE_unsigned:
 110   case dwarf::DW_ATE_unsigned_char:
 111     BTFEncoding = 0;
 112     break;
 113   default:
 114     llvm_unreachable("Unknown BTFTypeInt Encoding");
 115   }
 116
 117   Kind = BTF::BTF_KIND_INT;
 118   BTFType.Info = Kind << 24;
 119   BTFType.Size = roundupToBytes(SizeInBits);
 120   IntVal = (BTFEncoding << 24) | OffsetInBits << 16 | SizeInBits;
 121 }
 122
 123 void BTFTypeInt::completeType(BTFDebug &BDebug) {
 124   BTFType.NameOff = BDebug.addString(Name);
 125 }
 126
 127 void BTFTypeInt::emitType(MCStreamer &OS) {
 128   BTFTypeBase::emitType(OS);
 129   OS.AddComment("0x" + Twine::utohexstr(IntVal));
 130   OS.EmitIntValue(IntVal, 4);
 131 }
 132
 133 BTFTypeEnum::BTFTypeEnum(const DICompositeType *ETy, uint32_t VLen) : ETy(ETy) {
 134   Kind = BTF::BTF_KIND_ENUM;
 135   BTFType.Info = Kind << 24 | VLen;
 136   BTFType.Size = roundupToBytes(ETy->getSizeInBits());
 137 }
 138
 139 void BTFTypeEnum::completeType(BTFDebug &BDebug) {
 140   BTFType.NameOff = BDebug.addString(ETy->getName());
 141
 142   DINodeArray Elements = ETy->getElements();
 143   for (const auto Element : Elements) {
 144     const auto *Enum = cast<DIEnumerator>(Element);
 145
 146     struct BTF::BTFEnum BTFEnum;
 147     BTFEnum.NameOff = BDebug.addString(Enum->getName());
 148     // BTF enum value is 32bit, enforce it.
 149     BTFEnum.Val = static_cast<uint32_t>(Enum->getValue());
 150     EnumValues.push_back(BTFEnum);
 151   }
 152 }
 153
 154 void BTFTypeEnum::emitType(MCStreamer &OS) {
 155   BTFTypeBase::emitType(OS);
 156   for (const auto &Enum : EnumValues) {
 157     OS.EmitIntValue(Enum.NameOff, 4);
 158     OS.EmitIntValue(Enum.Val, 4);
 159   }
 160 }
 161
 162 BTFTypeArray::BTFTypeArray(const DICompositeType *ATy) : ATy(ATy) {
 163   Kind = BTF::BTF_KIND_ARRAY;
 164   BTFType.Info = Kind << 24;
 165 }
 166
 167 /// Represent a BTF array. BTF does not record array dimensions,
 168 /// so conceptually a BTF array is a one-dimensional array.
 169 void BTFTypeArray::completeType(BTFDebug &BDebug) {
 170   BTFType.NameOff = BDebug.addString(ATy->getName());
 171   BTFType.Size = 0;
 172
 173   auto *BaseType = ATy->getBaseType().resolve();
 174   ArrayInfo.ElemType = BDebug.getTypeId(BaseType);
 175
 176   // The IR does not really have a type for the index.
 177   // A special type for array index should have been
 178   // created during initial type traversal. Just
 179   // retrieve that type id.
 180   ArrayInfo.IndexType = BDebug.getArrayIndexTypeId();
 181
 182   // Get the number of array elements.
 183   // If the array size is 0, set the number of elements as 0.
 184   // Otherwise, recursively traverse the base types to
 185   // find the element size. The number of elements is
 186   // the totoal array size in bits divided by
 187   // element size in bits.
 188   uint64_t ArraySizeInBits = ATy->getSizeInBits();
 189   if (!ArraySizeInBits) {
 190     ArrayInfo.Nelems = 0;
 191   } else {
 192     uint32_t BaseTypeSize = BaseType->getSizeInBits();
 193     while (!BaseTypeSize) {
 194       const auto *DDTy = cast<DIDerivedType>(BaseType);
 195       BaseType = DDTy->getBaseType().resolve();
 196       assert(BaseType);
 197       BaseTypeSize = BaseType->getSizeInBits();
 198     }
 199     ArrayInfo.Nelems = ATy->getSizeInBits() / BaseTypeSize;
 200   }
 201 }
 202
 203 void BTFTypeArray::emitType(MCStreamer &OS) {
 204   BTFTypeBase::emitType(OS);
 205   OS.EmitIntValue(ArrayInfo.ElemType, 4);
 206   OS.EmitIntValue(ArrayInfo.IndexType, 4);
 207   OS.EmitIntValue(ArrayInfo.Nelems, 4);
 208 }
 209
 210 /// Represent either a struct or a union.
 211 BTFTypeStruct::BTFTypeStruct(const DICompositeType *STy, bool IsStruct,
 212                              bool HasBitField, uint32_t Vlen)
 213     : STy(STy), HasBitField(HasBitField) {
 214   Kind = IsStruct ? BTF::BTF_KIND_STRUCT : BTF::BTF_KIND_UNION;
 215   BTFType.Size = roundupToBytes(STy->getSizeInBits());
 216   BTFType.Info = (HasBitField << 31) | (Kind << 24) | Vlen;
 217 }
 218
 219 void BTFTypeStruct::completeType(BTFDebug &BDebug) {
 220   BTFType.NameOff = BDebug.addString(STy->getName());
 221
 222   // Add struct/union members.
 223   const DINodeArray Elements = STy->getElements();
 224   for (const auto *Element : Elements) {
 225     struct BTF::BTFMember BTFMember;
 226     const auto *DDTy = cast<DIDerivedType>(Element);
 227
 228     BTFMember.NameOff = BDebug.addString(DDTy->getName());
 229     if (HasBitField) {
 230       uint8_t BitFieldSize = DDTy->isBitField() ? DDTy->getSizeInBits() : 0;
 231       BTFMember.Offset = BitFieldSize << 24 | DDTy->getOffsetInBits();
 232     } else {
 233       BTFMember.Offset = DDTy->getOffsetInBits();
 234     }
 235     BTFMember.Type = BDebug.getTypeId(DDTy->getBaseType().resolve());
 236     Members.push_back(BTFMember);
 237   }
 238 }
 239
 240 void BTFTypeStruct::emitType(MCStreamer &OS) {
 241   BTFTypeBase::emitType(OS);
 242   for (const auto &Member : Members) {
 243     OS.EmitIntValue(Member.NameOff, 4);
 244     OS.EmitIntValue(Member.Type, 4);
 245     OS.AddComment("0x" + Twine::utohexstr(Member.Offset));
 246     OS.EmitIntValue(Member.Offset, 4);
 247   }
 248 }
 249
 250 /// The Func kind represents both subprogram and pointee of function
 251 /// pointers. If the FuncName is empty, it represents a pointee of function
 252 /// pointer. Otherwise, it represents a subprogram. The func arg names
 253 /// are empty for pointee of function pointer case, and are valid names
 254 /// for subprogram.
 255 BTFTypeFuncProto::BTFTypeFuncProto(
 256     const DISubroutineType *STy, uint32_t VLen,
 257     const std::unordered_map<uint32_t, StringRef> &FuncArgNames)
 258     : STy(STy), FuncArgNames(FuncArgNames) {
 259   Kind = BTF::BTF_KIND_FUNC_PROTO;
 260   BTFType.Info = (Kind << 24) | VLen;
 261 }
 262
 263 void BTFTypeFuncProto::completeType(BTFDebug &BDebug) {
 264   DITypeRefArray Elements = STy->getTypeArray();
 265   auto RetType = Elements[0].resolve();
 266   BTFType.Type = RetType ? BDebug.getTypeId(RetType) : 0;
 267   BTFType.NameOff = 0;
 268
 269   // For null parameter which is typically the last one
 270   // to represent the vararg, encode the NameOff/Type to be 0.
 271   for (unsigned I = 1, N = Elements.size(); I < N; ++I) {
 272     struct BTF::BTFParam Param;
 273     auto Element = Elements[I].resolve();
 274     if (Element) {
 275       Param.NameOff = BDebug.addString(FuncArgNames[I]);
 276       Param.Type = BDebug.getTypeId(Element);
 277     } else {
 278       Param.NameOff = 0;
 279       Param.Type = 0;
 280     }
 281     Parameters.push_back(Param);
 282   }
 283 }
 284
 285 void BTFTypeFuncProto::emitType(MCStreamer &OS) {
 286   BTFTypeBase::emitType(OS);
 287   for (const auto &Param : Parameters) {
 288     OS.EmitIntValue(Param.NameOff, 4);
 289     OS.EmitIntValue(Param.Type, 4);
 290   }
 291 }
 292
 293 BTFTypeFunc::BTFTypeFunc(StringRef FuncName, uint32_t ProtoTypeId)
 294     : Name(FuncName) {
 295   Kind = BTF::BTF_KIND_FUNC;
 296   BTFType.Info = Kind << 24;
 297   BTFType.Type = ProtoTypeId;
 298 }
 299
 300 void BTFTypeFunc::completeType(BTFDebug &BDebug) {
 301   BTFType.NameOff = BDebug.addString(Name);
 302 }
 303
 304 void BTFTypeFunc::emitType(MCStreamer &OS) { BTFTypeBase::emitType(OS); }
 305
 306 uint32_t BTFStringTable::addString(StringRef S) {
 307   // Check whether the string already exists.
 308   for (auto &OffsetM : OffsetToIdMap) {
 309     if (Table[OffsetM.second] == S)
 310       return OffsetM.first;
 311   }
 312   // Not find, add to the string table.
 313   uint32_t Offset = Size;
 314   OffsetToIdMap[Offset] = Table.size();
 315   Table.push_back(S);
 316   Size += S.size() + 1;
 317   return Offset;
 318 }
 319
 320 BTFDebug::BTFDebug(AsmPrinter *AP)
 321     : DebugHandlerBase(AP), OS(*Asm->OutStreamer), SkipInstruction(false),
 322       LineInfoGenerated(false), SecNameOff(0), ArrayIndexTypeId(0) {
 323   addString("\0");
 324 }
 325
 326 void BTFDebug::addType(std::unique_ptr<BTFTypeBase> TypeEntry,
 327                        const DIType *Ty) {
 328   TypeEntry->setId(TypeEntries.size() + 1);
 329   DIToIdMap[Ty] = TypeEntry->getId();
 330   TypeEntries.push_back(std::move(TypeEntry));
 331 }
 332
 333 uint32_t BTFDebug::addType(std::unique_ptr<BTFTypeBase> TypeEntry) {
 334   TypeEntry->setId(TypeEntries.size() + 1);
 335   uint32_t Id = TypeEntry->getId();
 336   TypeEntries.push_back(std::move(TypeEntry));
 337   return Id;
 338 }
 339
 340 void BTFDebug::visitBasicType(const DIBasicType *BTy) {
 341   // Only int types are supported in BTF.
 342   uint32_t Encoding = BTy->getEncoding();
 343   if (Encoding != dwarf::DW_ATE_boolean && Encoding != dwarf::DW_ATE_signed &&
 344       Encoding != dwarf::DW_ATE_signed_char &&
 345       Encoding != dwarf::DW_ATE_unsigned &&
 346       Encoding != dwarf::DW_ATE_unsigned_char)
 347     return;
 348
 349   // Create a BTF type instance for this DIBasicType and put it into
 350   // DIToIdMap for cross-type reference check.
 351   auto TypeEntry = llvm::make_unique<BTFTypeInt>(
 352       Encoding, BTy->getSizeInBits(), BTy->getOffsetInBits(), BTy->getName());
 353   addType(std::move(TypeEntry), BTy);
 354 }
 355
 356 /// Handle subprogram or subroutine types.
 357 void BTFDebug::visitSubroutineType(
 358     const DISubroutineType *STy, bool ForSubprog,
 359     const std::unordered_map<uint32_t, StringRef> &FuncArgNames,
 360     uint32_t &TypeId) {
 361   DITypeRefArray Elements = STy->getTypeArray();
 362   uint32_t VLen = Elements.size() - 1;
 363   if (VLen > BTF::MAX_VLEN)
 364     return;
 365
 366   // Subprogram has a valid non-zero-length name, and the pointee of
 367   // a function pointer has an empty name. The subprogram type will
 368   // not be added to DIToIdMap as it should not be referenced by
 369   // any other types.
 370   auto TypeEntry = llvm::make_unique<BTFTypeFuncProto>(STy, VLen, FuncArgNames);
 371   if (ForSubprog)
 372     TypeId = addType(std::move(TypeEntry)); // For subprogram
 373   else
 374     addType(std::move(TypeEntry), STy); // For func ptr
 375
 376   // Visit return type and func arg types.
 377   for (const auto Element : Elements) {
 378     visitTypeEntry(Element.resolve());
 379   }
 380 }
 381
 382 /// Handle structure/union types.
 383 void BTFDebug::visitStructType(const DICompositeType *CTy, bool IsStruct) {
 384   const DINodeArray Elements = CTy->getElements();
 385   uint32_t VLen = Elements.size();
 386   if (VLen > BTF::MAX_VLEN)
 387     return;
 388
 389   // Check whether we have any bitfield members or not
 390   bool HasBitField = false;
 391   for (const auto *Element : Elements) {
 392     auto E = cast<DIDerivedType>(Element);
 393     if (E->isBitField()) {
 394       HasBitField = true;
 395       break;
 396     }
 397   }
 398
 399   auto TypeEntry =
 400       llvm::make_unique<BTFTypeStruct>(CTy, IsStruct, HasBitField, VLen);
 401   addType(std::move(TypeEntry), CTy);
 402
 403   // Visit all struct members.
 404   for (const auto *Element : Elements)
 405     visitTypeEntry(cast<DIDerivedType>(Element));
 406 }
 407
 408 void BTFDebug::visitArrayType(const DICompositeType *CTy) {
 409   auto TypeEntry = llvm::make_unique<BTFTypeArray>(CTy);
 410   addType(std::move(TypeEntry), CTy);
 411
 412   // The IR does not have a type for array index while BTF wants one.
 413   // So create an array index type if there is none.
 414   if (!ArrayIndexTypeId) {
 415     auto TypeEntry = llvm::make_unique<BTFTypeInt>(dwarf::DW_ATE_unsigned, 32,
 416                                                    0, "__ARRAY_SIZE_TYPE__");
 417     ArrayIndexTypeId = addType(std::move(TypeEntry));
 418   }
 419
 420   // Visit array element type.
 421   visitTypeEntry(CTy->getBaseType().resolve());
 422 }
 423
 424 void BTFDebug::visitEnumType(const DICompositeType *CTy) {
 425   DINodeArray Elements = CTy->getElements();
 426   uint32_t VLen = Elements.size();
 427   if (VLen > BTF::MAX_VLEN)
 428     return;
 429
 430   auto TypeEntry = llvm::make_unique<BTFTypeEnum>(CTy, VLen);
 431   addType(std::move(TypeEntry), CTy);
 432   // No need to visit base type as BTF does not encode it.
 433 }
 434
 435 /// Handle structure/union forward declarations.
 436 void BTFDebug::visitFwdDeclType(const DICompositeType *CTy, bool IsUnion) {
 437   auto TypeEntry = llvm::make_unique<BTFTypeFwd>(CTy->getName(), IsUnion);
 438   addType(std::move(TypeEntry), CTy);
 439 }
 440
 441 /// Handle structure, union, array and enumeration types.
 442 void BTFDebug::visitCompositeType(const DICompositeType *CTy) {
 443   auto Tag = CTy->getTag();
 444   if (Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) {
 445     // Handle forward declaration differently as it does not have members.
 446     if (CTy->isForwardDecl())
 447       visitFwdDeclType(CTy, Tag == dwarf::DW_TAG_union_type);
 448     else
 449       visitStructType(CTy, Tag == dwarf::DW_TAG_structure_type);
 450   } else if (Tag == dwarf::DW_TAG_array_type)
 451     visitArrayType(CTy);
 452   else if (Tag == dwarf::DW_TAG_enumeration_type)
 453     visitEnumType(CTy);
 454 }
 455
 456 /// Handle pointer, typedef, const, volatile, restrict and member types.
 457 void BTFDebug::visitDerivedType(const DIDerivedType *DTy) {
 458   unsigned Tag = DTy->getTag();
 459
 460   if (Tag == dwarf::DW_TAG_pointer_type || Tag == dwarf::DW_TAG_typedef ||
 461       Tag == dwarf::DW_TAG_const_type || Tag == dwarf::DW_TAG_volatile_type ||
 462       Tag == dwarf::DW_TAG_restrict_type) {
 463     auto TypeEntry = llvm::make_unique<BTFTypeDerived>(DTy, Tag);
 464     addType(std::move(TypeEntry), DTy);
 465   } else if (Tag != dwarf::DW_TAG_member) {
 466     return;
 467   }
 468
 469   // Visit base type of pointer, typedef, const, volatile, restrict or
 470   // struct/union member.
 471   visitTypeEntry(DTy->getBaseType().resolve());
 472 }
 473
 474 void BTFDebug::visitTypeEntry(const DIType *Ty) {
 475   if (!Ty || DIToIdMap.find(Ty) != DIToIdMap.end())
 476     return;
 477
 478   uint32_t TypeId;
 479   if (const auto *BTy = dyn_cast<DIBasicType>(Ty))
 480     visitBasicType(BTy);
 481   else if (const auto *STy = dyn_cast<DISubroutineType>(Ty))
 482     visitSubroutineType(STy, false, std::unordered_map<uint32_t, StringRef>(),
 483                         TypeId);
 484   else if (const auto *CTy = dyn_cast<DICompositeType>(Ty))
 485     visitCompositeType(CTy);
 486   else if (const auto *DTy = dyn_cast<DIDerivedType>(Ty))
 487     visitDerivedType(DTy);
 488   else
 489     llvm_unreachable("Unknown DIType");
 490 }
 491
 492 /// Read file contents from the actual file or from the source
 493 std::string BTFDebug::populateFileContent(const DISubprogram *SP) {
 494   auto File = SP->getFile();
 495   std::string FileName;
 496
 497   if (File->getDirectory().size())
 498     FileName = File->getDirectory().str() + "/" + File->getFilename().str();
 499   else
 500     FileName = File->getFilename();
 501
 502   // No need to populate the contends if it has been populated!
 503   if (FileContent.find(FileName) != FileContent.end())
 504     return FileName;
 505
 506   std::vector<std::string> Content;
 507   std::string Line;
 508   Content.push_back(Line); // Line 0 for empty string
 509
 510   auto Source = File->getSource();
 511   if (Source) {
 512     std::istringstream InputString(Source.getValue());
 513     while (std::getline(InputString, Line))
 514       Content.push_back(Line);
 515   } else {
 516     std::ifstream InputFile(FileName);
 517     while (std::getline(InputFile, Line))
 518       Content.push_back(Line);
 519   }
 520
 521   FileContent[FileName] = Content;
 522   return FileName;
 523 }
 524
 525 void BTFDebug::constructLineInfo(const DISubprogram *SP, MCSymbol *Label,
 526                                  uint32_t Line, uint32_t Column) {
 527   std::string FileName = populateFileContent(SP);
 528   BTFLineInfo LineInfo;
 529
 530   LineInfo.Label = Label;
 531   LineInfo.FileNameOff = addString(FileName);
 532   // If file content is not available, let LineOff = 0.
 533   if (Line < FileContent[FileName].size())
 534     LineInfo.LineOff = addString(FileContent[FileName][Line]);
 535   else
 536     LineInfo.LineOff = 0;
 537   LineInfo.LineNum = Line;
 538   LineInfo.ColumnNum = Column;
 539   LineInfoTable[SecNameOff].push_back(LineInfo);
 540 }
 541
 542 void BTFDebug::emitCommonHeader() {
 543   OS.AddComment("0x" + Twine::utohexstr(BTF::MAGIC));
 544   OS.EmitIntValue(BTF::MAGIC, 2);
 545   OS.EmitIntValue(BTF::VERSION, 1);
 546   OS.EmitIntValue(0, 1);
 547 }
 548
 549 void BTFDebug::emitBTFSection() {
 550   MCContext &Ctx = OS.getContext();
 551   OS.SwitchSection(Ctx.getELFSection(".BTF", ELF::SHT_PROGBITS, 0));
 552
 553   // Emit header.
 554   emitCommonHeader();
 555   OS.EmitIntValue(BTF::HeaderSize, 4);
 556
 557   uint32_t TypeLen = 0, StrLen;
 558   for (const auto &TypeEntry : TypeEntries)
 559     TypeLen += TypeEntry->getSize();
 560   StrLen = StringTable.getSize();
 561
 562   OS.EmitIntValue(0, 4);
 563   OS.EmitIntValue(TypeLen, 4);
 564   OS.EmitIntValue(TypeLen, 4);
 565   OS.EmitIntValue(StrLen, 4);
 566
 567   // Emit type table.
 568   for (const auto &TypeEntry : TypeEntries)
 569     TypeEntry->emitType(OS);
 570
 571   // Emit string table.
 572   uint32_t StringOffset = 0;
 573   for (const auto &S : StringTable.getTable()) {
 574     OS.AddComment("string offset=" + std::to_string(StringOffset));
 575     OS.EmitBytes(S);
 576     OS.EmitBytes(StringRef("\0", 1));
 577     StringOffset += S.size() + 1;
 578   }
 579 }
 580
 581 void BTFDebug::emitBTFExtSection() {
 582   MCContext &Ctx = OS.getContext();
 583   OS.SwitchSection(Ctx.getELFSection(".BTF.ext", ELF::SHT_PROGBITS, 0));
 584
 585   // Emit header.
 586   emitCommonHeader();
 587   OS.EmitIntValue(BTF::ExtHeaderSize, 4);
 588
 589   // Account for FuncInfo/LineInfo record size as well.
 590   uint32_t FuncLen = 4, LineLen = 4;
 591   for (const auto &FuncSec : FuncInfoTable) {
 592     FuncLen += BTF::SecFuncInfoSize;
 593     FuncLen += FuncSec.second.size() * BTF::BPFFuncInfoSize;
 594   }
 595   for (const auto &LineSec : LineInfoTable) {
 596     LineLen += BTF::SecLineInfoSize;
 597     LineLen += LineSec.second.size() * BTF::BPFLineInfoSize;
 598   }
 599
 600   OS.EmitIntValue(0, 4);
 601   OS.EmitIntValue(FuncLen, 4);
 602   OS.EmitIntValue(FuncLen, 4);
 603   OS.EmitIntValue(LineLen, 4);
 604
 605   // Emit func_info table.
 606   OS.AddComment("FuncInfo");
 607   OS.EmitIntValue(BTF::BPFFuncInfoSize, 4);
 608   for (const auto &FuncSec : FuncInfoTable) {
 609     OS.AddComment("FuncInfo section string offset=" +
 610                   std::to_string(FuncSec.first));
 611     OS.EmitIntValue(FuncSec.first, 4);
 612     OS.EmitIntValue(FuncSec.second.size(), 4);
 613     for (const auto &FuncInfo : FuncSec.second) {
 614       Asm->EmitLabelReference(FuncInfo.Label, 4);
 615       OS.EmitIntValue(FuncInfo.TypeId, 4);
 616     }
 617   }
 618
 619   // Emit line_info table.
 620   OS.AddComment("LineInfo");
 621   OS.EmitIntValue(BTF::BPFLineInfoSize, 4);
 622   for (const auto &LineSec : LineInfoTable) {
 623     OS.AddComment("LineInfo section string offset=" +
 624                   std::to_string(LineSec.first));
 625     OS.EmitIntValue(LineSec.first, 4);
 626     OS.EmitIntValue(LineSec.second.size(), 4);
 627     for (const auto &LineInfo : LineSec.second) {
 628       Asm->EmitLabelReference(LineInfo.Label, 4);
 629       OS.EmitIntValue(LineInfo.FileNameOff, 4);
 630       OS.EmitIntValue(LineInfo.LineOff, 4);
 631       OS.AddComment("Line " + std::to_string(LineInfo.LineNum) + " Col " +
 632                     std::to_string(LineInfo.ColumnNum));
 633       OS.EmitIntValue(LineInfo.LineNum << 10 | LineInfo.ColumnNum, 4);
 634     }
 635   }
 636 }
 637
 638 void BTFDebug::beginFunctionImpl(const MachineFunction *MF) {
 639   auto *SP = MF->getFunction().getSubprogram();
 640   auto *Unit = SP->getUnit();
 641
 642   if (Unit->getEmissionKind() == DICompileUnit::NoDebug) {
 643     SkipInstruction = true;
 644     return;
 645   }
 646   SkipInstruction = false;
 647
 648   // Collect all types locally referenced in this function.
 649   // Use RetainedNodes so we can collect all argument names
 650   // even if the argument is not used.
 651   std::unordered_map<uint32_t, StringRef> FuncArgNames;
 652   for (const DINode *DN : SP->getRetainedNodes()) {
 653     if (const auto *DV = dyn_cast<DILocalVariable>(DN)) {
 654       visitTypeEntry(DV->getType().resolve());
 655
 656       // Collect function arguments for subprogram func type.
 657       uint32_t Arg = DV->getArg();
 658       if (Arg)
 659         FuncArgNames[Arg] = DV->getName();
 660     }
 661   }
 662
 663   // Construct subprogram func proto type.
 664   uint32_t ProtoTypeId;
 665   visitSubroutineType(SP->getType(), true, FuncArgNames, ProtoTypeId);
 666
 667   // Construct subprogram func type
 668   auto FuncTypeEntry =
 669       llvm::make_unique<BTFTypeFunc>(SP->getName(), ProtoTypeId);
 670   uint32_t FuncTypeId = addType(std::move(FuncTypeEntry));
 671
 672   // Construct funcinfo and the first lineinfo for the function.
 673   MCSymbol *FuncLabel = Asm->getFunctionBegin();
 674   BTFFuncInfo FuncInfo;
 675   FuncInfo.Label = FuncLabel;
 676   FuncInfo.TypeId = FuncTypeId;
 677   if (FuncLabel->isInSection()) {
 678     MCSection &Section = FuncLabel->getSection();
 679     const MCSectionELF *SectionELF = dyn_cast<MCSectionELF>(&Section);
 680     assert(SectionELF && "Null section for Function Label");
 681     SecNameOff = addString(SectionELF->getSectionName());
 682   } else {
 683     SecNameOff = addString(".text");
 684   }
 685   FuncInfoTable[SecNameOff].push_back(FuncInfo);
 686 }
 687
 688 void BTFDebug::endFunctionImpl(const MachineFunction *MF) {
 689   SkipInstruction = false;
 690   LineInfoGenerated = false;
 691   SecNameOff = 0;
 692 }
 693
 694 void BTFDebug::beginInstruction(const MachineInstr *MI) {
 695   DebugHandlerBase::beginInstruction(MI);
 696
 697   if (SkipInstruction || MI->isMetaInstruction() ||
 698       MI->getFlag(MachineInstr::FrameSetup))
 699     return;
 700
 701   if (MI->isInlineAsm()) {
 702     // Count the number of register definitions to find the asm string.
 703     unsigned NumDefs = 0;
 704     for (; MI->getOperand(NumDefs).isReg() && MI->getOperand(NumDefs).isDef();
 705          ++NumDefs)
 706       ;
 707
 708     // Skip this inline asm instruction if the asmstr is empty.
 709     const char *AsmStr = MI->getOperand(NumDefs).getSymbolName();
 710     if (AsmStr[0] == 0)
 711       return;
 712   }
 713
 714   // Skip this instruction if no DebugLoc or the DebugLoc
 715   // is the same as the previous instruction.
 716   const DebugLoc &DL = MI->getDebugLoc();
 717   if (!DL || PrevInstLoc == DL) {
 718     // This instruction will be skipped, no LineInfo has
 719     // been generated, construct one based on function signature.
 720     if (LineInfoGenerated == false) {
 721       auto *S = MI->getMF()->getFunction().getSubprogram();
 722       MCSymbol *FuncLabel = Asm->getFunctionBegin();
 723       constructLineInfo(S, FuncLabel, S->getLine(), 0);
 724       LineInfoGenerated = true;
 725     }
 726
 727     return;
 728   }
 729
 730   // Create a temporary label to remember the insn for lineinfo.
 731   MCSymbol *LineSym = OS.getContext().createTempSymbol();
 732   OS.EmitLabel(LineSym);
 733
 734   // Construct the lineinfo.
 735   auto SP = DL.get()->getScope()->getSubprogram();
 736   constructLineInfo(SP, LineSym, DL.getLine(), DL.getCol());
 737
 738   LineInfoGenerated = true;
 739   PrevInstLoc = DL;
 740 }
 741
 742 void BTFDebug::endModule() {
 743   // Collect all types referenced by globals.
 744   const Module *M = MMI->getModule();
 745   for (const DICompileUnit *CUNode : M->debug_compile_units()) {
 746     for (const auto *GVE : CUNode->getGlobalVariables()) {
 747       DIGlobalVariable *GV = GVE->getVariable();
 748       visitTypeEntry(GV->getType().resolve());
 749     }
 750   }
 751
 752   // Complete BTF type cross refereences.
 753   for (const auto &TypeEntry : TypeEntries)
 754     TypeEntry->completeType(*this);
 755
 756   // Emit BTF sections.
 757   emitBTFSection();
 758   emitBTFExtSection();
 759 }