[CIR][CIRGen] Scalar emission for casts of base to derived

clang/include/clang/CIR/Dialect/IR/CIROps.td

@@ -3142,7 +3142,7 @@ def VecShuffleDynamicOp : CIR_Op<"vec.shuffle.dynamic",
 }
 
 //===----------------------------------------------------------------------===//
-// BaseClassAddr
+// BaseClassAddr & BaseClassAddr
 //===----------------------------------------------------------------------===//
 
 def BaseClassAddrOp : CIR_Op<"base_class_addr"> {
@@ -3182,8 +3182,63 @@ def BaseClassAddrOp : CIR_Op<"base_class_addr"> {
     `)` `[` $offset `]` `->` qualified(type($base_addr)) attr-dict
   }];
 
-  // FIXME: add verifier.
-  // Check whether both src/dst pointee's are compatible.
+  // The validity of the relationship of derived and base cannot
+  // yet be verified, currently not worth adding such a feature
+  // just for this.
+  let hasVerifier = 0;
+}
+
+def DerivedClassAddrOp : CIR_Op<"derived_class_addr"> {
+  let summary = "Get the derived class address for a class/struct";
+  let description = [{
+    The `cir.derived_class_addr` operaration gets the address of a particular
+    derived class given a non-virtual base class pointer. The offset in bytes
+    of the base class must be passed in, similar to `cir.base_class_addr`, but
+    going into the other direction (In the itanium ABI this means lowering to
+    a negative offset).
+
+    The operation contains a flag for whether or not the operand may be nullptr.
+    That depends on the context and cannot be known by the operation, and that
+    information affects how the operation is lowered.
+
+    Example:
+    ```c++
+    class A { int a; };
+    class B { int b;
+    public:
+        A *getAsA();
+    };
+    class X : public A, public B { int x; };
+
+    A *B::getAsA() {
+      return static_cast<X*>(this);
+    ```
+
+    leads to
+    ```mlir
+      %2 = cir.load %0 : !cir.ptr<!cir.ptr<!ty_B>>, !cir.ptr<!ty_B>
+      %3 = cir.derived_class_addr(%2 : !cir.ptr<!ty_B> nonnull) [4] -> !cir.ptr<!ty_X>
+      %4 = cir.base_class_addr(%3 : !cir.ptr<!ty_X>) [0] -> !cir.ptr<!ty_A>
+      cir.return %4
+    ```
+  }];
+
+  let arguments = (ins
+    Arg<CIR_PointerType, "derived class pointer", [MemRead]>:$base_addr,
+    IndexAttr:$offset, UnitAttr:$assume_not_null);
+
+  let results = (outs Res<CIR_PointerType, "">:$derived_addr);
+
+  let assemblyFormat = [{
+    `(`
+      $base_addr `:` qualified(type($base_addr))
+      (`nonnull` $assume_not_null^)?
+    `)` `[` $offset `]` `->` qualified(type($derived_addr)) attr-dict
+  }];
+
+  // The validity of the relationship of derived and base cannot
+  // yet be verified, currently not worth adding such a feature
+  // just for this.
   let hasVerifier = 0;
 }
 

clang/lib/CIR/CodeGen/CIRGenBuilder.h

@@ -707,6 +707,18 @@ class CIRGenBuilderTy : public CIRBaseBuilderTy {
     return Address(baseAddr, ptrTy, addr.getAlignment());
   }
 
+  cir::Address createDerivedClassAddr(mlir::Location loc, cir::Address addr,
+                                      mlir::Type destType, unsigned offset,
+                                      bool assumeNotNull) {
+    if (destType == addr.getElementType())
+      return addr;
+
+    auto ptrTy = getPointerTo(destType);
+    auto derivedAddr = create<mlir::cir::DerivedClassAddrOp>(
+        loc, ptrTy, addr.getPointer(), mlir::APInt(64, offset), assumeNotNull);
+    return Address(derivedAddr, ptrTy, addr.getAlignment());
+  }
+
   mlir::Value createVTTAddrPoint(mlir::Location loc, mlir::Type retTy,
                                  mlir::Value addr, uint64_t offset) {
     return create<mlir::cir::VTTAddrPointOp>(

clang/lib/CIR/CodeGen/CIRGenClass.cpp

@@ -1503,6 +1503,37 @@ mlir::Value CIRGenFunction::GetVTTParameter(GlobalDecl GD, bool ForVirtualBase,
   }
 }
 
+CharUnits CIRGenModule::getNonVirtualBaseClassOffset(
+    const CXXRecordDecl *classDecl, CastExpr::path_const_iterator pathBegin,
+    CastExpr::path_const_iterator pathEnd) {
+  assert(pathBegin != pathEnd && "Base path should not be empty!");
+
+  CharUnits Offset =
+      computeNonVirtualBaseClassOffset(classDecl, pathBegin, pathEnd);
+  return Offset;
+}
+
+Address CIRGenFunction::getAddressOfDerivedClass(
+    Address baseAddr, const CXXRecordDecl *derived,
+    CastExpr::path_const_iterator pathBegin,
+    CastExpr::path_const_iterator pathEnd, bool nullCheckValue) {
+  assert(pathBegin != pathEnd && "Base path should not be empty!");
+
+  QualType derivedTy =
+      getContext().getCanonicalType(getContext().getTagDeclType(derived));
+  mlir::Type derivedValueTy = ConvertType(derivedTy);
+  CharUnits nonVirtualOffset =
+      CGM.getNonVirtualBaseClassOffset(derived, pathBegin, pathEnd);
+
+  // Note that in OG, no offset (nonVirtualOffset.getQuantity() == 0) means it
+  // just gives the address back. In CIR a `cir.derived_class` is created and
+  // made into a nop later on during lowering.
+  return builder.createDerivedClassAddr(getLoc(derived->getSourceRange()),
+                                        baseAddr, derivedValueTy,
+                                        nonVirtualOffset.getQuantity(),
+                                        /*assumeNotNull=*/not nullCheckValue);
+}
+
 Address
 CIRGenFunction::getAddressOfBaseClass(Address Value,
                                       const CXXRecordDecl *Derived,
@@ -1553,7 +1584,11 @@ CIRGenFunction::getAddressOfBaseClass(Address Value,
                                        /*assumeNotNull=*/not NullCheckValue);
   }
 
-  // Conversion to a virtual base.  cir.base_class_addr can't handle this.
+  if (sanitizePerformTypeCheck()) {
+    assert(!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");

clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp

@@ -1696,8 +1696,24 @@ mlir::Value ScalarExprEmitter::VisitCastExpr(CastExpr *CE) {
     }
     return V;
   }
-  case CK_BaseToDerived:
-    llvm_unreachable("NYI");
+  case CK_BaseToDerived: {
+    const CXXRecordDecl *DerivedClassDecl = DestTy->getPointeeCXXRecordDecl();
+    assert(DerivedClassDecl && "BaseToDerived arg isn't a C++ object pointer!");
+    Address Base = CGF.buildPointerWithAlignment(E);
+    Address Derived = CGF.getAddressOfDerivedClass(
+        Base, DerivedClassDecl, CE->path_begin(), CE->path_end(),
+        CGF.shouldNullCheckClassCastValue(CE));
+
+    // C++11 [expr.static.cast]p11: Behavior is undefined if a downcast is
+    // performed and the object is not of the derived type.
+    if (CGF.sanitizePerformTypeCheck())
+      assert(!MissingFeatures::sanitizeOther());
+
+    if (CGF.SanOpts.has(SanitizerKind::CFIDerivedCast))
+      assert(!MissingFeatures::sanitizeOther());
+
+    return CGF.getAsNaturalPointerTo(Derived, CE->getType()->getPointeeType());
+  }
   case CK_DerivedToBase: {
     // The EmitPointerWithAlignment path does this fine; just discard
     // the alignment.

clang/lib/CIR/CodeGen/CIRGenFunction.h

@@ -1631,6 +1631,12 @@ class CIRGenFunction : public CIRGenTypeCache {
                                 CastExpr::path_const_iterator PathEnd,
                                 bool NullCheckValue, SourceLocation Loc);
 
+  Address getAddressOfDerivedClass(Address baseAddr,
+                                   const CXXRecordDecl *derived,
+                                   CastExpr::path_const_iterator pathBegin,
+                                   CastExpr::path_const_iterator pathEnd,
+                                   bool nullCheckValue);
+
   /// Emit code for the start of a function.
   /// \param Loc       The location to be associated with the function.
   /// \param StartLoc  The location of the function body.

clang/lib/CIR/CodeGen/CIRGenModule.h

@@ -298,6 +298,13 @@ class CIRGenModule : public CIRGenTypeCache {
                                    CastExpr::path_const_iterator Start,
                                    CastExpr::path_const_iterator End);
 
+  /// Returns the offset from a derived class to a class. Returns null if the
+  /// offset is 0.
+  CharUnits
+  getNonVirtualBaseClassOffset(const CXXRecordDecl *classDecl,
+                               CastExpr::path_const_iterator pathBegin,
+                               CastExpr::path_const_iterator pathEnd);
+
   /// Get the CIR attributes and calling convention to use for a particular
   /// function type.
   ///

clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp

@@ -854,6 +854,40 @@ class CIRBaseClassAddrOpLowering
   }
 };
 
+class CIRDerivedClassAddrOpLowering
+    : public mlir::OpConversionPattern<mlir::cir::DerivedClassAddrOp> {
+public:
+  using mlir::OpConversionPattern<
+      mlir::cir::DerivedClassAddrOp>::OpConversionPattern;
+
+  mlir::LogicalResult
+  matchAndRewrite(mlir::cir::DerivedClassAddrOp derivedClassOp,
+                  OpAdaptor adaptor,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    const auto resultType =
+        getTypeConverter()->convertType(derivedClassOp.getType());
+    mlir::Value baseAddr = adaptor.getBaseAddr();
+    int64_t offsetVal = adaptor.getOffset().getZExtValue() * -1;
+    llvm::SmallVector<mlir::LLVM::GEPArg, 1> offset = {offsetVal};
+    mlir::Type byteType = mlir::IntegerType::get(resultType.getContext(), 8,
+                                                 mlir::IntegerType::Signless);
+    if (derivedClassOp.getAssumeNotNull()) {
+      rewriter.replaceOpWithNewOp<mlir::LLVM::GEPOp>(
+          derivedClassOp, resultType, byteType, baseAddr, offset);
+    } else {
+      auto loc = derivedClassOp.getLoc();
+      mlir::Value isNull = rewriter.create<mlir::LLVM::ICmpOp>(
+          loc, mlir::LLVM::ICmpPredicate::eq, baseAddr,
+          rewriter.create<mlir::LLVM::ZeroOp>(loc, baseAddr.getType()));
+      mlir::Value adjusted = rewriter.create<mlir::LLVM::GEPOp>(
+          loc, resultType, byteType, baseAddr, offset);
+      rewriter.replaceOpWithNewOp<mlir::LLVM::SelectOp>(derivedClassOp, isNull,
+                                                        baseAddr, adjusted);
+    }
+    return mlir::success();
+  }
+};
+
 static mlir::Value
 getValueForVTableSymbol(mlir::Operation *op,
                         mlir::ConversionPatternRewriter &rewriter,
@@ -4218,8 +4252,9 @@ void populateCIRToLLVMConversionPatterns(
       CIRCmpThreeWayOpLowering, CIRClearCacheOpLowering, CIREhTypeIdOpLowering,
       CIRCatchParamOpLowering, CIRResumeOpLowering, CIRAllocExceptionOpLowering,
       CIRFreeExceptionOpLowering, CIRThrowOpLowering, CIRIntrinsicCallLowering,
-      CIRBaseClassAddrOpLowering, CIRVTTAddrPointOpLowering,
-      CIRIsFPClassOpLowering, CIRAbsOpLowering, CIRMemMoveOpLowering
+      CIRBaseClassAddrOpLowering, CIRDerivedClassAddrOpLowering,
+      CIRVTTAddrPointOpLowering, CIRIsFPClassOpLowering, CIRAbsOpLowering,
+      CIRMemMoveOpLowering
 #define GET_BUILTIN_LOWERING_LIST
 #include "clang/CIR/Dialect/IR/CIRBuiltinsLowering.inc"
 #undef GET_BUILTIN_LOWERING_LIST

clang/test/CIR/CodeGen/derived-cast.cpp

@@ -0,0 +1,45 @@
+// RUN: %clang_cc1 -triple aarch64-none-linux-android21 -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 -fclangir -emit-llvm -fno-clangir-call-conv-lowering %s -o %t.ll
+// RUN: FileCheck --check-prefix=LLVM --input-file=%t.ll %s
+
+class A {
+    int a;
+};
+
+class B {
+    int b;
+public:
+    A *getAsA();
+};
+
+class X : public A, public B {
+    int x;
+};
+
+A *B::getAsA() {
+  return static_cast<X*>(this);
+
+  // CHECK-LABEL: define{{.*}} ptr @_ZN1B6getAsAEv
+  // CHECK: %[[THIS:.*]] = load ptr, ptr
+  // CHECK-NEXT: getelementptr inbounds i8, ptr %[[THIS]], i64 -4
+}
+
+// CIR-LABEL: @_ZN1B6getAsAEv
+// CIR: %[[VAL_1:.*]] = cir.alloca !cir.ptr<!ty_B>, !cir.ptr<!cir.ptr<!ty_B>>, ["this", init] {alignment = 8 : i64}
+// CIR: %[[VAL_2:.*]] = cir.alloca !cir.ptr<!ty_A>, !cir.ptr<!cir.ptr<!ty_A>>, ["__retval"] {alignment = 8 : i64}
+// CIR: %[[VAL_3:.*]] = cir.load %[[VAL_1]] : !cir.ptr<!cir.ptr<!ty_B>>, !cir.ptr<!ty_B>
+// CIR: %[[VAL_4:.*]] = cir.derived_class_addr(%[[VAL_3]] : !cir.ptr<!ty_B> nonnull) [4] -> !cir.ptr<!ty_X>
+// CIR: %[[VAL_5:.*]] = cir.base_class_addr(%[[VAL_4]] : !cir.ptr<!ty_X>) [0] -> !cir.ptr<!ty_A>
+// CIR: cir.store %[[VAL_5]], %[[VAL_2]] : !cir.ptr<!ty_A>, !cir.ptr<!cir.ptr<!ty_A>>
+// CIR: %[[VAL_6:.*]] = cir.load %[[VAL_2]] : !cir.ptr<!cir.ptr<!ty_A>>, !cir.ptr<!ty_A>
+// CIR: cir.return %[[VAL_6]] : !cir.ptr<!ty_A>
+
+// LLVM-LABEL: @_ZN1B6getAsAEv
+// LLVM:  %[[VAL_1:.*]] = alloca ptr, i64 1, align 8
+// LLVM:  store ptr %[[VAL_2:.*]], ptr %[[VAL_0:.*]], align 8
+// LLVM:  %[[VAL_3:.*]] = load ptr, ptr %[[VAL_0]], align 8
+// LLVM:  %[[VAL_4:.*]] = getelementptr i8, ptr %[[VAL_3]], i32 -4
+// LLVM:  %[[VAL_5:.*]] = icmp eq ptr %[[VAL_4]], null,
+// LLVM:  %[[VAL_6:.*]] = getelementptr i8, ptr %[[VAL_4]], i32 0,
+// LLVM:  %[[VAL_7:.*]] = select i1 %[[VAL_5]], ptr %[[VAL_4]], ptr %[[VAL_6]],