[CIR][CIRGen] Support for visual bases in getAddressOfBaseClass

This is going to be raised in follow up work, which is hard to
do in one go because createBaseClassAddr goes of the OG skeleton
and ideally we want ApplyNonVirtualAndVirtualOffset to work naturally.

This also doesn't handle null checks, coming next.

Author: bcardosolopes

clang/lib/CIR/CodeGen/CIRGenClass.cpp

@@ -1545,7 +1545,9 @@ CIRGenFunction::getAddressOfBaseClass(Address Value,
   // *start* with a step down to the correct virtual base subobject,
   // and hence will not require any further steps.
   if ((*Start)->isVirtual()) {
-    llvm_unreachable("NYI: Cast to virtual base class");
+    VBase = cast<CXXRecordDecl>(
+        (*Start)->getType()->castAs<RecordType>()->getDecl());
+    ++Start;
   }
 
   // Compute the static offset of the ultimate destination within its
@@ -1574,39 +1576,33 @@ CIRGenFunction::getAddressOfBaseClass(Address Value,
     if (sanitizePerformTypeCheck()) {
       llvm_unreachable("NYI: sanitizePerformTypeCheck");
     }
-    return builder.createBaseClassAddr(getLoc(Loc), Value, BaseValueTy,
-                                       NonVirtualOffset.getQuantity(),
-                                       /*assumeNotNull=*/not NullCheckValue);
   }
 
   if (sanitizePerformTypeCheck()) {
     assert(!cir::MissingFeatures::sanitizeOther());
   }
 
-  // Conversion to a virtual base. cir.base_class_addr can't handle this.
-  // Generate the code to look up the address in the virtual table.
-
-  llvm_unreachable("NYI: Cast to virtual base class");
-
-  // This is just an outline of what the code might look like, since I can't
-  // actually test it.
-#if 0
-  mlir::Value VirtualOffset = ...; // This is a dynamic expression.  Creating
-                                   // it requires calling an ABI-specific
-                                   // function.
-  Value = ApplyNonVirtualAndVirtualOffset(getLoc(Loc), *this, Value,
-                                          NonVirtualOffset, VirtualOffset,
-                                          Derived, VBase);
-  Value = builder.createElementBitCast(Value.getPointer().getLoc(), Value,
-                                       BaseValueTy);
-  if (sanitizePerformTypeCheck()) {
-    // Do something here
-  }
-  if (NullCheckValue) {
-    // Convert to 'derivedPtr == nullptr ? nullptr : basePtr'
+  // Compute the virtual offset.
+  mlir::Value VirtualOffset = nullptr;
+  if (VBase) {
+    VirtualOffset = CGM.getCXXABI().getVirtualBaseClassOffset(
+        getLoc(Loc), *this, Value, Derived, VBase);
+  } else {
+    Value = builder.createBaseClassAddr(getLoc(Loc), Value, BaseValueTy,
+                                        NonVirtualOffset.getQuantity(),
+                                        /*assumeNotNull=*/not NullCheckValue);
   }
-#endif
 
+  // Apply both offsets.
+  // FIXME: remove condition.
+  if (VBase)
+    Value = ApplyNonVirtualAndVirtualOffset(getLoc(Loc), *this, Value,
+                                            NonVirtualOffset, VirtualOffset,
+                                            Derived, VBase);
+
+  // Cast to the destination type.
+  if (VBase)
+    Value = Value.withElementType(BaseValueTy);
   return Value;
 }
 

clang/test/CIR/CodeGen/virtual-base-cast.cpp

@@ -0,0 +1,53 @@
+
+// RUN: %clang_cc1 -triple aarch64-none-linux-android21 -std=c++20 -mconstructor-aliases -O0 -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck --check-prefix=CIR --input-file=%t.cir %s
+// RUN: %clang_cc1 -triple aarch64-none-linux-android21 -std=c++20 -mconstructor-aliases -O0 -fclangir -emit-llvm -fno-clangir-call-conv-lowering %s -o %t.ll
+// RUN: FileCheck --check-prefix=LLVM --input-file=%t.ll %s
+
+struct A { int a; virtual int aa(); };
+struct B { int b; virtual int bb(); };
+struct C : virtual A, virtual B { int c; virtual int aa(); virtual int bb(); };
+struct AA { int a; virtual int aa(); };
+struct BB { int b; virtual int bb(); };
+struct CC : AA, BB { virtual int aa(); virtual int bb(); virtual int cc(); };
+struct D : virtual C, virtual CC { int e; };
+
+D* x;
+
+A* a() { return x; }
+// CIR-LABEL: @_Z1av()
+// CIR:  %[[OFFSET_OFFSET:.*]] = cir.const #cir.int<-32> : !s64i
+// CIR:  %[[OFFSET_PTR:.*]] = cir.ptr_stride(%4 : !cir.ptr<!u8i>, %[[OFFSET_OFFSET]] : !s64i), !cir.ptr<!u8i>
+// CIR:  %[[OFFSET_PTR_CAST:.*]] = cir.cast(bitcast, %[[OFFSET_PTR]] : !cir.ptr<!u8i>), !cir.ptr<!s64i>
+// CIR:  %[[OFFSET:.*]] = cir.load %[[OFFSET_PTR_CAST]] : !cir.ptr<!s64i>, !s64i
+// CIR:  %[[VBASE_ADDR:.*]] = cir.ptr_stride({{.*}} : !cir.ptr<!u8i>, %[[OFFSET]] : !s64i), !cir.ptr<!u8i>
+// CIR:  cir.cast(bitcast, %[[VBASE_ADDR]] : !cir.ptr<!u8i>), !cir.ptr<!ty_D>
+
+// FIXME: this version should include null check.
+// LLVM-LABEL: @_Z1av()
+// LLVM:  %[[OFFSET_OFFSET:.*]] = getelementptr i8, ptr {{.*}}, i64 -32
+// LLVM:  %[[OFFSET_PTR:.*]] = load i64, ptr %[[OFFSET_OFFSET]], align 8
+// LLVM:  %[[VBASE_ADDR:.*]] = getelementptr i8, ptr {{.*}}, i64 %[[OFFSET_PTR]]
+// LLVM:  store ptr %[[VBASE_ADDR]], ptr {{.*}}, align 8
+
+B* b() { return x; }
+BB* c() { return x; }
+
+// Put the vbptr at a non-zero offset inside a non-virtual base.
+struct E { int e; };
+struct F : E, D { int f; };
+
+F* y;
+
+BB* d() { return y; }
+// CIR-LABEL: @_Z1dv
+// CIR: %[[OFFSET:.*]] = cir.load {{.*}} : !cir.ptr<!s64i>, !s64i
+// CIR: %[[ADJUST:.*]] = cir.const #cir.int<16> : !s64i
+// CIR: cir.binop(add, %[[OFFSET]], %[[ADJUST]]) : !s64i
+
+// LLVM-LABEL: @_Z1dv
+// LLVM: %[[OFFSET_OFFSET:.*]] = getelementptr i8, ptr {{.*}}, i64 -48
+// LLVM: %[[OFFSET_PTR:.*]] = load i64, ptr %[[OFFSET_OFFSET]], align 8
+// LLVM: %[[ADJUST:.*]] = add i64 %[[OFFSET_PTR]], 16
+// LLVM: %[[VBASE_ADDR:.*]] = getelementptr i8, ptr {{.*}}, i64 %[[ADJUST]]
+// LLVM: store ptr %[[VBASE_ADDR]],