| //===-- Address.h - An aligned address -------------------------*- C++ -*-===// | |
| // | |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |
| // See https://llvm.org/LICENSE.txt for license information. | |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |
| // | |
| //===----------------------------------------------------------------------===// | |
| // | |
| // This class provides a simple wrapper for a pair of a pointer and an | |
| // alignment. | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #ifndef LLVM_CLANG_LIB_CODEGEN_ADDRESS_H | |
| #define LLVM_CLANG_LIB_CODEGEN_ADDRESS_H | |
| #include "CGPointerAuthInfo.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" | |
| 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 { | |
| llvm::PointerIntPair<llvm::Value *, 1, bool> PointerAndKnownNonNull; | |
| llvm::Type *ElementType; | |
| CharUnits Alignment; | |
| protected: | |
| RawAddress(std::nullptr_t) : ElementType(nullptr) {} | |
| public: | |
| RawAddress(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); } | |
| bool isValid() const { | |
| return PointerAndKnownNonNull.getPointer() != nullptr; | |
| } | |
| llvm::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. | |
| 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 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(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. | |
| /// | |
| /// 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`. | |
| /// | |
| /// An address may be either *raw*, meaning that it's an ordinary machine | |
| /// pointer, or *signed*, meaning that the pointer carries an embedded | |
| /// pointer-authentication signature. Representing signed pointers directly in | |
| /// this abstraction allows the authentication to be delayed as long as possible | |
| /// without forcing IRGen to use totally different code paths for signed and | |
| /// unsigned values or to separately propagate signature information through | |
| /// every API that manipulates addresses. Pointer arithmetic on signed addresses | |
| /// (e.g. drilling down to a struct field) is accumulated into a separate offset | |
| /// which is applied when the address is finally accessed. | |
| 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; | |
| /// The ptrauth information needed to authenticate the base pointer. | |
| CGPointerAuthInfo PtrAuthInfo; | |
| /// Offset from the base pointer. This is non-null only when the base | |
| /// pointer is signed. | |
| 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, | |
| CGPointerAuthInfo PtrAuthInfo, llvm::Value *Offset, | |
| KnownNonNull_t IsKnownNonNull = NotKnownNonNull) | |
| : Pointer(BasePtr, IsKnownNonNull), ElementType(ElementType), | |
| Alignment(Alignment), PtrAuthInfo(PtrAuthInfo), Offset(Offset) {} | |
| Address(RawAddress RawAddr) | |
| : Pointer(RawAddr.isValid() ? RawAddr.getPointer() : nullptr, | |
| RawAddr.isValid() ? RawAddr.isKnownNonNull() : NotKnownNonNull), | |
| 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; } | |
| llvm::Value *getPointerIfNotSigned() const { | |
| assert(isValid() && "pointer isn't valid"); | |
| return !isSigned() ? 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::cast<llvm::PointerType>(Pointer.getPointer()->getType()); | |
| } | |
| /// 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(); } | |
| const CGPointerAuthInfo &getPointerAuthInfo() const { return PtrAuthInfo; } | |
| void setPointerAuthInfo(const CGPointerAuthInfo &Info) { PtrAuthInfo = Info; } | |
| // 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; | |
| } | |
| bool isSigned() const { return PtrAuthInfo.isSigned(); } | |
| /// 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; } | |
| Address getResignedAddress(const CGPointerAuthInfo &NewInfo, | |
| CodeGenFunction &CGF) const; | |
| /// Return the pointer contained in this class after authenticating it and | |
| /// adding offset to it if necessary. | |
| llvm::Value *emitRawPointer(CodeGenFunction &CGF) const { | |
| if (!isSigned()) | |
| return getBasePointer(); | |
| return emitRawPointerSlow(CGF); | |
| } | |
| /// Return address with different pointer, but same element type and | |
| /// alignment. | |
| Address withPointer(llvm::Value *NewPointer, | |
| KnownNonNull_t IsKnownNonNull) const { | |
| return Address(NewPointer, getElementType(), getAlignment(), | |
| IsKnownNonNull); | |
| } | |
| /// Return address with different alignment, but same pointer and element | |
| /// type. | |
| Address withAlignment(CharUnits NewAlignment) const { | |
| return Address(Pointer.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(), | |
| getPointerAuthInfo(), /*Offset=*/nullptr, | |
| isKnownNonNull()); | |
| Address A(*this); | |
| A.ElementType = ElemTy; | |
| return A; | |
| } | |
| }; | |
| 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()) {} | |
| /// A specialization of Address that requires the address to be an | |
| /// LLVM Constant. | |
| class ConstantAddress : public RawAddress { | |
| ConstantAddress(std::nullptr_t) : RawAddress(nullptr) {} | |
| public: | |
| ConstantAddress(llvm::Constant *pointer, llvm::Type *elementType, | |
| CharUnits alignment) | |
| : RawAddress(pointer, elementType, alignment) {} | |
| static ConstantAddress invalid() { | |
| return ConstantAddress(nullptr); | |
| } | |
| llvm::Constant *getPointer() const { | |
| return llvm::cast<llvm::Constant>(RawAddress::getPointer()); | |
| } | |
| ConstantAddress withElementType(llvm::Type *ElemTy) const { | |
| return ConstantAddress(getPointer(), ElemTy, getAlignment()); | |
| } | |
| static bool isaImpl(RawAddress addr) { | |
| return llvm::isa<llvm::Constant>(addr.getPointer()); | |
| } | |
| static ConstantAddress castImpl(RawAddress addr) { | |
| return ConstantAddress(llvm::cast<llvm::Constant>(addr.getPointer()), | |
| addr.getElementType(), addr.getAlignment()); | |
| } | |
| }; | |
| } | |
| // Present a minimal LLVM-like casting interface. | |
| template <class U> inline U cast(CodeGen::Address addr) { | |
| return U::castImpl(addr); | |
| } | |
| template <class U> inline bool isa(CodeGen::Address addr) { | |
| return U::isaImpl(addr); | |
| } | |
| } | |
| #endif |