[BPF] Adding __attribute__((bpf_virtual_offsets)) for structs

[eddyz87]

Summary

This commit adds a new BPF specific structure attribte
__attribute__((bpf_virtual_offsets)) and passes to deal with it.

This attribute may be attached to a struct or union declaration, where
it notifies the compiler that runtime environment might patch access
to the fields of this type by updating the field offset.

BPF verifier limits access patterns allowed for certain data
types. E.g. struct __sk_buff and struct bpf_sock_ops. For these
types only BASE + static-offset memory loads and stores are allowed.

This is so because offsets of the fields of these structures do not
match real offsets in the running kernel. During BPF program
load/verification loads and stores to the fields of these types are
rewritten so that offsets match real offsets. For this rewrite to
happen static offsets have to be encoded in the instructions.

See kernel/bpf/verifier.c:convert_ctx_access function in the Linux
kernel source tree for details.

Access to the structure fields is translated to the IR as a pair:

• (load (getelementptr ...)) or
• (store (getelementptr ...))

During instruction selection phase the following sequence of
instructions:

%x = getelementptr %ptr, %offset
%y = load %x

Is translated as a single load instruction with embedded offset,
e.g. LDW %ptr, %offset, which matches access pattern necessary for
the restricted set of types described above (when %offset is
static).

Multiple optimizer passes might separate these instructions, this
includes:

• SimplifyCFGPass (sinking)
• InstCombine (sinking)
• GVN (hoisting)

The bpf_virtual_offsets attribute marks structures for which the
following transformations happen:

• at the early IR processing stage:
  • (load (getelementptr ...)) replaced by call to intrinsic llvm.bpf.getelementptr.and.load;
  • (store (getelementptr ...)) replaced by call to intrinsic llvm.bpf.getelementptr.and.store;
• at the late IR processing stage this modification is undone.

Such handling prevents various optimizer passes from generating
sequences of instructions that would be rejected by BPF verifier.

This addresses the issue reported by the following thread:

https://lore.kernel.org/bpf/CAA-VZPmxh8o8EBcJ=[e-mail]/T/#m4b9ce2ce73b34f34172328f975235fc6f19841b6

[eddyz87]

Handle GEP chains / proper test cases

clang/lib/CodeGen/CGExpr.cpp

if (const auto *DRE = dyn_cast<DeclRefExpr>(E)) {
     if (const auto *RecT = dyn_cast<RecordType>(PointeeT))
       return RecT->getDecl()->hasAttr<BPFPreserveAccessIndexAttr>();
     return false;
   }
 
   return false;
 }
 
+// Returns true if D is marked with __attribute__((btf_decl_tag("ctx")))
+static bool hasBTFCtxDeclTagAttr(const TypeDecl *D) {
+  if (auto *Attr = D->getAttr<BTFDeclTagAttr>())
+    return Attr->getBTFDeclTag().equals("ctx");
+
+  return false;
+}
+
+static bool pointeeHasBTFCtxDeclTagAttr(const Expr *E) {
+  if (auto *PtrType = dyn_cast<PointerType>(E->getType()))
+    if (auto *BaseDecl = PtrType->getPointeeType()->getAsRecordDecl())
+      return hasBTFCtxDeclTagAttr(BaseDecl);
+
+  return false;
+}
+
+// Wraps Addr with a call to llvm.bpf.context.marker intrinsic.
+// This is used for target specific rewrites, for details see
+// llvm/lib/Target/BPF/BPFContextMarker.cpp
+static Address wrapWithBPFContextMarker(CodeGenFunction &CGF,
+                                        Address &Addr) {
+  llvm::Function *Fn =
+    CGF.CGM.getIntrinsic(llvm::Intrinsic::bpf_context_marker,
+                         {Addr.getType(), Addr.getType()});
+  llvm::CallInst *Call = CGF.Builder.CreateCall(Fn, {Addr.getPointer()});
+  return Address(Call, Addr.getElementType(), Addr.getAlignment());
+}
+
 static Address emitArraySubscriptGEP(CodeGenFunction &CGF, Address addr,
                                      ArrayRef<llvm::Value *> indices,
                                      QualType eltType, bool inbounds,
                                      bool signedIndices, SourceLocation loc,
                                      QualType *arrayType = nullptr,
                                      const Expr *Base = nullptr,
                                      const llvm::Twine &name = "arrayidx") {
   // All the indices except that last must be zero.
if (auto vla = CGF.getContext().getAsVariableArrayType(eltType)) {
     eltType = getFixedSizeElementType(CGF.getContext(), vla);
   }
 
   // We can use that to compute the best alignment of the element.
   CharUnits eltSize = CGF.getContext().getTypeSizeInChars(eltType);
   CharUnits eltAlign =
     getArrayElementAlign(addr.getAlignment(), indices.back(), eltSize);
 
+  if (Base && pointeeHasBTFCtxDeclTagAttr(Base))
+    addr = wrapWithBPFContextMarker(CGF, addr);
+
   llvm::Value *eltPtr;
   auto LastIndex = dyn_cast<llvm::ConstantInt>(indices.back());
   if (!LastIndex ||
       (!CGF.IsInPreservedAIRegion && !IsPreserveAIArrayBase(CGF, Base))) {
     eltPtr = emitArraySubscriptGEP(
         CGF, addr.getElementType(), addr.getPointer(), indices, inbounds,
         signedIndices, loc, name);
   } else {
const bool UseVolatile = isAAPCS(CGM.getTarget()) &&
                              CGM.getCodeGenOpts().AAPCSBitfieldWidth &&
                              Info.VolatileStorageSize != 0 &&
                              field->getType()
                                  .withCVRQualifiers(base.getVRQualifiers())
                                  .isVolatileQualified();
     Address Addr = base.getAddress(*this);
     unsigned Idx = RL.getLLVMFieldNo(field);
     const RecordDecl *rec = field->getParent();
+    if (hasBTFCtxDeclTagAttr(rec))
+      Addr = wrapWithBPFContextMarker(*this, Addr);
     if (!UseVolatile) {
       if (!IsInPreservedAIRegion &&
           (!getDebugInfo() || !rec->hasAttr<BPFPreserveAccessIndexAttr>())) {
         if (Idx != 0)
           // For structs, we GEP to the field that the record layout suggests.
           Addr = Builder.CreateStructGEP(Addr, Idx, field->getName());
       } else {
         llvm::DIType *DbgInfo = getDebugInfo()->getOrCreateRecordType(
if (base.getTBAAInfo().isMayAlias() ||
 
     // Update the final access type and size.
     FieldTBAAInfo.AccessType = CGM.getTBAATypeInfo(FieldType);
     FieldTBAAInfo.Size =
         getContext().getTypeSizeInChars(FieldType).getQuantity();
   }
 
   Address addr = base.getAddress(*this);
+  if (hasBTFCtxDeclTagAttr(rec))
+    addr = wrapWithBPFContextMarker(*this, addr);
   if (auto *ClassDef = dyn_cast<CXXRecordDecl>(rec)) {
     if (CGM.getCodeGenOpts().StrictVTablePointers &&
         ClassDef->isDynamicClass()) {
       // Getting to any field of dynamic object requires stripping dynamic
       // information provided by invariant.group.  This is because accessing
       // fields may leak the real address of dynamic object, which could result
       // in miscompilation when leaked pointer would be compared.
       auto *stripped = Builder.CreateStripInvariantGroup(addr.getPointer());

clang/test/CodeGen/bpf-decl-tag-ctx-pai.c

+// Check interaction between two attributes:
+//   __attribute__((btf_decl_tag("ctx")))
+//   __attribute__((preserve_access_index))
+//
+// First, check that calls to context.marker are inserted where expected
+// (but limit it to the first function only as it is too verbose and
+// residual gep_and_load/store calls at MID level do tell if it
+// happened):
+//
+// RUN: %clang -g -target bpf -Xclang -disable-llvm-passes -S -emit-llvm %s -o - | \
+// RUN:        FileCheck -check-prefix=FRONT %s
+//
+// Next, check that gep_and_load/store calls were generated:
+//
+// RUN: %clang -g -target bpf -O2 -S -emit-llvm %s -o - |  \
+// RUN:        FileCheck -check-prefix=MID %s
+//
+// For gep_and_load/store calls lowering refer to test the case
+// bpf-decl-tag-ctx.c
+
+#define __ctx__ __attribute__((btf_decl_tag("ctx")))
+#define __preserve_access_index__ __attribute__((preserve_access_index))
+
+extern void consume_int(int);
+extern void consume_ptr(void *);
+
+struct vo3 {
+  int a;
+  int b;
+} __preserve_access_index__ __ctx__;
+
+struct pai2 {
+  int a;
+  int b;
+  struct vo3 vo;
+} __preserve_access_index__;
+
+struct vo2 {
+  int _;
+  struct pai2 pai;
+} __preserve_access_index__ __ctx__;
+
+struct pai1 {
+  int _;
+  struct vo2 vo;
+} __preserve_access_index__;
+
+struct vo1 {
+  int _;
+  struct pai1 pai;
+} __preserve_access_index__ __ctx__;
+
+struct xvo1 {
+  int a;
+  int b;
+} __ctx__;
+
+struct xpai1 {
+  int _;
+  struct xvo1 vo;
+} __preserve_access_index__;
+
+// FRONT-LABEL: define {{.*}} @combinations1
+//   MID-LABEL: define {{.*}} @combinations1
+void combinations1(struct vo1 *x, struct pai1 *y, struct xpai1 *z) {
+  consume_int(x->pai.vo.pai.b);
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = call ptr @llvm.preserve.struct.access.index.p0.p0(ptr elementtype(%struct.vo1) [[r1]], i32 1, i32 1)
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = call ptr @llvm.preserve.struct.access.index.p0.p0(ptr elementtype(%struct.pai1) [[r2]], i32 1, i32 1)
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r3]])
+// FRONT-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = call ptr @llvm.preserve.struct.access.index.p0.p0(ptr elementtype(%struct.vo2) [[r4]], i32 1, i32 1)
+// FRONT-NEXT:   [[r6:%[a-zA-Z0-9._]+]] = call ptr @llvm.preserve.struct.access.index.p0.p0(ptr elementtype(%struct.pai2) [[r5]], i32 1, i32 1)
+// FRONT-NEXT:   [[r7:%[a-zA-Z0-9._]+]] = load i32, ptr [[r6]]
+// FRONT-NEXT:   call void @consume_int(i32 noundef [[r7]])
+
+//   MID:        [[r0:%[a-zA-Z0-9._]+]] = load i64, ptr @"llvm.vo1:0:16$0:1:1:1:1"
+//   MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = tail call ptr @llvm.bpf.passthrough.p0.p0({{.*}}, ptr %x)
+//   MID-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(i8) [[r1]], i1 false, i8 0, i8 1, i8 2, i1 false, i64 [[r0]])
+//   MID-NEXT:   tail call void @consume_int(i32 noundef [[r2]])
+
+  consume_int(y->vo.pai.vo.b);
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.preserve.struct.access.index.p0.p0(ptr elementtype(%struct.pai1) [[r0]], i32 1, i32 1)
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r1]])
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = call ptr @llvm.preserve.struct.access.index.p0.p0(ptr elementtype(%struct.vo2) [[r2]], i32 1, i32 1)
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = call ptr @llvm.preserve.struct.access.index.p0.p0(ptr elementtype(%struct.pai2) [[r3]], i32 2, i32 2)
+// FRONT-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r4]])
+// FRONT-NEXT:   [[r6:%[a-zA-Z0-9._]+]] = call ptr @llvm.preserve.struct.access.index.p0.p0(ptr elementtype(%struct.vo3) [[r5]], i32 1, i32 1)
+// FRONT-NEXT:   [[r7:%[a-zA-Z0-9._]+]] = load i32, ptr [[r6]]
+// FRONT-NEXT:   call void @consume_int(i32 noundef [[r7]])
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load i64, ptr @"llvm.pai1:0:20$0:1:1:2:1"
+//   MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = tail call ptr @llvm.bpf.passthrough.p0.p0({{.*}}, ptr %y)
+//   MID-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(i8) [[r1]], i1 false, i8 0, i8 1, i8 2, i1 false, i64 [[r0]])
+//   MID-NEXT:   tail call void @consume_int(i32 noundef [[r2]])
+
+  consume_int(z->vo.b);
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.preserve.struct.access.index.p0.p0(ptr elementtype(%struct.xpai1) [[r0]], i32 1, i32 1)
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r1]])
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.xvo1, ptr [[r2]], i32 0, i32 1
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = load i32, ptr [[r3]]
+// FRONT-NEXT:   call void @consume_int(i32 noundef [[r4]])
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load i64, ptr @"llvm.xpai1:0:4$0:1"
+//   MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = getelementptr i8, ptr %z, i64 [[r0]]
+//   MID-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = tail call ptr @llvm.bpf.passthrough.p0.p0({{.*}}, ptr [[r1]])
+//   MID-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(%struct.xvo1) [[r2]], i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 1)
+//   MID-NEXT:   tail call void @consume_int(i32 noundef [[r3]])
+}
+
+struct context1_inner {
+  int a;
+  int b;
+  int c[5];
+} __ctx__ __preserve_access_index__;
+
+struct context1 {
+  int first;
+  struct context1_inner *inner;
+  struct context1_inner inner_inline;
+  int arr[4];
+  int *ptr;
+  int last;
+} __ctx__ __preserve_access_index__;
+
+// FRONT-LABEL: define {{.*}} @preserve_access_index1
+//   MID-LABEL: define {{.*}} @preserve_access_index1
+void preserve_access_index1(struct context1 *ctx) {
+  consume_int(ctx->first);
+//  MID:        [[r0:%[a-zA-Z0-9._]+]] = load i64, ptr @"llvm.context1:0:0$0:0"
+//  MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = tail call ptr @llvm.bpf.passthrough.p0.p0({{.*}}, ptr %ctx)
+//  MID-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//  MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(i8) [[r1]], i1 false, i8 0, i8 1, i8 3, i1 false, i64 [[r0]])
+//  MID-NEXT:   tail call void @consume_int(i32 noundef [[r2]])
+
+  consume_int(ctx->arr[2]);
+//  MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load i64, ptr @"llvm.context1:0:52$0:3:2"
+//  MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = tail call ptr @llvm.bpf.passthrough.p0.p0({{.*}}, ptr %ctx)
+//  MID-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//  MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(i8) [[r1]], i1 false, i8 0, i8 1, i8 2, i1 false, i64 [[r0]])
+//  MID-NEXT:   tail call void @consume_int(i32 noundef [[r2]])
+
+  consume_ptr(ctx->ptr);
+//  MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load i64, ptr @"llvm.context1:0:64$0:4"
+//  MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = tail call ptr @llvm.bpf.passthrough.p0.p0({{.*}}, ptr %ctx)
+//  MID-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = tail call ptr (ptr, i1, i8, i8, i8, i1, ...)
+//  MID-SAME:     @llvm.bpf.getelementptr.and.load.p0(ptr elementtype(i8) [[r1]], i1 false, i8 0, i8 1, i8 3, i1 false, i64 [[r0]])
+//  MID-NEXT:   tail call void @consume_ptr(ptr noundef [[r2]])
+
+  consume_int(ctx->last);
+//  MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load i64, ptr @"llvm.context1:0:72$0:5"
+//  MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = tail call ptr @llvm.bpf.passthrough.p0.p0({{.*}}, ptr %ctx)
+//  MID-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//  MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(i8) [[r1]], i1 false, i8 0, i8 1, i8 3, i1 false, i64 [[r0]])
+//  MID-NEXT:   tail call void @consume_int(i32 noundef [[r2]])
+
+  consume_int(ctx->inner->b);
+//  MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load i64, ptr @"llvm.context1:0:8$0:1"
+//  MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = tail call ptr @llvm.bpf.passthrough.p0.p0({{.*}}, ptr %ctx)
+//  MID-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = tail call ptr (ptr, i1, i8, i8, i8, i1, ...)
+//  MID-SAME:     @llvm.bpf.getelementptr.and.load.p0(ptr elementtype(i8) [[r1]], i1 false, i8 0, i8 1, i8 3, i1 false, i64 [[r0]])
+//  MID-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load i64, ptr @"llvm.context1_inner:0:4$0:1"
+//  MID-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = tail call ptr @llvm.bpf.passthrough.p0.p0({{.*}}, ptr [[r2]])
+//  MID-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//  MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(i8) [[r4]], i1 false, i8 0, i8 1, i8 2, i1 false, i64 [[r3]])
+//  MID-NEXT:   tail call void @consume_int(i32 noundef [[r5]])
+
+  consume_int(ctx->inner->c[3]);
+//  MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load i64, ptr @"llvm.context1:0:8$0:1"
+//  MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = tail call ptr @llvm.bpf.passthrough.p0.p0({{.*}}, ptr %ctx)
+//  MID-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = tail call ptr (ptr, i1, i8, i8, i8, i1, ...)
+//  MID-SAME:     @llvm.bpf.getelementptr.and.load.p0(ptr elementtype(i8) [[r1]], i1 false, i8 0, i8 1, i8 3, i1 false, i64 [[r0]])
+//  MID-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load i64, ptr @"llvm.context1_inner:0:20$0:2:3"
+//  MID-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = tail call ptr @llvm.bpf.passthrough.p0.p0({{.*}}, ptr [[r2]])
+//  MID-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//  MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(i8) [[r4]], i1 false, i8 0, i8 1, i8 2, i1 false, i64 [[r3]])
+//  MID-NEXT:   tail call void @consume_int(i32 noundef [[r5]])
+
+  consume_int(ctx->inner_inline.b);
+//  MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load i64, ptr @"llvm.context1:0:20$0:2:1"
+//  MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = tail call ptr @llvm.bpf.passthrough.p0.p0({{.*}}, ptr %ctx)
+//  MID-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//  MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(i8) [[r1]], i1 false, i8 0, i8 1, i8 2, i1 false, i64 [[r0]])
+//  MID-NEXT:   tail call void @consume_int(i32 noundef [[r2]])
+
+  consume_int(ctx->inner_inline.c[3]);
+//  MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load i64, ptr @"llvm.context1:0:36$0:2:2:3"
+//  MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = tail call ptr @llvm.bpf.passthrough.p0.p0({{.*}}, ptr %ctx)
+//  MID-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//  MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(i8) [[r1]], i1 false, i8 0, i8 1, i8 2, i1 false, i64 [[r0]])
+//  MID-NEXT:   tail call void @consume_int(i32 noundef [[r2]])
+
+  consume_int(ctx[17].arr[2]);
+//  MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load i64, ptr @"llvm.context1:0:1412$17:3:2"
+//  MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = tail call ptr @llvm.bpf.passthrough.p0.p0({{.*}}, ptr %ctx)
+//  MID-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//  MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(i8) [[r1]], i1 false, i8 0, i8 1, i8 2, i1 false, i64 [[r0]])
+//  MID-NEXT:   tail call void @consume_int(i32 noundef [[r2]])
+
+  ctx->first = 1;
+//  MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load i64, ptr @"llvm.context1:0:0$0:0"
+//  MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = tail call ptr @llvm.bpf.passthrough.p0.p0({{.*}}, ptr %ctx)
+//  MID-NEXT:   tail call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+//  MID-SAME:     @llvm.bpf.getelementptr.and.store.i32(i32 1, ptr elementtype(i8) [[r1]], i1 false, i8 0, i8 1, i8 3, i1 false, i64 [[r0]])
+
+  ctx->arr[2] = 2;
+//  MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load i64, ptr @"llvm.context1:0:52$0:3:2"
+//  MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = tail call ptr @llvm.bpf.passthrough.p0.p0({{.*}}, ptr %ctx)
+//  MID-NEXT:   tail call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+//  MID-SAME:     @llvm.bpf.getelementptr.and.store.i32(i32 2, ptr elementtype(i8) [[r1]], i1 false, i8 0, i8 1, i8 2, i1 false, i64 [[r0]])
+
+  ctx->ptr = (void*) 0;
+//  MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load i64, ptr @"llvm.context1:0:64$0:4"
+//  MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = tail call ptr @llvm.bpf.passthrough.p0.p0({{.*}}, ptr %ctx)
+//  MID-NEXT:   tail call void (ptr, ptr, i1, i8, i8, i8, i1, ...)
+//  MID-SAME:     @llvm.bpf.getelementptr.and.store.p0(ptr readnone null, ptr elementtype(i8) [[r1]], i1 false, i8 0, i8 1, i8 3, i1 false, i64 [[r0]])
+
+  ctx->last = 3;
+//  MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load i64, ptr @"llvm.context1:0:72$0:5"
+//  MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = tail call ptr @llvm.bpf.passthrough.p0.p0({{.*}}, ptr %ctx)
+//  MID-NEXT:   tail call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+//  MID-SAME:     @llvm.bpf.getelementptr.and.store.i32(i32 3, ptr elementtype(i8) [[r1]], i1 false, i8 0, i8 1, i8 3, i1 false, i64 [[r0]])
+
+  ctx->inner->b = 4;
+//  MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load i64, ptr @"llvm.context1:0:8$0:1"
+//  MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = tail call ptr @llvm.bpf.passthrough.p0.p0({{.*}}, ptr %ctx)
+//  MID-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = tail call ptr (ptr, i1, i8, i8, i8, i1, ...)
+//  MID-SAME:     @llvm.bpf.getelementptr.and.load.p0(ptr elementtype(i8) [[r1]], i1 false, i8 0, i8 1, i8 3, i1 false, i64 [[r0]])
+//  MID-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load i64, ptr @"llvm.context1_inner:0:4$0:1"
+//  MID-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = tail call ptr @llvm.bpf.passthrough.p0.p0({{.*}}, ptr [[r2]])
+//  MID-NEXT:   tail call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+//  MID-SAME:     @llvm.bpf.getelementptr.and.store.i32(i32 4, ptr elementtype(i8) [[r4]], i1 false, i8 0, i8 1, i8 2, i1 false, i64 [[r3]])
+
+  ctx->inner->c[3] = 5;
+//  MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load i64, ptr @"llvm.context1:0:8$0:1"
+//  MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = tail call ptr @llvm.bpf.passthrough.p0.p0({{.*}}, ptr %ctx)
+//  MID-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = tail call ptr (ptr, i1, i8, i8, i8, i1, ...)
+//  MID-SAME:     @llvm.bpf.getelementptr.and.load.p0(ptr elementtype(i8) [[r1]], i1 false, i8 0, i8 1, i8 3, i1 false, i64 [[r0]])
+//  MID-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load i64, ptr @"llvm.context1_inner:0:20$0:2:3"
+//  MID-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = tail call ptr @llvm.bpf.passthrough.p0.p0({{.*}}, ptr [[r2]])
+//  MID-NEXT:   tail call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+//  MID-SAME:     @llvm.bpf.getelementptr.and.store.i32(i32 5, ptr elementtype(i8) [[r4]], i1 false, i8 0, i8 1, i8 2, i1 false, i64 [[r3]])
+
+  ctx->inner_inline.b = 6;
+//  MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load i64, ptr @"llvm.context1:0:20$0:2:1"
+//  MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = tail call ptr @llvm.bpf.passthrough.p0.p0({{.*}}, ptr %ctx)
+//  MID-NEXT:   tail call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+//  MID-SAME:     @llvm.bpf.getelementptr.and.store.i32(i32 6, ptr elementtype(i8) [[r1]], i1 false, i8 0, i8 1, i8 2, i1 false, i64 [[r0]])
+
+  ctx->inner_inline.c[3] = 7;
+//  MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load i64, ptr @"llvm.context1:0:36$0:2:2:3"
+//  MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = tail call ptr @llvm.bpf.passthrough.p0.p0({{.*}}, ptr %ctx)
+//  MID-NEXT:   tail call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+//  MID-SAME:     @llvm.bpf.getelementptr.and.store.i32(i32 7, ptr elementtype(i8) [[r1]], i1 false, i8 0, i8 1, i8 2, i1 false, i64 [[r0]])
+
+  ctx[19].arr[2] = 55;
+//  MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load i64, ptr @"llvm.context1:0:1572$19:3:2"
+//  MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = tail call ptr @llvm.bpf.passthrough.p0.p0({{.*}}, ptr %ctx)
+//  MID-NEXT:   tail call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+//  MID-SAME:     @llvm.bpf.getelementptr.and.store.i32(i32 55, ptr elementtype(i8) [[r1]], i1 false, i8 0, i8 1, i8 2, i1 false, i64 [[r0]])
+
+  consume_ptr(ctx);
+}
+
+extern int magic2(int);
+
+struct bpf_sock {
+  int bound_dev_if;
+  int family;
+} __ctx__ __preserve_access_index__;
+
+struct bpf_sockopt {
+  struct bpf_sock *sk;
+  int level;
+  int optlen;
+} __ctx__ __preserve_access_index__;
+
+// FRONT-LABEL: define {{.*}} @known_load_sink_example_1
+//   MID-LABEL: define {{.*}} @known_load_sink_example_1
+int known_load_sink_example_1(struct bpf_sockopt *ctx)
+{
+  unsigned g = 0;
+  switch (ctx->level) {
+//  MID:      [[entry:[a-zA-Z0-9._]+]]:
+//  MID:        [[r0:%[a-zA-Z0-9._]+]] = load i64, ptr @"llvm.bpf_sockopt:0:8$0:1"
+//  MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = tail call ptr @llvm.bpf.passthrough.p0.p0({{.*}}, ptr %ctx)
+//  MID-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//  MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(i8) [[r1]], i1 false, i8 0, i8 1, i8 3, i1 false, i64 [[r0]])
+//  MID-NEXT:   switch i32 [[r2]], label {{.*}} [
+//  MID-NEXT:     i32 10, label
+//  MID-NEXT:     i32 20, label
+//  MID-NEXT:   ]
+
+  case 10:
+    g = magic2(ctx->sk->family);
+    break;
+//  MID:      {{.*}}:
+//  MID-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load i64, ptr @"llvm.bpf_sockopt:0:0$0:0"
+//  MID-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = tail call ptr @llvm.bpf.passthrough.p0.p0({{.*}}, ptr %ctx)
+//  MID-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = tail call ptr (ptr, i1, i8, i8, i8, i1, ...)
+//  MID-SAME:     @llvm.bpf.getelementptr.and.load.p0(ptr elementtype(i8) [[r4]], i1 false, i8 0, i8 1, i8 3, i1 false, i64 [[r3]])
+//  MID-NEXT:   [[r6:%[a-zA-Z0-9._]+]] = load i64, ptr @"llvm.bpf_sock:0:4$0:1"
+//  MID-NEXT:   [[r7:%[a-zA-Z0-9._]+]] = tail call ptr @llvm.bpf.passthrough.p0.p0({{.*}}, ptr [[r5]])
+//  MID-NEXT:   [[r8:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//  MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(i8) [[r7]], i1 false, i8 0, i8 1, i8 2, i1 false, i64 [[r6]])
+//  MID:        br label
+
+  case 20:
+    g = magic2(ctx->optlen);
+    break;
+//  MID:      {{.*}}:
+//  MID-NEXT:   [[r9:%[a-zA-Z0-9._]+]] = load i64, ptr @"llvm.bpf_sockopt:0:12$0:2"
+//  MID-NEXT:   [[r10:%[a-zA-Z0-9._]+]] = tail call ptr @llvm.bpf.passthrough.p0.p0({{.*}}, ptr %ctx)
+//  MID-NEXT:   [[r11:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//  MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(i8) [[r10]], i1 false, i8 0, i8 1, i8 2, i1 false, i64 [[r9]])
+//  MID:        br label
+
+//  MID:      {{.*}}:
+//  MID-NEXT:   [[_sink:%[a-zA-Z0-9._]+]] = phi
+//  MID-NEXT:   [[call2:%[a-zA-Z0-9._]+]] = tail call i32 @magic2(i32 noundef [[_sink]])
+//  MID-NEXT:   [[phi_bo:%[a-zA-Z0-9._]+]] = and i32 [[call2]], 1
+//  MID-NEXT:   br label
+  }
+
+//  MID:      {{.*}}:
+//  MID-NEXT:   [[g_0:%[a-zA-Z0-9._]+]] = phi
+//  MID:        ret i32 [[g_0]]
+  return g % 2;
+}

clang/test/CodeGen/bpf-decl-tag-ctx-required.c

+// Check that passes handling __attribute__((btf_decl_tag("ctx"))) are
+// executed when -O0 is specified
+
+// RUN: %clang -target bpf -O0 -S -emit-llvm %s -o - |  \
+// RUN:        FileCheck %s
+
+#define __ctx__ __attribute__((btf_decl_tag("ctx")))
+
+extern void consume_int(int);
+
+struct foo {
+  int a;
+  int b;
+} __ctx__;
+
+struct bar {
+  int _;
+  struct foo foo;
+} __ctx__;
+
+void testfn(struct bar *ctx) {
+  consume_int(ctx->foo.b);
+// CHECK:        [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// CHECK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call i32 (ptr, i1, i8, i8, i8, i1, ...)
+// CHECK-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(%struct.bar) [[r0]], i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 1, i32 1)
+// CHECK-NEXT:   call void @consume_int(i32 noundef [[r1]])
+
+  ctx->foo.b = 7;
+// CHECK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// CHECK-NEXT:   call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+// CHECK-SAME:     @llvm.bpf.getelementptr.and.store.i32(i32 7, ptr elementtype(%struct.bar) [[r0]], i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 1, i32 1)
+}

clang/test/CodeGen/bpf-decl-tag-ctx.c

+// This test covers various usages of __attribute__((btf_decl_tag("ctx"))).
+// This attribute is handled in three stages:
+// - context.marker intrinsic call is added while IR is generated from AST
+// - context.marker call is replaced with calls to either:
+//   llvm.bpf.getelementptr.and.load intrinsic, or
+//   llvm.bpf.getelementptr.and.store intrinsic
+//   at the early IR processing stage
+// - get and load/store intrinsics are lowered at the late IR processing stage
+//
+// The test verifies all three stages using three separate RUN commands.
+//
+// First, check that calls to context.marker intrinsic are inserted
+// where expected:
+//
+// RUN: %clang -target bpf -Xclang -disable-llvm-passes -S -emit-llvm -o - %s | \
+// RUN:        FileCheck -check-prefix=FRONT %s
+//
+// Next, check that gep_and_load/store calls were generated:
+//
+// RUN: %clang -target bpf -O2 -S -emit-llvm -o - %s | \
+// RUN:        FileCheck -check-prefix=MID %s
+//
+// Finally, verify that gep_and_load/store calls were rewritten:
+//
+// RUN: %clang -mllvm --print-after=bpf-check-and-opt-ir \
+// RUN:        -mllvm --stop-after=bpf-check-and-opt-ir \
+// RUN:        -target bpf -S -O2 -o /dev/null 2>&1 %s | \
+// RUN:        FileCheck -check-prefix=BACK %s
+
+#define __ctx__ __attribute__((btf_decl_tag("ctx")))
+#define __preserve_access_index__ __attribute__((preserve_access_index))
+
+struct inner_no_vof {
+  int a;
+  int b;
+};
+
+struct inner_vof {
+  int a;
+  int b;
+} __ctx__;
+
+struct context1 {
+   int first;
+   struct inner_no_vof inner_inline;
+   struct inner_no_vof *inner_ptr;
+   int butlast;
+   int last;
+} __ctx__;
+
+struct context2 {
+   int first;
+   struct inner_vof inner_inline;
+   struct inner_vof *inner_ptr;
+   int butlast;
+   int last;
+} __ctx__;
+
+extern void consume_int(int);
+extern void consume_float(float);
+extern void consume_ptr(void *);
+
+// FRONT-LABEL: define dso_local void @fields_access_1
+//   MID-LABEL: define dso_local void @fields_access_1
+//  BACK-LABEL: define dso_local void @fields_access_1
+void fields_access_1(struct context1 *ctx) {
+  consume_int(ctx->first);
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr [[r1]], i32 0, i32 0
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load i32, ptr [[r2]]
+// FRONT-NEXT:   call void @consume_int(i32 noundef [[r3]])
+
+//   MID:        [[r0:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:      @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(%struct.context1) %ctx, i1 false, i8 0, i8 1, i8 3, i1 true, i32 0, i32 0)
+//   MID-NEXT:   tail call void @consume_int(i32 noundef [[r0]])
+
+//  BACK:        [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr %ctx, i32 0, i32 0
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load i32, ptr [[r0]]
+//  BACK-NEXT:   tail call void @consume_int(i32 noundef [[r1]])
+
+  consume_int(ctx->inner_inline.a);
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr [[r1]], i32 0, i32 1
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r2]], i32 0, i32 0
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = load i32, ptr [[r3]]
+// FRONT-NEXT:   call void @consume_int(i32 noundef [[r4]])
+
+//   MID-NEXT:    [[a:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:      @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(%struct.context1) %ctx, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 1, i32 0)
+//   MID-NEXT:    tail call void @consume_int(i32 noundef [[a]])
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr %ctx, i32 0, i32 1, i32 0
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load i32, ptr [[r0]]
+//  BACK-NEXT:   tail call void @consume_int(i32 noundef [[r1]])
+
+  consume_int(ctx->inner_inline.b);
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr [[r1]], i32 0, i32 1
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r2]], i32 0, i32 1
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = load i32, ptr [[r3]]
+// FRONT-NEXT:   call void @consume_int(i32 noundef [[r4]])
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(%struct.context1) %ctx, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 1, i32 1)
+//   MID-NEXT:   tail call void @consume_int(i32 noundef [[r0]])
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr %ctx, i32 0, i32 1, i32 1
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load i32, ptr [[r0]]
+//  BACK-NEXT:   tail call void @consume_int(i32 noundef [[r1]])
+
+  consume_int(ctx->inner_ptr->a);
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr [[r1]], i32 0, i32 2
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r2]]
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r3]], i32 0, i32 0
+// FRONT-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = load i32, ptr [[r4]]
+// FRONT-NEXT:   call void @consume_int(i32 noundef [[r5]])
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = tail call ptr (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:      @llvm.bpf.getelementptr.and.load.p0(ptr elementtype(%struct.context1) %ctx, i1 false, i8 0, i8 1, i8 3, i1 true, i32 0, i32 2)
+//   MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load i32, ptr [[r0]]
+//   MID-NEXT:   tail call void @consume_int(i32 noundef [[r1]])
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr %ctx, i32 0, i32 2
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r0]]
+//  BACK-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = load i32, ptr [[r1]]
+//  BACK-NEXT:   tail call void @consume_int(i32 noundef [[r2]])
+
+  consume_int(ctx->inner_ptr->b);
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr [[r1]], i32 0, i32 2
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r2]]
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r3]], i32 0, i32 1
+// FRONT-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = load i32, ptr [[r4]]
+// FRONT-NEXT:   call void @consume_int(i32 noundef [[r5]])
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = tail call ptr (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:      @llvm.bpf.getelementptr.and.load.p0(ptr elementtype(%struct.context1) %ctx, i1 false, i8 0, i8 1, i8 3, i1 true, i32 0, i32 2)
+//   MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r0]], i64 0, i32 1
+//   MID-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = load i32, ptr [[r1]]
+//   MID-NEXT:   tail call void @consume_int(i32 noundef [[r2]])
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr %ctx, i32 0, i32 2
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r0]]
+//  BACK-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r1]], i64 0, i32 1
+//  BACK-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load i32, ptr [[r2]]
+//  BACK-NEXT:   tail call void @consume_int(i32 noundef [[r3]])
+
+  ctx->first = 1;
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr [[r1]], i32 0, i32 0
+// FRONT-NEXT:   store i32 1, ptr [[r2]]
+
+//   MID-NEXT:   tail call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:      @llvm.bpf.getelementptr.and.store.i32(i32 1, ptr elementtype(%struct.context1) %ctx, i1 false, i8 0, i8 1, i8 3, i1 true, i32 0, i32 0)
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr %ctx, i32 0, i32 0
+//  BACK-NEXT:   store i32 1, ptr [[r0]]
+
+  ctx->inner_inline.a = 2;
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr [[r1]], i32 0, i32 1
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r2]], i32 0, i32 0
+// FRONT-NEXT:   store i32 2, ptr [[r3]]
+
+//   MID-NEXT:   tail call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.store.i32(i32 2, ptr elementtype(%struct.context1) %ctx, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 1, i32 0)
+
+//  BACK-NEXT:   [[r0:%[0-9]+]] = getelementptr inbounds %struct.context1, ptr %ctx, i32 0, i32 1, i32 0
+//  BACK-NEXT:   store i32 2, ptr [[r0]]
+
+  ctx->inner_inline.b = 3;
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr [[r1]], i32 0, i32 1
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r2]], i32 0, i32 1
+// FRONT-NEXT:   store i32 3, ptr [[r3]]
+
+//   MID-NEXT:   tail call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.store.i32(i32 3, ptr elementtype(%struct.context1) %ctx, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 1, i32 1)
+
+//  BACK-NEXT:   [[r0:%[0-9]+]] = getelementptr inbounds %struct.context1, ptr %ctx, i32 0, i32 1, i32 1
+//  BACK-NEXT:   store i32 3, ptr [[r0]]
+
+  ctx->inner_ptr->a = 4;
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr [[r1]], i32 0, i32 2
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r2]]
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r3]], i32 0, i32 0
+// FRONT-NEXT:   store i32 4, ptr [[r4]]
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = tail call ptr (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:      @llvm.bpf.getelementptr.and.load.p0(ptr elementtype(%struct.context1) %ctx, i1 false, i8 0, i8 1, i8 3, i1 true, i32 0, i32 2)
+//   MID-NEXT:   store i32 4, ptr [[r0]]
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr %ctx, i32 0, i32 2
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r0]]
+//  BACK-NEXT:   store i32 4, ptr [[r1]]
+
+  ctx->inner_ptr->b = 5;
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr [[r1]], i32 0, i32 2
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r2]]
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r3]], i32 0, i32 1
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = tail call ptr (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:      @llvm.bpf.getelementptr.and.load.p0(ptr elementtype(%struct.context1) %ctx, i1 false, i8 0, i8 1, i8 3, i1 true, i32 0, i32 2)
+//   MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r0]], i64 0, i32 1
+//   MID-NEXT:   store i32 5, ptr [[r1]]
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr %ctx, i32 0, i32 2
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r0]]
+//  BACK-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r1]], i64 0, i32 1
+//  BACK-NEXT:   store i32 5, ptr [[r2]]
+
+  consume_ptr(ctx);
+// FRONT:   ret void
+//   MID:   ret void
+//  BACK:   ret void
+}
+
+// FRONT-LABEL: define dso_local void @fields_access_2
+//   MID-LABEL: define dso_local void @fields_access_2
+//  BACK-LABEL-LABEL: define dso_local void @fields_access_2
+void fields_access_2(struct context2 *ctx) {
+  consume_int(ctx->inner_inline.a);
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context2, ptr [[r1]], i32 0, i32 1
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r2]])
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_vof, ptr [[r3]], i32 0, i32 0
+// FRONT-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = load i32, ptr [[r4]]
+// FRONT-NEXT:   call void @consume_int(i32 noundef [[r5]])
+
+//   MID:        [[r0:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(%struct.context2) %ctx, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 1, i32 0)
+//   MID-NEXT:   tail call void @consume_int(i32 noundef [[r0]])
+
+//  BACK:        [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context2, ptr %ctx, i32 0, i32 1, i32 0
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load i32, ptr [[r0]]
+//  BACK-NEXT:   tail call void @consume_int(i32 noundef [[r1]])
+
+  consume_int(ctx->inner_inline.b);
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context2, ptr [[r1]], i32 0, i32 1
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r2]])
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_vof, ptr [[r3]], i32 0, i32 1
+// FRONT-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = load i32, ptr [[r4]]
+// FRONT-NEXT:   call void @consume_int(i32 noundef [[r5]])
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(%struct.context2) %ctx, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 1, i32 1)
+//   MID-NEXT:   tail call void @consume_int(i32 noundef [[r0]])
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context2, ptr %ctx, i32 0, i32 1, i32 1
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load i32, ptr [[r0]]
+//  BACK-NEXT:   tail call void @consume_int(i32 noundef [[r1]])
+
+  consume_int(ctx->inner_ptr->a);
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context2, ptr [[r1]], i32 0, i32 2
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r2]]
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r3]])
+// FRONT-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_vof, ptr [[r4]], i32 0, i32 0
+// FRONT-NEXT:   [[r6:%[a-zA-Z0-9._]+]] = load i32, ptr [[r5]]
+// FRONT-NEXT:   call void @consume_int(i32 noundef [[r6]])
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = tail call ptr (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.p0(ptr elementtype(%struct.context2) %ctx, i1 false, i8 0, i8 1, i8 3, i1 true, i32 0, i32 2)
+//   MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(%struct.inner_vof) [[r0]], i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 0)
+//   MID-NEXT:   tail call void @consume_int(i32 noundef [[r1]])
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context2, ptr %ctx, i32 0, i32 2
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r0]]
+//  BACK-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_vof, ptr [[r1]], i32 0, i32 0
+//  BACK-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load i32, ptr [[r2]]
+//  BACK-NEXT:   tail call void @consume_int(i32 noundef [[r3]])
+
+  consume_int(ctx->inner_ptr->b);
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context2, ptr [[r1]], i32 0, i32 2
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r2]]
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r3]])
+// FRONT-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_vof, ptr [[r4]], i32 0, i32 1
+// FRONT-NEXT:   [[r6:%[a-zA-Z0-9._]+]] = load i32, ptr [[r5]]
+// FRONT-NEXT:   call void @consume_int(i32 noundef [[r6]])
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = tail call ptr (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.p0(ptr elementtype(%struct.context2) %ctx, i1 false, i8 0, i8 1, i8 3, i1 true, i32 0, i32 2)
+//   MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(%struct.inner_vof) [[r0]], i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 1)
+//   MID-NEXT:   tail call void @consume_int(i32 noundef [[r1]])
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context2, ptr %ctx, i32 0, i32 2
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r0]]
+//  BACK-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_vof, ptr [[r1]], i32 0, i32 1
+//  BACK-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load i32, ptr [[r2]]
+//  BACK-NEXT:   tail call void @consume_int(i32 noundef [[r3]])
+
+  ctx->inner_inline.a = 2;
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context2, ptr [[r1]], i32 0, i32 1
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r2]])
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_vof, ptr [[r3]], i32 0, i32 0
+// FRONT-NEXT:   store i32 2, ptr [[r4]]
+
+//   MID-NEXT:   tail call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.store.i32(i32 2, ptr elementtype(%struct.context2) %ctx, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 1, i32 0)
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context2, ptr %ctx, i32 0, i32 1, i32 0
+//  BACK-NEXT:   store i32 2, ptr [[r0]]
+
+  ctx->inner_inline.b = 3;
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context2, ptr [[r1]], i32 0, i32 1
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r2]])
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_vof, ptr [[r3]], i32 0, i32 1
+// FRONT-NEXT:   store i32 3, ptr [[r4]]
+
+//   MID-NEXT:   tail call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.store.i32(i32 3, ptr elementtype(%struct.context2) %ctx, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 1, i32 1)
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context2, ptr %ctx, i32 0, i32 1, i32 1
+//  BACK-NEXT:   store i32 3, ptr [[r0]]
+
+  ctx->inner_ptr->a = 4;
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context2, ptr [[r1]], i32 0, i32 2
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r2]]
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r3]])
+// FRONT-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_vof, ptr [[r4]], i32 0, i32 0
+// FRONT-NEXT:   store i32 4, ptr [[r5]]
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = tail call ptr (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.p0(ptr elementtype(%struct.context2) %ctx, i1 false, i8 0, i8 1, i8 3, i1 true, i32 0, i32 2)
+//   MID-NEXT:   tail call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.store.i32(i32 4, ptr elementtype(%struct.inner_vof) [[r0]], i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 0)
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context2, ptr %ctx, i32 0, i32 2
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r0]]
+//  BACK-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_vof, ptr [[r1]], i32 0, i32 0
+//  BACK-NEXT:   store i32 4, ptr [[r2]]
+
+  ctx->inner_ptr->b = 5;
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context2, ptr [[r1]], i32 0, i32 2
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r2]]
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r3]])
+// FRONT-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_vof, ptr [[r4]], i32 0, i32 1
+// FRONT-NEXT:   store i32 5, ptr [[r5]]
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = tail call ptr (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.p0(ptr elementtype(%struct.context2) %ctx, i1 false, i8 0, i8 1, i8 3, i1 true, i32 0, i32 2)
+//   MID-NEXT:   tail call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.store.i32(i32 5, ptr elementtype(%struct.inner_vof) [[r0]], i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 1)
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context2, ptr %ctx, i32 0, i32 2
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r0]]
+//  BACK-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_vof, ptr [[r1]], i32 0, i32 1
+//  BACK-NEXT:   store i32 5, ptr [[r2]]
+
+  consume_ptr(ctx);
+// FRONT:   ret void
+//   MID:   ret void
+//  BACK:   ret void
+}
+
+// FRONT-LABEL: define dso_local void @pointer_access_not_affected_1
+//   MID-LABEL: define dso_local void @pointer_access_not_affected_1
+//  BACK-LABEL: define dso_local void @pointer_access_not_affected_1
+void pointer_access_not_affected_1(struct context1 *ctx) {
+  consume_ptr(&ctx->inner_inline);
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr [[r1]], i32 0, i32 1
+// FRONT-NEXT:   call void @consume_ptr(ptr noundef [[r2]])
+
+//   MID:        [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr %ctx, i64 0, i32 1
+//   MID-NEXT:   tail call void @consume_ptr(ptr noundef nonnull [[r0]])
+
+//  BACK:        [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr %ctx, i64 0, i32 1
+//  BACK-NEXT:   tail call void @consume_ptr(ptr noundef nonnull [[r0]])
+
+  consume_ptr(&ctx->inner_inline.b);
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr [[r1]], i32 0, i32 1
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r2]], i32 0, i32 1
+// FRONT-NEXT:   call void @consume_ptr(ptr noundef [[r3]])
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr %ctx, i64 0, i32 1, i32 1
+//   MID-NEXT:   tail call void @consume_ptr(ptr noundef nonnull [[r0]])
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr %ctx, i64 0, i32 1, i32 1
+//  BACK-NEXT:   tail call void @consume_ptr(ptr noundef nonnull [[r0]])
+
+  consume_ptr(&ctx->inner_ptr);
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr [[r1]], i32 0, i32 2
+// FRONT-NEXT:   call void @consume_ptr(ptr noundef [[r2]])
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr %ctx, i64 0, i32 2
+//   MID-NEXT:   tail call void @consume_ptr(ptr noundef nonnull [[r0]])
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr %ctx, i64 0, i32 2
+//  BACK-NEXT:   tail call void @consume_ptr(ptr noundef nonnull [[r0]])
+
+  consume_ptr(&ctx->inner_ptr->b);
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr [[r1]], i32 0, i32 2
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r2]]
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r3]], i32 0, i32 1
+// FRONT-NEXT:   call void @consume_ptr(ptr noundef [[r4]])
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = tail call ptr (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.p0(ptr elementtype(%struct.context1) %ctx, i1 false, i8 0, i8 1, i8 3, i1 true, i32 0, i32 2)
+//   MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r0]], i64 0, i32 1
+//   MID-NEXT:   tail call void @consume_ptr(ptr noundef nonnull [[r1]])
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr %ctx, i32 0, i32 2
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r0]]
+//  BACK-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r1]], i64 0, i32 1
+//  BACK-NEXT:   tail call void @consume_ptr(ptr noundef nonnull [[r2]])
+
+  consume_ptr(&ctx->last);
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr [[r1]], i32 0, i32 4
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr %ctx, i64 0, i32 4
+//   MID-NEXT:   tail call void @consume_ptr(ptr noundef nonnull [[r0]])
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context1, ptr %ctx, i64 0, i32 4
+//  BACK-NEXT:   tail call void @consume_ptr(ptr noundef nonnull [[r0]])
+
+//  FRONT:   ret void
+//    MID:   ret void
+//   BACK:   ret void
+}
+
+// FRONT-LABEL: define dso_local void @pointer_access_not_affected_2
+//   MID-LABEL: define dso_local void @pointer_access_not_affected_2
+//  BACK-LABEL: define dso_local void @pointer_access_not_affected_2
+void pointer_access_not_affected_2(struct context2 *ctx) {
+  consume_ptr(&ctx->inner_inline);
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context2, ptr [[r1]], i32 0, i32 1
+// FRONT-NEXT:   call void @consume_ptr(ptr noundef [[r2]])
+
+//   MID:        [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context2, ptr %ctx, i64 0, i32 1
+//   MID-NEXT:   tail call void @consume_ptr(ptr noundef nonnull [[r0]])
+
+//  BACK:        [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context2, ptr %ctx, i64 0, i32 1
+//  BACK-NEXT:   tail call void @consume_ptr(ptr noundef nonnull [[r0]])
+
+  consume_ptr(&ctx->inner_inline.b);
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context2, ptr [[r1]], i32 0, i32 1
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r2]])
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_vof, ptr [[r3]], i32 0, i32 1
+// FRONT-NEXT:   call void @consume_ptr(ptr noundef [[r4]])
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context2, ptr %ctx, i64 0, i32 1, i32 1
+//   MID-NEXT:   tail call void @consume_ptr(ptr noundef nonnull [[r0]])
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context2, ptr %ctx, i64 0, i32 1, i32 1
+//  BACK-NEXT:   tail call void @consume_ptr(ptr noundef nonnull [[r0]])
+
+  consume_ptr(&ctx->inner_ptr);
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context2, ptr [[r1]], i32 0, i32 2
+// FRONT-NEXT:   call void @consume_ptr(ptr noundef [[r2]])
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context2, ptr %ctx, i64 0, i32 2
+//   MID-NEXT:   tail call void @consume_ptr(ptr noundef nonnull [[r0]])
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context2, ptr %ctx, i64 0, i32 2
+//  BACK-NEXT:   tail call void @consume_ptr(ptr noundef nonnull [[r0]])
+
+  consume_ptr(&ctx->inner_ptr->b);
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context2, ptr [[r1]], i32 0, i32 2
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r2]]
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r3]])
+// FRONT-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_vof, ptr [[r4]], i32 0, i32 1
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = tail call ptr (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.p0(ptr elementtype(%struct.context2) %ctx, i1 false, i8 0, i8 1, i8 3, i1 true, i32 0, i32 2)
+//   MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_vof, ptr [[r0]], i64 0, i32 1
+//   MID-NEXT:   tail call void @consume_ptr(ptr noundef nonnull [[r1]])
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context2, ptr %ctx, i32 0, i32 2
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r0]]
+//  BACK-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_vof, ptr [[r1]], i64 0, i32 1
+//  BACK-NEXT:   tail call void @consume_ptr(ptr noundef nonnull [[r2]])
+
+// FRONT:   ret void
+//   MID:   ret void
+//  BACK:   ret void
+}
+
+struct context3 {
+  int first;
+  struct inner_no_vof *no_vof_ptr;
+  struct inner_no_vof  no_vof_arr[5];
+  struct inner_no_vof *no_vof_arr_ptr[7];
+  struct inner_vof *vof_ptr;
+  struct inner_vof  vof_arr[5];
+  struct inner_vof *vof_arr_ptr[7];
+  int arr[4];
+} __ctx__;
+
+// FRONT-LABEL: define dso_local void @array_access
+//   MID-LABEL: define dso_local void @array_access
+//  BACK-LABEL: define dso_local void @array_access
+void array_access(struct context3 *ctx) {
+  consume_int(ctx->no_vof_ptr[1].b);
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context3, ptr [[r1]], i32 0, i32 1
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r2]]
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r3]], i64 1
+// FRONT-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r4]], i32 0, i32 1
+// FRONT-NEXT:   [[r6:%[a-zA-Z0-9._]+]] = load i32, ptr [[r5]]
+// FRONT-NEXT:   call void @consume_int(i32 noundef [[r6]])
+
+//   MID:        [[r0:%[a-zA-Z0-9._]+]] = tail call ptr (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.p0(ptr elementtype(%struct.context3) %ctx, i1 false, i8 0, i8 1, i8 3, i1 true, i32 0, i32 1)
+//   MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r0]], i64 1, i32 1
+//   MID-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = load i32, ptr [[r1]]
+//   MID-NEXT:   tail call void @consume_int(i32 noundef [[r2]])
+
+//  BACK:        [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context3, ptr %ctx, i32 0, i32 1
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r0]]
+//  BACK-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r1]], i64 1, i32 1
+//  BACK-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load i32, ptr [[r2]]
+//  BACK-NEXT:   tail call void @consume_int(i32 noundef [[r3]])
+
+  consume_int(ctx->no_vof_arr[2].b);
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context3, ptr [[r1]], i32 0, i32 2
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = getelementptr inbounds [5 x %struct.inner_no_vof], ptr [[r2]], i64 0, i64 2
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r3]], i32 0, i32 1
+// FRONT-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = load i32, ptr [[r4]]
+// FRONT-NEXT:   call void @consume_int(i32 noundef [[r5]])
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(%struct.context3) %ctx, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 2, i64 2, i32 1)
+//   MID-NEXT:   tail call void @consume_int(i32 noundef [[r0]])
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context3, ptr %ctx, i32 0, i32 2, i64 2, i32 1
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load i32, ptr [[r0]]
+//  BACK-NEXT:   tail call void @consume_int(i32 noundef [[r1]])
+
+  consume_int(ctx->no_vof_arr_ptr[3]->a);
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context3, ptr [[r1]], i32 0, i32 3
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = getelementptr inbounds [7 x ptr], ptr [[r2]], i64 0, i64 3
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r3]]
+// FRONT-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r4]], i32 0, i32 0
+// FRONT-NEXT:   [[r6:%[a-zA-Z0-9._]+]] = load i32, ptr [[r5]]
+// FRONT-NEXT:   call void @consume_int(i32 noundef [[r6]])
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = tail call ptr (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.p0(ptr elementtype(%struct.context3) %ctx, i1 false, i8 0, i8 1, i8 3, i1 true, i32 0, i32 3, i64 3)
+//   MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load i32, ptr [[r0]]
+//   MID-NEXT:   tail call void @consume_int(i32 noundef [[r1]])
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context3, ptr %ctx, i32 0, i32 3, i64 3
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r0]]
+//  BACK-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = load i32, ptr [[r1]]
+//  BACK-NEXT:   tail call void @consume_int(i32 noundef [[r2]])
+
+  consume_int(ctx->vof_ptr[1].b);
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context3, ptr [[r1]], i32 0, i32 4
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r2]]
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r3]])
+// FRONT-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_vof, ptr [[r4]], i64 1
+// FRONT-NEXT:   [[r6:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r5]])
+// FRONT-NEXT:   [[r7:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_vof, ptr [[r6]], i32 0, i32 1
+// FRONT-NEXT:   [[r8:%[a-zA-Z0-9._]+]] = load i32, ptr [[r7]]
+// FRONT-NEXT:   call void @consume_int(i32 noundef [[r8]])
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = tail call ptr (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.p0(ptr elementtype(%struct.context3) %ctx, i1 false, i8 0, i8 1, i8 3, i1 true, i32 0, i32 4)
+//   MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(%struct.inner_vof) [[r0]], i1 false, i8 0, i8 1, i8 2, i1 true, i64 1, i32 1)
+//   MID-NEXT:   tail call void @consume_int(i32 noundef [[r1]])
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr  inbounds %struct.context3, ptr %ctx, i32 0, i32 4
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r0]]
+//  BACK-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_vof, ptr [[r1]], i64 1, i32 1
+//  BACK-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load i32, ptr [[r2]]
+//  BACK-NEXT:   tail call void @consume_int(i32 noundef [[r3]])
+
+  consume_int(ctx->vof_arr[2].b);
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context3, ptr [[r1]], i32 0, i32 5
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r2]])
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = getelementptr inbounds [5 x %struct.inner_vof], ptr [[r3]], i64 0, i64 2
+// FRONT-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r4]])
+// FRONT-NEXT:   [[r6:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_vof, ptr [[r5]], i32 0, i32 1
+// FRONT-NEXT:   [[r7:%[a-zA-Z0-9._]+]] = load i32, ptr [[r6]]
+// FRONT-NEXT:   call void @consume_int(i32 noundef [[r7]])
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(%struct.context3) %ctx, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 5, i64 2, i32 1)
+//   MID-NEXT:   tail call void @consume_int(i32 noundef [[r0]])
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr  inbounds %struct.context3, ptr %ctx, i32 0, i32 5, i64 2, i32 1
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load i32, ptr [[r0]]
+//  BACK-NEXT:   tail call void @consume_int(i32 noundef [[r1]])
+
+  consume_int(ctx->vof_arr_ptr[3]->b);
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context3, ptr [[r1]], i32 0, i32 6
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = getelementptr inbounds [7 x ptr], ptr [[r2]], i64 0, i64 3
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r3]]
+// FRONT-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r4]])
+// FRONT-NEXT:   [[r6:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_vof, ptr [[r5]], i32 0, i32 1
+// FRONT-NEXT:   [[r7:%[a-zA-Z0-9._]+]] = load i32, ptr [[r6]]
+// FRONT-NEXT:   call void @consume_int(i32 noundef [[r7]])
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = tail call ptr (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.p0(ptr elementtype(%struct.context3) %ctx, i1 false, i8 0, i8 1, i8 3, i1 true, i32 0, i32 6, i64 3)
+//   MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(%struct.inner_vof) [[r0]], i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 1)
+//   MID-NEXT:   tail call void @consume_int(i32 noundef [[r1]])
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr  inbounds %struct.context3, ptr %ctx, i32 0, i32 6, i64 3
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r0]]
+//  BACK-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr  inbounds %struct.inner_vof, ptr [[r1]], i32 0, i32 1
+//  BACK-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load i32, ptr [[r2]]
+//  BACK-NEXT:   tail call void @consume_int(i32 noundef [[r3]])
+
+  consume_int(ctx[12].arr[3]);
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context3, ptr [[r1]], i64 12
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r2]])
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context3, ptr [[r3]], i32 0, i32 7
+// FRONT-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = getelementptr inbounds [4 x i32], ptr [[r4]], i64 0, i64 3
+// FRONT-NEXT:   [[r6:%[a-zA-Z0-9._]+]] = load i32, ptr [[r5]]
+// FRONT-NEXT:   call void @consume_int(i32 noundef [[r6]])
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(%struct.context3) %ctx, i1 false, i8 0, i8 1, i8 2, i1 true, i64 12, i32 7, i64 3)
+//   MID-NEXT:   tail call void @consume_int(i32 noundef [[r0]])
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context3, ptr %ctx, i64 12, i32 7, i64 3
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load i32, ptr [[r0]]
+//  BACK-NEXT:   tail call void @consume_int(i32 noundef [[r1]])
+
+  ctx->no_vof_ptr[1].b = 2;
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context3, ptr [[r1]], i32 0, i32 1
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r2]]
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r3]], i64 1
+// FRONT-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r4]], i32 0, i32 1
+// FRONT-NEXT:   store i32 2, ptr [[r5]]
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = tail call ptr (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.p0(ptr elementtype(%struct.context3) %ctx, i1 false, i8 0, i8 1, i8 3, i1 true, i32 0, i32 1)
+//   MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r0]], i64 1, i32 1
+//   MID-NEXT:   store i32 2, ptr [[r1]]
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr  inbounds %struct.context3, ptr %ctx, i32 0, i32 1
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r0]]
+//  BACK-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r1]], i64 1, i32 1
+//  BACK-NEXT:   store i32 2, ptr [[r2]]
+
+  ctx->no_vof_arr[2].b = 4;
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context3, ptr [[r1]], i32 0, i32 2
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = getelementptr inbounds [5 x %struct.inner_no_vof], ptr [[r2]], i64 0, i64 2
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r3]], i32 0, i32 1
+// FRONT-NEXT:   store i32 4, ptr [[r4]]
+
+//   MID-NEXT:   tail call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.store.i32(i32 4, ptr elementtype(%struct.context3) %ctx, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 2, i64 2, i32 1)
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr  inbounds %struct.context3, ptr %ctx, i32 0, i32 2, i64 2, i32 1
+//  BACK-NEXT:   store i32 4, ptr [[r0]]
+
+  ctx->no_vof_arr_ptr[3]->b = 6;
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context3, ptr [[r1]], i32 0, i32 3
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = getelementptr inbounds [7 x ptr], ptr [[r2]], i64 0, i64 3
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r3]]
+// FRONT-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r4]], i32 0, i32 1
+// FRONT-NEXT:   store i32 6, ptr [[r5]]
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = tail call ptr (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.p0(ptr elementtype(%struct.context3) %ctx, i1 false, i8 0, i8 1, i8 3, i1 true, i32 0, i32 3, i64 3)
+//   MID-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r0]], i64 0, i32 1
+//   MID-NEXT:   store i32 6, ptr [[r1]]
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr  inbounds %struct.context3, ptr %ctx, i32 0, i32 3, i64 3
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r0]]
+//  BACK-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_no_vof, ptr [[r1]], i64 0, i32 1
+//  BACK-NEXT:   store i32 6, ptr [[r2]]
+
+  ctx->vof_ptr[1].b = 2;
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context3, ptr [[r1]], i32 0, i32 4
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r2]]
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r3]])
+// FRONT-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_vof, ptr [[r4]], i64 1
+// FRONT-NEXT:   [[r6:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r5]])
+// FRONT-NEXT:   [[r7:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_vof, ptr [[r6]], i32 0, i32 1
+// FRONT-NEXT:   store i32 2, ptr [[r7]]
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = tail call ptr (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.p0(ptr elementtype(%struct.context3) %ctx, i1 false, i8 0, i8 1, i8 3, i1 true, i32 0, i32 4)
+//   MID-NEXT:   tail call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.store.i32(i32 2, ptr elementtype(%struct.inner_vof) [[r0]], i1 false, i8 0, i8 1, i8 2, i1 true, i64 1, i32 1)
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr  inbounds %struct.context3, ptr %ctx, i32 0, i32 4
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r0]]
+//  BACK-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_vof, ptr [[r1]], i64 1, i32 1
+//  BACK-NEXT:   store i32 2, ptr [[r2]]
+
+  ctx->vof_arr[2].b = 4;
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context3, ptr [[r1]], i32 0, i32 5
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r2]])
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = getelementptr inbounds [5 x %struct.inner_vof], ptr [[r3]], i64 0, i64 2
+// FRONT-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r4]])
+// FRONT-NEXT:   [[r6:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_vof, ptr [[r5]], i32 0, i32 1
+// FRONT-NEXT:   store i32 4, ptr [[r6]]
+
+//   MID-NEXT:   tail call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.store.i32(i32 4, ptr elementtype(%struct.context3) %ctx, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 5, i64 2, i32 1)
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr  inbounds %struct.context3, ptr %ctx, i32 0, i32 5, i64 2, i32 1
+//  BACK-NEXT:   store i32 4, ptr [[r0]]
+
+  ctx->vof_arr_ptr[3]->b = 6;
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context3, ptr [[r1]], i32 0, i32 6
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = getelementptr inbounds [7 x ptr], ptr [[r2]], i64 0, i64 3
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r3]]
+// FRONT-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r4]])
+// FRONT-NEXT:   [[r6:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.inner_vof, ptr [[r5]], i32 0, i32 1
+// FRONT-NEXT:   store i32 6, ptr [[r6]]
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = tail call ptr (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.p0(ptr elementtype(%struct.context3) %ctx, i1 false, i8 0, i8 1, i8 3, i1 true, i32 0, i32 6, i64 3)
+//   MID-NEXT:   tail call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.store.i32(i32 6, ptr elementtype(%struct.inner_vof) [[r0]], i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 1)
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr  inbounds %struct.context3, ptr %ctx, i32 0, i32 6, i64 3
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load ptr, ptr [[r0]]
+//  BACK-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr  inbounds %struct.inner_vof, ptr [[r1]], i32 0, i32 1
+//  BACK-NEXT:   store i32 6, ptr [[r2]]
+
+  ctx[15].arr[3] = 22;
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context3, ptr [[r1]], i64 15
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r2]])
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context3, ptr [[r3]], i32 0, i32 7
+// FRONT-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = getelementptr inbounds [4 x i32], ptr [[r4]], i64 0, i64 3
+// FRONT-NEXT:   store i32 22, ptr [[r5]]
+
+//   MID-NEXT:   tail call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.store.i32(i32 22, ptr elementtype(%struct.context3) %ctx, i1 false, i8 0, i8 1, i8 2, i1 true, i64 15, i32 7, i64 3)
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context3, ptr %ctx, i64 15, i32 7, i64 3
+//  BACK-NEXT:   store i32 22, ptr [[r0]]
+
+  consume_ptr(ctx);
+
+// FRONT:   ret void
+//   MID:   ret void
+//  BACK:   ret void
+}
+
+typedef int aligned_int __attribute__((aligned(128)));
+
+struct context4 {
+  volatile int a;
+  aligned_int b;
+  volatile aligned_int c;
+} __ctx__;
+
+// FRONT-LABEL: define dso_local void @load_and_store_attrs
+//   MID-LABEL: define dso_local void @load_and_store_attrs
+//  BACK-LABEL: define dso_local void @load_and_store_attrs
+void load_and_store_attrs(struct context4 *ctx) {
+  int r;
+  consume_int(ctx->a);
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context4, ptr [[r1]], i32 0, i32 0
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load volatile i32, ptr [[r2]]
+// FRONT-NEXT:   call void @consume_int(i32 noundef [[r3]])
+
+//   MID:        [[r0:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:      @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(%struct.context4) %ctx, i1 true, i8 0, i8 1, i8 7, i1 true, i32 0, i32 0)
+//   MID-NEXT:   tail call void @consume_int(i32 noundef [[r0]])
+
+//  BACK:        [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context4, ptr %ctx, i32 0, i32 0
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load volatile i32, ptr [[r0]]
+//  BACK-NEXT:   tail call void @consume_int(i32 noundef [[r1]])
+
+  consume_int(ctx->b);
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context4, ptr [[r1]], i32 0, i32 2
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load i32, ptr [[r2]]
+// FRONT-NEXT:   call void @consume_int(i32 noundef [[r3]])
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:      @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(%struct.context4) %ctx, i1 false, i8 0, i8 1, i8 7, i1 true, i32 0, i32 2)
+//   MID-NEXT:   tail call void @consume_int(i32 noundef [[r0]])
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr  inbounds %struct.context4, ptr %ctx, i32 0, i32 2
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load i32, ptr [[r0]]
+//  BACK-NEXT:   tail call void @consume_int(i32 noundef [[r1]])
+
+  consume_int(ctx->c);
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context4, ptr [[r1]], i32 0, i32 4
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load volatile i32, ptr [[r2]]
+// FRONT-NEXT:   call void @consume_int(i32 noundef [[r3]])
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:      @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(%struct.context4) %ctx, i1 true, i8 0, i8 1, i8 7, i1 true, i32 0, i32 4)
+//   MID-NEXT:   tail call void @consume_int(i32 noundef [[r0]])
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context4, ptr %ctx, i32 0, i32 4
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load volatile i32, ptr [[r0]]
+//  BACK-NEXT:   tail call void @consume_int(i32 noundef [[r1]])
+
+  __atomic_load(&ctx->a, &r, 2);
+  consume_int(r);
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context4, ptr [[r1]], i32 0, i32 0
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load atomic volatile i32, ptr [[r2]] acquire
+// FRONT:   call void @consume_int
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:      @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(%struct.context4) %ctx, i1 true, i8 4, i8 1, i8 7, i1 true, i32 0, i32 0)
+//   MID-NEXT:   tail call void @consume_int(i32 noundef [[r0]])
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context4, ptr %ctx, i32 0, i32 0
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load atomic volatile i32, ptr [[r0]] acquire
+//  BACK-NEXT:   tail call void @consume_int(i32 noundef [[r1]])
+
+  ctx->a = 1;
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context4, ptr [[r1]], i32 0, i32 0
+// FRONT-NEXT:   store volatile i32 1, ptr [[r2]]
+
+//   MID-NEXT:   tail call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:      @llvm.bpf.getelementptr.and.store.i32(i32 1, ptr elementtype(%struct.context4) %ctx, i1 true, i8 0, i8 1, i8 7, i1 true, i32 0, i32 0)
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context4, ptr %ctx, i32 0, i32 0
+//  BACK-NEXT:   store volatile i32 1, ptr [[r0]]
+
+  ctx->b = 2;
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context4, ptr [[r1]], i32 0, i32 2
+// FRONT-NEXT:   store i32 2, ptr [[r2]]
+
+//   MID-NEXT:   tail call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:      @llvm.bpf.getelementptr.and.store.i32(i32 2, ptr elementtype(%struct.context4) %ctx, i1 false, i8 0, i8 1, i8 7, i1 true, i32 0, i32 2)
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr  inbounds %struct.context4, ptr %ctx, i32 0, i32 2
+//  BACK-NEXT:   store i32 2, ptr [[r0]]
+
+  ctx->c = 3;
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context4, ptr [[r1]], i32 0, i32 4
+// FRONT-NEXT:   store volatile i32 3, ptr [[r2]]
+
+//   MID-NEXT:   tail call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:      @llvm.bpf.getelementptr.and.store.i32(i32 3, ptr elementtype(%struct.context4) %ctx, i1 true, i8 0, i8 1, i8 7, i1 true, i32 0, i32 4)
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context4, ptr %ctx, i32 0, i32 4
+//  BACK-NEXT:   store volatile i32 3, ptr [[r0]]
+
+  r = 7;
+  __atomic_store(&ctx->a, &r, 3);
+// FRONT-NEXT:   store i32 7, ptr %r
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context4, ptr [[r1]], i32 0, i32 0
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load i32, ptr %r
+// FRONT-NEXT:   store atomic volatile i32 [[r3]], ptr [[r2]] release
+
+//   MID-NEXT:   tail call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:      @llvm.bpf.getelementptr.and.store.i32(i32 7, ptr elementtype(%struct.context4) %ctx, i1 true, i8 5, i8 1, i8 7, i1 true, i32 0, i32 0)
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context4, ptr %ctx, i32 0, i32 0
+//  BACK-NEXT:   store atomic volatile i32 7, ptr [[r0]] release
+//  BACK-NEXT:   tail call void @consume_ptr(ptr noundef %ctx)
+
+  consume_ptr(ctx);
+// FRONT:   ret void
+//   MID:   ret void
+//  BACK:   ret void
+}
+
+struct context5 {
+  union {
+    int a;
+    float b;
+  } u;
+} __ctx__;
+
+// FRONT-LABEL: define dso_local void @union_access
+//   MID-LABEL: define dso_local void @union_access
+//  BACK-LABEL: define dso_local void @union_access
+void union_access(struct context5 *ctx1, struct context5 *ctx2) {
+  consume_int(ctx1->u.a);
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr %ctx1.addr
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context5, ptr [[r1]], i32 0, i32 0
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load i32, ptr [[r2]]
+// FRONT-NEXT:   call void @consume_int(i32 noundef [[r3]])
+
+//   MID:        [[r0:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:      @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(%struct.context5) %ctx1, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 0)
+//   MID-NEXT:   tail call void @consume_int(i32 noundef [[r0]])
+
+//  BACK:        [[r0:%[a-zA-Z0-9._]+]] = getelementptr  inbounds %struct.context5, ptr %ctx1, i32 0, i32 0
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load i32, ptr [[r0]]
+//  BACK-NEXT:   tail call void @consume_int(i32 noundef [[r1]])
+
+  consume_float(ctx2->u.b);
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr %ctx2.addr
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context5, ptr [[r1]], i32 0, i32 0
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load float, ptr [[r2]]
+// FRONT-NEXT:   call void @consume_float(float noundef [[r3]])
+
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = tail call float (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:      @llvm.bpf.getelementptr.and.load.f32(ptr elementtype(%struct.context5) %ctx2, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 0)
+//   MID-NEXT:   tail call void @consume_float(float noundef [[r0]])
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr  inbounds %struct.context5, ptr %ctx2, i32 0, i32 0
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load float, ptr [[r0]]
+//  BACK-NEXT:   tail call void @consume_float(float noundef [[r1]])
+
+  ctx1->u.a = 2;
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr %ctx1.addr
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context5, ptr [[r1]], i32 0, i32 0
+// FRONT-NEXT:   store i32 2, ptr [[r2]]
+
+//   MID-NEXT:   tail call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:      @llvm.bpf.getelementptr.and.store.i32(i32 2, ptr elementtype(%struct.context5) %ctx1, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 0)
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr  inbounds %struct.context5, ptr %ctx1, i32 0, i32 0
+//  BACK-NEXT:   store i32 2, ptr [[r0]]
+
+  ctx2->u.b = 3.4f;
+// FRONT-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr %ctx2.addr
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context5, ptr [[r1]], i32 0, i32 0
+// FRONT-NEXT:   store float {{.*}}, ptr [[r2]]
+
+//   MID-NEXT:   tail call void (float, ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:      @llvm.bpf.getelementptr.and.store.f32(float {{.*}}, ptr elementtype(%struct.context5) %ctx2, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 0)
+
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = getelementptr  inbounds %struct.context5, ptr %ctx2, i32 0, i32 0
+//  BACK-NEXT:   store float {{.*}}, ptr [[r0]]
+
+  consume_ptr(ctx1);
+  consume_ptr(ctx2);
+// FRONT:   ret void
+//   MID:   ret void
+//  BACK:   ret void
+}
+
+// TODO: add an offset at the start!
+struct context6 {
+  unsigned _;
+  unsigned a:1;
+  unsigned b:2;
+} __ctx__;
+
+// FRONT-LABEL: define dso_local void @bitfield_access
+//   MID-LABEL: define dso_local void @bitfield_access
+//  BACK-LABEL: define dso_local void @bitfield_access
+void bitfield_access(struct context6 *ctx) {
+  consume_int(ctx->a);
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr {{.*}})
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context6, ptr [[r0]], i32 0, i32 1
+// FRONT-NEXT:   load i8, ptr [[r1]]
+// FRONT:        @consume_int
+
+//   MID:        tail call i8 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.i8(ptr elementtype(%struct.context6) %ctx, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 1)
+//   MID:        @consume_int
+
+//  BACK:        [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context6, ptr %ctx, i32 0, i32 1
+//  BACK:        load i8, ptr [[r0]]
+//  BACK:        @consume_int
+
+  consume_int(ctx->b);
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr {{.*}})
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context6, ptr [[r0]], i32 0, i32 1
+// FRONT-NEXT:   load i8, ptr [[r1]]
+// FRONT:        @consume_int
+
+//   MID:        [[r0:%[a-zA-Z0-9._]+]] = tail call i8 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.i8(ptr elementtype(%struct.context6) %ctx, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 1)
+//   MID:        @consume_int
+
+//  BACK:        [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context6, ptr %ctx, i32 0, i32 1
+//  BACK:        load i8, ptr [[r0]]
+//  BACK:        tail call void @consume_int
+
+  ctx->a = 1;
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr {{.*}})
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context6, ptr [[r0]], i32 0, i32 1
+// FRONT-NEXT:   load i8, ptr [[r1]]
+// FRONT:        store {{.*}}, ptr [[r1]]
+
+//   MID-NEXT:  tail call i8 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.i8(ptr elementtype(%struct.context6) %ctx, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 1)
+//   MID:       tail call void (i8, ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.store.i8(i8 {{.*}}, ptr elementtype(%struct.context6) %ctx, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 1)
+
+//  BACK:       [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context6, ptr %ctx, i32 0, i32 1
+//  BACK:       load i8, ptr [[r0]]
+//  BACK:       [[r1:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context6, ptr %ctx, i32 0, i32 1
+//  BACK:       store i8 {{.*}}, ptr [[r1]]
+
+  ctx->b = 2;
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr {{.*}})
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context6, ptr [[r0]], i32 0, i32 1
+// FRONT-NEXT:   load i8, ptr [[r1]]
+// FRONT:        store {{.*}}, ptr [[r1]]
+
+//   MID:       tail call i8 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.i8(ptr elementtype(%struct.context6) %ctx, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 1)
+//   MID:       tail call void (i8, ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.store.i8(i8 {{.*}}, ptr elementtype(%struct.context6) %ctx, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 1)
+
+//  BACK:       [[r0:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context6, ptr %ctx, i32 0, i32 1
+//  BACK:       load i8, ptr [[r0]]
+//  BACK:       [[r1:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.context6, ptr %ctx, i32 0, i32 1
+//  BACK:       store i8 {{.*}}, ptr [[r1]]
+
+  consume_ptr(ctx);
+// FRONT: ret void
+//   MID: ret void
+//  BACK: ret void
+}
+
+struct pattern_bug1 {
+  int src_port;
+  int dst_port;
+} __ctx__;
+
+// No need to check FRONT or BACK
+//   MID-LABEL: define dso_local i32 @pattern_bug1
+int pattern_bug1(struct pattern_bug1 *sk) {
+  int *port = &sk->dst_port;
+  return port[0] == 0x777;
+//   MID:        [[dst_port:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.pattern_bug1, ptr %sk, i64 0, i32 1
+//   MID-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load i32, ptr [[dst_port]]
+//   MID-NEXT:   [[cmp:%[a-zA-Z0-9._]+]] = icmp eq i32 [[r0]], 1911
+//   MID-NEXT:   [[conv:%[a-zA-Z0-9._]+]] = zext i1 [[cmp]] to i32
+//   MID-NEXT:   ret i32 [[conv]]
+}
+
+struct bpf_sock {
+  int bound_dev_if;
+  int family;
+} __ctx__;
+
+struct bpf_sockopt {
+  struct bpf_sock *sk;
+  int level;
+  int optlen;
+} __ctx__;
+
+extern int magic(void);
+extern int magic2(int);
+
+// The next test case is related to the issue described in the following thread:
+// https://lore.kernel.org/bpf/CAA-VZPmxh8o8EBcJ=[e-mail]/T/#m4b9ce2ce73b34f34172328f975235fc6f19841b6
+
+// FRONT-LABEL: define dso_local i32 @known_load_sink_example_1
+//   MID-LABEL: define dso_local i32 @known_load_sink_example_1
+//  BACK-LABEL: define dso_local i32 @known_load_sink_example_1
+int known_load_sink_example_1(struct bpf_sockopt *ctx)
+{
+  unsigned g = 0;
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[level:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.bpf_sockopt, ptr [[r1]], i32 0, i32 1
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = load i32, ptr [[level]]
+// FRONT-NEXT:   switch i32 [[r2]], label [[sw_epilog:%[a-zA-Z0-9._]+]] [
+// FRONT-NEXT:     i32 10, label [[sw_bb:%[a-zA-Z0-9._]+]]
+// FRONT-NEXT:     i32 20, label [[sw_bb1:%[a-zA-Z0-9._]+]]
+// FRONT-NEXT:   ]
+
+//   MID:        [[level3:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:      @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(%struct.bpf_sockopt) %ctx, i1 false, i8 0, i8 1, i8 3, i1 true, i32 0, i32 1)
+//   MID-NEXT:   switch i32 [[level3]], label [[sw_epilog:%[a-zA-Z0-9._]+]] [
+//   MID-NEXT:     i32 10, label [[sw_bb:%[a-zA-Z0-9._]+]]
+//   MID-NEXT:     i32 20, label [[sw_bb1:%[a-zA-Z0-9._]+]]
+//   MID-NEXT:   ]
+
+//  BACK:        [[level39:%[a-zA-Z0-9._]+]] = getelementptr  inbounds %struct.bpf_sockopt, ptr %ctx, i32 0, i32 1
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load i32, ptr [[level39]]
+//  BACK-NEXT:   switch i32 [[r0]], label [[sw_epilog:%[a-zA-Z0-9._]+]] [
+//  BACK-NEXT:     i32 10, label [[sw_bb:%[a-zA-Z0-9._]+]]
+//  BACK-NEXT:     i32 20, label [[sw_bb1:%[a-zA-Z0-9._]+]]
+//  BACK-NEXT:   ]
+  switch (ctx->level) {
+  case 10:
+    g = magic2(ctx->sk->family);
+    break;
+// FRONT:        [[r3:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r3]])
+// FRONT-NEXT:   [[sk:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.bpf_sockopt, ptr [[r4]], i32 0, i32 0
+// FRONT-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = load ptr, ptr [[sk]]
+// FRONT-NEXT:   [[r6:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r5]])
+// FRONT-NEXT:   [[family:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.bpf_sock, ptr [[r6]], i32 0, i32 1
+// FRONT-NEXT:   [[r7:%[a-zA-Z0-9._]+]] = load i32, ptr [[family]]
+// FRONT-NEXT:   [[call:%[a-zA-Z0-9._]+]] = call i32 @magic2(i32 noundef [[r7]])
+// FRONT-NEXT:   store i32 [[call]], ptr %g
+// FRONT-NEXT:   br label %sw.epilog
+
+//   MID:      sw.bb:
+//   MID-NEXT:   [[sk4:%[a-zA-Z0-9._]+]] = tail call ptr (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.p0(ptr elementtype(%struct.bpf_sockopt) %ctx, i1 false, i8 0, i8 1, i8 3, i1 true, i32 0, i32 0)
+//   MID-NEXT:   [[family5:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(%struct.bpf_sock) [[sk4]], i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 1)
+//   MID-NEXT:   br label [[sw_epilog_sink_split:%[a-zA-Z0-9._]+]]
+
+//  BACK:      sw.{{.*}}:
+//  BACK-NEXT:   [[sk410:%[a-zA-Z0-9._]+]] = getelementptr  inbounds %struct.bpf_sockopt, ptr %ctx, i32 0, i32 0
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load ptr, ptr [[sk410]]
+//  BACK-NEXT:   [[family511:%[a-zA-Z0-9._]+]] = getelementptr  inbounds %struct.bpf_sock, ptr [[r1]], i32 0, i32 1
+//  BACK-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = load i32, ptr [[family511]]
+//  BACK-NEXT:   br label %sw.epilog.sink.split
+
+  case 20:
+    g = magic2(ctx->optlen);
+    break;
+// FRONT:        [[r8:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r9:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r8]])
+// FRONT-NEXT:   [[optlen:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.bpf_sockopt, ptr [[r9]], i32 0, i32 2
+// FRONT-NEXT:   [[r10:%[a-zA-Z0-9._]+]] = load i32, ptr [[optlen]]
+// FRONT-NEXT:   [[call2:%[a-zA-Z0-9._]+]] = call i32 @magic2(i32 noundef [[r10]])
+// FRONT-NEXT:   store i32 [[call2]], ptr %g
+// FRONT-NEXT:   br label %sw.epilog
+
+//   MID:      sw.{{.*}}:
+//   MID-NEXT:   [[optlen6:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(%struct.bpf_sockopt) %ctx, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 2)
+//   MID-NEXT:   br label %sw.epilog.sink.split
+
+//  BACK:      sw.{{.*}}:
+//  BACK-NEXT:   [[optlen612:%[a-zA-Z0-9._]+]] = getelementptr  inbounds %struct.bpf_sockopt, ptr %ctx, i32 0, i32 2
+//  BACK-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load i32, ptr [[optlen612]]
+//  BACK-NEXT:   br label %sw.epilog.sink.split
+  }
+// FRONT:      sw.epilog:
+// FRONT-NEXT:   [[r11:%[a-zA-Z0-9._]+]] = load i32, ptr %g
+// FRONT-NEXT:   [[rem:%[a-zA-Z0-9._]+]] = urem i32 [[r11]], 2
+// FRONT:        ret i32 [[rem]]
+
+//   MID:      sw.epilog.sink.split:
+//   MID-NEXT:   [[optlen6_sink:%[a-zA-Z0-9._]+]] = phi i32 [ [[optlen6]], [[sw_bb1]] ], [ [[family5]], [[sw_bb]] ]
+//   MID-NEXT:   [[call2:%[a-zA-Z0-9._]+]] = tail call i32 @magic2(i32 noundef [[optlen6_sink]])
+//   MID-NEXT:   [[phi_bo:%[a-zA-Z0-9._]+]] = and i32 [[call2]], 1
+//   MID-NEXT:   br label %sw.epilog
+
+//   MID:      sw.epilog:
+//   MID-NEXT:   [[g_0:%[a-zA-Z0-9._]+]] = phi i32 [ 0, %entry ], [ %phi.bo, %sw.epilog.sink.split ]
+//   MID-NEXT:   ret i32 [[g_0]]
+
+//  BACK:      sw.epilog.sink.split:
+//  BACK-NEXT:   [[optlen6_sink:%[a-zA-Z0-9._]+]] = phi i32 [ [[r3]], [[sw_bb1]] ], [ [[r2]], [[sw_bb]] ]
+//  BACK-NEXT:   [[call2:%[a-zA-Z0-9._]+]] = tail call i32 @magic2(i32 noundef [[optlen6_sink]])
+//  BACK-NEXT:   [[phi_bo:%[a-zA-Z0-9._]+]] = and i32 [[call2]], 1
+//  BACK-NEXT:   br label %sw.epilog
+
+//  BACK:      sw.epilog:
+//  BACK-NEXT:   [[g_0:%[a-zA-Z0-9._]+]] = phi
+//  BACK-NEXT:   ret i32 [[g_0]]
+
+  return g % 2;
+}
+
+struct __sk_buff {
+  int priority;
+  int mark;
+  int tc_index;
+} __ctx__;
+
+// FRONT-LABEL: define dso_local i32 @known_store_sink_example_1
+//   MID-LABEL: define dso_local i32 @known_store_sink_example_1
+//  BACK-LABEL: define dso_local i32 @known_store_sink_example_1
+int known_store_sink_example_1(struct __sk_buff *ctx) {
+  switch (ctx->priority) {
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[priority:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.__sk_buff, ptr [[r1]], i32 0, i32 0
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = load i32, ptr [[priority]]
+// FRONT-NEXT:   switch i32 [[r2]], label [[sw_epilog:%[a-zA-Z0-9._]+]] [
+// FRONT-NEXT:     i32 10, label [[sw_bb:%[a-zA-Z0-9._]+]]
+// FRONT-NEXT:     i32 20, label [[sw_bb1:%[a-zA-Z0-9._]+]]
+// FRONT-NEXT:   ]
+
+//   MID:        [[priority3:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(%struct.__sk_buff) %ctx, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 0)
+//   MID-NEXT:   switch i32 [[priority3]], label [[sw_epilog:%[a-zA-Z0-9._]+]] [
+//   MID-NEXT:     i32 10, label [[sw_bb:%[a-zA-Z0-9._]+]]
+//   MID-NEXT:     i32 20, label [[sw_bb1:%[a-zA-Z0-9._]+]]
+//   MID-NEXT:   ]
+
+//  BACK:        [[priority36:%[a-zA-Z0-9._]+]] = getelementptr  inbounds %struct.__sk_buff, ptr %ctx, i32 0, i32 0
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load i32, ptr [[priority36]]
+//  BACK-NEXT:   switch i32 [[r0]], label [[sw_epilog:%[a-zA-Z0-9._]+]] [
+//  BACK-NEXT:     i32 10, label [[sw_bb:%[a-zA-Z0-9._]+]]
+//  BACK-NEXT:     i32 20, label [[sw_bb1:%[a-zA-Z0-9._]+]]
+//  BACK-NEXT:   ]
+  case 10:
+    ctx->mark = 3;
+    break;
+// FRONT:      sw.bb:
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r3]])
+// FRONT-NEXT:   [[mark:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.__sk_buff, ptr [[r4]], i32 0, i32 1
+// FRONT-NEXT:   store i32 3, ptr [[mark]]
+// FRONT-NEXT:   br label %sw.epilog
+
+//   MID:      sw.bb:
+//   MID-NEXT:   tail call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.store.i32(i32 3, ptr elementtype(%struct.__sk_buff) %ctx, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 1)
+//   MID-NEXT:   br label %sw.epilog
+
+//  BACK:      sw.{{.*}}:
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = getelementptr  inbounds %struct.__sk_buff, ptr %ctx, i32 0, i32 1
+//  BACK-NEXT:   store i32 3, ptr [[r1]]
+//  BACK-NEXT:   br label %sw.epilog
+
+  case 20:
+    ctx->priority = 4;
+    break;
+// FRONT:      sw.bb1:
+// FRONT-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r6:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r5]])
+// FRONT-NEXT:   [[priority2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.__sk_buff, ptr [[r6]], i32 0, i32 0
+// FRONT-NEXT:   store i32 4, ptr [[priority2]]
+// FRONT-NEXT:   br label %sw.epilog
+
+//   MID:      sw.bb1:
+//   MID-NEXT:   tail call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.store.i32(i32 4, ptr elementtype(%struct.__sk_buff) %ctx, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 0)
+//   MID-NEXT:   br label %sw.epilog
+
+//  BACK:      sw.{{.*}}:
+//  BACK-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr  inbounds %struct.__sk_buff, ptr %ctx, i32 0, i32 0
+//  BACK-NEXT:   store i32 4, ptr [[r2]]
+//  BACK-NEXT:   br label %sw.epilog
+  }
+// FRONT:      sw.epilog:
+// FRONT-NEXT:   ret i32 0
+//   MID:      sw.epilog:
+//   MID-NEXT:   ret i32 0
+//  BACK:      sw.epilog:
+//  BACK-NEXT:   ret i32 0
+  return 0;
+}
+
+// FRONT-LABEL: define dso_local i32 @known_store_sink_example_2
+//   MID-LABEL: define dso_local i32 @known_store_sink_example_2
+//  BACK-LABEL: define dso_local i32 @known_store_sink_example_2
+int known_store_sink_example_2(struct __sk_buff *ctx) {
+  switch (ctx->tc_index) {
+// FRONT:        [[r0:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r0]])
+// FRONT-NEXT:   [[tc_index:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.__sk_buff, ptr [[r1]], i32 0, i32 2
+// FRONT-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = load i32, ptr [[tc_index]]
+// FRONT-NEXT:   switch i32 [[r2]], label [[sw_epilog:%[a-zA-Z0-9._]+]] [
+// FRONT-NEXT:     i32 10, label [[sw_bb:%[a-zA-Z0-9._]+]]
+// FRONT-NEXT:     i32 20, label [[sw_bb3:%[a-zA-Z0-9._]+]]
+// FRONT-NEXT:   ]
+
+//   MID:        [[tc_index8:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(%struct.__sk_buff) %ctx, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 2)
+//   MID-NEXT:   switch i32 [[tc_index8]], label [[sw_epilog:%[a-zA-Z0-9._]+]] [
+//   MID-NEXT:     i32 10, label [[sw_bb:%[a-zA-Z0-9._]+]]
+//   MID-NEXT:     i32 20, label [[sw_bb3:%[a-zA-Z0-9._]+]]
+//   MID-NEXT:   ]
+
+//  BACK:        [[tc_index814:%[a-zA-Z0-9._]+]] = getelementptr  inbounds %struct.__sk_buff, ptr %ctx, i32 0, i32 2
+//  BACK-NEXT:   [[r0:%[a-zA-Z0-9._]+]] = load i32, ptr [[tc_index814]]
+//  BACK-NEXT:   switch i32 [[r0]], label [[sw_epilog:%[a-zA-Z0-9._]+]] [
+//  BACK-NEXT:     i32 10, label [[sw_bb:%[a-zA-Z0-9._]+]]
+//  BACK-NEXT:     i32 20, label [[sw_bb3:%[a-zA-Z0-9._]+]]
+//  BACK-NEXT:   ]
+
+  case 10:
+    magic2(ctx->mark);
+    ctx->mark = magic();
+    break;
+// FRONT:      sw.bb:
+// FRONT-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r3]])
+// FRONT-NEXT:   [[mark:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.__sk_buff, ptr [[r4]], i32 0, i32 1
+// FRONT-NEXT:   [[r5:%[a-zA-Z0-9._]+]] = load i32, ptr [[mark]]
+// FRONT-NEXT:   [[call:%[a-zA-Z0-9._]+]] = call i32 @magic2(i32 noundef [[r5]])
+// FRONT-NEXT:   [[call1:%[a-zA-Z0-9._]+]] = call i32 @magic()
+// FRONT-NEXT:   [[r6:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r7:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r6]])
+// FRONT-NEXT:   [[mark2:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.__sk_buff, ptr [[r7]], i32 0, i32 1
+// FRONT-NEXT:   store i32 [[call1]], ptr [[mark2]]
+// FRONT-NEXT:   br label %sw.epilog
+
+//   MID:      sw.bb:
+//   MID-NEXT:   [[mark7:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(%struct.__sk_buff) %ctx, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 1)
+//   MID-NEXT:   [[call:%[a-zA-Z0-9._]+]] = tail call i32 @magic2(i32 noundef [[mark7]])
+//   MID-NEXT:   [[call1:%[a-zA-Z0-9._]+]] = tail call i32 @magic()
+//   MID-NEXT:   tail call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.store.i32(i32 [[call1]], ptr elementtype(%struct.__sk_buff) %ctx, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 1)
+//   MID-NEXT:   br label %sw.epilog
+
+//  BACK:      sw.{{.*}}:
+//  BACK-NEXT:   [[mark715:%[a-zA-Z0-9._]+]] = getelementptr  inbounds %struct.__sk_buff, ptr %ctx, i32 0, i32 1
+//  BACK-NEXT:   [[r1:%[a-zA-Z0-9._]+]] = load i32, ptr [[mark715]]
+//  BACK-NEXT:   [[call:%[a-zA-Z0-9._]+]] = tail call i32 @magic2(i32 noundef [[r1]])
+//  BACK-NEXT:   [[call1:%[a-zA-Z0-9._]+]] = tail call i32 @magic()
+//  BACK-NEXT:   [[r2:%[a-zA-Z0-9._]+]] = getelementptr  inbounds %struct.__sk_buff, ptr %ctx, i32 0, i32 1
+//  BACK-NEXT:   store i32 [[call1]], ptr [[r2]]
+//  BACK-NEXT:   br label %sw.epilog
+
+  case 20:
+    magic2(ctx->priority);
+    ctx->priority = magic();
+    break;
+// FRONT:      sw.{{.*}}:
+// FRONT-NEXT:   [[r8:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r9:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r8]])
+// FRONT-NEXT:   [[priority:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.__sk_buff, ptr [[r9]], i32 0, i32 0
+// FRONT-NEXT:   [[r10:%[a-zA-Z0-9._]+]] = load i32, ptr [[priority]]
+// FRONT-NEXT:   [[call4:%[a-zA-Z0-9._]+]] = call i32 @magic2(i32 noundef [[r10]])
+// FRONT-NEXT:   [[call5:%[a-zA-Z0-9._]+]] = call i32 @magic()
+// FRONT-NEXT:   [[r11:%[a-zA-Z0-9._]+]] = load ptr, ptr {{.*}}
+// FRONT-NEXT:   [[r12:%[a-zA-Z0-9._]+]] = call ptr @llvm.bpf.context.marker.p0.p0(ptr [[r11]])
+// FRONT-NEXT:   [[priority6:%[a-zA-Z0-9._]+]] = getelementptr inbounds %struct.__sk_buff, ptr [[r12]], i32 0, i32 0
+// FRONT-NEXT:   store i32 [[call5]], ptr [[priority6]]
+// FRONT-NEXT:   br label %sw.epilog
+
+//   MID:      sw.{{.*}}:
+//   MID-NEXT:   [[priority9:%[a-zA-Z0-9._]+]] = tail call i32 (ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.load.i32(ptr elementtype(%struct.__sk_buff) %ctx, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 0)
+//   MID-NEXT:   [[call4:%[a-zA-Z0-9._]+]] = tail call i32 @magic2(i32 noundef [[priority9]])
+//   MID-NEXT:   [[call5:%[a-zA-Z0-9._]+]] = tail call i32 @magic()
+//   MID-NEXT:   tail call void (i32, ptr, i1, i8, i8, i8, i1, ...)
+//   MID-SAME:     @llvm.bpf.getelementptr.and.store.i32(i32 [[call5]], ptr elementtype(%struct.__sk_buff) %ctx, i1 false, i8 0, i8 1, i8 2, i1 true, i32 0, i32 0)
+//   MID-NEXT:   br label %sw.epilog
+
+//  BACK:      sw.{{.*}}:
+//  BACK-NEXT:   [[priority916:%[a-zA-Z0-9._]+]] = getelementptr  inbounds %struct.__sk_buff, ptr %ctx, i32 0, i32 0
+//  BACK-NEXT:   [[r3:%[a-zA-Z0-9._]+]] = load i32, ptr [[priority916]]
+//  BACK-NEXT:   [[call4:%[a-zA-Z0-9._]+]] = tail call i32 @magic2(i32 noundef [[r3]])
+//  BACK-NEXT:   [[call5:%[a-zA-Z0-9._]+]] = tail call i32 @magic()
+//  BACK-NEXT:   [[r4:%[a-zA-Z0-9._]+]] = getelementptr  inbounds %struct.__sk_buff, ptr %ctx, i32 0, i32 0
+//  BACK-NEXT:   store i32 [[call5]], ptr [[r4]]
+//  BACK-NEXT:   br label %sw.epilog
+  }
+  return 0;
+// FRONT:      sw.epilog:
+// FRONT-NEXT:   ret i32 0
+//   MID:      sw.epilog:
+//   MID-NEXT:   ret i32 0
+//  BACK:      sw.epilog:
+//  BACK-NEXT:   ret i32 0
+}

llvm/include/llvm/IR/Intrinsics.td

def int_preserve_union_access_index : DefaultAttrsIntrinsic<[llvm_anyptr_ty],
                                                 [IntrNoMem,
                                                  ImmArg<ArgIndex<1>>]>;
 def int_preserve_struct_access_index : DefaultAttrsIntrinsic<[llvm_anyptr_ty],
                                                  [llvm_anyptr_ty, llvm_i32_ty,
                                                   llvm_i32_ty],
                                                  [IntrNoMem,
                                                   ImmArg<ArgIndex<1>>,
                                                   ImmArg<ArgIndex<2>>]>;
+def int_bpf_context_marker : DefaultAttrsIntrinsic<[llvm_anyptr_ty],
+                                                   [llvm_anyptr_ty],
+                                                   [IntrNoMem]>;
 
 //===------------ Intrinsics to perform common vector shuffles ------------===//
 
 def int_experimental_vector_reverse : DefaultAttrsIntrinsic<[llvm_anyvector_ty],
                                                             [LLVMMatchType<0>],
                                                             [IntrNoMem]>;
 
 def int_experimental_vector_splice : DefaultAttrsIntrinsic<[llvm_anyvector_ty],

llvm/include/llvm/IR/IntrinsicsBPF.td

let TargetPrefix = "bpf" in {  // All intrinsics start with "llvm.bpf."
   def int_bpf_preserve_enum_value : ClangBuiltin<"__builtin_bpf_preserve_enum_value">,
               Intrinsic<[llvm_i64_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_i64_ty],
               [IntrNoMem]>;
   def int_bpf_passthrough : ClangBuiltin<"__builtin_bpf_passthrough">,
               Intrinsic<[llvm_any_ty], [llvm_i32_ty, llvm_any_ty], [IntrNoMem]>;
   def int_bpf_compare : ClangBuiltin<"__builtin_bpf_compare">,
               Intrinsic<[llvm_i1_ty], [llvm_i32_ty, llvm_anyint_ty, llvm_anyint_ty],
               [IntrNoMem]>;
+  def int_bpf_getelementptr_and_load : ClangBuiltin<"__builtin_bpf_getelementptr_and_load">,
+              Intrinsic<[llvm_any_ty],
+                        [llvm_ptr_ty,     // base ptr for getelementptr
+                         llvm_i1_ty,      // volatile
+                         llvm_i8_ty,      // atomic order
+                         llvm_i8_ty,      // synscope id
+                         llvm_i8_ty,      // alignment
+                         llvm_i1_ty,      // inbounds
+                         llvm_vararg_ty], // indices for getelementptr insn
+                        [IntrReadMem,
+                         IntrArgMemOnly,
+                         NoCapture <ArgIndex<0>>,
+                         ReadOnly  <ArgIndex<0>>,
+                         ImmArg    <ArgIndex<1>>, // volatile
+                         ImmArg    <ArgIndex<2>>, // atomic order
+                         ImmArg    <ArgIndex<3>>, // synscope id
+                         ImmArg    <ArgIndex<4>>, // alignment
+                         ImmArg    <ArgIndex<5>>, // inbounds
+                        ]>;
+  def int_bpf_getelementptr_and_store : ClangBuiltin<"__builtin_bpf_getelementptr_and_store">,
+              Intrinsic<[],
+                        [llvm_any_ty,     // value to store
+                         llvm_ptr_ty,     // base ptr for getelementptr
+                         llvm_i1_ty,      // volatile
+                         llvm_i8_ty,      // atomic order
+                         llvm_i8_ty,      // syncscope id
+                         llvm_i8_ty,      // alignment
+                         llvm_i1_ty,      // inbounds
+                         llvm_vararg_ty], // indexes for getelementptr insn
+                        [IntrWriteMem,
+                         IntrArgMemOnly,
+                         NoCapture <ArgIndex<1>>,
+                         WriteOnly <ArgIndex<1>>,
+                         ImmArg    <ArgIndex<2>>, // volatile
+                         ImmArg    <ArgIndex<3>>, // atomic order
+                         ImmArg    <ArgIndex<4>>, // syncscope id
+                         ImmArg    <ArgIndex<5>>, // alignment
+                         ImmArg    <ArgIndex<6>>, // inbounds
+                        ]>;
 }

llvm/lib/Target/BPF/BPF.h

 FunctionPass *createBPFPreserveDIType();
 FunctionPass *createBPFIRPeephole();
 FunctionPass *createBPFISelDag(BPFTargetMachine &TM);
 FunctionPass *createBPFMISimplifyPatchablePass();
 FunctionPass *createBPFMIPeepholePass();
 FunctionPass *createBPFMIPeepholeTruncElimPass();
 FunctionPass *createBPFMIPreEmitPeepholePass();
 FunctionPass *createBPFMIPreEmitCheckingPass();
+FunctionPass *createBPFRewriteContextAccessPass();
+FunctionPass *createBPFSimplifyContextMarkersPass();
 
 void initializeBPFAdjustOptPass(PassRegistry&);
 void initializeBPFCheckAndAdjustIRPass(PassRegistry&);
 
 void initializeBPFAbstractMemberAccessLegacyPassPass(PassRegistry &);
 void initializeBPFPreserveDITypePass(PassRegistry&);
 void initializeBPFIRPeepholePass(PassRegistry&);
 void initializeBPFMISimplifyPatchablePass(PassRegistry&);
 void initializeBPFMIPeepholePass(PassRegistry&);
 void initializeBPFMIPeepholeTruncElimPass(PassRegistry&);
 void initializeBPFMIPreEmitPeepholePass(PassRegistry&);
 void initializeBPFMIPreEmitCheckingPass(PassRegistry&);
+void initializeBPFSimplifyContextMarkersLegacyPassPass(PassRegistry &);
+void initializeBPFRewriteContextAccessLegacyPassPass(PassRegistry &);
 
 class BPFAbstractMemberAccessPass
     : public PassInfoMixin<BPFAbstractMemberAccessPass> {
   BPFTargetMachine *TM;
 
 public:
   BPFAbstractMemberAccessPass(BPFTargetMachine *TM) : TM(TM) {}
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
public:
 
   static bool isRequired() { return true; }
 };
 
 class BPFAdjustOptPass : public PassInfoMixin<BPFAdjustOptPass> {
 public:
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
 };
+
+class BPFRewriteContextAccessPass
+    : public PassInfoMixin<BPFRewriteContextAccessPass> {
+public:
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+  static bool isRequired() { return true; }
+};
+
+class BPFSimplifyContextMarkersPass
+    : public PassInfoMixin<BPFSimplifyContextMarkersPass> {
+public:
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+  static bool isRequired() { return true; }
+};
+
 } // namespace llvm
 
 #endif

llvm/lib/Target/BPF/BPFCheckAndAdjustIR.cpp

 //===------------ BPFCheckAndAdjustIR.cpp - Check and Adjust IR -----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Check IR and adjust IR for verifier friendly codes.
 // The following are done for IR checking:
 //   - no relocation globals in PHI node.
 // The following are done for IR adjustment:
 //   - remove __builtin_bpf_passthrough builtins. Target independent IR
 //     optimizations are done and those builtins can be removed.
+//   - remove llvm.bpf.getelementptr.and.load builtins.
+//   - remove llvm.bpf.getelementptr.and.store builtins.
 //
 //===----------------------------------------------------------------------===//
 
 #include "BPF.h"
 #include "BPFCORE.h"
 #include "BPFTargetMachine.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
+#include "llvm/IR/IntrinsicsBPF.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/User.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Pass.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 
 #define DEBUG_TYPE "bpf-check-and-opt-ir"
public:
   static char ID;
   BPFCheckAndAdjustIR() : ModulePass(ID) {}
 
 private:
   void checkIR(Module &M);
   bool adjustIR(Module &M);
   bool removePassThroughBuiltin(Module &M);
   bool removeCompareBuiltin(Module &M);
+  bool removeGEPBuiltins(Module &M);
 };
 } // End anonymous namespace
 
 char BPFCheckAndAdjustIR::ID = 0;
 INITIALIZE_PASS(BPFCheckAndAdjustIR, DEBUG_TYPE, "BPF Check And Adjust IR",
                 false, false)
 
 ModulePass *llvm::createBPFCheckAndAdjustIR() {
for (auto &BB : F)
         BB.getInstList().insert(Call->getIterator(), ICmp);
 
         Call->replaceAllUsesWith(ICmp);
         ToBeDeleted = Call;
       }
   return Changed;
 }
 
+static unsigned getOperandAsUnsigned(CallInst *Call, unsigned ArgNo) {
+  if (auto *Int = dyn_cast<ConstantInt>(Call->getOperand(ArgNo)))
+    return Int->getValue().getZExtValue();
+  std::string Report;
+  raw_string_ostream ReportS(Report);
+  ReportS << "Expecting ConstantInt as argument #" << ArgNo << " of " << *Call
+          << "\n";
+  report_fatal_error(StringRef(Report));
+}
+
+static GetElementPtrInst *reconstructGEP(CallInst *Call, int Delta) {
+  SmallVector<Value *> Indices;
+  Indices.append(Call->data_operands_begin() + 6 + Delta,
+                 Call->data_operands_end());
+  auto *GEPPointeeType = Call->getParamElementType(Delta);
+  auto *GEP = GetElementPtrInst::Create(GEPPointeeType, Call->getOperand(Delta),
+                                        ArrayRef<Value *>(Indices),
+                                        Call->getName(), Call);
+  GEP->setIsInBounds(getOperandAsUnsigned(Call, 5 + Delta));
+  return GEP;
+}
+
+template <class T = std::disjunction<LoadInst, StoreInst>>
+static void unrollCommon(CallInst *Call, GetElementPtrInst *GEP, T *Insn,
+                         int Delta) {
+  Insn->setVolatile(getOperandAsUnsigned(Call, 1 + Delta));
+  Insn->setOrdering((AtomicOrdering)getOperandAsUnsigned(Call, 2 + Delta));
+  Insn->setSyncScopeID(getOperandAsUnsigned(Call, 3 + Delta));
+  auto AlignShiftValue = getOperandAsUnsigned(Call, 4 + Delta);
+  Insn->setAlignment(Align(uint64_t(1) << AlignShiftValue));
+  GEP->setDebugLoc(Call->getDebugLoc());
+  Insn->setDebugLoc(Call->getDebugLoc());
+  Call->replaceAllUsesWith(Insn);
+  Call->eraseFromParent();
+}
+
+static void unrollGEPLoad(CallInst *Call) {
+  auto *GEP = reconstructGEP(Call, 0);
+  auto *ReturnType = Call->getFunctionType()->getReturnType();
+  auto *Load = new LoadInst(ReturnType, GEP, "", Call);
+  unrollCommon(Call, GEP, Load, 0);
+}
+
+static void unrollGEPStore(CallInst *Call) {
+  auto *GEP = reconstructGEP(Call, 1);
+  auto *Store = new StoreInst(Call->getOperand(0), GEP, Call);
+  unrollCommon(Call, GEP, Store, 1);
+}
+
+static bool removeGEPBuiltinsInFunc(Function &F) {
+  SmallVector<CallInst *> GEPLoads;
+  SmallVector<CallInst *> GEPStores;
+  for (auto &BB : F)
+    for (auto &Insn : BB)
+      if (auto *Call = dyn_cast<CallInst>(&Insn))
+        if (auto *Called = Call->getCalledFunction())
+          switch (Called->getIntrinsicID()) {
+          case Intrinsic::bpf_getelementptr_and_load:
+            GEPLoads.push_back(Call);
+            break;
+          case Intrinsic::bpf_getelementptr_and_store:
+            GEPStores.push_back(Call);
+            break;
+          }
+
+  if (GEPLoads.empty() && GEPStores.empty())
+    return false;
+
+  for_each(GEPLoads, unrollGEPLoad);
+  for_each(GEPStores, unrollGEPStore);
+
+  return true;
+}
+
+// Rewrites the following builtins:
+// - llvm.bpf.getelementptr.and.load
+// - llvm.bpf.getelementptr.and.store
+// As (load (getelementptr ...)) or (store (getelementptr ...)).
+bool BPFCheckAndAdjustIR::removeGEPBuiltins(Module &M) {
+  bool Changed = false;
+  for (auto &F : M)
+    Changed = removeGEPBuiltinsInFunc(F) || Changed;
+  return Changed;
+}
+
 bool BPFCheckAndAdjustIR::adjustIR(Module &M) {
   bool Changed = removePassThroughBuiltin(M);
   Changed = removeCompareBuiltin(M) || Changed;
+  Changed = removeGEPBuiltins(M) || Changed;
   return Changed;
 }
 
 bool BPFCheckAndAdjustIR::runOnModule(Module &M) {
   checkIR(M);
   return adjustIR(M);
 }

llvm/lib/Target/BPF/BPFContextMarker.cpp

+//===------ BPFContextMarker.cpp ------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains passes that address two BPF verifier specific issues:
+//
+// (a) Access to some structural types is allowed only using
+//     LD / ST instructions with static immediate offsets;
+//
+//     Examples of such types are `struct __sk_buff` and `struct bpf_sock_ops`.
+//     This is so because offsets of the fields of these structures do
+//     not match real offsets in the running kernel. During BPF
+//     program load/verification loads and stores to the fields of
+//     these types are rewritten so that offsets match real
+//     offsets. For this rewrite to happen static offsets have to be
+//     encoded in the instructions.
+//
+//     See kernel/bpf/verifier.c:convert_ctx_access function in the
+//     Linux kernel source tree for details.
+//
+// (b) Pointers to context parameters of BPF programs must not be
+//     modified before access.
+//
+//     During BPF program verification a tag PTR_TO_CTX is tracked for
+//     register values. In case if register with such tag is modified
+//     BPF programs are not allowed to read or write memory using
+//     register. See kernel/bpf/verifier.c:check_mem_access function in the
+//     Linux kernel source tree for details.
+//
+// Both cases limit the ways structural types could be accessed.
+// After AST translation the IR for structural types access has the
+// following form:
+//
+//   %x = getelementptr %ptr, %offset
+//   %y = load %x
+//
+// Instruction selection for BPF translates such series of
+// instructions as a single instruction:
+//
+//   LDW %ptr, %offset
+//
+// However, several optimization passes might sink `load` instruction
+// or hoist `getelementptr` instruction so that the instructions are
+// no longer in sequence. Examples of such passes are:
+// SimplifyCFGPass, InstCombinePass, GVNPass.
+// After such modification the verifier would reject the BPF program.
+//
+// To avoid this issue the patterns like (load/store (getelementptr ...))
+// are replaced by calls to BPF specific intrinsic functions:
+// - llvm.bpf.getelementptr.and.load
+// - llvm.bpf.getelementptr.and.store
+//
+// These calls are lowered back to (load/store (getelementptr ...))
+// by BPFCheckAndAdjustIR pass right before the translation from IR to
+// machine instructions.
+//
+// Two passes are used to achieve this transformation:
+//
+// - BPFRewriteContextAccessPass:
+//   uses calls to llvm.bpf.context.marker to identify starting points
+//   of (load/store (gep (gep ...))) chains and replaces these chains
+//   with calls to intrinsics.
+//
+// - BPFSimplifyContextMarkersPass:
+//   reorders calls to llvm.bpf.context.marker and preserve.access.index
+//   intrinsics in a single gep chain to avoid interruption of
+//   preserve.access.index chains.
+//
+// Both passes are implemented in this file.
+
+#include "BPF.h"
+#include "BPFCORE.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/DebugInfoMetadata.h"
+#include "llvm/IR/InstIterator.h"
+#include "llvm/IR/Instruction.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/Intrinsics.h"
+#include "llvm/IR/IntrinsicsBPF.h"
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/PassManager.h"
+#include "llvm/InitializePasses.h"
+#include "llvm/Pass.h"
+#include <set>
+
+#define DEBUG_TYPE "bpf-context-marker"
+
+using namespace llvm;
+
+static bool isNamedFuncCall(Value *I, const char *Name) {
+  auto *Call = dyn_cast<CallInst>(I);
+  if (!Call)
+    return false;
+  auto *Func = Call->getCalledFunction();
+  if (!Func)
+    return false;
+  return Func->getName().startswith(Name);
+}
+
+static bool isPassThroughCall(Value *I) {
+  return isNamedFuncCall(I, "llvm.bpf.passthrough");
+}
+
+static bool isContextMarkerCall(Value *I) {
+  return isNamedFuncCall(I, "llvm.bpf.context.marker");
+}
+
+static std::vector<Instruction *> collectContextMarkers(Function &F) {
+  std::vector<Instruction *> Markers;
+  for (auto &Insn : instructions(F))
+    if (isContextMarkerCall(&Insn))
+      Markers.push_back(&Insn);
+  return Markers;
+}
+
+template <class T = Instruction>
+static const DILocation *mergeDILocations(SmallVector<T *> &Insns) {
+  const DILocation *Merged = (*Insns.begin())->getDebugLoc();
+  for (auto *I : Insns)
+    Merged = DILocation::getMergedLocation(Merged, I->getDebugLoc());
+  return Merged;
+}
+
+static CallInst *makeIntrinsicCall(Module *M,
+                                   Intrinsic::BPFIntrinsics Intrinsic,
+                                   ArrayRef<Type *> Types,
+                                   SmallVector<Value *> &Args) {
+
+  Function *Fn =
+    Intrinsic::getDeclaration(M, Intrinsic, ArrayRef<Type *>(Types));
+  return CallInst::Create(Fn, ArrayRef<Value *>(Args));
+}
+
+static void setParamElementType(CallInst *Call, unsigned ArgNo, Type *Type) {
+  auto &C = Call->getContext();
+  Call->addParamAttr(ArgNo, Attribute::get(C, Attribute::ElementType, Type));
+}
+
+static void setParamReadNone(CallInst *Call, unsigned ArgNo) {
+  auto &C = Call->getContext();
+  Call->addParamAttr(ArgNo, Attribute::get(C, Attribute::ReadNone));
+}
+
+namespace {
+struct GEPChainInfo {
+  bool InBounds = true;
+  Type *SourceElementType;
+  Type *ResultElementType;
+  SmallVector<Value *> Indices;
+  SmallVector<GetElementPtrInst *> Members;
+};
+} // Anonymous namespace
+
+template <class T = std::disjunction<LoadInst, StoreInst>>
+static void fillCommonArgs(SmallVector<Value *> &Args,
+                           GEPChainInfo &GEP,
+                           T *Insn,
+                           Value *PointerValueOverride) {
+  auto &C = Insn->getContext();
+  auto *Int8Ty = Type::getInt8Ty(C);
+  auto *Int1Ty = Type::getInt1Ty(C);
+  // Implementation of Align guarantees that ShiftValue < 64
+  auto AlignShiftValue = Log2_64(Insn->getAlign().value());
+  Args.push_back(PointerValueOverride
+                 ? PointerValueOverride
+                 : GEP.Members[0]->getPointerOperand());
+  Args.push_back(ConstantInt::get(Int1Ty, Insn->isVolatile()));
+  Args.push_back(ConstantInt::get(Int8Ty, (unsigned) Insn->getOrdering()));
+  Args.push_back(ConstantInt::get(Int8Ty, (unsigned) Insn->getSyncScopeID()));
+  Args.push_back(ConstantInt::get(Int8Ty, AlignShiftValue));
+  Args.push_back(ConstantInt::get(Int1Ty, GEP.InBounds));
+  Args.append(GEP.Indices.begin(), GEP.Indices.end());
+}
+
+static Instruction *makeGEPAndLoad(GEPChainInfo &GEP,
+                                   LoadInst *Load,
+                                   Value *PointerValueOverride) {
+  auto *M = Load->getModule();
+  SmallVector<Value *> Args;
+  fillCommonArgs(Args, GEP, Load, PointerValueOverride);
+  auto *Call = makeIntrinsicCall(M, Intrinsic::bpf_getelementptr_and_load,
+                                 {Load->getType()}, Args);
+  setParamElementType(Call, 0, GEP.SourceElementType);
+  Call->applyMergedLocation(mergeDILocations(GEP.Members),
+                            Load->getDebugLoc());
+  Call->setName((*GEP.Members.rbegin())->getName());
+  return Call;
+}
+
+static Instruction *makeGEPAndStore(GEPChainInfo &GEP,
+                                    StoreInst *Store,
+                                    Value *PointerValueOverride) {
+  auto *M = Store->getModule();
+  SmallVector<Value *> Args;
+  Args.push_back(Store->getValueOperand());
+  fillCommonArgs(Args, GEP, Store, PointerValueOverride);
+  auto *Call = makeIntrinsicCall(M, Intrinsic::bpf_getelementptr_and_store,
+                                 {Store->getValueOperand()->getType()}, Args);
+  setParamElementType(Call, 1, GEP.SourceElementType);
+  if (Store->getValueOperand()->getType()->isPointerTy())
+    setParamReadNone(Call, 0);
+  Call->applyMergedLocation(mergeDILocations(GEP.Members),
+                            Store->getDebugLoc());
+  return Call;
+}
+
+// Given a chain of GEP instructions collect information necessary to
+// merge this chain as a single instruction.
+// Return `true` is such merge is possible, `false` otherwise.
+static bool collectGEPChainInfo(SmallVector<GetElementPtrInst *> &GEPs,
+                                GEPChainInfo &Info) {
+  if (GEPs.empty())
+    return false;
+
+  auto *First = GEPs[0];
+  Info.InBounds = First->isInBounds();
+  Info.SourceElementType = First->getSourceElementType();
+  Info.ResultElementType = First->getResultElementType();
+  Info.Indices.append(First->idx_begin(), First->idx_end());
+  Info.Members.push_back(First);
+
+  for (auto *Iter = GEPs.begin() + 1; Iter != GEPs.end(); ++Iter) {
+    auto *GEP = *Iter;
+    auto *CI = dyn_cast<ConstantInt>(GEP->idx_begin());
+    if (!CI || !CI->isZero())
+      return false;
+    if (!GEP->getSourceElementType() ||
+        GEP->getSourceElementType() != Info.ResultElementType)
+      return false;
+    Info.InBounds &= GEP->isInBounds();
+    Info.Indices.append(GEP->idx_begin() + 1, GEP->idx_end());
+    Info.Members.push_back(GEP);
+    Info.ResultElementType = GEP->getResultElementType();
+  }
+
+  return true;
+}
+
+static Instruction *makePassThroughCall(Instruction *Input,
+                                        Instruction *Before) {
+  return BPFCoreSharedInfo::insertPassThrough
+    (Before->getModule(), Before->getParent(), Input, Before);
+}
+
+static bool isPointerOperand(Instruction *I, User *U) {
+  if (auto *L = dyn_cast<LoadInst>(U))
+    return L->getPointerOperand() == I;
+  if (auto *S = dyn_cast<StoreInst>(U))
+    return S->getPointerOperand() == I;
+  if (auto *GEP = dyn_cast<GetElementPtrInst>(U))
+    return GEP->getPointerOperand() == I;
+  return true;
+}
+
+// A DFS traversal of GEP chain trees starting from Root.
+// This is slightly complicated by handling patterns generated by
+// BPFAbstractMemberAccessPass.
+//
+// Recursion descends through GEP, BitCast instructions and
+// llvm.bpf.passthrough calls. Recursion stops at any other
+// instruction. If load or store instruction is reached at the end
+// it is replaced by the call to llvm.bpf.getelementptr.and.load or
+// llvm.bpf.getelementptr.and.store intrinsic.
+//
+// Parameters description:
+// - Root - a call to llvm.bpf.context.marker, the root of the tree
+// - Insn - current position in the tree
+// - GEPs - GEP instructions for the current branch
+// - PassThrough - the replacement call to the llvm.bpf.passthrough
+// - Visited - a list of visited instructions in DFS order,
+//   order is important for unused instruction deletion.
+static void rewriteAccessChain(Instruction *Root,
+                               Instruction *Insn,
+                               SmallVector<GetElementPtrInst *> &GEPs,
+                               Instruction *PassThrough,
+                               SmallVector<Instruction *> &Visited) {
+  auto MarkAndTraverseUses = [&](Instruction *NewPassThrough) {
+    Visited.push_back(Insn);
+    for (auto *U : Insn->users())
+      if (auto *UI = dyn_cast<Instruction>(U))
+        if (isPointerOperand(Insn, UI))
+          rewriteAccessChain(Root, UI, GEPs, NewPassThrough, Visited);
+  };
+  if (isa<LoadInst>(Insn) || isa<StoreInst>(Insn)) {
+    GEPChainInfo GEPChain;
+    if (!collectGEPChainInfo(GEPs, GEPChain)) {
+      errs() << "Can't generate gep and load/store for "
+             << *Root << ": irreducable GEP chain\n";
+      return;
+    }
+    Visited.push_back(Insn);
+    if (auto *Load = dyn_cast<LoadInst>(Insn)) {
+      auto *Replacement = makeGEPAndLoad(GEPChain, Load, PassThrough);
+      Replacement->insertBefore(Load);
+      Load->replaceAllUsesWith(Replacement);
+    }
+    if (auto *Store = dyn_cast<StoreInst>(Insn)) {
+      auto *Replacement = makeGEPAndStore(GEPChain, Store, PassThrough);
+      Replacement->insertBefore(Store);
+    }
+  } else if (auto *GEP = dyn_cast<GetElementPtrInst>(Insn)) {
+    GEPs.push_back(GEP);
+    MarkAndTraverseUses(PassThrough);
+    GEPs.pop_back();
+  } else if (isa<BitCastInst>(Insn)) {
+    MarkAndTraverseUses(PassThrough);
+  } else if (isPassThroughCall(Insn)) {
+    Instruction *NewPassThrough = PassThrough;
+    if (!PassThrough) {
+      NewPassThrough = makePassThroughCall(Root, Insn);
+      Visited.push_back(NewPassThrough);
+    }
+    MarkAndTraverseUses(NewPassThrough);
+  }
+}
+
+// Rewrite the GEP chains starting at Marker and delete instructions
+// that are not used after rewrite.
+static void rewriteAccessChain(Instruction *Marker) {
+  SmallVector<GetElementPtrInst *> GEPs;
+  SmallVector<Instruction *> Visited;
+  for (auto *U : Marker->users())
+    if (auto *UI = dyn_cast<Instruction>(U))
+      if (isPointerOperand(Marker, UI))
+        rewriteAccessChain(Marker, UI, GEPs, nullptr, Visited);
+  // Check if Visited instructions could be removed, iterate in
+  // reverse to unblock instructions higher in the chain.
+  for (auto V = Visited.rbegin(); V != Visited.rend(); ++V)
+    if ((*V)->use_empty())
+      (*V)->eraseFromParent();
+}
+
+static void removeMarker(Instruction *Marker) {
+    Marker->replaceAllUsesWith(Marker->getOperand(0));
+    Marker->eraseFromParent();
+}
+
+static bool rewriteContextAccess(Function &F) {
+  LLVM_DEBUG(dbgs() << "********** Rewrite Context Access ************\n");
+
+  auto ContextMarkers = collectContextMarkers(F);
+
+  LLVM_DEBUG(dbgs()
+             << "There are " << ContextMarkers.size()
+             << " context markers\n");
+
+  if (ContextMarkers.empty())
+    return false;
+
+  for (auto *Marker : ContextMarkers) {
+    rewriteAccessChain(Marker);
+    removeMarker(Marker);
+  }
+
+  return true;
+}
+
+static bool isPreserveAccessIndexCall(Value *Val) {
+  if (auto *Call = dyn_cast<CallInst>(Val))
+    return Call->getMetadata(LLVMContext::MD_preserve_access_index);
+  return false;
+}
+
+using InsnSet = std::set<Instruction *>;
+
+static void collectMarksInUsers(Instruction *Insn, InsnSet &MarkSet) {
+  for (auto *U : Insn->users()) {
+    if (auto *UI = dyn_cast<Instruction>(U)) {
+      bool IsMarker = isContextMarkerCall(U);
+      if (IsMarker)
+        MarkSet.insert(UI);
+      if (IsMarker ||
+          isa<GetElementPtrInst>(UI) ||
+          isPreserveAccessIndexCall(UI))
+        collectMarksInUsers(UI, MarkSet);
+    }
+  }
+}
+
+// Apply two simplifications to GEP chains that contain calls to
+// llvm.bpf.context.marker:
+// - Remove repeating calls to llvm.bpf.context.marker;
+// - Hoist calls to llvm.bpf.context.marker above
+//   preserve access index calls.
+//
+// E.g.:
+//     %0 = call @llvm.preserve.struct.access.index ...
+//     %1 = call @llvm.bpf.context.marker %0
+//     %2 = call @llvm.preserve.struct.access.index %2
+//     %3 = call @llvm.bpf.context.marker %3
+//     %4 = call @llvm.preserve.struct.access.index %4
+//   ->
+//     %0 = call @llvm.bpf.context.marker ...
+//     %1 = call @llvm.preserve.struct.access.index %0
+//     %2 = call @llvm.preserve.struct.access.index %1
+//     %3 = call @llvm.preserve.struct.access.index %2
+//
+// This allows BPFAbstractMemberAccessPass to generate single
+// relocatable load instruction for each such chain.
+static bool simplifyContextAccessMarkers(Function &F) {
+  InsnSet ToRemove;
+  InsnSet ToPushUp;
+
+  for (auto &I : instructions(F))
+    if (isContextMarkerCall(&I) && ToRemove.find(&I) == ToRemove.end()) {
+      collectMarksInUsers(&I, ToRemove);
+      auto *User = I.getUniqueUndroppableUser();
+      if (isPreserveAccessIndexCall(I.getOperand(0)) &&
+          User && isPreserveAccessIndexCall(User))
+        ToPushUp.insert(&I);
+    }
+
+  if (ToRemove.empty() && ToPushUp.empty())
+    return false;
+
+  for (auto *Marker : ToRemove)
+    removeMarker(Marker);
+
+  for (auto *Marker : ToPushUp) {
+    auto *TopPAICall = Marker;
+    while (isPreserveAccessIndexCall(TopPAICall->getOperand(0)))
+      TopPAICall = cast<Instruction>(TopPAICall->getOperand(0));
+    Marker->replaceAllUsesWith(Marker->getOperand(0));
+    Marker->removeFromParent();
+
+    Marker->insertBefore(TopPAICall);
+    Marker->setOperand(0, TopPAICall->getOperand(0));
+    TopPAICall->setOperand(0, Marker);
+  }
+
+  return true;
+}
+
+namespace {
+
+class BPFRewriteContextAccessLegacyPass final : public FunctionPass {
+public:
+  static char ID;
+
+  BPFRewriteContextAccessLegacyPass() : FunctionPass(ID) {}
+
+  bool runOnFunction(Function &F) override {
+    return rewriteContextAccess(F);
+  }
+};
+
+class BPFSimplifyContextMarkersLegacyPass final : public FunctionPass {
+public:
+  static char ID;
+
+  BPFSimplifyContextMarkersLegacyPass() : FunctionPass(ID) {}
+
+  bool runOnFunction(Function &F) override {
+    return simplifyContextAccessMarkers(F);
+  }
+};
+
+} // End anonymous namespace
+
+char BPFRewriteContextAccessLegacyPass::ID = 0;
+INITIALIZE_PASS(BPFRewriteContextAccessLegacyPass, DEBUG_TYPE,
+                "BPF Rewrite Context Access", false, false)
+
+char BPFSimplifyContextMarkersLegacyPass::ID = 0;
+INITIALIZE_PASS(BPFSimplifyContextMarkersLegacyPass, "bpf-simplify-context-markers",
+                "BPF Simplify Context Markers", false, false)
+
+
+
+FunctionPass *llvm::createBPFRewriteContextAccessPass() {
+  return new BPFRewriteContextAccessLegacyPass();
+}
+
+FunctionPass *llvm::createBPFSimplifyContextMarkersPass() {
+  return new BPFSimplifyContextMarkersLegacyPass();
+}
+
+PreservedAnalyses
+llvm::BPFRewriteContextAccessPass::run(Function &F, FunctionAnalysisManager &AM) {
+  return rewriteContextAccess(F)
+    ? PreservedAnalyses::none()
+    : PreservedAnalyses::all();
+}
+
+PreservedAnalyses
+llvm::BPFSimplifyContextMarkersPass::run(Function &F,
+                                         FunctionAnalysisManager &AM) {
+  return simplifyContextAccessMarkers(F)
+    ? PreservedAnalyses::none()
+    : PreservedAnalyses::all();
+}

llvm/lib/Target/BPF/BPFTargetMachine.cpp

extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeBPFTarget() {
   PassRegistry &PR = *PassRegistry::getPassRegistry();
   initializeBPFAbstractMemberAccessLegacyPassPass(PR);
   initializeBPFPreserveDITypePass(PR);
   initializeBPFIRPeepholePass(PR);
   initializeBPFAdjustOptPass(PR);
   initializeBPFCheckAndAdjustIRPass(PR);
   initializeBPFMIPeepholePass(PR);
   initializeBPFMIPeepholeTruncElimPass(PR);
+  initializeBPFSimplifyContextMarkersLegacyPassPass(PR);
+  initializeBPFRewriteContextAccessLegacyPassPass(PR);
 }
 
 // DataLayout: little or big endian
 static std::string computeDataLayout(const Triple &TT) {
   if (TT.getArch() == Triple::bpfeb)
     return "E-m:e-p:64:64-i64:64-i128:128-n32:64-S128";
   else
     return "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128";

 };
 }
 
 TargetPassConfig *BPFTargetMachine::createPassConfig(PassManagerBase &PM) {
   return new BPFPassConfig(*this, PM);
 }
 
 void BPFTargetMachine::adjustPassManager(PassManagerBuilder &Builder) {
   Builder.addExtension(
       PassManagerBuilder::EP_EarlyAsPossible,
       [&](const PassManagerBuilder &, legacy::PassManagerBase &PM) {
+        PM.add(createBPFSimplifyContextMarkersPass());
         PM.add(createBPFAbstractMemberAccess(this));
         PM.add(createBPFPreserveDIType());
+        PM.add(createBPFRewriteContextAccessPass());
         PM.add(createBPFIRPeephole());
       });
 
   Builder.addExtension(
       PassManagerBuilder::EP_Peephole,
       [&](const PassManagerBuilder &, legacy::PassManagerBase &PM) {
         PM.add(createCFGSimplificationPass(
             SimplifyCFGOptions().hoistCommonInsts(true)));
       });
   Builder.addExtension(
       PassManagerBuilder::EP_ModuleOptimizerEarly,
       [&](const PassManagerBuilder &, legacy::PassManagerBase &PM) {
         PM.add(createBPFAdjustOpt());
       });
 }
 
 void BPFTargetMachine::registerPassBuilderCallbacks(PassBuilder &PB) {
   PB.registerPipelineStartEPCallback(
       [=](ModulePassManager &MPM, OptimizationLevel) {
         FunctionPassManager FPM;
+        FPM.addPass(BPFSimplifyContextMarkersPass());
         FPM.addPass(BPFAbstractMemberAccessPass(this));
         FPM.addPass(BPFPreserveDITypePass());
+        FPM.addPass(BPFRewriteContextAccessPass());
         FPM.addPass(BPFIRPeepholePass());
         MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
       });
   PB.registerPeepholeEPCallback([=](FunctionPassManager &FPM,
                                     OptimizationLevel Level) {
     FPM.addPass(SimplifyCFGPass(SimplifyCFGOptions().hoistCommonInsts(true)));
   });
   PB.registerPipelineEarlySimplificationEPCallback(

llvm/lib/Target/BPF/CMakeLists.txt

 
 add_public_tablegen_target(BPFCommonTableGen)
 
 add_llvm_target(BPFCodeGen
   BPFAbstractMemberAccess.cpp
   BPFAdjustOpt.cpp
   BPFAsmPrinter.cpp
   BPFCheckAndAdjustIR.cpp
+  BPFContextMarker.cpp
   BPFFrameLowering.cpp
   BPFInstrInfo.cpp
   BPFIRPeephole.cpp
   BPFISelDAGToDAG.cpp
   BPFISelLowering.cpp
   BPFMCInstLower.cpp
   BPFPreserveDIType.cpp
   BPFRegisterInfo.cpp