clang/lib/CodeGen/Address.h

   1 //===-- Address.h - An aligned address -------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This class provides a simple wrapper for a pair of a pointer and an
  10 // alignment.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_CLANG_LIB_CODEGEN_ADDRESS_H
  15 #define LLVM_CLANG_LIB_CODEGEN_ADDRESS_H
  16
  17 #include "clang/AST/CharUnits.h"
  18 #include "llvm/ADT/PointerIntPair.h"
  19 #include "llvm/IR/Constants.h"
  20 #include "llvm/Support/MathExtras.h"
  21
  22 namespace clang {
  23 namespace CodeGen {
  24
  25 // Indicates whether a pointer is known not to be null.
  26 enum KnownNonNull_t { NotKnownNonNull, KnownNonNull };
  27
  28 /// An aligned address.
  29 class Address {
  30   llvm::PointerIntPair<llvm::Value *, 1, bool> PointerAndKnownNonNull;
  31   llvm::Type *ElementType;
  32   CharUnits Alignment;
  33
  34 protected:
  35   Address(std::nullptr_t) : ElementType(nullptr) {}
  36
  37 public:
  38   Address(llvm::Value *Pointer, llvm::Type *ElementType, CharUnits Alignment,
  39           KnownNonNull_t IsKnownNonNull = NotKnownNonNull)
  40       : PointerAndKnownNonNull(Pointer, IsKnownNonNull),
  41         ElementType(ElementType), Alignment(Alignment) {
  42     assert(Pointer != nullptr && "Pointer cannot be null");
  43     assert(ElementType != nullptr && "Element type cannot be null");
  44   }
  45
  46   static Address invalid() { return Address(nullptr); }
  47   bool isValid() const {
  48     return PointerAndKnownNonNull.getPointer() != nullptr;
  49   }
  50
  51   llvm::Value *getPointer() const {
  52     assert(isValid());
  53     return PointerAndKnownNonNull.getPointer();
  54   }
  55
  56   /// Return the type of the pointer value.
  57   llvm::PointerType *getType() const {
  58     return llvm::cast<llvm::PointerType>(getPointer()->getType());
  59   }
  60
  61   /// Return the type of the values stored in this address.
  62   llvm::Type *getElementType() const {
  63     assert(isValid());
  64     return ElementType;
  65   }
  66
  67   /// Return the address space that this address resides in.
  68   unsigned getAddressSpace() const {
  69     return getType()->getAddressSpace();
  70   }
  71
  72   /// Return the IR name of the pointer value.
  73   llvm::StringRef getName() const {
  74     return getPointer()->getName();
  75   }
  76
  77   /// Return the alignment of this pointer.
  78   CharUnits getAlignment() const {
  79     assert(isValid());
  80     return Alignment;
  81   }
  82
  83   /// Return address with different pointer, but same element type and
  84   /// alignment.
  85   Address withPointer(llvm::Value *NewPointer,
  86                       KnownNonNull_t IsKnownNonNull) const {
  87     return Address(NewPointer, getElementType(), getAlignment(),
  88                    IsKnownNonNull);
  89   }
  90
  91   /// Return address with different alignment, but same pointer and element
  92   /// type.
  93   Address withAlignment(CharUnits NewAlignment) const {
  94     return Address(getPointer(), getElementType(), NewAlignment,
  95                    isKnownNonNull());
  96   }
  97
  98   /// Return address with different element type, but same pointer and
  99   /// alignment.
 100   Address withElementType(llvm::Type *ElemTy) const {
 101     return Address(getPointer(), ElemTy, getAlignment(), isKnownNonNull());
 102   }
 103
 104   /// Whether the pointer is known not to be null.
 105   KnownNonNull_t isKnownNonNull() const {
 106     assert(isValid());
 107     return (KnownNonNull_t)PointerAndKnownNonNull.getInt();
 108   }
 109
 110   /// Set the non-null bit.
 111   Address setKnownNonNull() {
 112     assert(isValid());
 113     PointerAndKnownNonNull.setInt(true);
 114     return *this;
 115   }
 116 };
 117
 118 /// A specialization of Address that requires the address to be an
 119 /// LLVM Constant.
 120 class ConstantAddress : public Address {
 121   ConstantAddress(std::nullptr_t) : Address(nullptr) {}
 122
 123 public:
 124   ConstantAddress(llvm::Constant *pointer, llvm::Type *elementType,
 125                   CharUnits alignment)
 126       : Address(pointer, elementType, alignment) {}
 127
 128   static ConstantAddress invalid() {
 129     return ConstantAddress(nullptr);
 130   }
 131
 132   llvm::Constant *getPointer() const {
 133     return llvm::cast<llvm::Constant>(Address::getPointer());
 134   }
 135
 136   ConstantAddress withElementType(llvm::Type *ElemTy) const {
 137     return ConstantAddress(getPointer(), ElemTy, getAlignment());
 138   }
 139
 140   static bool isaImpl(Address addr) {
 141     return llvm::isa<llvm::Constant>(addr.getPointer());
 142   }
 143   static ConstantAddress castImpl(Address addr) {
 144     return ConstantAddress(llvm::cast<llvm::Constant>(addr.getPointer()),
 145                            addr.getElementType(), addr.getAlignment());
 146   }
 147 };
 148
 149 }
 150
 151 // Present a minimal LLVM-like casting interface.
 152 template <class U> inline U cast(CodeGen::Address addr) {
 153   return U::castImpl(addr);
 154 }
 155 template <class U> inline bool isa(CodeGen::Address addr) {
 156   return U::isaImpl(addr);
 157 }
 158
 159 }
 160
 161 #endif