AddressRanges.h Source File (original) (raw)

9#ifndef LLVM_ADT_ADDRESSRANGES_H

10#define LLVM_ADT_ADDRESSRANGES_H

14#include

15#include

16#include <stdint.h>

23public:

32 bool contains(uint64_t Addr) const { return Start <= Addr && Addr < End; }

34 return Start <= R.Start && R.End <= End;

35 }

37 return Start < R.End && R.Start < End;

38 }

40 return Start == R.Start && End == R.End;

41 }

44 return std::make_pair(Start, End) < std::make_pair(R.Start, R.End);

45 }

47private:

50};

59protected:

63public:

67 return find(Addr, Addr + 1) != Ranges.end();

68 }

72 void reserve(size_t Capacity) { Ranges.reserve(Capacity); }

76 typename Collection::const_iterator It = find(Addr, Addr + 1);

77 if (It == Ranges.end())

78 return std::nullopt;

80 return *It;

81 }

83 typename Collection::const_iterator begin() const { return Ranges.begin(); }

84 typename Collection::const_iterator end() const { return Ranges.end(); }

95protected:

97 if (Start >= End)

102

103 if (It == Ranges.begin())

105

106 --It;

109

110 return It;

111 }

112};

113

114

115

116

117

118

120public:

122 if (Range.empty())

124

126 auto It2 = It;

127 while (It2 != Ranges.end() && It2->start() <= Range.end())

128 ++It2;

129 if (It != It2) {

130 Range = {Range.start(), std::max(Range.end(), std::prev(It2)->end())};

131 It = Ranges.erase(It, It2);

132 }

133 if (It != Ranges.begin() && Range.start() <= std::prev(It)->end()) {

134 --It;

135 *It = {It->start(), std::max(It->end(), Range.end())};

136 return It;

137 }

138

140 }

141};

142

150

153 return LHS.Range == RHS.Range && LHS.Value == RHS.Value;

154}

155

156

157

158

159

160

161

162

164public:

166 if (Range.empty())

167 return;

168

169

170 auto It =

172 return R.Range.start() <= Range.start();

173 });

174

175 if (It != Ranges.begin())

176 It--;

177

178 while ( Range .empty()) {

179

180

181 if (It == Ranges.end() || Range.end() <= It->Range.start()) {

183 return;

184 }

185

186

187

188 if (Range.start() < It->Range.start()) {

189 It = Ranges.insert(It, {{Range.start(), It->Range.start()}, Value});

190 It++;

191 Range = {It->Range.start(), Range.end()};

192 continue;

193 }

194

195

196 if (Range.end() <= It->Range.end())

197 return;

198

199

200

201 if (Range.start() < It->Range.end())

202 Range = {It->Range.end(), Range.end()};

203

204 It++;

205 }

206 }

207};

208

209}

210

211#endif

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")

ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))

This file defines the SmallVector class.

Definition AddressRanges.h:143

AddressRange Range

Definition AddressRanges.h:147

int64_t Value

Definition AddressRanges.h:148

A class that represents an address range.

Definition AddressRanges.h:22

AddressRange(uint64_t S, uint64_t E)

Definition AddressRanges.h:25

uint64_t start() const

Definition AddressRanges.h:28

bool operator<(const AddressRange &R) const

Definition AddressRanges.h:43

uint64_t empty() const

Definition AddressRanges.h:31

uint64_t end() const

Definition AddressRanges.h:29

bool contains(const AddressRange &R) const

Definition AddressRanges.h:33

bool intersects(const AddressRange &R) const

Definition AddressRanges.h:36

bool operator!=(const AddressRange &R) const

Definition AddressRanges.h:42

bool contains(uint64_t Addr) const

Definition AddressRanges.h:32

bool operator==(const AddressRange &R) const

Definition AddressRanges.h:39

uint64_t size() const

Definition AddressRanges.h:30

The AddressRangesBase class presents the base functionality for the normalized address ranges collect...

Definition AddressRanges.h:58

void reserve(size_t Capacity)

Definition AddressRanges.h:72

bool contains(uint64_t Addr) const

Definition AddressRanges.h:66

Collection Ranges

Definition AddressRanges.h:61

void clear()

Definition AddressRanges.h:64

SmallVector< T > Collection

Definition AddressRanges.h:60

Collection::const_iterator find(uint64_t Start, uint64_t End) const

Definition AddressRanges.h:96

const T & operator[](size_t I) const

Definition AddressRanges.h:86

std::optional< T > getRangeThatContains(uint64_t Addr) const

Definition AddressRanges.h:75

bool empty() const

Definition AddressRanges.h:65

bool contains(AddressRange Range) const

Definition AddressRanges.h:69

Collection::const_iterator end() const

Definition AddressRanges.h:84

Collection::const_iterator begin() const

Definition AddressRanges.h:83

size_t size() const

Definition AddressRanges.h:73

bool operator==(const AddressRangesBase &RHS) const

Definition AddressRanges.h:91

AddressRangesMap class maps values to the address ranges.

Definition AddressRanges.h:163

void insert(AddressRange Range, int64_t Value)

Definition AddressRanges.h:165

The AddressRanges class helps normalize address range collections.

Definition AddressRanges.h:119

Collection::const_iterator insert(AddressRange Range)

Definition AddressRanges.h:121

typename SuperClass::const_iterator const_iterator

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

LLVM Value Representation.

This is an optimization pass for GlobalISel generic memory operations.

Definition AddressRanges.h:18

auto partition_point(R &&Range, Predicate P)

Binary search for the first iterator in a range where a predicate is false.

auto upper_bound(R &&Range, T &&Value)

Provide wrappers to std::upper_bound which take ranges instead of having to pass begin/end explicitly...

bool operator==(const AddressRangeValuePair &LHS, const AddressRangeValuePair &RHS)

Definition AddressRanges.h:151