Revert "[CodeGen][arm64e] Add methods and data members to Address, which are needed to authenticate signed pointers (#67454)" #86674
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
…ich are needed to authenticate signed pointers (llvm#67454)" This reverts commit 8bd1f91. It appears that the commit broke msan bots.
llvmbot
added
clang
|
@llvm/pr-subscribers-llvm-ir @llvm/pr-subscribers-backend-systemz Author: Akira Hatanaka (ahatanak) ChangesThis reverts commit 8bd1f91. It appears that the commit broke msan bots. Patch is 350.82 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/86674.diff 50 Files Affected:
diff --git a/clang/lib/CodeGen/ABIInfoImpl.cpp b/clang/lib/CodeGen/ABIInfoImpl.cpp
index 1dc76065a35572..2b20d5a13346d3 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]
|
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This reverts commit 8bd1f91.
It appears that the commit broke msan bots.