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

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