mirror of
https://github.com/llvm/llvm-project.git
synced 2025-05-02 00:16:06 +00:00
c3b624a191
Change all uses of the deprecated constructor to pass the element type explicitly and drop it. For cases where the correct element type was not immediately obvious to me or would require a slightly larger change I'm falling back to explicitly calling getPointerElementType() for now.
130 lines
3.8 KiB
C++
130 lines
3.8 KiB
C++
//===-- 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 "llvm/IR/Constants.h"
|
|
#include "clang/AST/CharUnits.h"
|
|
|
|
namespace clang {
|
|
namespace CodeGen {
|
|
|
|
/// An aligned address.
|
|
class Address {
|
|
llvm::Value *Pointer;
|
|
llvm::Type *ElementType;
|
|
CharUnits Alignment;
|
|
|
|
protected:
|
|
Address(std::nullptr_t) : Pointer(nullptr), ElementType(nullptr) {}
|
|
|
|
public:
|
|
Address(llvm::Value *pointer, llvm::Type *elementType, CharUnits alignment)
|
|
: Pointer(pointer), ElementType(elementType), Alignment(alignment) {
|
|
assert(pointer != nullptr && "Pointer cannot be null");
|
|
assert(elementType != nullptr && "Element type cannot be null");
|
|
assert(llvm::cast<llvm::PointerType>(pointer->getType())
|
|
->isOpaqueOrPointeeTypeMatches(elementType) &&
|
|
"Incorrect pointer element type");
|
|
assert(!alignment.isZero() && "Alignment cannot be zero");
|
|
}
|
|
|
|
// Deprecated: Use constructor with explicit element type instead.
|
|
Address(llvm::Value *Pointer, CharUnits Alignment)
|
|
: Address(Pointer, Pointer->getType()->getPointerElementType(),
|
|
Alignment) {}
|
|
|
|
static Address invalid() { return Address(nullptr); }
|
|
bool isValid() const { return Pointer != nullptr; }
|
|
|
|
llvm::Value *getPointer() const {
|
|
assert(isValid());
|
|
return Pointer;
|
|
}
|
|
|
|
/// 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;
|
|
}
|
|
};
|
|
|
|
/// A specialization of Address that requires the address to be an
|
|
/// LLVM Constant.
|
|
class ConstantAddress : public Address {
|
|
ConstantAddress(std::nullptr_t) : Address(nullptr) {}
|
|
|
|
public:
|
|
ConstantAddress(llvm::Constant *pointer, llvm::Type *elementType,
|
|
CharUnits alignment)
|
|
: Address(pointer, elementType, alignment) {}
|
|
|
|
static ConstantAddress invalid() {
|
|
return ConstantAddress(nullptr);
|
|
}
|
|
|
|
llvm::Constant *getPointer() const {
|
|
return llvm::cast<llvm::Constant>(Address::getPointer());
|
|
}
|
|
|
|
ConstantAddress getElementBitCast(llvm::Type *ElemTy) const {
|
|
llvm::Constant *BitCast = llvm::ConstantExpr::getBitCast(
|
|
getPointer(), ElemTy->getPointerTo(getAddressSpace()));
|
|
return ConstantAddress(BitCast, ElemTy, getAlignment());
|
|
}
|
|
|
|
static bool isaImpl(Address addr) {
|
|
return llvm::isa<llvm::Constant>(addr.getPointer());
|
|
}
|
|
static ConstantAddress castImpl(Address 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
|