[clang] df6d1cf - [CIR] Upstream support for l-value references (#138001)
via cfe-commits
cfe-commits at lists.llvm.org
Wed Apr 30 14:51:48 PDT 2025
Author: Andy Kaylor
Date: 2025-04-30T14:51:45-07:00
New Revision: df6d1cf4c2e9660967a53498a991ef9c1915c61e
URL: https://github.com/llvm/llvm-project/commit/df6d1cf4c2e9660967a53498a991ef9c1915c61e
DIFF: https://github.com/llvm/llvm-project/commit/df6d1cf4c2e9660967a53498a991ef9c1915c61e.diff
LOG: [CIR] Upstream support for l-value references (#138001)
This adds basic support for handling reference values.
Added:
Modified:
clang/lib/CIR/CodeGen/CIRGenDecl.cpp
clang/lib/CIR/CodeGen/CIRGenExpr.cpp
clang/lib/CIR/CodeGen/CIRGenFunction.h
clang/lib/CIR/CodeGen/CIRGenStmt.cpp
clang/lib/CIR/CodeGen/CIRGenTypes.cpp
clang/test/CIR/CodeGen/basic.cpp
Removed:
################################################################################
diff --git a/clang/lib/CIR/CodeGen/CIRGenDecl.cpp b/clang/lib/CIR/CodeGen/CIRGenDecl.cpp
index f16671cc3f522..90498cd18f46b 100644
--- a/clang/lib/CIR/CodeGen/CIRGenDecl.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenDecl.cpp
@@ -90,8 +90,13 @@ void CIRGenFunction::emitAutoVarInit(
// If this local has an initializer, emit it now.
const Expr *init = d.getInit();
- if (!type.isPODType(getContext())) {
- cgm.errorNYI(d.getSourceRange(), "emitAutoVarInit: non-POD type");
+ // Initialize the variable here if it doesn't have a initializer and it is a
+ // C struct that is non-trivial to initialize or an array containing such a
+ // struct.
+ if (!init && type.isNonTrivialToPrimitiveDefaultInitialize() ==
+ QualType::PDIK_Struct) {
+ cgm.errorNYI(d.getSourceRange(),
+ "emitAutoVarInit: non-trivial to default initialize");
return;
}
@@ -240,7 +245,10 @@ void CIRGenFunction::emitExprAsInit(const Expr *init, const ValueDecl *d,
QualType type = d->getType();
if (type->isReferenceType()) {
- cgm.errorNYI(init->getSourceRange(), "emitExprAsInit: reference type");
+ RValue rvalue = emitReferenceBindingToExpr(init);
+ if (capturedByInit)
+ cgm.errorNYI(init->getSourceRange(), "emitExprAsInit: captured by init");
+ emitStoreThroughLValue(rvalue, lvalue);
return;
}
switch (CIRGenFunction::getEvaluationKind(type)) {
diff --git a/clang/lib/CIR/CodeGen/CIRGenExpr.cpp b/clang/lib/CIR/CodeGen/CIRGenExpr.cpp
index ff14798b9d34c..a50e1fd18c807 100644
--- a/clang/lib/CIR/CodeGen/CIRGenExpr.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenExpr.cpp
@@ -439,7 +439,13 @@ LValue CIRGenFunction::emitDeclRefLValue(const DeclRefExpr *e) {
cgm.errorNYI(e->getSourceRange(), "emitDeclRefLValue: static local");
}
- return makeAddrLValue(addr, ty, AlignmentSource::Type);
+ // Drill into reference types.
+ LValue lv =
+ vd->getType()->isReferenceType()
+ ? emitLoadOfReferenceLValue(addr, getLoc(e->getSourceRange()),
+ vd->getType(), AlignmentSource::Decl)
+ : makeAddrLValue(addr, ty, AlignmentSource::Decl);
+ return lv;
}
cgm.errorNYI(e->getSourceRange(), "emitDeclRefLValue: unhandled decl type");
@@ -1065,6 +1071,45 @@ mlir::Value CIRGenFunction::emitAlloca(StringRef name, mlir::Type ty,
return addr;
}
+RValue CIRGenFunction::emitReferenceBindingToExpr(const Expr *e) {
+ // Emit the expression as an lvalue.
+ LValue lv = emitLValue(e);
+ assert(lv.isSimple());
+ mlir::Value value = lv.getPointer();
+
+ assert(!cir::MissingFeatures::sanitizers());
+
+ return RValue::get(value);
+}
+
+Address CIRGenFunction::emitLoadOfReference(LValue refLVal, mlir::Location loc,
+ LValueBaseInfo *pointeeBaseInfo) {
+ if (refLVal.isVolatile())
+ cgm.errorNYI(loc, "load of volatile reference");
+
+ cir::LoadOp load =
+ builder.create<cir::LoadOp>(loc, refLVal.getAddress().getElementType(),
+ refLVal.getAddress().getPointer());
+
+ assert(!cir::MissingFeatures::opTBAA());
+
+ QualType pointeeType = refLVal.getType()->getPointeeType();
+ CharUnits align = cgm.getNaturalTypeAlignment(pointeeType, pointeeBaseInfo);
+ return Address(load, convertTypeForMem(pointeeType), align);
+}
+
+LValue CIRGenFunction::emitLoadOfReferenceLValue(Address refAddr,
+ mlir::Location loc,
+ QualType refTy,
+ AlignmentSource source) {
+ LValue refLVal = makeAddrLValue(refAddr, refTy, LValueBaseInfo(source));
+ LValueBaseInfo pointeeBaseInfo;
+ assert(!cir::MissingFeatures::opTBAA());
+ Address pointeeAddr = emitLoadOfReference(refLVal, loc, &pointeeBaseInfo);
+ return makeAddrLValue(pointeeAddr, refLVal.getType()->getPointeeType(),
+ pointeeBaseInfo);
+}
+
mlir::Value CIRGenFunction::createDummyValue(mlir::Location loc,
clang::QualType qt) {
mlir::Type t = convertType(qt);
diff --git a/clang/lib/CIR/CodeGen/CIRGenFunction.h b/clang/lib/CIR/CodeGen/CIRGenFunction.h
index 592d39930089d..d50abfcfbc867 100644
--- a/clang/lib/CIR/CodeGen/CIRGenFunction.h
+++ b/clang/lib/CIR/CodeGen/CIRGenFunction.h
@@ -560,6 +560,11 @@ class CIRGenFunction : public CIRGenTypeCache {
/// returning the rvalue.
RValue emitLoadOfLValue(LValue lv, SourceLocation loc);
+ Address emitLoadOfReference(LValue refLVal, mlir::Location loc,
+ LValueBaseInfo *pointeeBaseInfo);
+ LValue emitLoadOfReferenceLValue(Address refAddr, mlir::Location loc,
+ QualType refTy, AlignmentSource source);
+
/// EmitLoadOfScalar - Load a scalar value from an address, taking
/// care to appropriately convert from the memory representation to
/// the LLVM value representation. The l-value must be a simple
@@ -587,6 +592,9 @@ class CIRGenFunction : public CIRGenTypeCache {
Address emitPointerWithAlignment(const clang::Expr *expr,
LValueBaseInfo *baseInfo);
+ /// Emits a reference binding to the passed in expression.
+ RValue emitReferenceBindingToExpr(const Expr *e);
+
mlir::LogicalResult emitReturnStmt(const clang::ReturnStmt &s);
/// Emit a conversion from the specified type to the specified destination
diff --git a/clang/lib/CIR/CodeGen/CIRGenStmt.cpp b/clang/lib/CIR/CodeGen/CIRGenStmt.cpp
index 31e29e7828156..dffa71046df1d 100644
--- a/clang/lib/CIR/CodeGen/CIRGenStmt.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenStmt.cpp
@@ -384,8 +384,10 @@ mlir::LogicalResult CIRGenFunction::emitReturnStmt(const ReturnStmt &s) {
} else if (cast<FunctionDecl>(curGD.getDecl())
->getReturnType()
->isReferenceType()) {
- getCIRGenModule().errorNYI(s.getSourceRange(),
- "function return type that is a reference");
+ // If this function returns a reference, take the address of the
+ // expression rather than the value.
+ RValue result = emitReferenceBindingToExpr(rv);
+ builder.createStore(loc, result.getScalarVal(), *fnRetAlloca);
} else {
mlir::Value value = nullptr;
switch (CIRGenFunction::getEvaluationKind(rv->getType())) {
diff --git a/clang/lib/CIR/CodeGen/CIRGenTypes.cpp b/clang/lib/CIR/CodeGen/CIRGenTypes.cpp
index de8ea0bd92158..98c9398fd4d94 100644
--- a/clang/lib/CIR/CodeGen/CIRGenTypes.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenTypes.cpp
@@ -381,6 +381,16 @@ mlir::Type CIRGenTypes::convertType(QualType type) {
break;
}
+ case Type::LValueReference:
+ case Type::RValueReference: {
+ const ReferenceType *refTy = cast<ReferenceType>(ty);
+ QualType elemTy = refTy->getPointeeType();
+ auto pointeeType = convertTypeForMem(elemTy);
+ resultType = builder.getPointerTo(pointeeType);
+ assert(resultType && "Cannot get pointer type?");
+ break;
+ }
+
case Type::Pointer: {
const PointerType *ptrTy = cast<PointerType>(ty);
QualType elemTy = ptrTy->getPointeeType();
diff --git a/clang/test/CIR/CodeGen/basic.cpp b/clang/test/CIR/CodeGen/basic.cpp
index 1f289e905dd09..b5b3e36b4aa08 100644
--- a/clang/test/CIR/CodeGen/basic.cpp
+++ b/clang/test/CIR/CodeGen/basic.cpp
@@ -102,3 +102,42 @@ size_type max_size() {
// CHECK: %3 = cir.cast(integral, %2 : !s32i), !u64i
// CHECK: %4 = cir.const #cir.int<8> : !u64i
// CHECK: %5 = cir.binop(div, %3, %4) : !u64i
+
+void ref_arg(int &x) {
+ int y = x;
+ x = 3;
+}
+
+// CHECK: cir.func @_Z7ref_argRi(%[[ARG:.*]]: !cir.ptr<!s32i> {{.*}})
+// CHECK: %[[X_REF_ADDR:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["x", init, const] {alignment = 8 : i64}
+// CHECK: %[[Y_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["y", init] {alignment = 4 : i64}
+// CHECK: cir.store %[[ARG]], %[[X_REF_ADDR]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
+// CHECK: %[[X_REF:.*]] = cir.load %[[X_REF_ADDR]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CHECK: %[[Y:.*]] = cir.load %[[X_REF]] : !cir.ptr<!s32i>, !s32i
+// CHECK: cir.store %[[Y]], %[[Y_ADDR]] : !s32i, !cir.ptr<!s32i>
+// CHECK: %[[THREE:.*]] = cir.const #cir.int<3> : !s32i
+// CHECK: %[[X_REF:.*]] = cir.load %[[X_REF_ADDR]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CHECK: cir.store %[[THREE]], %[[X_REF]] : !s32i, !cir.ptr<!s32i>
+// CHECK: cir.return
+
+short gs;
+short &return_ref() {
+ return gs;
+}
+
+// CHECK: cir.func @_Z10return_refv() -> !cir.ptr<!s16i>
+// CHECK: %[[RETVAL_ADDR:.*]] = cir.alloca !cir.ptr<!s16i>, !cir.ptr<!cir.ptr<!s16i>>, ["__retval"] {alignment = 8 : i64}
+// CHECK: %[[GS_ADDR:.*]] = cir.get_global @gs : !cir.ptr<!s16i>
+// CHECK: cir.store %[[GS_ADDR]], %[[RETVAL_ADDR]] : !cir.ptr<!s16i>, !cir.ptr<!cir.ptr<!s16i>>
+// CHECK: %[[RETVAL:.*]] = cir.load %[[RETVAL_ADDR]] : !cir.ptr<!cir.ptr<!s16i>>, !cir.ptr<!s16i>
+// CHECK: cir.return %[[RETVAL]] : !cir.ptr<!s16i>
+
+void ref_local(short x) {
+ short &y = x;
+}
+
+// CHECK: cir.func @_Z9ref_locals(%[[ARG:.*]]: !s16i {{.*}})
+// CHECK: %[[X_ADDR:.*]] = cir.alloca !s16i, !cir.ptr<!s16i>, ["x", init] {alignment = 2 : i64}
+// CHECK: %[[Y_REF_ADDR:.*]] = cir.alloca !cir.ptr<!s16i>, !cir.ptr<!cir.ptr<!s16i>>, ["y", init, const] {alignment = 8 : i64}
+// CHECK: cir.store %[[ARG]], %[[X_ADDR]] : !s16i, !cir.ptr<!s16i>
+// CHECK: cir.store %[[X_ADDR]], %[[Y_REF_ADDR]] : !cir.ptr<!s16i>, !cir.ptr<!cir.ptr<!s16i>>
More information about the cfe-commits
mailing list