[CIR] Add basic support for operator new (#145802)

This adds the code to handle operator new expressions in ClangIR.

Author: andykaylor

clang/include/clang/CIR/MissingFeatures.h

@@ -110,6 +110,9 @@ struct MissingFeatures {
   static bool opCallLandingPad() { return false; }
   static bool opCallContinueBlock() { return false; }
 
+  // CXXNewExpr
+  static bool exprNewNullCheck() { return false; }
+
   // FnInfoOpts -- This is used to track whether calls are chain calls or
   // instance methods. Classic codegen uses chain call to track and extra free
   // register for x86 and uses instance method as a condition for a thunk
@@ -170,6 +173,7 @@ struct MissingFeatures {
   static bool armComputeVolatileBitfields() { return false; }
   static bool asmLabelAttr() { return false; }
   static bool astVarDeclInterface() { return false; }
+  static bool attributeBuiltin() { return false; }
   static bool attributeNoBuiltin() { return false; }
   static bool bitfields() { return false; }
   static bool builtinCall() { return false; }

clang/lib/CIR/CodeGen/CIRGenCXXExpr.cpp

@@ -197,3 +197,195 @@ RValue CIRGenFunction::emitCXXMemberOrOperatorCall(
   assert(!cir::MissingFeatures::opCallMustTail());
   return emitCall(fnInfo, callee, returnValue, args, nullptr, loc);
 }
+
+static mlir::Value emitCXXNewAllocSize(CIRGenFunction &cgf, const CXXNewExpr *e,
+                                       unsigned minElements,
+                                       mlir::Value &numElements,
+                                       mlir::Value &sizeWithoutCookie) {
+  QualType type = e->getAllocatedType();
+  mlir::Location loc = cgf.getLoc(e->getSourceRange());
+
+  if (!e->isArray()) {
+    CharUnits typeSize = cgf.getContext().getTypeSizeInChars(type);
+    sizeWithoutCookie = cgf.getBuilder().getConstant(
+        loc, cir::IntAttr::get(cgf.SizeTy, typeSize.getQuantity()));
+    return sizeWithoutCookie;
+  }
+
+  cgf.cgm.errorNYI(e->getSourceRange(), "emitCXXNewAllocSize: array");
+  return {};
+}
+
+static void storeAnyExprIntoOneUnit(CIRGenFunction &cgf, const Expr *init,
+                                    QualType allocType, Address newPtr,
+                                    AggValueSlot::Overlap_t mayOverlap) {
+  // FIXME: Refactor with emitExprAsInit.
+  switch (cgf.getEvaluationKind(allocType)) {
+  case cir::TEK_Scalar:
+    cgf.emitScalarInit(init, cgf.getLoc(init->getSourceRange()),
+                       cgf.makeAddrLValue(newPtr, allocType), false);
+    return;
+  case cir::TEK_Complex:
+    cgf.cgm.errorNYI(init->getSourceRange(),
+                     "storeAnyExprIntoOneUnit: complex");
+    return;
+  case cir::TEK_Aggregate: {
+    assert(!cir::MissingFeatures::aggValueSlotGC());
+    assert(!cir::MissingFeatures::sanitizers());
+    AggValueSlot slot = AggValueSlot::forAddr(
+        newPtr, allocType.getQualifiers(), AggValueSlot::IsDestructed,
+        AggValueSlot::IsNotAliased, mayOverlap, AggValueSlot::IsNotZeroed);
+    cgf.emitAggExpr(init, slot);
+    return;
+  }
+  }
+  llvm_unreachable("bad evaluation kind");
+}
+
+static void emitNewInitializer(CIRGenFunction &cgf, const CXXNewExpr *e,
+                               QualType elementType, mlir::Type elementTy,
+                               Address newPtr, mlir::Value numElements,
+                               mlir::Value allocSizeWithoutCookie) {
+  assert(!cir::MissingFeatures::generateDebugInfo());
+  if (e->isArray()) {
+    cgf.cgm.errorNYI(e->getSourceRange(), "emitNewInitializer: array");
+  } else if (const Expr *init = e->getInitializer()) {
+    storeAnyExprIntoOneUnit(cgf, init, e->getAllocatedType(), newPtr,
+                            AggValueSlot::DoesNotOverlap);
+  }
+}
+
+/// 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;
+}
+
+mlir::Value CIRGenFunction::emitCXXNewExpr(const CXXNewExpr *e) {
+  // The element type being allocated.
+  QualType allocType = getContext().getBaseElementType(e->getAllocatedType());
+
+  // 1. Build a call to the allocation function.
+  FunctionDecl *allocator = e->getOperatorNew();
+
+  // If there is a brace-initializer, cannot allocate fewer elements than inits.
+  unsigned minElements = 0;
+  if (e->isArray() && e->hasInitializer()) {
+    cgm.errorNYI(e->getSourceRange(), "emitCXXNewExpr: array initializer");
+  }
+
+  mlir::Value numElements = nullptr;
+  mlir::Value allocSizeWithoutCookie = nullptr;
+  mlir::Value allocSize = emitCXXNewAllocSize(
+      *this, e, minElements, numElements, allocSizeWithoutCookie);
+  CharUnits allocAlign = getContext().getTypeAlignInChars(allocType);
+
+  // Emit the allocation call.
+  Address allocation = Address::invalid();
+  CallArgList allocatorArgs;
+  if (allocator->isReservedGlobalPlacementOperator()) {
+    cgm.errorNYI(e->getSourceRange(),
+                 "emitCXXNewExpr: reserved global placement operator");
+  } else {
+    const FunctionProtoType *allocatorType =
+        allocator->getType()->castAs<FunctionProtoType>();
+    unsigned paramsToSkip = 0;
+
+    // The allocation size is the first argument.
+    QualType sizeType = getContext().getSizeType();
+    allocatorArgs.add(RValue::get(allocSize), sizeType);
+    ++paramsToSkip;
+
+    if (allocSize != allocSizeWithoutCookie) {
+      CharUnits cookieAlign = getSizeAlign(); // FIXME: Ask the ABI.
+      allocAlign = std::max(allocAlign, cookieAlign);
+    }
+
+    // The allocation alignment may be passed as the second argument.
+    if (e->passAlignment()) {
+      cgm.errorNYI(e->getSourceRange(), "emitCXXNewExpr: pass alignment");
+    }
+
+    // FIXME: Why do we not pass a CalleeDecl here?
+    emitCallArgs(allocatorArgs, allocatorType, e->placement_arguments(),
+                 AbstractCallee(), paramsToSkip);
+    RValue rv =
+        emitNewDeleteCall(*this, allocator, allocatorType, allocatorArgs);
+
+    // Set !heapallocsite metadata on the call to operator new.
+    assert(!cir::MissingFeatures::generateDebugInfo());
+
+    // If this was a call to a global replaceable allocation function that does
+    // not take an alignment argument, the allocator is known to produce storage
+    // that's suitably aligned for any object that fits, up to a known
+    // threshold. Otherwise assume it's suitably aligned for the allocated type.
+    CharUnits allocationAlign = allocAlign;
+    if (!e->passAlignment() &&
+        allocator->isReplaceableGlobalAllocationFunction()) {
+      const TargetInfo &target = cgm.getASTContext().getTargetInfo();
+      unsigned allocatorAlign = llvm::bit_floor(std::min<uint64_t>(
+          target.getNewAlign(), getContext().getTypeSize(allocType)));
+      allocationAlign = std::max(
+          allocationAlign, getContext().toCharUnitsFromBits(allocatorAlign));
+    }
+
+    mlir::Value allocPtr = rv.getValue();
+    allocation = Address(
+        allocPtr, mlir::cast<cir::PointerType>(allocPtr.getType()).getPointee(),
+        allocationAlign);
+  }
+
+  // Emit a null check on the allocation result if the allocation
+  // function is allowed to return null (because it has a non-throwing
+  // exception spec or is the reserved placement new) and we have an
+  // interesting initializer will be running sanitizers on the initialization.
+  bool nullCheck = e->shouldNullCheckAllocation() &&
+                   (!allocType.isPODType(getContext()) || e->hasInitializer());
+  assert(!cir::MissingFeatures::exprNewNullCheck());
+  if (nullCheck)
+    cgm.errorNYI(e->getSourceRange(), "emitCXXNewExpr: null check");
+
+  // If there's an operator delete, enter a cleanup to call it if an
+  // exception is thrown.
+  if (e->getOperatorDelete() &&
+      !e->getOperatorDelete()->isReservedGlobalPlacementOperator())
+    cgm.errorNYI(e->getSourceRange(), "emitCXXNewExpr: operator delete");
+
+  if (allocSize != allocSizeWithoutCookie)
+    cgm.errorNYI(e->getSourceRange(), "emitCXXNewExpr: array with cookies");
+
+  mlir::Type elementTy = convertTypeForMem(allocType);
+  Address result = builder.createElementBitCast(getLoc(e->getSourceRange()),
+                                                allocation, elementTy);
+
+  // Passing pointer through launder.invariant.group to avoid propagation of
+  // vptrs information which may be included in previous type.
+  // To not break LTO with different optimizations levels, we do it regardless
+  // of optimization level.
+  if (cgm.getCodeGenOpts().StrictVTablePointers &&
+      allocator->isReservedGlobalPlacementOperator())
+    cgm.errorNYI(e->getSourceRange(), "emitCXXNewExpr: strict vtable pointers");
+
+  assert(!cir::MissingFeatures::sanitizers());
+
+  emitNewInitializer(*this, e, allocType, elementTy, result, numElements,
+                     allocSizeWithoutCookie);
+  return result.getPointer();
+}

clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp

@@ -609,6 +609,10 @@ class ScalarExprEmitter : public StmtVisitor<ScalarExprEmitter, mlir::Value> {
 
   mlir::Value VisitCXXThisExpr(CXXThisExpr *te) { return cgf.loadCXXThis(); }
 
+  mlir::Value VisitCXXNewExpr(const CXXNewExpr *e) {
+    return cgf.emitCXXNewExpr(e);
+  }
+
   /// Emit a conversion from the specified type to the specified destination
   /// type, both of which are CIR scalar types.
   /// TODO: do we need ScalarConversionOpts here? Should be done in another

clang/lib/CIR/CodeGen/CIRGenFunction.h

@@ -770,6 +770,15 @@ class CIRGenFunction : public CIRGenTypeCache {
                   const CIRGenCallee &callee, ReturnValueSlot returnValue,
                   const CallArgList &args, cir::CIRCallOpInterface *callOp,
                   mlir::Location loc);
+  RValue emitCall(const CIRGenFunctionInfo &funcInfo,
+                  const CIRGenCallee &callee, ReturnValueSlot returnValue,
+                  const CallArgList &args,
+                  cir::CIRCallOpInterface *callOrTryCall = nullptr) {
+    assert(currSrcLoc && "source location must have been set");
+    return emitCall(funcInfo, callee, returnValue, args, callOrTryCall,
+                    *currSrcLoc);
+  }
+
   RValue emitCall(clang::QualType calleeTy, const CIRGenCallee &callee,
                   const clang::CallExpr *e, ReturnValueSlot returnValue);
   void emitCallArg(CallArgList &args, const clang::Expr *e,
@@ -836,6 +845,8 @@ class CIRGenFunction : public CIRGenTypeCache {
       clang::NestedNameSpecifier *qualifier, bool isArrow,
       const clang::Expr *base);
 
+  mlir::Value emitCXXNewExpr(const CXXNewExpr *e);
+
   RValue emitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *e,
                                        const CXXMethodDecl *md,
                                        ReturnValueSlot returnValue);

clang/lib/CIR/CodeGen/CIRGenModule.cpp

@@ -95,6 +95,7 @@ CIRGenModule::CIRGenModule(mlir::MLIRContext &mlirContext,
   // TODO(CIR): Should be updated once TypeSizeInfoAttr is upstreamed
   const unsigned sizeTypeSize =
       astContext.getTypeSize(astContext.getSignedSizeType());
+  SizeAlignInBytes = astContext.toCharUnitsFromBits(sizeTypeSize).getQuantity();
   // In CIRGenTypeCache, UIntPtrTy and SizeType are fields of the same union
   UIntPtrTy =
       cir::IntType::get(&getMLIRContext(), sizeTypeSize, /*isSigned=*/false);

clang/lib/CIR/CodeGen/CIRGenTypeCache.h

@@ -66,6 +66,13 @@ struct CIRGenTypeCache {
     unsigned char PointerSizeInBytes;
   };
 
+  /// The alignment of size_t.
+  unsigned char SizeAlignInBytes;
+
+  clang::CharUnits getSizeAlign() const {
+    return clang::CharUnits::fromQuantity(SizeAlignInBytes);
+  }
+
   clang::CharUnits getPointerAlign() const {
     return clang::CharUnits::fromQuantity(PointerAlignInBytes);
   }