Save progress

Author: monthdev

clang/lib/CIR/CodeGen/Address.h

@@ -15,6 +15,7 @@
 #define LLVM_CLANG_LIB_CIR_ADDRESS_H
 
 #include "clang/AST/CharUnits.h"
+#include "clang/CIR/Dialect/IR/CIROpsEnums.h"
 #include "clang/CIR/Dialect/IR/CIRTypes.h"
 
 #include "llvm/IR/Constants.h"
@@ -185,77 +186,6 @@ class Address {
   }
 };
 
-/// An abstract representation of an aligned address. This is designed to be an
-/// IR-level abstraction, carrying just the information necessary to perform IR
-/// operations on an address like loads and stores.  In particular, it doesn't
-/// carry C type information or allow the representation of things like
-/// bit-fields; clients working at that level should generally be using
-/// `LValue`.
-/// The pointer contained in this class is known to be unsigned.
-class RawAddress {
-  llvm::PointerIntPair<mlir::Value *, 1, bool> PointerAndKnownNonNull;
-  mlir::Type *ElementType;
-  CharUnits Alignment;
-
-protected:
-  RawAddress(std::nullptr_t) : ElementType(nullptr) {}
-
-public:
-  RawAddress(mlir::Value *Pointer, mlir::Type *ElementType, CharUnits Alignment,
-             KnownNonNull_t IsKnownNonNull = NotKnownNonNull)
-      : PointerAndKnownNonNull(Pointer, IsKnownNonNull),
-        ElementType(ElementType), Alignment(Alignment) {
-    assert(Pointer != nullptr && "Pointer cannot be null");
-    assert(ElementType != nullptr && "Element type cannot be null");
-  }
-
-  inline RawAddress(Address Addr);
-
-  static RawAddress invalid() { return RawAddress(nullptr); }
-  bool isValid() const {
-    return PointerAndKnownNonNull.getPointer() != nullptr;
-  }
-
-  mlir::Value *getPointer() const {
-    assert(isValid());
-    return PointerAndKnownNonNull.getPointer();
-  }
-
-  /// Return the type of the pointer value.
-  llvm::PointerType *getType() const {
-    return llvm::cast<llvm::PointerType>(getPointer()->getType());
-  }
-
-  /// Return the type of the values stored in this address.
-  mlir::Type *getElementType() const {
-    assert(isValid());
-    return ElementType;
-  }
-
-  /// Return the address space that this address resides in.
-  unsigned getAddressSpace() const { return getType()->getAddressSpace(); }
-
-  /// Return the IR name of the pointer value.
-  llvm::StringRef getName() const { return getPointer()->getName(); }
-
-  /// Return the alignment of this pointer.
-  CharUnits getAlignment() const {
-    assert(isValid());
-    return Alignment;
-  }
-
-  /// Return address with different element type, but same pointer and
-  /// alignment.
-  RawAddress withElementType(mlir::Type *ElemTy) const {
-    return RawAddress(getPointer(), ElemTy, getAlignment(), isKnownNonNull());
-  }
-
-  KnownNonNull_t isKnownNonNull() const {
-    assert(isValid());
-    return (KnownNonNull_t)PointerAndKnownNonNull.getInt();
-  }
-};
-
 } // namespace clang::CIRGen
 
 #endif // LLVM_CLANG_LIB_CIR_ADDRESS_H

clang/lib/CIR/CodeGen/CIRGenBuilder.h

@@ -729,28 +729,6 @@ class CIRGenBuilderTy : public cir::CIRBaseBuilderTy {
     return Address(derivedAddr, destType, addr.getAlignment());
   }
 
-  Address CreateInBoundsGEP(Address Addr, ArrayRef<llvm::Value *> IdxList,
-                            llvm::Type *ElementType, CharUnits Align,
-                            const Twine &Name = "") {
-    return RawAddress(CreateInBoundsGEP(Addr.getElementType(),
-                                        emitRawPointerFromAddress(Addr),
-                                        IdxList, Name),
-                      ElementType, Align, Addr.isKnownNonNull());
-  }
-
-  mlir::Value emitRawPointerFromAddress(Address Addr) const {
-    return Addr.getBasePointer();
-  }
-
-  Address createInBoundsGEP(Address Addr, ArrayRef<llvm::Value *> IdxList,
-                            llvm::Type *ElementType, CharUnits Align,
-                            const Twine &Name = "") {
-    return RawAddress(CreateInBoundsGEP(Addr.getElementType(),
-                                        emitRawPointerFromAddress(Addr),
-                                        IdxList, Name),
-                      ElementType, Align, Addr.isKnownNonNull());
-  }
-
   mlir::Value createVTTAddrPoint(mlir::Location loc, mlir::Type retTy,
                                  mlir::Value addr, uint64_t offset) {
     return cir::VTTAddrPointOp::create(*this, loc, retTy,

clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp

@@ -1305,8 +1305,8 @@ 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) {
-  llvm::Value *numElements = nullptr;
-  llvm::Value *allocatedPtr = nullptr;
+  mlir::Value *numElements = nullptr;
+  mlir::Value *allocatedPtr = nullptr;
   CharUnits cookieSize;
   CGF.CGM.getCXXABI().ReadArrayCookie(CGF, deletedPtr, E, elementType,
                                       numElements, allocatedPtr, cookieSize);
@@ -1328,13 +1328,11 @@ static void EmitArrayDelete(CIRGenFunction &CGF, const CXXDeleteExpr *E,
         deletedPtr.getAlignment().alignmentOfArrayElement(elementSize);
 
     mlir::Value arrayBegin = deletedPtr.emitRawPointer();
-    mlir::Value arrayEnd = CGF.Builder.createInBoundsGEP(
-        deletedPtr.getElementType(), arrayBegin, numElements, "delete.end");
 
     // 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, arrayEnd, elementType, elementAlign,
+    CGF.emitArrayDestroy(arrayBegin, *numElements, elementType, elementAlign,
                          CGF.getDestroyer(dtorKind),
                          /*checkZeroLength*/ true,
                          CGF.needsEHCleanup(dtorKind));