[BPF] Generate BTF info using 'btf:type_tag' annotation

This is a follow-up for BPF mailing list discussion at [1].

Previous commit in a series updated DWARF generation for the following
example:

    int __attribute__((btf_type_tag("tag1"))) *g;

To generate DWARF that looks as follows:

    0x0000001e:   DW_TAG_variable
                    DW_AT_name      ("g")
                    DW_AT_type      (0x00000029 "int *")

    0x00000029:   DW_TAG_pointer_type
                    DW_AT_type      (0x00000032 "int")

    0x00000032:   DW_TAG_base_type
                    DW_AT_name      ("int")

    0x00000036:     DW_TAG_LLVM_annotation
                      DW_AT_name    ("btf:type_tag")
                      DW_AT_const_value     ("tag1")

The fresh part is attachment of `btf:type_tag` annotations to types
other than pointers. This commit changes BTF generation to rely on
`btf:type_tag` annotations to generate TYPE_TAG entries.
This necessitates the following changes:
- The logic for `BTFTypeTypeTag` chains creation is moved to
  `BTFDebug::addType()`;
- Special logic is added to avoid duplicate BTF entries for tagged
  and un-tagged type variants, e.g. in the following case:

  #define __tag1 __attribute__((btf_type_tag("tag1")))
  #define __tag2 __attribute__((btf_type_tag("tag2")))

  struct foo {};

  struct bar {
    struct foo __tag1 aa;
    struct foo __tag2 bb;
    struct foo cc;
  };

  Debug information generated for this example contains three
  instances of `DICompositeType(name: "foo")` with different
  `annotations` fields, however single BTF definition for structure
  "foo" should be generated. Field `BTFDebug::DIDedupMap` and method
  `BTFDebug::lookupType()` are responsible for this logic;
- Care is taken to avoid references to type tags in relocation
  entries.

[1] https://lore.kernel.org/bpf/87r0w9jjoq.fsf@oracle.com/

This was previously tracked as differential revision:
https://reviews.llvm.org/D145891

Author: eddyz87

llvm/lib/Target/BPF/BTFDebug.cpp

@@ -48,6 +48,7 @@ class BTFTypeBase {
   virtual ~BTFTypeBase() = default;
   void setId(uint32_t Id) { this->Id = Id; }
   uint32_t getId() { return Id; }
+  uint32_t getKind() { return Kind; }
   uint32_t roundupToBytes(uint32_t NumBits) { return (NumBits + 7) >> 3; }
   /// Get the size of this BTF type entry.
   virtual uint32_t getSize() { return BTF::CommonTypeSize; }
@@ -68,10 +69,12 @@ class BTFTypeDerived : public BTFTypeBase {
 
 public:
   BTFTypeDerived(const DIDerivedType *Ty, unsigned Tag, bool NeedsFixup);
-  BTFTypeDerived(unsigned NextTypeId, unsigned Tag, StringRef Name);
+  BTFTypeDerived(unsigned NextTypeId, enum BTF::TypeKinds Kind,
+                 StringRef Name = StringRef());
   void completeType(BTFDebug &BDebug) override;
   void emitType(MCStreamer &OS) override;
   void setPointeeType(uint32_t PointeeType);
+  uint32_t getPointeeType();
 };
 
 /// Handle struct or union forward declaration.
@@ -240,6 +243,8 @@ class BTFTypeTypeTag : public BTFTypeBase {
   BTFTypeTypeTag(uint32_t NextTypeId, StringRef Tag);
   BTFTypeTypeTag(const DIDerivedType *DTy, StringRef Tag);
   void completeType(BTFDebug &BDebug) override;
+  uint32_t getNextTypeId();
+  StringRef getTag();
 };
 
 /// String table.
@@ -285,6 +290,20 @@ struct BTFFieldReloc {
   uint32_t RelocKind;     ///< What to patch the instruction
 };
 
+/// Used for de-duplication for types annotated with btf_type_tag annotation,
+/// See comment at BTFDebug.cpp:addType() for details.
+struct BTFTypeDedupKey {
+  const DIType *CanonTy;
+
+  BTFTypeDedupKey(const DIType *CanonTy) : CanonTy(CanonTy) {}
+
+  bool operator==(const BTFTypeDedupKey &Other) const;
+
+  struct Hash {
+    size_t operator()(BTFTypeDedupKey const &Key) const;
+  };
+};
+
 /// Collect and emit BTF information.
 class BTFDebug : public DebugHandlerBase {
   MCStreamer &OS;
@@ -296,6 +315,8 @@ class BTFDebug : public DebugHandlerBase {
   BTFStringTable StringTable;
   std::vector<std::unique_ptr<BTFTypeBase>> TypeEntries;
   std::unordered_map<const DIType *, uint32_t> DIToIdMap;
+  std::unordered_map<BTFTypeDedupKey, uint32_t, BTFTypeDedupKey::Hash>
+      DIDedupMap;
   std::map<uint32_t, std::vector<BTFFuncInfo>> FuncInfoTable;
   std::map<uint32_t, std::vector<BTFLineInfo>> LineInfoTable;
   std::map<uint32_t, std::vector<BTFFieldReloc>> FieldRelocTable;
@@ -311,11 +332,17 @@ class BTFDebug : public DebugHandlerBase {
   /// Add types to TypeEntries.
   /// @{
   /// Add types to TypeEntries and DIToIdMap.
-  uint32_t addType(std::unique_ptr<BTFTypeBase> TypeEntry, const DIType *Ty);
+  uint32_t addType(std::unique_ptr<BTFTypeBase> TypeEntry, const DIType *Ty,
+                   uint32_t *RealId = nullptr);
   /// Add types to TypeEntries only and return type id.
   uint32_t addType(std::unique_ptr<BTFTypeBase> TypeEntry);
+  uint32_t replaceType(uint32_t Id, std::unique_ptr<BTFTypeBase> TypeEntry);
   /// @}
 
+  BTFTypeBase *getType(uint32_t Id);
+
+  std::optional<uint32_t> lookupType(const DIType *Ty);
+
   /// IR type visiting functions.
   /// @{
   void visitTypeEntry(const DIType *Ty);
@@ -368,7 +395,10 @@ class BTFDebug : public DebugHandlerBase {
   /// the base type of DTy. Return the type id of the first BTF type_tag
   /// in the chain. If no type_tag's are generated, a negative value
   /// is returned.
-  int genBTFTypeTags(const DIDerivedType *DTy, int BaseTypeId);
+  uint32_t genBTFTypeTags(const DIType *Ty, int BaseId,
+                          const DIDerivedType *DTy, StringRef AnnotName);
+  uint32_t genBTFTypeTagsV1(const DIDerivedType *DTy);
+  uint32_t genBTFTypeTagsV2(const DIType *Ty, uint32_t BaseId);
 
   /// Generate one field relocation record.
   void generatePatchImmReloc(const MCSymbol *ORSym, uint32_t RootId,
@@ -390,6 +420,16 @@ class BTFDebug : public DebugHandlerBase {
   /// Emit the .BTF.ext section.
   void emitBTFExtSection();
 
+  uint32_t skipBTFTypeTags(uint32_t Id);
+
+  /// BTF post processing phase rewriting type chains like below:
+  ///   CONST -> TYPE_TAG '...' -> ...
+  /// To:
+  ///   TYPE_TAG '...' -> CONST -> ...
+  void moveTypeTagsBeforeCVR();
+  class QualifiedTypesCache;
+  void rebuildTypeTagsChain(uint32_t Id, QualifiedTypesCache &Cache);
+
 protected:
   /// Gather pre-function debug information.
   void beginFunctionImpl(const MachineFunction *MF) override;