[BPF][DebugInfo] Show CO-RE relocations in llvm-objdump

Extend llvm-objdump to show CO-RE relocations when `-r` option is
passed and object file has .BTF and .BTF.ext sections.

For example, the following C program:

    #define __pai __attribute__((preserve_access_index))

    struct foo { int i; int j;} __pai;
    struct bar { struct foo f[7]; } __pai;
    extern void sink(void *);

    void root(struct bar *bar) {
      sink(&bar[2].f[3].j);
    }

Should lead to the following objdump output:

    $ clang --target=bpf -O2 -g t.c -c -o - | \
        llvm-objdump  --no-addresses --no-show-raw-insn -dr -

    ...
            r2 = 0x94
                    CO-RE <byte_off> [2] struct bar::[2].f[3].j (2:0:3:1)
            r1 += r2
            call -0x1
                    R_BPF_64_32     sink
            exit
    ...

More examples could be found in unit tests, see BTFParserTest.cpp.

To achieve this:
- Move CO-RE relocation kinds definitions from BPFCORE.h to BTF.h.
- Extend BTF.h with types derived from BTF::CommonType, e.g.
  BTF::IntType and BTF::StrutType, to allow dyn_cast() and access to
  type additional data.
- Extend BTFParser to load BTF type and relocation data.
- Modify llvm-objdump.cpp to create instance of BTFParser when
  disassembly of object file with BTF sections is processed and `-r`
  flag is supplied.

Additional information about CO-RE is available at [1].

[1] https://docs.kernel.org/bpf/llvm_reloc.html

Depends on D149058

Differential Revision: https://reviews.llvm.org/D150079

Author: eddyz87

llvm/include/llvm/DebugInfo/BTF/BTF.h

@@ -48,7 +48,8 @@
 #ifndef LLVM_LIB_TARGET_BPF_BTF_H
 #define LLVM_LIB_TARGET_BPF_BTF_H
 
-#include <cstdint>
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/Support/TrailingObjects.h"
 
 namespace llvm {
 namespace BTF {
@@ -97,6 +98,10 @@ enum TypeKinds : uint8_t {
 #include "BTF.def"
 };
 
+// Constants for CommonType::Info field.
+constexpr uint32_t FWD_UNION_FLAG = 1u << 31;
+constexpr uint32_t ENUM_SIGNED_FLAG = 1u << 31;
+
 /// The BTF common type definition. Different kinds may have
 /// additional information after this structure data.
 struct CommonType {
@@ -106,8 +111,8 @@ struct CommonType {
   /// "Info" bits arrangement:
   /// Bits  0-15: vlen (e.g. # of struct's members)
   /// Bits 16-23: unused
-  /// Bits 24-27: kind (e.g. int, ptr, array...etc)
-  /// Bits 28-30: unused
+  /// Bits 24-28: kind (e.g. int, ptr, array...etc)
+  /// Bits 29-30: unused
   /// Bit     31: kind_flag, currently used by
   ///             struct, union and fwd
   uint32_t Info;
@@ -122,6 +127,9 @@ struct CommonType {
     uint32_t Size;
     uint32_t Type;
   };
+
+  uint32_t getKind() const { return Info >> 24 & 0x1f; }
+  uint32_t getVlen() const { return Info & 0xffff; }
 };
 
 // For some specific BTF_KIND, "struct CommonType" is immediately
@@ -269,6 +277,84 @@ struct SecFieldReloc {
   uint32_t NumFieldReloc; ///< Number of offset reloc's in this section
 };
 
+/// CO-RE relocation kind codes used in .BTF.ext section.
+enum PatchableRelocKind : uint32_t {
+  FIELD_BYTE_OFFSET = 0,
+  FIELD_BYTE_SIZE,
+  FIELD_EXISTENCE,
+  FIELD_SIGNEDNESS,
+  FIELD_LSHIFT_U64,
+  FIELD_RSHIFT_U64,
+  BTF_TYPE_ID_LOCAL,
+  BTF_TYPE_ID_REMOTE,
+  TYPE_EXISTENCE,
+  TYPE_SIZE,
+  ENUM_VALUE_EXISTENCE,
+  ENUM_VALUE,
+  TYPE_MATCH,
+  MAX_FIELD_RELOC_KIND,
+};
+
+// Define a number of sub-types for CommonType, each with:
+// - An accessor for a relevant "tail" information (data fields that
+//   follow the CommonType record in binary format).
+// - A classof() definition based on CommonType::getKind() value to
+//   allow use with dyn_cast<>() function.
+
+// For CommonType sub-types that are followed by a single entry of
+// some type in the binary format.
+#define BTF_DEFINE_TAIL(Type, Accessor)                                        \
+  const Type &Accessor() const { return *getTrailingObjects<Type>(); }
+
+// For CommonType sub-types that are followed by CommonType::getVlen()
+// number of entries of some type in the binary format.
+#define BTF_DEFINE_TAIL_ARR(Type, Accessor)                                    \
+  ArrayRef<Type> Accessor() const {                                            \
+    return ArrayRef<Type>(getTrailingObjects<Type>(), getVlen());              \
+  }
+
+struct ArrayType final : CommonType,
+                         private TrailingObjects<ArrayType, BTFArray> {
+  friend TrailingObjects;
+  BTF_DEFINE_TAIL(BTFArray, getArray)
+
+  static bool classof(const CommonType *V) {
+    return V->getKind() == BTF_KIND_ARRAY;
+  }
+};
+
+struct StructType final : CommonType,
+                          private TrailingObjects<StructType, BTFMember> {
+  friend TrailingObjects;
+  BTF_DEFINE_TAIL_ARR(BTFMember, members)
+
+  static bool classof(const CommonType *V) {
+    return V->getKind() == BTF_KIND_STRUCT || V->getKind() == BTF_KIND_UNION;
+  }
+};
+
+struct EnumType final : CommonType, private TrailingObjects<EnumType, BTFEnum> {
+  friend TrailingObjects;
+  BTF_DEFINE_TAIL_ARR(BTFEnum, values)
+
+  static bool classof(const CommonType *V) {
+    return V->getKind() == BTF_KIND_ENUM;
+  }
+};
+
+struct Enum64Type final : CommonType,
+                          private TrailingObjects<Enum64Type, BTFEnum64> {
+  friend TrailingObjects;
+  BTF_DEFINE_TAIL_ARR(BTFEnum64, values)
+
+  static bool classof(const CommonType *V) {
+    return V->getKind() == BTF_KIND_ENUM64;
+  }
+};
+
+#undef BTF_DEFINE_TAIL
+#undef BTF_DEFINE_TAIL_ARR
+
 } // End namespace BTF.
 } // End namespace llvm.
 

llvm/include/llvm/DebugInfo/BTF/BTFParser.h

@@ -10,7 +10,9 @@
 // BPF backend and provides introspection for the stored information.
 // Currently the following information is accessible:
 // - string table;
-// - instruction offset to line information mapping.
+// - instruction offset to line information mapping;
+// - types table;
+// - CO-RE relocations table.
 //
 // See llvm/DebugInfo/BTF/BTF.h for some details about binary format
 // and links to Linux Kernel documentation.
@@ -32,22 +34,42 @@ using object::SectionRef;
 
 class BTFParser {
   using BTFLinesVector = SmallVector<BTF::BPFLineInfo, 0>;
+  using BTFRelocVector = SmallVector<BTF::BPFFieldReloc, 0>;
 
   // In BTF strings are stored as a continuous memory region with
   // individual strings separated by 0 bytes. Strings are identified
   // by an offset in such region.
   // The `StringsTable` points to this region in the parsed ObjectFile.
   StringRef StringsTable;
 
+  // A copy of types table from the object file but using native byte
+  // order. Should not be too big in practice, e.g. for ~250MiB vmlinux
+  // image it is ~4MiB.
+  OwningArrayRef<uint8_t> TypesBuffer;
+
   // Maps ELF section number to instruction line number information.
   // Each BTFLinesVector is sorted by `InsnOffset` to allow fast lookups.
   DenseMap<uint64_t, BTFLinesVector> SectionLines;
 
+  // Maps ELF section number to CO-RE relocation information.
+  // Each BTFRelocVector is sorted by `InsnOffset` to allow fast lookups.
+  DenseMap<uint64_t, BTFRelocVector> SectionRelocs;
+
+  // Vector of pointers to all known types, index in this vector
+  // equals to logical type BTF id.
+  // Pointers point to memory owned by `TypesBuffer`
+  // (except pointer at index 0, which is statically allocated).
+  std::vector<const BTF::CommonType *> Types;
+
   struct ParseContext;
   Error parseBTF(ParseContext &Ctx, SectionRef BTF);
   Error parseBTFExt(ParseContext &Ctx, SectionRef BTFExt);
   Error parseLineInfo(ParseContext &Ctx, DataExtractor &Extractor,
                       uint64_t LineInfoStart, uint64_t LineInfoEnd);
+  Error parseRelocInfo(ParseContext &Ctx, DataExtractor &Extractor,
+                       uint64_t RelocInfoStart, uint64_t RelocInfoEnd);
+  Error parseTypesInfo(ParseContext &Ctx, uint64_t TypesInfoStart,
+                       StringRef RawData);
 
 public:
   // Looks-up a string in the .BTF section's string table.
@@ -61,6 +83,34 @@ class BTFParser {
   // owned by this class.
   const BTF::BPFLineInfo *findLineInfo(SectionedAddress Address) const;
 
+  // Search for CO-RE relocation information for a specific address.
+  // Return nullptr if no information found.
+  // If information is present, return a pointer to object
+  // owned by this class.
+  const BTF::BPFFieldReloc *findFieldReloc(SectionedAddress Address) const;
+
+  // Return a human readable representation of the CO-RE relocation
+  // record, this is for display purpose only.
+  // See implementation for details.
+  void symbolize(const BTF::BPFFieldReloc *Reloc,
+                 SmallVectorImpl<char> &Result) const;
+
+  // Lookup BTF type definition with a specific index.
+  // Return nullptr if no information found.
+  // If information is present, return a pointer to object
+  // owned by this class.
+  const BTF::CommonType *findType(uint32_t Id) const;
+
+  // Return total number of known BTF types.
+  size_t typesCount() const { return Types.size(); }
+
+  // Allow to selectively load BTF information.
+  struct ParseOptions {
+    bool LoadLines = false;
+    bool LoadTypes = false;
+    bool LoadRelocs = false;
+  };
+
   // Fills instance of BTFParser with information stored in .BTF and
   // .BTF.ext sections of the `Obj`. If this instance was already
   // filled, old data is discarded.
@@ -70,7 +120,8 @@ class BTFParser {
   // - state of the BTFParser might be incomplete but is not invalid,
   //   queries might be run against it, but some (or all) information
   //   might be unavailable;
-  Error parse(const ObjectFile &Obj);
+  Error parse(const ObjectFile &Obj, const ParseOptions &Opts);
+  Error parse(const ObjectFile &Obj) { return parse(Obj, {true, true, true}); }
 
   // Return true if `Obj` has .BTF and .BTF.ext sections.
   static bool hasBTFSections(const ObjectFile &Obj);

llvm/lib/DebugInfo/BTF/BTFContext.cpp

@@ -63,7 +63,9 @@ std::unique_ptr<BTFContext>
 BTFContext::create(const ObjectFile &Obj,
                    std::function<void(Error)> ErrorHandler) {
   auto Ctx = std::make_unique<BTFContext>();
-  if (Error E = Ctx->BTF.parse(Obj))
+  BTFParser::ParseOptions Opts;
+  Opts.LoadLines = true;
+  if (Error E = Ctx->BTF.parse(Obj, Opts))
     ErrorHandler(std::move(E));
   return Ctx;
 }