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
22namespace clang {
23namespace CodeGen {
24
25// Indicates whether a pointer is known not to be null.
26enum KnownNonNull_t { NotKnownNonNull, KnownNonNull };
27
28/// An aligned address.
29class Address {
30  llvm::PointerIntPair<llvm::Value *, 1, bool> PointerAndKnownNonNull;
31  llvm::Type *ElementType;
32  CharUnits Alignment;
33
34protected:
35  Address(std::nullptr_t) : ElementType(nullptr) {}
36
37public:
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.
120class ConstantAddress : public Address {
121  ConstantAddress(std::nullptr_t) : Address(nullptr) {}
122
123public:
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.
152template <class U> inline U cast(CodeGen::Address addr) {
153  return U::castImpl(addr);
154}
155template <class U> inline bool isa(CodeGen::Address addr) {
156  return U::isaImpl(addr);
157}
158
159}
160
161#endif
162