================
@@ -647,6 +647,198 @@ static mlir::Value emitCXXNewAllocSize(CIRGenFunction
&cgf, const CXXNewExpr *e,
return size;
}
+/// Emit a call to an operator new or operator delete function, as implicitly
+/// created by new-expressions and delete-expressions.
+static RValue emitNewDeleteCall(CIRGenFunction &cgf,
+ const FunctionDecl *calleeDecl,
+ const FunctionProtoType *calleeType,
+ const CallArgList &args) {
+ cir::CIRCallOpInterface callOrTryCall;
+ cir::FuncOp calleePtr = cgf.cgm.getAddrOfFunction(calleeDecl);
+ CIRGenCallee callee =
+ CIRGenCallee::forDirect(calleePtr, GlobalDecl(calleeDecl));
+ RValue rv =
+ cgf.emitCall(cgf.cgm.getTypes().arrangeFreeFunctionCall(args,
calleeType),
+ callee, ReturnValueSlot(), args, &callOrTryCall);
+
+ /// C++1y [expr.new]p10:
+ /// [In a new-expression,] an implementation is allowed to omit a call
+ /// to a replaceable global allocation function.
+ ///
+ /// We model such elidable calls with the 'builtin' attribute.
+ assert(!cir::MissingFeatures::attributeBuiltin());
+ return rv;
+}
+
+RValue CIRGenFunction::emitNewOrDeleteBuiltinCall(const FunctionProtoType
*type,
+ const CallExpr *callExpr,
+ OverloadedOperatorKind op) {
+ CallArgList args;
+ emitCallArgs(args, type, callExpr->arguments());
+ // Find the allocation or deallocation function that we're calling.
+ ASTContext &astContext = getContext();
+ assert(op == OO_New || op == OO_Delete);
+ DeclarationName name = astContext.DeclarationNames.getCXXOperatorName(op);
+
+ clang::DeclContextLookupResult lookupResult =
+ astContext.getTranslationUnitDecl()->lookup(name);
+ for (const auto *decl : lookupResult) {
+ if (const auto *funcDecl = dyn_cast<FunctionDecl>(decl)) {
+ if (astContext.hasSameType(funcDecl->getType(), QualType(type, 0))) {
+ if (sanOpts.has(SanitizerKind::AllocToken)) {
+ // TODO: Set !alloc_token metadata.
+ assert(!cir::MissingFeatures::allocToken());
+ cgm.errorNYI("Alloc token sanitizer not yet supported!");
+ }
+
+ // Emit the call to operator new/delete.
+ return emitNewDeleteCall(*this, funcDecl, type, args);
+ }
+ }
+ }
+
+ llvm_unreachable("predeclared global operator new/delete is missing");
+}
+
+namespace {
+/// A cleanup to call the given 'operator delete' function upon abnormal
+/// exit from a new expression. Templated on a traits type that deals with
+/// ensuring that the arguments dominate the cleanup if necessary.
+template <typename Traits>
+class CallDeleteDuringNew final : public EHScopeStack::Cleanup {
+ /// Type used to hold llvm::Value*s.
+ typedef typename Traits::ValueTy ValueTy;
+ /// Type used to hold RValues.
+ typedef typename Traits::RValueTy RValueTy;
+ struct PlacementArg {
+ RValueTy argValue;
+ QualType argType;
+ };
+
+ unsigned numPlacementArgs : 30;
+ LLVM_PREFERRED_TYPE(AlignedAllocationMode)
+ unsigned passAlignmentToPlacementDelete : 1;
+ const FunctionDecl *operatorDelete;
+ ValueTy ptr;
+ ValueTy allocSize;
+ CharUnits allocAlign;
+
+ PlacementArg *getPlacementArgs() {
+ return reinterpret_cast<PlacementArg *>(this + 1);
+ }
+
+public:
+ static size_t getExtraSize(size_t numPlacementArgs) {
+ return numPlacementArgs * sizeof(PlacementArg);
+ }
+
+ CallDeleteDuringNew(size_t numPlacementArgs,
+ const FunctionDecl *operatorDelete, ValueTy ptr,
+ ValueTy allocSize,
+ const ImplicitAllocationParameters &iap,
+ CharUnits allocAlign)
+ : numPlacementArgs(numPlacementArgs),
+ passAlignmentToPlacementDelete(isAlignedAllocation(iap.PassAlignment)),
+ operatorDelete(operatorDelete), ptr(ptr), allocSize(allocSize),
+ allocAlign(allocAlign) {}
+
+ void setPlacementArg(unsigned i, RValueTy argValue, QualType argType) {
+ assert(i < numPlacementArgs && "index out of range");
+ getPlacementArgs()[i] = {argValue, argType};
+ }
+
+ void emit(CIRGenFunction &cgf, Flags flags) override {
+ const auto *fpt = operatorDelete->getType()->castAs<FunctionProtoType>();
+ CallArgList deleteArgs;
+
+ unsigned firstNonTypeArg = 0;
+ TypeAwareAllocationMode typeAwareDeallocation =
TypeAwareAllocationMode::No;
+ assert(!cir::MissingFeatures::typeAwareAllocation());
+
+ // The first argument after type-identity parameter (if any) is always
+ // a void* (or C* for a destroying operator delete for class type C).
+ deleteArgs.add(Traits::get(cgf, ptr), fpt->getParamType(firstNonTypeArg));
+
+ // Figure out what other parameters we should be implicitly passing.
+ UsualDeleteParams params;
+ if (numPlacementArgs) {
+ // A placement deallocation function is implicitly passed an alignment
+ // if the placement allocation function was, but is never passed a size.
+ params.Alignment =
+ alignedAllocationModeFromBool(passAlignmentToPlacementDelete);
+ params.TypeAwareDelete = typeAwareDeallocation;
+ params.Size = isTypeAwareAllocation(params.TypeAwareDelete);
+ } else {
+ // For a non-placement new-expression, 'operator delete' can take a
+ // size and/or an alignment if it has the right parameters.
+ params = operatorDelete->getUsualDeleteParams();
+ }
+
+ assert(!params.DestroyingDelete &&
+ "should not call destroying delete in a new-expression");
+
+ // The second argument can be a std::size_t (for non-placement delete).
+ if (params.Size)
+ deleteArgs.add(Traits::get(cgf, allocSize),
+ cgf.getContext().getSizeType());
+
+ // The next (second or third) argument can be a std::align_val_t, which
+ // is an enum whose underlying type is std::size_t.
+ // FIXME: Use the right type as the parameter type. Note that in a call
+ // to operator delete(size_t, ...), we may not have it available.
+ if (isAlignedAllocation(params.Alignment))
+ cgf.cgm.errorNYI("CallDeleteDuringNew: aligned allocation");
+
+ // Pass the rest of the arguments, which must match exactly.
+ for (unsigned i = 0; i != numPlacementArgs; ++i) {
+ auto arg = getPlacementArgs()[i];
+ deleteArgs.add(Traits::get(cgf, arg.argValue), arg.argType);
+ }
+
+ // Call 'operator delete'.
+ emitNewDeleteCall(cgf, operatorDelete, fpt, deleteArgs);
+ }
+};
+} // namespace
+
+/// Enter a cleanup to call 'operator delete' if the initializer in a
+/// new-expression throws.
+static void enterNewDeleteCleanup(CIRGenFunction &cgf, const CXXNewExpr *e,
+ Address newPtr, mlir::Value allocSize,
+ CharUnits allocAlign,
+ const CallArgList &newArgs) {
+ unsigned numNonPlacementArgs = e->getNumImplicitArgs();
+
+ // If we're not inside a conditional branch, then the cleanup will
+ // dominate and we can do the easier (and more efficient) thing.
+ if (!cgf.isInConditionalBranch()) {
+ struct DirectCleanupTraits {
+ typedef mlir::Value ValueTy;
+ typedef RValue RValueTy;
+ static RValue get(CIRGenFunction &, ValueTy v) { return RValue::get(v); }
+ static RValue get(CIRGenFunction &, RValueTy v) { return v; }
+ };
+
+ typedef CallDeleteDuringNew<DirectCleanupTraits> DirectCleanup;
+
+ assert(!cir::MissingFeatures::typeAwareAllocation());
+ DirectCleanup *cleanup = cgf.ehStack.pushCleanupWithExtra<DirectCleanup>(
+ EHCleanup, e->getNumPlacementArgs(), e->getOperatorDelete(),
+ newPtr.getPointer(), allocSize, e->implicitAllocationParameters(),
+ allocAlign);
+ for (unsigned i = 0, n = e->getNumPlacementArgs(); i != n; ++i) {
+ const CallArg &arg = newArgs[i + numNonPlacementArgs];
----------------
erichkeane wrote:
Since we're doing this immediately, is there a good reason we cannot pass these
as an argument to the cleanup constructor and have it do it there, rather than
risk not constructing it?
https://github.com/llvm/llvm-project/pull/184707
_______________________________________________
cfe-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
