[clang] [CIR] Upstream AssignmentMemcpyizer (PR #236803)
Steffen Larsen via cfe-commits
cfe-commits at lists.llvm.org
Thu Nov 5 00:33:17 PST 2026
================
@@ -24,6 +24,273 @@
using namespace clang;
using namespace clang::CIRGen;
+namespace {
+// TODO(cir): a lot of what we see under this namespace is a strong candidate
+// to be shared between LLVM and CIR codegen.
+
+/// RAII object to indicate that codegen is copying the value representation
+/// instead of the object representation. Useful when copying a struct or
+/// class which has uninitialized members and we're only performing
+/// lvalue-to-rvalue conversion on the object but not its members.
+class CopyingValueRepresentation {
+public:
+ explicit CopyingValueRepresentation(CIRGenFunction &cgf)
+ : cgf(cgf), oldSanOpts(cgf.sanOpts) {
+ cgf.sanOpts.set(SanitizerKind::Bool, false);
+ cgf.sanOpts.set(SanitizerKind::Enum, false);
+ }
+ ~CopyingValueRepresentation() { cgf.sanOpts = oldSanOpts; }
+
+private:
+ CIRGenFunction &cgf;
+ SanitizerSet oldSanOpts;
+};
+
+class FieldMemcpyizer {
+public:
+ FieldMemcpyizer(CIRGenFunction &cgf, const CXXMethodDecl *methodDecl,
+ const VarDecl *srcRec)
+ : cgf(cgf), methodDecl(methodDecl), classDecl(methodDecl->getParent()),
+ srcRec(srcRec),
+ recLayout(cgf.getContext().getASTRecordLayout(classDecl)),
+ firstField(nullptr), lastField(nullptr), firstFieldOffset(0),
+ lastFieldOffset(0), lastAddedFieldIndex(0) {}
+
+ bool isMemcpyableField(FieldDecl *f) const {
+ // Never memcpy fields when we are adding poised paddings.
+ if (cgf.getContext().getLangOpts().SanitizeAddressFieldPadding)
+ return false;
+ Qualifiers qual = f->getType().getQualifiers();
+ if (qual.hasVolatile() || qual.hasObjCLifetime())
+ return false;
+ return true;
+ }
+
+ void addMemcpyableField(FieldDecl *f) {
+ // TODO(cir): isEmptyFieldForLayout is not handled here yet.
+ // Incubator has assert(!cir::MissingFeatures::isEmptyFieldForLayout());
+ if (f->isZeroSize(cgf.getContext()))
+ return;
+ if (!firstField)
+ addInitialField(f);
+ else
+ addNextField(f);
+ }
+
+ CharUnits getMemcpySize(uint64_t firstByteOffset) const {
+ ASTContext &astContext = cgf.getContext();
+ unsigned lastFieldSize =
+ lastField->isBitField()
+ ? lastField->getBitWidthValue()
+ : astContext.toBits(
+ astContext.getTypeInfoDataSizeInChars(lastField->getType())
+ .Width);
+ uint64_t memcpySizeBits = lastFieldOffset + lastFieldSize -
+ firstByteOffset + astContext.getCharWidth() - 1;
+ return astContext.toCharUnitsFromBits(memcpySizeBits);
+ }
+
+ void emitMemcpy() {
+ // Give the subclass a chance to bail out if it feels the memcpy isn't worth
+ // it (e.g. Hasn't aggregated enough data).
+ if (!firstField)
+ return;
+
+ uint64_t firstByteOffset;
+ if (firstField->isBitField()) {
+ const CIRGenRecordLayout &rl =
+ cgf.getTypes().getCIRGenRecordLayout(firstField->getParent());
+ const CIRGenBitFieldInfo &bfInfo = rl.getBitFieldInfo(firstField);
+ // firstFieldOffset is not appropriate for bitfields,
+ // we need to use the storage offset instead.
+ firstByteOffset = cgf.getContext().toBits(bfInfo.storageOffset);
+ } else {
+ firstByteOffset = firstFieldOffset;
+ }
+
+ CharUnits memcpySize = getMemcpySize(firstByteOffset);
+ QualType recordTy = cgf.getContext().getTagType(
+ ElaboratedTypeKeyword::None, /*Qualifier=*/std::nullopt, classDecl,
+ /*OwnsTag=*/false);
+ Address thisPtr = cgf.loadCXXThisAddress();
+ LValue destLv = cgf.makeAddrLValue(thisPtr, recordTy);
+ LValue dest = cgf.emitLValueForFieldInitialization(destLv, firstField,
+ firstField->getName());
+ cir::LoadOp srcPtr = cgf.getBuilder().createLoad(
+ cgf.getLoc(methodDecl->getLocation()), cgf.getAddrOfLocalVar(srcRec));
+ LValue srcLv = cgf.makeNaturalAlignAddrLValue(srcPtr, recordTy);
+ LValue src = cgf.emitLValueForFieldInitialization(srcLv, firstField,
+ firstField->getName());
+
+ emitMemcpyIR(dest.isBitField() ? dest.getBitFieldAddress()
+ : dest.getAddress(),
+ src.isBitField() ? src.getBitFieldAddress() : src.getAddress(),
+ memcpySize);
+ reset();
+ }
+
+ void reset() { firstField = nullptr; }
+
+protected:
+ CIRGenFunction &cgf;
+ const CXXMethodDecl *methodDecl;
+ const CXXRecordDecl *classDecl;
+
+private:
+ void emitMemcpyIR(Address destPtr, Address srcPtr, CharUnits size) {
+ mlir::Location loc = cgf.getLoc(methodDecl->getLocation());
+ CIRGenBuilderTy &builder = cgf.getBuilder();
+ mlir::Value sizeOp =
+ builder.getConstInt(loc, cgf.sizeTy, size.getQuantity());
+ Address destCast = destPtr.withElementType(builder, cgf.voidTy);
+ Address srcCast = srcPtr.withElementType(builder, cgf.voidTy);
+ builder.createMemCpy(loc, destCast, srcCast, sizeOp);
+ }
+
+ void addInitialField(FieldDecl *f) {
+ firstField = f;
+ lastField = f;
+ firstFieldOffset = recLayout.getFieldOffset(f->getFieldIndex());
+ lastFieldOffset = firstFieldOffset;
+ lastAddedFieldIndex = f->getFieldIndex();
+ }
+
+ void addNextField(FieldDecl *f) {
+ // For the most part, the following invariant will hold:
+ // f->getFieldIndex() == lastAddedFieldIndex + 1
+ // The one exception is that Sema won't add a copy-initializer for an
+ // unnamed bitfield, which will show up here as a gap in the sequence.
+ assert(f->getFieldIndex() >= lastAddedFieldIndex + 1 &&
+ "Cannot aggregate fields out of order.");
+ lastAddedFieldIndex = f->getFieldIndex();
+
+ // The 'first' and 'last' fields are chosen by offset, rather than field
+ // index. This allows the code to support bitfields, as well as regular
+ // fields.
+ uint64_t fOffset = recLayout.getFieldOffset(f->getFieldIndex());
+ if (fOffset < firstFieldOffset) {
+ firstField = f;
+ firstFieldOffset = fOffset;
+ } else if (fOffset >= lastFieldOffset) {
+ lastField = f;
+ lastFieldOffset = fOffset;
+ }
+ }
----------------
steffenlarsen wrote:
Admittedly, these seem odd to me. From what I can tell, they are only used in one place each and the logic between inserting initial and "next" is something the caller has to check anyway. I would just inline these and have the "Set initial if missing" return after its work to avoid indenting the larger body.
https://github.com/llvm/llvm-project/pull/236803
More information about the cfe-commits
mailing list