llvm/lib/Target/BPF/BTFDebug.h

   1 //===- BTFDebug.h -----------------------------------------------*- C++ -*-===//
   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 /// \file
  10 /// This file contains support for writing BTF debug info.
  11 ///
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_LIB_TARGET_BPF_BTFDEBUG_H
  15 #define LLVM_LIB_TARGET_BPF_BTFDEBUG_H
  16
  17 #include "llvm/ADT/StringMap.h"
  18 #include "llvm/CodeGen/DebugHandlerBase.h"
  19 #include <cstdint>
  20 #include <map>
  21 #include <set>
  22 #include <unordered_map>
  23 #include "BTF.h"
  24
  25 namespace llvm {
  26
  27 class AsmPrinter;
  28 class BTFDebug;
  29 class DIType;
  30 class GlobalVariable;
  31 class MachineFunction;
  32 class MachineInstr;
  33 class MachineOperand;
  34 class MCInst;
  35 class MCStreamer;
  36 class MCSymbol;
  37
  38 /// The base class for BTF type generation.
  39 class BTFTypeBase {
  40 protected:
  41   uint8_t Kind;
  42   bool IsCompleted;
  43   uint32_t Id;
  44   struct BTF::CommonType BTFType;
  45
  46 public:
  47   BTFTypeBase() : IsCompleted(false) {}
  48   virtual ~BTFTypeBase() = default;
  49   void setId(uint32_t Id) { this->Id = Id; }
  50   uint32_t getId() { return Id; }
  51   uint32_t roundupToBytes(uint32_t NumBits) { return (NumBits + 7) >> 3; }
  52   /// Get the size of this BTF type entry.
  53   virtual uint32_t getSize() { return BTF::CommonTypeSize; }
  54   /// Complete BTF type generation after all related DebugInfo types
  55   /// have been visited so their BTF type id's are available
  56   /// for cross referece.
  57   virtual void completeType(BTFDebug &BDebug) {}
  58   /// Emit types for this BTF type entry.
  59   virtual void emitType(MCStreamer &OS);
  60 };
  61
  62 /// Handle several derived types include pointer, const,
  63 /// volatile, typedef and restrict.
  64 class BTFTypeDerived : public BTFTypeBase {
  65   const DIDerivedType *DTy;
  66   bool NeedsFixup;
  67
  68 public:
  69   BTFTypeDerived(const DIDerivedType *Ty, unsigned Tag, bool NeedsFixup);
  70   void completeType(BTFDebug &BDebug) override;
  71   void emitType(MCStreamer &OS) override;
  72   void setPointeeType(uint32_t PointeeType);
  73 };
  74
  75 /// Handle struct or union forward declaration.
  76 class BTFTypeFwd : public BTFTypeBase {
  77   StringRef Name;
  78
  79 public:
  80   BTFTypeFwd(StringRef Name, bool IsUnion);
  81   void completeType(BTFDebug &BDebug) override;
  82   void emitType(MCStreamer &OS) override;
  83 };
  84
  85 /// Handle int type.
  86 class BTFTypeInt : public BTFTypeBase {
  87   StringRef Name;
  88   uint32_t IntVal; ///< Encoding, offset, bits
  89
  90 public:
  91   BTFTypeInt(uint32_t Encoding, uint32_t SizeInBits, uint32_t OffsetInBits,
  92              StringRef TypeName);
  93   uint32_t getSize() override { return BTFTypeBase::getSize() + sizeof(uint32_t); }
  94   void completeType(BTFDebug &BDebug) override;
  95   void emitType(MCStreamer &OS) override;
  96 };
  97
  98 /// Handle enumerate type.
  99 class BTFTypeEnum : public BTFTypeBase {
 100   const DICompositeType *ETy;
 101   std::vector<struct BTF::BTFEnum> EnumValues;
 102
 103 public:
 104   BTFTypeEnum(const DICompositeType *ETy, uint32_t NumValues);
 105   uint32_t getSize() override {
 106     return BTFTypeBase::getSize() + EnumValues.size() * BTF::BTFEnumSize;
 107   }
 108   void completeType(BTFDebug &BDebug) override;
 109   void emitType(MCStreamer &OS) override;
 110 };
 111
 112 /// Handle array type.
 113 class BTFTypeArray : public BTFTypeBase {
 114   struct BTF::BTFArray ArrayInfo;
 115
 116 public:
 117   BTFTypeArray(uint32_t ElemTypeId, uint32_t NumElems);
 118   uint32_t getSize() override { return BTFTypeBase::getSize() + BTF::BTFArraySize; }
 119   void completeType(BTFDebug &BDebug) override;
 120   void emitType(MCStreamer &OS) override;
 121 };
 122
 123 /// Handle struct/union type.
 124 class BTFTypeStruct : public BTFTypeBase {
 125   const DICompositeType *STy;
 126   bool HasBitField;
 127   std::vector<struct BTF::BTFMember> Members;
 128
 129 public:
 130   BTFTypeStruct(const DICompositeType *STy, bool IsStruct, bool HasBitField,
 131                 uint32_t NumMembers);
 132   uint32_t getSize() override {
 133     return BTFTypeBase::getSize() + Members.size() * BTF::BTFMemberSize;
 134   }
 135   void completeType(BTFDebug &BDebug) override;
 136   void emitType(MCStreamer &OS) override;
 137   std::string getName();
 138 };
 139
 140 /// Handle function pointer.
 141 class BTFTypeFuncProto : public BTFTypeBase {
 142   const DISubroutineType *STy;
 143   std::unordered_map<uint32_t, StringRef> FuncArgNames;
 144   std::vector<struct BTF::BTFParam> Parameters;
 145
 146 public:
 147   BTFTypeFuncProto(const DISubroutineType *STy, uint32_t NumParams,
 148                    const std::unordered_map<uint32_t, StringRef> &FuncArgNames);
 149   uint32_t getSize() override {
 150     return BTFTypeBase::getSize() + Parameters.size() * BTF::BTFParamSize;
 151   }
 152   void completeType(BTFDebug &BDebug) override;
 153   void emitType(MCStreamer &OS) override;
 154 };
 155
 156 /// Handle subprogram
 157 class BTFTypeFunc : public BTFTypeBase {
 158   StringRef Name;
 159
 160 public:
 161   BTFTypeFunc(StringRef FuncName, uint32_t ProtoTypeId, uint32_t Scope);
 162   uint32_t getSize() override { return BTFTypeBase::getSize(); }
 163   void completeType(BTFDebug &BDebug) override;
 164   void emitType(MCStreamer &OS) override;
 165 };
 166
 167 /// Handle variable instances
 168 class BTFKindVar : public BTFTypeBase {
 169   StringRef Name;
 170   uint32_t Info;
 171
 172 public:
 173   BTFKindVar(StringRef VarName, uint32_t TypeId, uint32_t VarInfo);
 174   uint32_t getSize() override { return BTFTypeBase::getSize() + 4; }
 175   void completeType(BTFDebug &BDebug) override;
 176   void emitType(MCStreamer &OS) override;
 177 };
 178
 179 /// Handle data sections
 180 class BTFKindDataSec : public BTFTypeBase {
 181   AsmPrinter *Asm;
 182   std::string Name;
 183   std::vector<std::tuple<uint32_t, const MCSymbol *, uint32_t>> Vars;
 184
 185 public:
 186   BTFKindDataSec(AsmPrinter *AsmPrt, std::string SecName);
 187   uint32_t getSize() override {
 188     return BTFTypeBase::getSize() + BTF::BTFDataSecVarSize * Vars.size();
 189   }
 190   void addDataSecEntry(uint32_t Id, const MCSymbol *Sym, uint32_t Size) {
 191     Vars.push_back(std::make_tuple(Id, Sym, Size));
 192   }
 193   std::string getName() { return Name; }
 194   void completeType(BTFDebug &BDebug) override;
 195   void emitType(MCStreamer &OS) override;
 196 };
 197
 198 /// Handle binary floating point type.
 199 class BTFTypeFloat : public BTFTypeBase {
 200   StringRef Name;
 201
 202 public:
 203   BTFTypeFloat(uint32_t SizeInBits, StringRef TypeName);
 204   void completeType(BTFDebug &BDebug) override;
 205 };
 206
 207 /// String table.
 208 class BTFStringTable {
 209   /// String table size in bytes.
 210   uint32_t Size;
 211   /// A mapping from string table offset to the index
 212   /// of the Table. It is used to avoid putting
 213   /// duplicated strings in the table.
 214   std::map<uint32_t, uint32_t> OffsetToIdMap;
 215   /// A vector of strings to represent the string table.
 216   std::vector<std::string> Table;
 217
 218 public:
 219   BTFStringTable() : Size(0) {}
 220   uint32_t getSize() { return Size; }
 221   std::vector<std::string> &getTable() { return Table; }
 222   /// Add a string to the string table and returns its offset
 223   /// in the table.
 224   uint32_t addString(StringRef S);
 225 };
 226
 227 /// Represent one func and its type id.
 228 struct BTFFuncInfo {
 229   const MCSymbol *Label; ///< Func MCSymbol
 230   uint32_t TypeId;       ///< Type id referring to .BTF type section
 231 };
 232
 233 /// Represent one line info.
 234 struct BTFLineInfo {
 235   MCSymbol *Label;      ///< MCSymbol identifying insn for the lineinfo
 236   uint32_t FileNameOff; ///< file name offset in the .BTF string table
 237   uint32_t LineOff;     ///< line offset in the .BTF string table
 238   uint32_t LineNum;     ///< the line number
 239   uint32_t ColumnNum;   ///< the column number
 240 };
 241
 242 /// Represent one field relocation.
 243 struct BTFFieldReloc {
 244   const MCSymbol *Label;  ///< MCSymbol identifying insn for the reloc
 245   uint32_t TypeID;        ///< Type ID
 246   uint32_t OffsetNameOff; ///< The string to traverse types
 247   uint32_t RelocKind;     ///< What to patch the instruction
 248 };
 249
 250 /// Collect and emit BTF information.
 251 class BTFDebug : public DebugHandlerBase {
 252   MCStreamer &OS;
 253   bool SkipInstruction;
 254   bool LineInfoGenerated;
 255   uint32_t SecNameOff;
 256   uint32_t ArrayIndexTypeId;
 257   bool MapDefNotCollected;
 258   BTFStringTable StringTable;
 259   std::vector<std::unique_ptr<BTFTypeBase>> TypeEntries;
 260   std::unordered_map<const DIType *, uint32_t> DIToIdMap;
 261   std::map<uint32_t, std::vector<BTFFuncInfo>> FuncInfoTable;
 262   std::map<uint32_t, std::vector<BTFLineInfo>> LineInfoTable;
 263   std::map<uint32_t, std::vector<BTFFieldReloc>> FieldRelocTable;
 264   StringMap<std::vector<std::string>> FileContent;
 265   std::map<std::string, std::unique_ptr<BTFKindDataSec>> DataSecEntries;
 266   std::vector<BTFTypeStruct *> StructTypes;
 267   std::map<const GlobalVariable *, std::pair<int64_t, uint32_t>> PatchImms;
 268   std::map<StringRef, std::pair<bool, std::vector<BTFTypeDerived *>>>
 269       FixupDerivedTypes;
 270   std::set<const Function *>ProtoFunctions;
 271
 272   /// Add types to TypeEntries.
 273   /// @{
 274   /// Add types to TypeEntries and DIToIdMap.
 275   uint32_t addType(std::unique_ptr<BTFTypeBase> TypeEntry, const DIType *Ty);
 276   /// Add types to TypeEntries only and return type id.
 277   uint32_t addType(std::unique_ptr<BTFTypeBase> TypeEntry);
 278   /// @}
 279
 280   /// IR type visiting functions.
 281   /// @{
 282   void visitTypeEntry(const DIType *Ty);
 283   void visitTypeEntry(const DIType *Ty, uint32_t &TypeId, bool CheckPointer,
 284                       bool SeenPointer);
 285   void visitBasicType(const DIBasicType *BTy, uint32_t &TypeId);
 286   void visitSubroutineType(
 287       const DISubroutineType *STy, bool ForSubprog,
 288       const std::unordered_map<uint32_t, StringRef> &FuncArgNames,
 289       uint32_t &TypeId);
 290   void visitFwdDeclType(const DICompositeType *CTy, bool IsUnion,
 291                         uint32_t &TypeId);
 292   void visitCompositeType(const DICompositeType *CTy, uint32_t &TypeId);
 293   void visitStructType(const DICompositeType *STy, bool IsStruct,
 294                        uint32_t &TypeId);
 295   void visitArrayType(const DICompositeType *ATy, uint32_t &TypeId);
 296   void visitEnumType(const DICompositeType *ETy, uint32_t &TypeId);
 297   void visitDerivedType(const DIDerivedType *DTy, uint32_t &TypeId,
 298                         bool CheckPointer, bool SeenPointer);
 299   void visitMapDefType(const DIType *Ty, uint32_t &TypeId);
 300   /// @}
 301
 302   /// Get the file content for the subprogram. Certain lines of the file
 303   /// later may be put into string table and referenced by line info.
 304   std::string populateFileContent(const DISubprogram *SP);
 305
 306   /// Construct a line info.
 307   void constructLineInfo(const DISubprogram *SP, MCSymbol *Label, uint32_t Line,
 308                          uint32_t Column);
 309
 310   /// Generate types and variables for globals.
 311   void processGlobals(bool ProcessingMapDef);
 312
 313   /// Generate types for function prototypes.
 314   void processFuncPrototypes(const Function *);
 315
 316   /// Generate one field relocation record.
 317   void generatePatchImmReloc(const MCSymbol *ORSym, uint32_t RootId,
 318                              const GlobalVariable *, bool IsAma);
 319
 320   /// Populating unprocessed type on demand.
 321   unsigned populateType(const DIType *Ty);
 322
 323   /// Process global variables referenced by relocation instructions
 324   /// and extern function references.
 325   void processGlobalValue(const MachineOperand &MO);
 326
 327   /// Emit common header of .BTF and .BTF.ext sections.
 328   void emitCommonHeader();
 329
 330   /// Emit the .BTF section.
 331   void emitBTFSection();
 332
 333   /// Emit the .BTF.ext section.
 334   void emitBTFExtSection();
 335
 336 protected:
 337   /// Gather pre-function debug information.
 338   void beginFunctionImpl(const MachineFunction *MF) override;
 339
 340   /// Post process after all instructions in this function are processed.
 341   void endFunctionImpl(const MachineFunction *MF) override;
 342
 343 public:
 344   BTFDebug(AsmPrinter *AP);
 345
 346   ///
 347   bool InstLower(const MachineInstr *MI, MCInst &OutMI);
 348
 349   /// Get the special array index type id.
 350   uint32_t getArrayIndexTypeId() {
 351     assert(ArrayIndexTypeId);
 352     return ArrayIndexTypeId;
 353   }
 354
 355   /// Add string to the string table.
 356   size_t addString(StringRef S) { return StringTable.addString(S); }
 357
 358   /// Get the type id for a particular DIType.
 359   uint32_t getTypeId(const DIType *Ty) {
 360     assert(Ty && "Invalid null Type");
 361     assert(DIToIdMap.find(Ty) != DIToIdMap.end() &&
 362            "DIType not added in the BDIToIdMap");
 363     return DIToIdMap[Ty];
 364   }
 365
 366   void setSymbolSize(const MCSymbol *Symbol, uint64_t Size) override {}
 367
 368   /// Process beginning of an instruction.
 369   void beginInstruction(const MachineInstr *MI) override;
 370
 371   /// Complete all the types and emit the BTF sections.
 372   void endModule() override;
 373 };
 374
 375 } // end namespace llvm
 376
 377 #endif