Commit progress

Author: monthdev

clang/lib/CIR/CodeGen/Address.h

@@ -183,6 +183,18 @@ class Address {
   template <typename T> T getDefiningOp() const {
     return mlir::dyn_cast_or_null<T>(getDefiningOp());
   }
+
+  /// Return address with different element type, but same pointer and
+  /// alignment.
+  Address withElementType(mlir::Type elemTy) const {
+    if (!hasOffset())
+      return Address(getBasePointer(), elemTy, getAlignment(),
+                     getPointerAuthInfo(), /*Offset=*/nullptr,
+                     isKnownNonNull());
+    Address a(*this);
+    a.ElementType = elemTy;
+    return a;
+  }
 };
 
 } // namespace clang::CIRGen

clang/lib/CIR/CodeGen/CIRGenCXXABI.cpp

@@ -104,3 +104,36 @@ bool CIRGenCXXABI::requiresArrayCookie(const CXXNewExpr *E) {
 
   return E->getAllocatedType().isDestructedType();
 }
+
+bool CIRGenCXXABI::requiresArrayCookie(const CXXDeleteExpr *expr,
+                                       QualType elementType) {
+  // If the class's usual deallocation function takes two arguments,
+  // it needs a cookie.
+  if (expr->doesUsualArrayDeleteWantSize())
+    return true;
+
+  return elementType.isDestructedType();
+}
+
+void CIRGenCXXABI::readArrayCookie(CIRGenFunction &cgf, Address ptr,
+                                   const CXXDeleteExpr *expr, QualType eltTy,
+                                   mlir::Value &numElements,
+                                   mlir::Value &allocPtr,
+                                   CharUnits &cookieSize) {
+  // Derive a char* in the same address space as the pointer.
+  ptr = ptr.withElementType(cgf.UInt8Ty);
+
+  // If we don't need an array cookie, bail out early.
+  if (!requiresArrayCookie(expr, eltTy)) {
+    allocPtr = ptr.emitRawPointer();
+    numElements = nullptr;
+    cookieSize = CharUnits::Zero();
+    return;
+  }
+
+  cookieSize = getArrayCookieSizeImpl(eltTy);
+  Address allocAddr =
+      cgf.getBuilder().CreateConstInBoundsByteGEP(ptr, -cookieSize);
+  allocPtr = allocAddr.emitRawPointer();
+  numElements = readArrayCookieImpl(CGF, allocAddr, cookieSize);
+}

clang/lib/CIR/CodeGen/CIRGenCXXABI.h

@@ -39,6 +39,7 @@ class CIRGenCXXABI {
   clang::ASTContext &getContext() const { return CGM.getASTContext(); }
 
   virtual bool requiresArrayCookie(const CXXNewExpr *E);
+  virtual bool requiresArrayCookie(const CXXDeleteExpr *e, QualType eltType);
 
 public:
   /// Similar to AddedStructorArgs, but only notes the number of additional
@@ -403,6 +404,24 @@ class CIRGenCXXABI {
                                         const CXXNewExpr *E,
                                         QualType ElementType) = 0;
 
+  /// Reads the array cookie associated with the given pointer,
+  /// if it has one.
+  ///
+  /// \param ptr - a pointer to the first element in the array
+  /// \param elementType - the base element type of elements of the array
+  /// \param numElements - an out parameter which will be initialized
+  ///   with the number of elements allocated, or zero if there is no
+  ///   cookie
+  /// \param allocPtr - an out parameter which will be initialized
+  ///   with a char* pointing to the address returned by the allocation
+  ///   function
+  /// \param cookieSize - an out parameter which will be initialized
+  ///   with the size of the cookie, or zero if there is no cookie
+  virtual void readArrayCookie(CIRGenFunction &cgf, Address ptr,
+                               const CXXDeleteExpr *expr, QualType elementType,
+                               mlir::Value &numElements, mlir::Value &allocPtr,
+                               CharUnits &cookieSize);
+
 protected:
   /// Returns the extra size required in order to store the array
   /// cookie for the given type.  Assumes that an array cookie is

clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp

@@ -1305,10 +1305,10 @@ struct CallArrayDelete final : EHScopeStack::Cleanup {
 /// Emit the code for deleting an array of objects.
 static void EmitArrayDelete(CIRGenFunction &CGF, const CXXDeleteExpr *E,
                             Address deletedPtr, QualType elementType) {
-  mlir::Value *numElements = nullptr;
-  mlir::Value *allocatedPtr = nullptr;
+  mlir::Value numElements = nullptr;
+  mlir::Value allocatedPtr = nullptr;
   CharUnits cookieSize;
-  CGF.CGM.getCXXABI().ReadArrayCookie(CGF, deletedPtr, E, elementType,
+  CGF.CGM.getCXXABI().readArrayCookie(CGF, deletedPtr, E, elementType,
                                       numElements, allocatedPtr, cookieSize);
 
   assert(allocatedPtr && "ReadArrayCookie didn't set allocated pointer");
@@ -1328,11 +1328,14 @@ static void EmitArrayDelete(CIRGenFunction &CGF, const CXXDeleteExpr *E,
         deletedPtr.getAlignment().alignmentOfArrayElement(elementSize);
 
     mlir::Value arrayBegin = deletedPtr.emitRawPointer();
+    auto loc = CGF.getLoc(E->getBeginLoc());
+    mlir::Value arrayEnd =
+        CGF.getBuilder().createPtrStride(loc, arrayBegin, *numElements);
 
     // Note that it is legal to allocate a zero-length array, and we
     // can never fold the check away because the length should always
     // come from a cookie.
-    CGF.emitArrayDestroy(arrayBegin, *numElements, elementType, elementAlign,
+    CGF.emitArrayDestroy(arrayBegin, arrayEnd, elementType, elementAlign,
                          CGF.getDestroyer(dtorKind),
                          /*checkZeroLength*/ true,
                          CGF.needsEHCleanup(dtorKind));