mirror of
https://github.com/llvm/llvm-project.git
synced 2025-05-01 15:26:09 +00:00
2946cd7010
to reflect the new license. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351636
118 lines
3.3 KiB
C++
118 lines
3.3 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;
|
|
CharUnits Alignment;
|
|
public:
|
|
Address(llvm::Value *pointer, CharUnits alignment)
|
|
: Pointer(pointer), Alignment(alignment) {
|
|
assert((!alignment.isZero() || pointer == nullptr) &&
|
|
"creating valid address with invalid alignment");
|
|
}
|
|
|
|
static Address invalid() { return Address(nullptr, CharUnits()); }
|
|
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.
|
|
///
|
|
/// When IR pointer types lose their element type, we should simply
|
|
/// store it in Address instead for the convenience of writing code.
|
|
llvm::Type *getElementType() const {
|
|
return getType()->getElementType();
|
|
}
|
|
|
|
/// 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 {
|
|
public:
|
|
ConstantAddress(llvm::Constant *pointer, CharUnits alignment)
|
|
: Address(pointer, alignment) {}
|
|
|
|
static ConstantAddress invalid() {
|
|
return ConstantAddress(nullptr, CharUnits());
|
|
}
|
|
|
|
llvm::Constant *getPointer() const {
|
|
return llvm::cast<llvm::Constant>(Address::getPointer());
|
|
}
|
|
|
|
ConstantAddress getBitCast(llvm::Type *ty) const {
|
|
return ConstantAddress(llvm::ConstantExpr::getBitCast(getPointer(), ty),
|
|
getAlignment());
|
|
}
|
|
|
|
ConstantAddress getElementBitCast(llvm::Type *ty) const {
|
|
return getBitCast(ty->getPointerTo(getAddressSpace()));
|
|
}
|
|
|
|
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.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
|