[BPF] Introduce support for type match relocations

[d-e-s-o]

Summary

Among others, BPF currently supports the type-exists CO-RE relocation
(e.g., see D83878 & D83242). Its intention, as the name tries to convey,
is to be used for checking existence of a type in a target.
While that check is useful and has its place, we would also like to
be able to perform stricter type queries: instead of just checking mere
existence, we want to make sure that members match up in composite
types, that enum variants are present, etc. We refer to this as "type
match".
This change proposes the addition of a new relocation variant/value that
we intend to use for establishing this match relation.

[d-e-s-o]

llvm/test/CodeGen/BPF/CORE/intrinsic-typeinfo-type-match.ll

71–101

I am unsure how that blob is created or whether I need to adjust it. I just copied it from an existing file for now.

[yonghong-song]

llvm/test/CodeGen/BPF/CORE/intrinsic-typeinfo-type-match.ll

71–101

As mentioned in the test itself, it is generated with

clang -target bpf -S -O2 -g -emit-llvm -Xclang -disable-llvm-passes t1.c

Let us use latest llvm-project to generate IR for this test. The test you are copied using llvm12 which is not correct for this patch as this patch will apply to llvm15. Also please add '/tmp' as the prefix to the path in the below IR,

!1 = !DIFile(filename: "t1.c", directory: "/tmp/home/yhs/tmp1")

The reason is to avoid test failures when merging the tests. The reason is the path will be actually used by llvm, so adding /tmp will make sure both your local run and also sanity run after merging will have the same behavior.

[d-e-s-o]

Addressed Yonghong's comment and regenerated IR. Thanks for the review!

[d-e-s-o]

llvm/test/CodeGen/BPF/CORE/intrinsic-typeinfo-type-match.ll

71–101

Makes sense, thanks for the explanation. Done.

llvm/lib/Target/BPF/BPFAbstractMemberAccess.cpp

if (GV->getName().startswith("llvm.bpf.preserve.type.info")) {
     CInfo.Metadata = Call->getMetadata(LLVMContext::MD_preserve_access_index);
     if (!CInfo.Metadata)
       report_fatal_error("Missing metadata for llvm.preserve.type.info intrinsic");
     uint64_t Flag = getConstant(Call->getArgOperand(1));
     if (Flag >= BPFCoreSharedInfo::MAX_PRESERVE_TYPE_INFO_FLAG)
       report_fatal_error("Incorrect flag for llvm.bpf.preserve.type.info intrinsic");
     if (Flag == BPFCoreSharedInfo::PRESERVE_TYPE_INFO_EXISTENCE)
       CInfo.AccessIndex = BPFCoreSharedInfo::TYPE_EXISTENCE;
+    else if (Flag == BPFCoreSharedInfo::PRESERVE_TYPE_INFO_MATCH)
+      CInfo.AccessIndex = BPFCoreSharedInfo::TYPE_MATCH;
     else
       CInfo.AccessIndex = BPFCoreSharedInfo::TYPE_SIZE;
     return true;
   }
   if (GV->getName().startswith("llvm.bpf.preserve.enum.value")) {
     CInfo.Kind = BPFPreserveFieldInfoAI;
     CInfo.Metadata = Call->getMetadata(LLVMContext::MD_preserve_access_index);
     if (!CInfo.Metadata)
MDNode *BPFAbstractMemberAccess::computeAccessKey(CallInst *Call,
                                                   CallInfo &CInfo,
                                                   std::string &AccessKey,
                                                   bool &IsInt32Ret) {
   DIType *Ty = stripQualifiers(cast<DIType>(CInfo.Metadata), false);
   assert(!Ty->getName().empty());
 
   int64_t PatchImm;
   std::string AccessStr("0");
-  if (CInfo.AccessIndex == BPFCoreSharedInfo::TYPE_EXISTENCE) {
+  if (CInfo.AccessIndex == BPFCoreSharedInfo::TYPE_EXISTENCE ||
+      CInfo.AccessIndex == BPFCoreSharedInfo::TYPE_MATCH) {
     PatchImm = 1;
   } else if (CInfo.AccessIndex == BPFCoreSharedInfo::TYPE_SIZE) {
     // typedef debuginfo type has size 0, get the eventual base type.
     DIType *BaseTy = stripQualifiers(Ty, true);
     PatchImm = BaseTy->getSizeInBits() / 8;
   } else {
     // ENUM_VALUE_EXISTENCE and ENUM_VALUE
     IsInt32Ret = false;

llvm/lib/Target/BPF/BPFCORE.h

enum PatchableRelocKind : uint32_t {
     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,
   };
 
   enum BTFTypeIdFlag : uint32_t {
     BTF_TYPE_ID_LOCAL_RELOC = 0,
     BTF_TYPE_ID_REMOTE_RELOC,
 
     MAX_BTF_TYPE_ID_FLAG,
   };
 
   enum PreserveTypeInfo : uint32_t {
     PRESERVE_TYPE_INFO_EXISTENCE = 0,
     PRESERVE_TYPE_INFO_SIZE,
+    PRESERVE_TYPE_INFO_MATCH,
 
     MAX_PRESERVE_TYPE_INFO_FLAG,
   };
 
   enum PreserveEnumValue : uint32_t {
     PRESERVE_ENUM_VALUE_EXISTENCE = 0,
     PRESERVE_ENUM_VALUE,
 

llvm/test/CodeGen/BPF/CORE/intrinsic-typeinfo-type-match.ll

+; RUN: opt -O2 %s | llvm-dis > %t1
+; RUN: llc -filetype=asm -o - %t1 | FileCheck %s
+; RUN: llc -mattr=+alu32 -filetype=asm -o - %t1 | FileCheck %s
+;
+; Source:
+;   enum AA { VAL = 100 };
+;   typedef int (*func_t)(void);
+;   struct s2 { int a[10]; };
+;   int test() {
+;     return __builtin_preserve_type_info(*(func_t *)0, 2) +
+;            __builtin_preserve_type_info(*(struct s2 *)0, 2) +
+;            __builtin_preserve_type_info(*(enum AA *)0, 2);
+;   }
+; Compiler flag to generate IR:
+;   clang -target bpf -S -O2 -g -emit-llvm -Xclang -disable-llvm-passes t1.c
+
+target triple = "bpf"
+
+; Function Attrs: nounwind readnone
+define dso_local i32 @test() local_unnamed_addr #0 !dbg !17 {
+entry:
+  %0 = tail call i32 @llvm.bpf.preserve.type.info(i32 0, i64 2), !dbg !19, !llvm.preserve.access.index !8
+  %1 = tail call i32 @llvm.bpf.preserve.type.info(i32 1, i64 2), !dbg !20, !llvm.preserve.access.index !21
+  %add = add i32 %1, %0, !dbg !27
+  %2 = tail call i32 @llvm.bpf.preserve.type.info(i32 2, i64 2), !dbg !28, !llvm.preserve.access.index !3
+  %add1 = add i32 %add, %2, !dbg !29
+  ret i32 %add1, !dbg !30
+}
+
+; CHECK:             r{{[0-9]+}} = 1
+; CHECK:             r{{[0-9]+}} = 1
+; CHECK:             r{{[0-9]+}} = 1
+; CHECK:             exit
+
+; CHECK:             .long   16                              # BTF_KIND_TYPEDEF(id = 4)
+; CHECK:             .long   49                              # BTF_KIND_STRUCT(id = 7)
+; CHECK:             .long   74                              # BTF_KIND_ENUM(id = 10)
+
+; CHECK:             .ascii  ".text"                         # string offset=10
+; CHECK:             .ascii  "func_t"                        # string offset=16
+; CHECK:             .byte   48                              # string offset=23
+; CHECK:             .ascii  "s2"                            # string offset=49
+; CHECK:             .ascii  "AA"                            # string offset=74
+
+; CHECK:             .long   16                              # FieldReloc
+; CHECK-NEXT:        .long   10                              # Field reloc section string offset=10
+; CHECK-NEXT:        .long   3
+; CHECK-NEXT:        .long   .Ltmp{{[0-9]+}}
+; CHECK-NEXT:        .long   4
+; CHECK-NEXT:        .long   23
+; CHECK-NEXT:        .long   12
+; CHECK-NEXT:        .long   .Ltmp{{[0-9]+}}
+; CHECK-NEXT:        .long   7
+; CHECK-NEXT:        .long   23
+; CHECK-NEXT:        .long   12
+; CHECK-NEXT:        .long   .Ltmp{{[0-9]+}}
+; CHECK-NEXT:        .long   10
+; CHECK-NEXT:        .long   23
+; CHECK-NEXT:        .long   12
+
+; Function Attrs: nounwind readnone
+declare i32 @llvm.bpf.preserve.type.info(i32, i64) #1
+
+attributes #0 = { nounwind readnone "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "frame-pointer"="all" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { nounwind readnone }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!13, !14, !15}
+!llvm.ident = !{!16}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 12.0.0 (https://github.com/llvm/llvm-project.git d8b1394a0f4bbf57c254f69f8d3aa5381a89b5cd)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, retainedTypes: !7, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "t1.c", directory: "/tmp/home/yhs/tmp1")
+!2 = !{!3}
+!3 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "AA", file: !1, line: 1, baseType: !4, size: 32, elements: !5)
+!4 = !DIBasicType(name: "unsigned int", size: 32, encoding: DW_ATE_unsigned)
+!5 = !{!6}
+!6 = !DIEnumerator(name: "VAL", value: 100, isUnsigned: true)
+!7 = !{!8}
+!8 = !DIDerivedType(tag: DW_TAG_typedef, name: "func_t", file: !1, line: 2, baseType: !9)
+!9 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !10, size: 64)
+!10 = !DISubroutineType(types: !11)
+!11 = !{!12}
+!12 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!13 = !{i32 7, !"Dwarf Version", i32 4}
+!14 = !{i32 2, !"Debug Info Version", i32 3}
+!15 = !{i32 1, !"wchar_size", i32 4}
+!16 = !{!"clang version 12.0.0 (https://github.com/llvm/llvm-project.git d8b1394a0f4bbf57c254f69f8d3aa5381a89b5cd)"}
+!17 = distinct !DISubprogram(name: "test", scope: !1, file: !1, line: 4, type: !10, scopeLine: 4, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !18)
+!18 = !{}
+!19 = !DILocation(line: 5, column: 10, scope: !17)
+!20 = !DILocation(line: 6, column: 10, scope: !17)
+!21 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "s2", file: !1, line: 3, size: 320, elements: !22)
+!22 = !{!23}
+!23 = !DIDerivedType(tag: DW_TAG_member, name: "a", scope: !21, file: !1, line: 3, baseType: !24, size: 320)
+!24 = !DICompositeType(tag: DW_TAG_array_type, baseType: !12, size: 320, elements: !25)
+!25 = !{!26}
+!26 = !DISubrange(count: 10)
+!27 = !DILocation(line: 5, column: 56, scope: !17)
+!28 = !DILocation(line: 7, column: 10, scope: !17)
+!29 = !DILocation(line: 6, column: 59, scope: !17)
+!30 = !DILocation(line: 5, column: 3, scope: !17)