BPF LLVM Relocations

BPF LLVM relocation 개요

`BPF LLVM Relocations` 문서는 `(LGPL-2.1 OR BSD-2-Clause)` license를 따르며 LLVM BPF backend가 사용하는 relocation type을 설명합니다.

ELF relocation record

LLVM BPF backend는 각 relocation을 다음 16-byte ELF structure로 기록합니다. `r_offset`은 section 시작점 기준 offset이고 `r_info`는 relocation type과 symbol index를 함께 담습니다.

typedef struct
{
  Elf64_Addr    r_offset;  // Offset from the beginning of section.
  Elf64_Xword   r_info;    // Relocation type and symbol index.
} Elf64_Rel;

Global·static variable relocation 예제

예제는 같은 `sec` section에 global variable `g1`, `g2`와 static volatile variable `l1`, `l2`를 두고 `test()`에서 네 값을 더합니다.

int g1 __attribute__((section("sec")));
int g2 __attribute__((section("sec")));
static volatile int l1 __attribute__((section("sec")));
static volatile int l2 __attribute__((section("sec")));
int test() {
  return g1 + g2 + l1 + l2;
}

`clang --target=bpf -O2 -c test.c`로 compile한 뒤 `llvm-objdump -dr test.o`를 실행하면 네 `LD_imm64` instruction에 대응하는 네 `R_BPF_64_64` relocation을 볼 수 있습니다.

 0:       18 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 r1 = 0 ll
          0000000000000000:  R_BPF_64_64  g1
 2:       61 11 00 00 00 00 00 00 r1 = *(u32 *)(r1 + 0)
 3:       18 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 r2 = 0 ll
          0000000000000018:  R_BPF_64_64  g2
 5:       61 20 00 00 00 00 00 00 r0 = *(u32 *)(r2 + 0)
 6:       0f 10 00 00 00 00 00 00 r0 += r1
 7:       18 01 00 00 08 00 00 00 00 00 00 00 00 00 00 00 r1 = 8 ll
          0000000000000038:  R_BPF_64_64  sec
 9:       61 11 00 00 00 00 00 00 r1 = *(u32 *)(r1 + 0)
10:       0f 10 00 00 00 00 00 00 r0 += r1
11:       18 01 00 00 0c 00 00 00 00 00 00 00 00 00 00 00 r1 = 12 ll
          0000000000000058:  R_BPF_64_64  sec
13:       61 11 00 00 00 00 00 00 r1 = *(u32 *)(r1 + 0)
14:       0f 10 00 00 00 00 00 00 r0 += r1
15:       95 00 00 00 00 00 00 00 exit

`llvm-readelf -r test.o`는 네 relocation의 binary value를 `.rel.text` section에서 다음과 같이 보여 줍니다.

Relocation section '.rel.text' at offset 0x190 contains 4 entries:
    Offset             Info             Type               Symbol's Value  Symbol's Name
0000000000000000  0000000600000001 R_BPF_64_64            0000000000000000 g1
0000000000000018  0000000700000001 R_BPF_64_64            0000000000000004 g2
0000000000000038  0000000400000001 R_BPF_64_64            0000000000000000 sec
0000000000000058  0000000400000001 R_BPF_64_64            0000000000000000 sec

Symbol table과 implicit addend A

각 relocation은 8-byte `Offset`과 8-byte `Info`로 표현됩니다. 첫 relocation은 offset `0x0`의 첫 instruction이며, `Info`는 relocation type `R_BPF_64_64` `(type 1)`과 symbol table entry 6을 가리킵니다. `llvm-readelf -s test.o`의 symbol table은 다음과 같습니다.

Symbol table '.symtab' contains 8 entries:
   Num:    Value          Size Type    Bind   Vis       Ndx Name
     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT   UND
     1: 0000000000000000     0 FILE    LOCAL  DEFAULT   ABS test.c
     2: 0000000000000008     4 OBJECT  LOCAL  DEFAULT     4 l1
     3: 000000000000000c     4 OBJECT  LOCAL  DEFAULT     4 l2
     4: 0000000000000000     0 SECTION LOCAL  DEFAULT     4 sec
     5: 0000000000000000   128 FUNC    GLOBAL DEFAULT     2 test
     6: 0000000000000000     4 OBJECT  GLOBAL DEFAULT     4 g1
     7: 0000000000000004     4 OBJECT  GLOBAL DEFAULT     4 g2

Entry 6은 value 0인 global variable `g1`입니다. 두 번째 relocation은 `.text` offset `0x18`의 instruction 3에 있으며 `R_BPF_64_64`와 entry 7을 가리킵니다. 이 entry의 global variable `g2`는 symbol value 4를 가지며, 이 값은 `g2` initial value가 저장된 `.data` section 시작점 기준 offset입니다.

세 번째와 네 번째 relocation은 static variable `l1`, `l2`를 가리키지만 `.rel.text`에서는 둘 다 section을 나타내는 `STT_SECTION` symbol `sec`, 즉 entry 4를 참조합니다. Static variable이나 function의 실제 section offset은 original instruction buffer의 `A`라는 addend에 기록됩니다. Instruction 7과 11의 offset 8과 12는 symbol table entry 2의 `l1`, entry 3의 `l2`에 대응합니다.

일반적으로 global variable과 function의 `A`는 0입니다. Static variable과 function에서는 section offset 또는 이를 바탕으로 계산한 결과가 `A`가 됩니다. 단순 section offset이 아닌 경우는 function call에 해당합니다.

지원하는 ELF relocation type

LLVM BPF backend는 다음 여섯 relocation type을 지원합니다. `S`는 symbol table에 기록된 symbol value입니다.

`R_BPF_64_64`는 `ld_imm64` instruction에 사용합니다. Relocate할 0 또는 section offset은 `r_offset + 4`에 저장되고 read/write bit size는 32입니다. `S + A`로 resolve하며 section offset은 `UINT32_MAX` 이하여야 합니다. LLVM BPF backend가 이 제한을 enforce합니다.

`R_BPF_64_ABS64`는 일반 64-bit data에 사용합니다. Relocate할 data는 `r_offset`에 저장되고 64-bit로 읽고 쓰며 역시 `S + A`로 resolve합니다.

`R_BPF_64_ABS32`와 `R_BPF_64_NODYLD32`는 32-bit data용입니다. 다만 `R_BPF_64_NODYLD32`는 `.BTF`와 `.BTF.ext` section의 relocation 전용입니다. BCC처럼 LLVM `ExecutionEngine RuntimeDyld`를 사용하는 경우 이를 실제 function 또는 variable address로 resolve하면 BCC와 kernel이 `.BTF` 및 `.BTF.ext`를 사용할 수 없게 됩니다.

`R_BPF_64_32`는 call instruction에 사용합니다. Call target section offset은 `r_offset + 4`에 32-bit로 저장되며 `(S + A) / 8 - 1`로 계산합니다.

ld_imm64와 call relocation 예제

`R_BPF_64_64`와 `R_BPF_64_32`가 각각 `ld_imm64`와 `call` instruction을 resolve하는 예제입니다. `gfunc`는 global function, `lfunc`는 같은 `sec1` section의 static function이며 `global`은 `sec2`에 놓입니다.

__attribute__((noinline)) __attribute__((section("sec1")))
int gfunc(int a, int b) {
  return a * b;
}
static __attribute__((noinline)) __attribute__((section("sec1")))
int lfunc(int a, int b) {
  return a + b;
}
int global __attribute__((section("sec2")));
int test(int a, int b) {
  return gfunc(a, b) +  lfunc(a, b) + global;
}

`clang --target=bpf -O2 -c test.c`와 `llvm-objdump -dr test.o`의 결과는 다음과 같습니다.

Disassembly of section .text:

0000000000000000 <test>:
       0:       bf 26 00 00 00 00 00 00 r6 = r2
       1:       bf 17 00 00 00 00 00 00 r7 = r1
       2:       85 10 00 00 ff ff ff ff call -1
                0000000000000010:  R_BPF_64_32  gfunc
       3:       bf 08 00 00 00 00 00 00 r8 = r0
       4:       bf 71 00 00 00 00 00 00 r1 = r7
       5:       bf 62 00 00 00 00 00 00 r2 = r6
       6:       85 10 00 00 02 00 00 00 call 2
                0000000000000030:  R_BPF_64_32  sec1
       7:       0f 80 00 00 00 00 00 00 r0 += r8
       8:       18 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 r1 = 0 ll
                0000000000000040:  R_BPF_64_64  global
      10:       61 11 00 00 00 00 00 00 r1 = *(u32 *)(r1 + 0)
      11:       0f 10 00 00 00 00 00 00 r0 += r1
      12:       95 00 00 00 00 00 00 00 exit

Disassembly of section sec1:

0000000000000000 <gfunc>:
       0:       bf 20 00 00 00 00 00 00 r0 = r2
       1:       2f 10 00 00 00 00 00 00 r0 *= r1
       2:       95 00 00 00 00 00 00 00 exit

0000000000000018 <lfunc>:
       3:       bf 20 00 00 00 00 00 00 r0 = r2
       4:       0f 10 00 00 00 00 00 00 r0 += r1
       5:       95 00 00 00 00 00 00 00 exit

첫 relocation은 value 0인 `gfunc(a, b)`에 대응하므로 call offset은 `(0 + 0)/8 - 1 = -1`입니다. 두 번째는 section offset `0x18`인 `lfunc(a, b)`이므로 `(0 + 0x18)/8 - 1 = 2`입니다. 세 번째는 section offset 0인 `global`을 대상으로 한 `ld_imm64` relocation입니다.

ABS64·ABS32·NODYLD32 data relocation 예제

`R_BPF_64_ABS64`를 생성하는 예제는 function `global`의 address를 struct initializer에 저장합니다.

int global() { return 0; }
struct t { void *g; } gbl = { global };

`clang --target=bpf -O2 -g -c test.c`로 compile하고 `llvm-readelf -r test.o`를 실행하면 `.data` section에 다음 relocation이 나타납니다.

Relocation section '.rel.data' at offset 0x458 contains 1 entries:
    Offset             Info             Type               Symbol's Value  Symbol's Name
0000000000000000  0000000700000002 R_BPF_64_ABS64         0000000000000000 global

이 relocation은 `.data` section의 첫 8 byte를 `global` variable의 address로 채워야 한다는 뜻입니다. DWARF section에는 여러 `R_BPF_64_ABS32` 및 `R_BPF_64_ABS64` relocation이 존재합니다.

Relocation section '.rel.debug_info' at offset 0x468 contains 13 entries:
    Offset             Info             Type               Symbol's Value  Symbol's Name
0000000000000006  0000000300000003 R_BPF_64_ABS32         0000000000000000 .debug_abbrev
000000000000000c  0000000400000003 R_BPF_64_ABS32         0000000000000000 .debug_str
0000000000000012  0000000400000003 R_BPF_64_ABS32         0000000000000000 .debug_str
0000000000000016  0000000600000003 R_BPF_64_ABS32         0000000000000000 .debug_line
000000000000001a  0000000400000003 R_BPF_64_ABS32         0000000000000000 .debug_str
000000000000001e  0000000200000002 R_BPF_64_ABS64         0000000000000000 .text
000000000000002b  0000000400000003 R_BPF_64_ABS32         0000000000000000 .debug_str
0000000000000037  0000000800000002 R_BPF_64_ABS64         0000000000000000 gbl
0000000000000040  0000000400000003 R_BPF_64_ABS32         0000000000000000 .debug_str
......

`.BTF`와 `.BTF.ext` section에는 다음과 같이 `R_BPF_64_NODYLD32` relocation이 들어 있습니다.

Relocation section '.rel.BTF' at offset 0x538 contains 1 entries:
    Offset             Info             Type               Symbol's Value  Symbol's Name
0000000000000084  0000000800000004 R_BPF_64_NODYLD32      0000000000000000 gbl

Relocation section '.rel.BTF.ext' at offset 0x548 contains 2 entries:
    Offset             Info             Type               Symbol's Value  Symbol's Name
000000000000002c  0000000200000004 R_BPF_64_NODYLD32      0000000000000000 .text
0000000000000040  0000000200000004 R_BPF_64_NODYLD32      0000000000000000 .text

CO-RE relocation 적용 위치

Object file 관점에서 CO-RE mechanism은 CO-RE 전용 relocation record 집합으로 구현됩니다. 이 record는 ELF relocation과 관계가 없으며 `.BTF.ext` section에 encode됩니다. `.BTF.ext` structure의 자세한 내용은 `Documentation/bpf/btf.rst`의 `BTF_Ext_Section`을 참고합니다.

CO-RE relocation은 load time에 target kernel 정보로 BPF instruction의 immediate 또는 offset field를 update합니다. Patch할 field는 instruction class에 따라 정합니다.

• `BPF_ALU`, `BPF_ALU64`, `BPF_LD`에서는 `immediate` field를 patch합니다.
• `BPF_LDX`, `BPF_STX`, `BPF_ST`에서는 `offset` field를 patch합니다.
• `BPF_JMP`, `BPF_JMP32` instruction은 patch하면 안 됩니다.

CO-RE relocation kind와 type match

CO-RE relocation은 다음 세 group으로 나눌 수 있습니다.

• **Field-based**: target kernel의 특정 structure field offset을 반영하도록 `BPF_LDX` instruction의 offset을 바꾸는 것처럼 field 관련 정보로 instruction을 patch합니다.
• **Type-based**: target kernel에 특정 type이 존재하는지 나타내기 위해 `BPF_ALU` move instruction의 immediate를 0 또는 1로 바꾸는 것처럼 type 관련 정보로 patch합니다.
• **Enum-based**: target kernel의 특정 enum literal value를 반영하도록 `BPF_LD_IMM64` instruction의 immediate를 바꾸는 것처럼 enum 관련 정보로 patch합니다.

전체 relocation kind는 다음 `enum bpf_core_relo_kind`로 정의합니다.

enum bpf_core_relo_kind {
       BPF_CORE_FIELD_BYTE_OFFSET = 0,  /* field byte offset */
       BPF_CORE_FIELD_BYTE_SIZE   = 1,  /* field size in bytes */
       BPF_CORE_FIELD_EXISTS      = 2,  /* field existence in target kernel */
       BPF_CORE_FIELD_SIGNED      = 3,  /* field signedness (0 - unsigned, 1 - signed) */
       BPF_CORE_FIELD_LSHIFT_U64  = 4,  /* bitfield-specific left bitshift */
       BPF_CORE_FIELD_RSHIFT_U64  = 5,  /* bitfield-specific right bitshift */
       BPF_CORE_TYPE_ID_LOCAL     = 6,  /* type ID in local BPF object */
       BPF_CORE_TYPE_ID_TARGET    = 7,  /* type ID in target kernel */
       BPF_CORE_TYPE_EXISTS       = 8,  /* type existence in target kernel */
       BPF_CORE_TYPE_SIZE         = 9,  /* type size in bytes */
       BPF_CORE_ENUMVAL_EXISTS    = 10, /* enum value existence in target kernel */
       BPF_CORE_ENUMVAL_VALUE     = 11, /* enum value integer value */
       BPF_CORE_TYPE_MATCHES      = 12, /* type match in target kernel */
};

`BPF_CORE_FIELD_LSHIFT_U64`와 `BPF_CORE_FIELD_RSHIFT_U64`는 bitfield value를 읽을 때 사용합니다. Signedness, byte offset, byte size, left shift, right shift relocation을 구한 뒤 해당 size의 signed 또는 unsigned integer로 읽고 두 shift를 순서대로 적용합니다.

// To read bitfield ``f`` from ``struct s``
is_signed = relo(s->f, BPF_CORE_FIELD_SIGNED)
off = relo(s->f, BPF_CORE_FIELD_BYTE_OFFSET)
sz  = relo(s->f, BPF_CORE_FIELD_BYTE_SIZE)
l   = relo(s->f, BPF_CORE_FIELD_LSHIFT_U64)
r   = relo(s->f, BPF_CORE_FIELD_RSHIFT_U64)
// define ``v`` as signed or unsigned integer of size ``sz``
v = *({s|u}<sz> *)((void *)s + off)
v <<= l
v >>= r

`BPF_CORE_TYPE_MATCHES`가 판정하는 matching relation은 다음과 같습니다.

• Integer는 size와 signedness가 같아야 match합니다.
• Array와 pointer는 target type을 recursive하게 match합니다.
• Struct와 union은 local member가 target에 같은 name으로 존재해야 합니다. Pointer 뒤에 있는 member가 아니면 각 member를 recursive하게 검사하고, pointer 뒤라면 name과 compatible kind만 확인합니다.
• Enum은 local variant가 numeric value와 무관하게 symbolic name으로 target variant와 match해야 하며 size도 같아야 합니다. `enum`과 `enum64`는 서로 match할 수 있습니다.
• Function pointer는 local type과 target type의 argument 수와 위치가 같아야 하며 각 argument와 return value를 recursive하게 검사합니다.

CO-RE relocation record와 access string

CO-RE relocation record는 다음 structure로 encode됩니다.

struct bpf_core_relo {
       __u32 insn_off;
       __u32 type_id;
       __u32 access_str_off;
       enum bpf_core_relo_kind kind;
};

• `insn_off`: relocation과 연결된 code section 내부의 byte 단위 instruction offset입니다.
• `type_id`: relocatable type 또는 field를 포함하는 root entity의 BTF type ID입니다.
• `access_str_off`: 대응하는 `.BTF` string section 내부 offset입니다. 해석은 relocation kind에 따라 달라집니다.
• `kind`: `enum bpf_core_relo_kind` 중 하나입니다.

Field-based relocation의 access string은 colon으로 구분한 field와 array index sequence로 accessed field를 encode합니다. 이는 field offset을 식별하는 LLVM `getelementptr` instruction argument와 개념적으로 매우 가깝습니다. 다음 sample structure를 기준으로 encoding을 살펴봅니다.

struct sample {
    int a;
    int b;
    struct { int c[10]; };
} __attribute__((preserve_access_index));
struct sample *s;

`s[0].a`와 `s->a`는 `0:0`입니다. 첫 `0`은 array로 간주한 `s`의 첫 element, 두 번째 `0`은 `struct sample`의 field `a` index입니다. `s->b`는 첫 element와 field `b` index를 뜻하는 `0:1`입니다.

`s[1].c[5]`는 `1:2:0:5`입니다. 차례로 `s`의 두 번째 element, `struct sample`의 anonymous structure field index 2, anonymous structure 안의 `c` field index 0, array element 5를 뜻합니다.

Type-based relocation의 string은 단순히 `"0"`이어야 합니다. Enum value-based relocation의 string은 enum type 내부 enum value index를 담습니다.

[LLVM getelementptr instruction reference](https://llvm.org/docs/LangRef.html#getelementptr-instruction)가 이 문서의 `GEP` external reference입니다.

CO-RE 예제 type과 BTF definition

CO-RE relocation 예제는 `preserve_access_index` attribute가 붙은 `struct foo`와 `enum bar`를 사용합니다.

struct foo {
  int a;
  int b;
  unsigned c:15;
} __attribute__((preserve_access_index));

enum bar { U, V };

BTF definition에는 `foo`의 `a`, `b`, 15-bit bitfield `c`, signed `int`, unsigned `int`, 그리고 `U`, `V`를 가진 `bar` enum이 기록됩니다.

...
[2] STRUCT 'foo' size=8 vlen=2
       'a' type_id=3 bits_offset=0
       'b' type_id=3 bits_offset=32
       'c' type_id=4 bits_offset=64 bitfield_size=15
[3] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED
[4] INT 'unsigned int' size=4 bits_offset=0 nr_bits=32 encoding=(none)
...
[16] ENUM 'bar' encoding=UNSIGNED size=4 vlen=2
       'U' val=0
       'V' val=1

Field-based relocation 예제

`__attribute__((preserve_access_index))`를 사용하면 field offset relocation이 자동으로 생성됩니다. `alpha()`의 load와 store는 모두 `struct foo::a`의 `0:0` access를 대상으로 `CO-RE <byte_off>` record를 가집니다.

void alpha(struct foo *s, volatile unsigned long *g) {
  *g = s->a;
  s->a = 1;
}

00 <alpha>:
  0:  r3 = *(s32 *)(r1 + 0x0)
         00:  CO-RE <byte_off> [2] struct foo::a (0:0)
  1:  *(u64 *)(r2 + 0x0) = r3
  2:  *(u32 *)(r1 + 0x0) = 0x1
         10:  CO-RE <byte_off> [2] struct foo::a (0:0)
  3:  exit

모든 field-based relocation kind는 `__builtin_preserve_field_info()`로 명시적으로 요청할 수 있습니다. `bravo()`는 byte offset, byte size, existence, signedness, bitfield left shift, bitfield right shift를 각각 요청하며 disassembly에 대응 CO-RE record가 나타납니다.

void bravo(struct foo *s, volatile unsigned long *g) {
  *g = __builtin_preserve_field_info(s->b, 0 /* field byte offset */);
  *g = __builtin_preserve_field_info(s->b, 1 /* field byte size */);
  *g = __builtin_preserve_field_info(s->b, 2 /* field existence */);
  *g = __builtin_preserve_field_info(s->b, 3 /* field signedness */);
  *g = __builtin_preserve_field_info(s->c, 4 /* bitfield left shift */);
  *g = __builtin_preserve_field_info(s->c, 5 /* bitfield right shift */);
}

20 <bravo>:
   4:     r1 = 0x4
          20:  CO-RE <byte_off> [2] struct foo::b (0:1)
   5:     *(u64 *)(r2 + 0x0) = r1
   6:     r1 = 0x4
          30:  CO-RE <byte_sz> [2] struct foo::b (0:1)
   7:     *(u64 *)(r2 + 0x0) = r1
   8:     r1 = 0x1
          40:  CO-RE <field_exists> [2] struct foo::b (0:1)
   9:     *(u64 *)(r2 + 0x0) = r1
  10:     r1 = 0x1
          50:  CO-RE <signed> [2] struct foo::b (0:1)
  11:     *(u64 *)(r2 + 0x0) = r1
  12:     r1 = 0x31
          60:  CO-RE <lshift_u64> [2] struct foo::c (0:2)
  13:     *(u64 *)(r2 + 0x0) = r1
  14:     r1 = 0x31
          70:  CO-RE <rshift_u64> [2] struct foo::c (0:2)
  15:     *(u64 *)(r2 + 0x0) = r1
  16:     exit

Type-based relocation 예제

`charlie()`는 `__builtin_preserve_type_info()`로 type existence, size, match를 요청하고 `__builtin_btf_type_id()`로 local object file과 target kernel의 type ID를 요청합니다. 각 value는 instruction immediate와 `type_exists`, `type_size`, `type_matches`, `local_type_id`, `target_type_id` CO-RE record로 나타납니다.

void charlie(struct foo *s, volatile unsigned long *g) {
  *g = __builtin_preserve_type_info(*s, 0 /* type existence */);
  *g = __builtin_preserve_type_info(*s, 1 /* type size */);
  *g = __builtin_preserve_type_info(*s, 2 /* type matches */);
  *g = __builtin_btf_type_id(*s, 0 /* type id in this object file */);
  *g = __builtin_btf_type_id(*s, 1 /* type id in target kernel */);
}

88 <charlie>:
  17:     r1 = 0x1
          88:  CO-RE <type_exists> [2] struct foo
  18:     *(u64 *)(r2 + 0x0) = r1
  19:     r1 = 0xc
          98:  CO-RE <type_size> [2] struct foo
  20:     *(u64 *)(r2 + 0x0) = r1
  21:     r1 = 0x1
          a8:  CO-RE <type_matches> [2] struct foo
  22:     *(u64 *)(r2 + 0x0) = r1
  23:     r1 = 0x2 ll
          b8:  CO-RE <local_type_id> [2] struct foo
  25:     *(u64 *)(r2 + 0x0) = r1
  26:     r1 = 0x2 ll
          d0:  CO-RE <target_type_id> [2] struct foo
  28:     *(u64 *)(r2 + 0x0) = r1
  29:     exit

Enum-based relocation 예제

`delta()`는 `__builtin_preserve_enum_value()`를 사용하여 enum literal `U`의 existence와 `V`의 integer value를 요청합니다. 결과 instruction에는 각각 `CO-RE <enumval_exists>`와 `CO-RE <enumval_value>` record가 연결됩니다.

void delta(struct foo *s, volatile unsigned long *g) {
  *g = __builtin_preserve_enum_value(*(enum bar *)U, 0 /* enum literal existence */);
  *g = __builtin_preserve_enum_value(*(enum bar *)V, 1 /* enum literal value */);
}

f0 <delta>:
  30:     r1 = 0x1 ll
          f0:  CO-RE <enumval_exists> [16] enum bar::U = 0
  32:     *(u64 *)(r2 + 0x0) = r1
  33:     r1 = 0x1 ll
          108:  CO-RE <enumval_value> [16] enum bar::V = 1
  35:     *(u64 *)(r2 + 0x0) = r1
  36:     exit