llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-clang-codegen Author: Akira Hatanaka (ahatanak) <details> <summary>Changes</summary> This reverts commit d9a685a9dd589486e882b722e513ee7b8c84870c. The commit broke ubsan bots. --- Patch is 350.99 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/86898.diff 50 Files Affected: - (modified) clang/lib/CodeGen/ABIInfoImpl.cpp (+5-5) - (modified) clang/lib/CodeGen/Address.h (+28-167) - (modified) clang/lib/CodeGen/CGAtomic.cpp (+25-28) - (modified) clang/lib/CodeGen/CGBlocks.cpp (+15-19) - (modified) clang/lib/CodeGen/CGBlocks.h (+1-2) - (modified) clang/lib/CodeGen/CGBuilder.h (+74-160) - (modified) clang/lib/CodeGen/CGBuiltin.cpp (+83-90) - (modified) clang/lib/CodeGen/CGCUDANV.cpp (+9-10) - (modified) clang/lib/CodeGen/CGCXXABI.cpp (+6-15) - (modified) clang/lib/CodeGen/CGCXXABI.h (+12-2) - (modified) clang/lib/CodeGen/CGCall.cpp (+74-97) - (modified) clang/lib/CodeGen/CGCall.h (-1) - (modified) clang/lib/CodeGen/CGClass.cpp (+31-45) - (modified) clang/lib/CodeGen/CGCleanup.cpp (+69-41) - (modified) clang/lib/CodeGen/CGCleanup.h (+1-1) - (modified) clang/lib/CodeGen/CGCoroutine.cpp (+2-2) - (modified) clang/lib/CodeGen/CGDecl.cpp (+12-16) - (modified) clang/lib/CodeGen/CGException.cpp (+8-11) - (modified) clang/lib/CodeGen/CGExpr.cpp (+108-119) - (modified) clang/lib/CodeGen/CGExprAgg.cpp (+13-16) - (modified) clang/lib/CodeGen/CGExprCXX.cpp (+60-51) - (modified) clang/lib/CodeGen/CGExprConstant.cpp (+2-2) - (modified) clang/lib/CodeGen/CGExprScalar.cpp (+4-19) - (modified) clang/lib/CodeGen/CGNonTrivialStruct.cpp (+4-4) - (modified) clang/lib/CodeGen/CGObjC.cpp (+24-19) - (modified) clang/lib/CodeGen/CGObjCGNU.cpp (+20-22) - (modified) clang/lib/CodeGen/CGObjCMac.cpp (+47-48) - (modified) clang/lib/CodeGen/CGObjCRuntime.cpp (+3-3) - (modified) clang/lib/CodeGen/CGOpenMPRuntime.cpp (+92-102) - (modified) clang/lib/CodeGen/CGOpenMPRuntime.h (+3-2) - (modified) clang/lib/CodeGen/CGOpenMPRuntimeGPU.cpp (+37-39) - (modified) clang/lib/CodeGen/CGStmt.cpp (+4-4) - (modified) clang/lib/CodeGen/CGStmtOpenMP.cpp (+42-45) - (modified) clang/lib/CodeGen/CGVTables.cpp (+5-4) - (modified) clang/lib/CodeGen/CGValue.h (+125-125) - (modified) clang/lib/CodeGen/CodeGenFunction.cpp (+29-42) - (modified) clang/lib/CodeGen/CodeGenFunction.h (+71-186) - (modified) clang/lib/CodeGen/CodeGenModule.cpp (+1-1) - (modified) clang/lib/CodeGen/CodeGenPGO.cpp (+4-6) - (modified) clang/lib/CodeGen/CodeGenPGO.h (+2-4) - (modified) clang/lib/CodeGen/ItaniumCXXABI.cpp (+30-22) - (modified) clang/lib/CodeGen/MicrosoftCXXABI.cpp (+35-23) - (modified) clang/lib/CodeGen/TargetInfo.h (-5) - (modified) clang/lib/CodeGen/Targets/NVPTX.cpp (+1-1) - (modified) clang/lib/CodeGen/Targets/PPC.cpp (+5-6) - (modified) clang/lib/CodeGen/Targets/Sparc.cpp (+1-1) - (modified) clang/lib/CodeGen/Targets/SystemZ.cpp (+5-4) - (modified) clang/lib/CodeGen/Targets/XCore.cpp (+1-1) - (modified) clang/utils/TableGen/MveEmitter.cpp (+1-1) - (modified) llvm/include/llvm/IR/IRBuilder.h (-1) ``````````diff diff --git a/clang/lib/CodeGen/ABIInfoImpl.cpp b/clang/lib/CodeGen/ABIInfoImpl.cpp index 3e34d82cb399ba..dd59101ecc81b8 100644 --- a/clang/lib/CodeGen/ABIInfoImpl.cpp +++ b/clang/lib/CodeGen/ABIInfoImpl.cpp @@ -187,7 +187,7 @@ CodeGen::emitVoidPtrDirectVAArg(CodeGenFunction &CGF, Address VAListAddr, CharUnits FullDirectSize = DirectSize.alignTo(SlotSize); Address NextPtr = CGF.Builder.CreateConstInBoundsByteGEP(Addr, FullDirectSize, "argp.next"); - CGF.Builder.CreateStore(NextPtr.emitRawPointer(CGF), VAListAddr); + CGF.Builder.CreateStore(NextPtr.getPointer(), VAListAddr); // If the argument is smaller than a slot, and this is a big-endian // target, the argument will be right-adjusted in its slot. @@ -239,8 +239,8 @@ Address CodeGen::emitMergePHI(CodeGenFunction &CGF, Address Addr1, const llvm::Twine &Name) { assert(Addr1.getType() == Addr2.getType()); llvm::PHINode *PHI = CGF.Builder.CreatePHI(Addr1.getType(), 2, Name); - PHI->addIncoming(Addr1.emitRawPointer(CGF), Block1); - PHI->addIncoming(Addr2.emitRawPointer(CGF), Block2); + PHI->addIncoming(Addr1.getPointer(), Block1); + PHI->addIncoming(Addr2.getPointer(), Block2); CharUnits Align = std::min(Addr1.getAlignment(), Addr2.getAlignment()); return Address(PHI, Addr1.getElementType(), Align); } @@ -400,7 +400,7 @@ Address CodeGen::EmitVAArgInstr(CodeGenFunction &CGF, Address VAListAddr, llvm::Type *ElementTy = CGF.ConvertTypeForMem(Ty); llvm::Type *BaseTy = llvm::PointerType::getUnqual(ElementTy); llvm::Value *Addr = - CGF.Builder.CreateVAArg(VAListAddr.emitRawPointer(CGF), BaseTy); + CGF.Builder.CreateVAArg(VAListAddr.getPointer(), BaseTy); return Address(Addr, ElementTy, TyAlignForABI); } else { assert((AI.isDirect() || AI.isExtend()) && @@ -416,7 +416,7 @@ Address CodeGen::EmitVAArgInstr(CodeGenFunction &CGF, Address VAListAddr, "Unexpected CoerceToType seen in arginfo in generic VAArg emitter!"); Address Temp = CGF.CreateMemTemp(Ty, "varet"); - Val = CGF.Builder.CreateVAArg(VAListAddr.emitRawPointer(CGF), + Val = CGF.Builder.CreateVAArg(VAListAddr.getPointer(), CGF.ConvertTypeForMem(Ty)); CGF.Builder.CreateStore(Val, Temp); return Temp; diff --git a/clang/lib/CodeGen/Address.h b/clang/lib/CodeGen/Address.h index 35ec370a139c92..cf48df8f5e7367 100644 --- a/clang/lib/CodeGen/Address.h +++ b/clang/lib/CodeGen/Address.h @@ -15,7 +15,6 @@ #define LLVM_CLANG_LIB_CODEGEN_ADDRESS_H #include "clang/AST/CharUnits.h" -#include "clang/AST/Type.h" #include "llvm/ADT/PointerIntPair.h" #include "llvm/IR/Constants.h" #include "llvm/Support/MathExtras.h" @@ -23,41 +22,28 @@ namespace clang { namespace CodeGen { -class Address; -class CGBuilderTy; -class CodeGenFunction; -class CodeGenModule; - // Indicates whether a pointer is known not to be null. enum KnownNonNull_t { NotKnownNonNull, KnownNonNull }; -/// 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 { +/// An aligned address. +class Address { llvm::PointerIntPair<llvm::Value *, 1, bool> PointerAndKnownNonNull; llvm::Type *ElementType; CharUnits Alignment; protected: - RawAddress(std::nullptr_t) : ElementType(nullptr) {} + Address(std::nullptr_t) : ElementType(nullptr) {} public: - RawAddress(llvm::Value *Pointer, llvm::Type *ElementType, CharUnits Alignment, - KnownNonNull_t IsKnownNonNull = NotKnownNonNull) + Address(llvm::Value *Pointer, llvm::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); } + static Address invalid() { return Address(nullptr); } bool isValid() const { return PointerAndKnownNonNull.getPointer() != nullptr; } @@ -94,133 +80,6 @@ class RawAddress { return Alignment; } - /// Return address with different element type, but same pointer and - /// alignment. - RawAddress withElementType(llvm::Type *ElemTy) const { - return RawAddress(getPointer(), ElemTy, getAlignment(), isKnownNonNull()); - } - - KnownNonNull_t isKnownNonNull() const { - assert(isValid()); - return (KnownNonNull_t)PointerAndKnownNonNull.getInt(); - } -}; - -/// Like RawAddress, an abstract representation of an aligned address, but the -/// pointer contained in this class is possibly signed. -class Address { - friend class CGBuilderTy; - - // The boolean flag indicates whether the pointer is known to be non-null. - llvm::PointerIntPair<llvm::Value *, 1, bool> Pointer; - - /// The expected IR type of the pointer. Carrying accurate element type - /// information in Address makes it more convenient to work with Address - /// values and allows frontend assertions to catch simple mistakes. - llvm::Type *ElementType = nullptr; - - CharUnits Alignment; - - /// Offset from the base pointer. - llvm::Value *Offset = nullptr; - - llvm::Value *emitRawPointerSlow(CodeGenFunction &CGF) const; - -protected: - Address(std::nullptr_t) : ElementType(nullptr) {} - -public: - Address(llvm::Value *pointer, llvm::Type *elementType, CharUnits alignment, - KnownNonNull_t IsKnownNonNull = NotKnownNonNull) - : Pointer(pointer, IsKnownNonNull), ElementType(elementType), - Alignment(alignment) { - assert(pointer != nullptr && "Pointer cannot be null"); - assert(elementType != nullptr && "Element type cannot be null"); - assert(!alignment.isZero() && "Alignment cannot be zero"); - } - - Address(llvm::Value *BasePtr, llvm::Type *ElementType, CharUnits Alignment, - llvm::Value *Offset, KnownNonNull_t IsKnownNonNull = NotKnownNonNull) - : Pointer(BasePtr, IsKnownNonNull), ElementType(ElementType), - Alignment(Alignment), Offset(Offset) {} - - Address(RawAddress RawAddr) - : Pointer(RawAddr.isValid() ? RawAddr.getPointer() : nullptr), - ElementType(RawAddr.isValid() ? RawAddr.getElementType() : nullptr), - Alignment(RawAddr.isValid() ? RawAddr.getAlignment() - : CharUnits::Zero()) {} - - static Address invalid() { return Address(nullptr); } - bool isValid() const { return Pointer.getPointer() != nullptr; } - - /// This function is used in situations where the caller is doing some sort of - /// opaque "laundering" of the pointer. - void replaceBasePointer(llvm::Value *P) { - assert(isValid() && "pointer isn't valid"); - assert(P->getType() == Pointer.getPointer()->getType() && - "Pointer's type changed"); - Pointer.setPointer(P); - assert(isValid() && "pointer is invalid after replacement"); - } - - CharUnits getAlignment() const { return Alignment; } - - void setAlignment(CharUnits Value) { Alignment = Value; } - - llvm::Value *getBasePointer() const { - assert(isValid() && "pointer isn't valid"); - return Pointer.getPointer(); - } - - /// Return the type of the pointer value. - llvm::PointerType *getType() const { - return llvm::PointerType::get( - ElementType, - llvm::cast<llvm::PointerType>(Pointer.getPointer()->getType()) - ->getAddressSpace()); - } - - /// Return the type of the values stored in this address. - llvm::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 Pointer.getPointer()->getName(); } - - // This function is called only in CGBuilderBaseTy::CreateElementBitCast. - void setElementType(llvm::Type *Ty) { - assert(hasOffset() && - "this funcion shouldn't be called when there is no offset"); - ElementType = Ty; - } - - /// Whether the pointer is known not to be null. - KnownNonNull_t isKnownNonNull() const { - assert(isValid()); - return (KnownNonNull_t)Pointer.getInt(); - } - - Address setKnownNonNull() { - assert(isValid()); - Pointer.setInt(KnownNonNull); - return *this; - } - - bool hasOffset() const { return Offset; } - - llvm::Value *getOffset() const { return Offset; } - - /// Return the pointer contained in this class after authenticating it and - /// adding offset to it if necessary. - llvm::Value *emitRawPointer(CodeGenFunction &CGF) const { - return getBasePointer(); - } - /// Return address with different pointer, but same element type and /// alignment. Address withPointer(llvm::Value *NewPointer, @@ -232,59 +91,61 @@ class Address { /// Return address with different alignment, but same pointer and element /// type. Address withAlignment(CharUnits NewAlignment) const { - return Address(Pointer.getPointer(), getElementType(), NewAlignment, + return Address(getPointer(), getElementType(), NewAlignment, isKnownNonNull()); } /// Return address with different element type, but same pointer and /// alignment. Address withElementType(llvm::Type *ElemTy) const { - if (!hasOffset()) - return Address(getBasePointer(), ElemTy, getAlignment(), nullptr, - isKnownNonNull()); - Address A(*this); - A.ElementType = ElemTy; - return A; + return Address(getPointer(), ElemTy, getAlignment(), isKnownNonNull()); } -}; -inline RawAddress::RawAddress(Address Addr) - : PointerAndKnownNonNull(Addr.isValid() ? Addr.getBasePointer() : nullptr, - Addr.isValid() ? Addr.isKnownNonNull() - : NotKnownNonNull), - ElementType(Addr.isValid() ? Addr.getElementType() : nullptr), - Alignment(Addr.isValid() ? Addr.getAlignment() : CharUnits::Zero()) {} + /// Whether the pointer is known not to be null. + KnownNonNull_t isKnownNonNull() const { + assert(isValid()); + return (KnownNonNull_t)PointerAndKnownNonNull.getInt(); + } + + /// Set the non-null bit. + Address setKnownNonNull() { + assert(isValid()); + PointerAndKnownNonNull.setInt(true); + return *this; + } +}; /// A specialization of Address that requires the address to be an /// LLVM Constant. -class ConstantAddress : public RawAddress { - ConstantAddress(std::nullptr_t) : RawAddress(nullptr) {} +class ConstantAddress : public Address { + ConstantAddress(std::nullptr_t) : Address(nullptr) {} public: ConstantAddress(llvm::Constant *pointer, llvm::Type *elementType, CharUnits alignment) - : RawAddress(pointer, elementType, alignment) {} + : Address(pointer, elementType, alignment) {} static ConstantAddress invalid() { return ConstantAddress(nullptr); } llvm::Constant *getPointer() const { - return llvm::cast<llvm::Constant>(RawAddress::getPointer()); + return llvm::cast<llvm::Constant>(Address::getPointer()); } ConstantAddress withElementType(llvm::Type *ElemTy) const { return ConstantAddress(getPointer(), ElemTy, getAlignment()); } - static bool isaImpl(RawAddress addr) { + static bool isaImpl(Address addr) { return llvm::isa<llvm::Constant>(addr.getPointer()); } - static ConstantAddress castImpl(RawAddress addr) { + static ConstantAddress castImpl(Address addr) { return ConstantAddress(llvm::cast<llvm::Constant>(addr.getPointer()), addr.getElementType(), addr.getAlignment()); } }; + } // Present a minimal LLVM-like casting interface. diff --git a/clang/lib/CodeGen/CGAtomic.cpp b/clang/lib/CodeGen/CGAtomic.cpp index 56198385de9dcb..fb03d013e8afc7 100644 --- a/clang/lib/CodeGen/CGAtomic.cpp +++ b/clang/lib/CodeGen/CGAtomic.cpp @@ -80,7 +80,7 @@ namespace { AtomicSizeInBits = C.toBits( C.toCharUnitsFromBits(Offset + OrigBFI.Size + C.getCharWidth() - 1) .alignTo(lvalue.getAlignment())); - llvm::Value *BitFieldPtr = lvalue.getRawBitFieldPointer(CGF); + llvm::Value *BitFieldPtr = lvalue.getBitFieldPointer(); auto OffsetInChars = (C.toCharUnitsFromBits(OrigBFI.Offset) / lvalue.getAlignment()) * lvalue.getAlignment(); @@ -139,13 +139,13 @@ namespace { const LValue &getAtomicLValue() const { return LVal; } llvm::Value *getAtomicPointer() const { if (LVal.isSimple()) - return LVal.emitRawPointer(CGF); + return LVal.getPointer(CGF); else if (LVal.isBitField()) - return LVal.getRawBitFieldPointer(CGF); + return LVal.getBitFieldPointer(); else if (LVal.isVectorElt()) - return LVal.getRawVectorPointer(CGF); + return LVal.getVectorPointer(); assert(LVal.isExtVectorElt()); - return LVal.getRawExtVectorPointer(CGF); + return LVal.getExtVectorPointer(); } Address getAtomicAddress() const { llvm::Type *ElTy; @@ -368,7 +368,7 @@ bool AtomicInfo::emitMemSetZeroIfNecessary() const { return false; CGF.Builder.CreateMemSet( - addr.emitRawPointer(CGF), llvm::ConstantInt::get(CGF.Int8Ty, 0), + addr.getPointer(), llvm::ConstantInt::get(CGF.Int8Ty, 0), CGF.getContext().toCharUnitsFromBits(AtomicSizeInBits).getQuantity(), LVal.getAlignment().getAsAlign()); return true; @@ -1055,8 +1055,7 @@ RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E) { return getTargetHooks().performAddrSpaceCast( *this, V, AS, LangAS::opencl_generic, DestType, false); }; - - Args.add(RValue::get(CastToGenericAddrSpace(Ptr.emitRawPointer(*this), + Args.add(RValue::get(CastToGenericAddrSpace(Ptr.getPointer(), E->getPtr()->getType())), getContext().VoidPtrTy); @@ -1087,10 +1086,10 @@ RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E) { LibCallName = "__atomic_compare_exchange"; RetTy = getContext().BoolTy; HaveRetTy = true; - Args.add(RValue::get(CastToGenericAddrSpace(Val1.emitRawPointer(*this), + Args.add(RValue::get(CastToGenericAddrSpace(Val1.getPointer(), E->getVal1()->getType())), getContext().VoidPtrTy); - Args.add(RValue::get(CastToGenericAddrSpace(Val2.emitRawPointer(*this), + Args.add(RValue::get(CastToGenericAddrSpace(Val2.getPointer(), E->getVal2()->getType())), getContext().VoidPtrTy); Args.add(RValue::get(Order), getContext().IntTy); @@ -1106,7 +1105,7 @@ RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E) { case AtomicExpr::AO__scoped_atomic_exchange: case AtomicExpr::AO__scoped_atomic_exchange_n: LibCallName = "__atomic_exchange"; - Args.add(RValue::get(CastToGenericAddrSpace(Val1.emitRawPointer(*this), + Args.add(RValue::get(CastToGenericAddrSpace(Val1.getPointer(), E->getVal1()->getType())), getContext().VoidPtrTy); break; @@ -1121,7 +1120,7 @@ RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E) { LibCallName = "__atomic_store"; RetTy = getContext().VoidTy; HaveRetTy = true; - Args.add(RValue::get(CastToGenericAddrSpace(Val1.emitRawPointer(*this), + Args.add(RValue::get(CastToGenericAddrSpace(Val1.getPointer(), E->getVal1()->getType())), getContext().VoidPtrTy); break; @@ -1200,8 +1199,7 @@ RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E) { if (!HaveRetTy) { // Value is returned through parameter before the order. RetTy = getContext().VoidTy; - Args.add(RValue::get( - CastToGenericAddrSpace(Dest.emitRawPointer(*this), RetTy)), + Args.add(RValue::get(CastToGenericAddrSpace(Dest.getPointer(), RetTy)), getContext().VoidPtrTy); } // Order is always the last parameter. @@ -1515,7 +1513,7 @@ RValue AtomicInfo::EmitAtomicLoad(AggValueSlot ResultSlot, SourceLocation Loc, } else TempAddr = CreateTempAlloca(); - EmitAtomicLoadLibcall(TempAddr.emitRawPointer(CGF), AO, IsVolatile); + EmitAtomicLoadLibcall(TempAddr.getPointer(), AO, IsVolatile); // Okay, turn that back into the original value or whole atomic (for // non-simple lvalues) type. @@ -1675,9 +1673,9 @@ std::pair<RValue, llvm::Value *> AtomicInfo::EmitAtomicCompareExchange( if (shouldUseLibcall()) { // Produce a source address. Address ExpectedAddr = materializeRValue(Expected); - llvm::Value *ExpectedPtr = ExpectedAddr.emitRawPointer(CGF); - llvm::Value *DesiredPtr = materializeRValue(Desired).emitRawPointer(CGF); - auto *Res = EmitAtomicCompareExchangeLibcall(ExpectedPtr, DesiredPtr, + Address DesiredAddr = materializeRValue(Desired); + auto *Res = EmitAtomicCompareExchangeLibcall(ExpectedAddr.getPointer(), + DesiredAddr.getPointer(), Success, Failure); return std::make_pair( convertAtomicTempToRValue(ExpectedAddr, AggValueSlot::ignored(), @@ -1759,7 +1757,7 @@ void AtomicInfo::EmitAtomicUpdateLibcall( Address ExpectedAddr = CreateTempAlloca(); - EmitAtomicLoadLibcall(ExpectedAddr.emitRawPointer(CGF), AO, IsVolatile); + EmitAtomicLoadLibcall(ExpectedAddr.getPointer(), AO, IsVolatile); auto *ContBB = CGF.createBasicBlock("atomic_cont"); auto *ExitBB = CGF.createBasicBlock("atomic_exit"); CGF.EmitBlock(ContBB); @@ -1773,10 +1771,10 @@ void AtomicInfo::EmitAtomicUpdateLibcall( AggValueSlot::ignored(), SourceLocation(), /*AsValue=*/false); EmitAtomicUpdateValue(CGF, *this, OldRVal, UpdateOp, DesiredAddr); - llvm::Value *ExpectedPtr = ExpectedAddr.emitRawPointer(CGF); - llvm::Value *DesiredPtr = DesiredAddr.emitRawPointer(CGF); auto *Res = - EmitAtomicCompareExchangeLibcall(ExpectedPtr, DesiredPtr, AO, Failure); + EmitAtomicCompareExchangeLibcall(ExpectedAddr.getPointer(), + DesiredAddr.getPointer(), + AO, Failure); CGF.Builder.CreateCondBr(Res, ExitBB, ContBB); CGF.EmitBlock(ExitBB, /*IsFinished=*/true); } @@ -1845,7 +1843,7 @@ void AtomicInfo::EmitAtomicUpdateLibcall(llvm::AtomicOrdering AO, Address ExpectedAddr = CreateTempAlloca(); - EmitAtomicLoadLibcall(ExpectedAddr.emitRawPointer(CGF), AO, IsVolatile); + EmitAtomicLoadLibcall(ExpectedAddr.getPointer(), AO, IsVolatile); auto *ContBB = CGF.createBasicBlock("atomic_cont"); auto *ExitBB = CGF.createBasicBlock("atomic_exit"); CGF.EmitBlock(ContBB); @@ -1856,10 +1854,10 @@ void AtomicInfo::EmitAtomicUpdateLibcall(llvm::AtomicOrdering AO, CGF.Builder.CreateStore(OldVal, DesiredAddr); } EmitAtomicUpdateValue(CGF, *this, UpdateRVal, DesiredAddr); - llvm::Value *ExpectedPtr = ExpectedAddr.emitRawPointer(CGF); - llvm::Value *DesiredPtr = DesiredAddr.emitRawPointer(CGF); auto *Res = - EmitAtomicCompareExchangeLibcall(ExpectedPtr, DesiredPtr, AO, Failure); + EmitAtomicCompareExchangeLibcall(ExpectedAddr.getPointer(), + DesiredAddr.getPointer(), + AO, Failure); CGF.Builder.CreateCondBr(Res, ExitBB, ContBB); CGF.EmitBlock(ExitBB, /*IsFinished=*/true); } @@ -1959,8 +1957,7 @@ void CodeGenFunction::EmitAtomicStore(RValue rvalue, LValue dest, args.add(RValue::get(atomics.getAtomicSizeValue()), getContext().getSizeType()); ... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/86898 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
