1 | //===- ArrayRef.h - Array Reference Wrapper ---------------------*- 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 | #ifndef LLVM_ADT_ARRAYREF_H |

10 | #define LLVM_ADT_ARRAYREF_H |

11 | |

12 | #include "llvm/ADT/Hashing.h" |

13 | #include "llvm/ADT/None.h" |

14 | #include "llvm/ADT/SmallVector.h" |

15 | #include "llvm/ADT/STLExtras.h" |

16 | #include "llvm/Support/Compiler.h" |

17 | #include <algorithm> |

18 | #include <array> |

19 | #include <cassert> |

20 | #include <cstddef> |

21 | #include <initializer_list> |

22 | #include <iterator> |

23 | #include <memory> |

24 | #include <type_traits> |

25 | #include <vector> |

26 | |

27 | namespace llvm { |

28 | template<typename T> class [[nodiscard]] MutableArrayRef; |

29 | |

30 | /// ArrayRef - Represent a constant reference to an array (0 or more elements |

31 | /// consecutively in memory), i.e. a start pointer and a length. It allows |

32 | /// various APIs to take consecutive elements easily and conveniently. |

33 | /// |

34 | /// This class does not own the underlying data, it is expected to be used in |

35 | /// situations where the data resides in some other buffer, whose lifetime |

36 | /// extends past that of the ArrayRef. For this reason, it is not in general |

37 | /// safe to store an ArrayRef. |

38 | /// |

39 | /// This is intended to be trivially copyable, so it should be passed by |

40 | /// value. |

41 | template<typename T> |

42 | class LLVM_GSL_POINTER [[nodiscard]] ArrayRef { |

43 | public: |

44 | using value_type = T; |

45 | using pointer = value_type *; |

46 | using const_pointer = const value_type *; |

47 | using reference = value_type &; |

48 | using const_reference = const value_type &; |

49 | using iterator = const_pointer; |

50 | using const_iterator = const_pointer; |

51 | using reverse_iterator = std::reverse_iterator<iterator>; |

52 | using const_reverse_iterator = std::reverse_iterator<const_iterator>; |

53 | using size_type = size_t; |

54 | using difference_type = ptrdiff_t; |

55 | |

56 | private: |

57 | /// The start of the array, in an external buffer. |

58 | const T *Data = nullptr; |

59 | |

60 | /// The number of elements. |

61 | size_type Length = 0; |

62 | |

63 | public: |

64 | /// @name Constructors |

65 | /// @{ |

66 | |

67 | /// Construct an empty ArrayRef. |

68 | /*implicit*/ ArrayRef() = default; |

69 | |

70 | /// Construct an empty ArrayRef from None. |

71 | /*implicit*/ ArrayRef(NoneType) {} |

72 | |

73 | /// Construct an ArrayRef from a single element. |

74 | /*implicit*/ ArrayRef(const T &OneElt) |

75 | : Data(&OneElt), Length(1) {} |

76 | |

77 | /// Construct an ArrayRef from a pointer and length. |

78 | /*implicit*/ ArrayRef(const T *data, size_t length) |

79 | : Data(data), Length(length) {} |

80 | |

81 | /// Construct an ArrayRef from a range. |

82 | ArrayRef(const T *begin, const T *end) |

83 | : Data(begin), Length(end - begin) {} |

84 | |

85 | /// Construct an ArrayRef from a SmallVector. This is templated in order to |

86 | /// avoid instantiating SmallVectorTemplateCommon<T> whenever we |

87 | /// copy-construct an ArrayRef. |

88 | template<typename U> |

89 | /*implicit*/ ArrayRef(const SmallVectorTemplateCommon<T, U> &Vec) |

90 | : Data(Vec.data()), Length(Vec.size()) { |

91 | } |

92 | |

93 | /// Construct an ArrayRef from a std::vector. |

94 | template<typename A> |

95 | /*implicit*/ ArrayRef(const std::vector<T, A> &Vec) |

96 | : Data(Vec.data()), Length(Vec.size()) {} |

97 | |

98 | /// Construct an ArrayRef from a std::array |

99 | template <size_t N> |

100 | /*implicit*/ constexpr ArrayRef(const std::array<T, N> &Arr) |

101 | : Data(Arr.data()), Length(N) {} |

102 | |

103 | /// Construct an ArrayRef from a C array. |

104 | template <size_t N> |

105 | /*implicit*/ constexpr ArrayRef(const T (&Arr)[N]) : Data(Arr), Length(N) {} |

106 | |

107 | /// Construct an ArrayRef from a std::initializer_list. |

108 | #if LLVM_GNUC_PREREQ(9, 0, 0) |

109 | // Disable gcc's warning in this constructor as it generates an enormous amount |

110 | // of messages. Anyone using ArrayRef should already be aware of the fact that |

111 | // it does not do lifetime extension. |

112 | #pragma GCC diagnostic push |

113 | #pragma GCC diagnostic ignored "-Winit-list-lifetime" |

114 | #endif |

115 | /*implicit*/ ArrayRef(const std::initializer_list<T> &Vec) |

116 | : Data(Vec.begin() == Vec.end() ? (T*)nullptr : Vec.begin()), |

117 | Length(Vec.size()) {} |

118 | #if LLVM_GNUC_PREREQ(9, 0, 0) |

119 | #pragma GCC diagnostic pop |

120 | #endif |

121 | |

122 | /// Construct an ArrayRef<const T*> from ArrayRef<T*>. This uses SFINAE to |

123 | /// ensure that only ArrayRefs of pointers can be converted. |

124 | template <typename U> |

125 | ArrayRef(const ArrayRef<U *> &A, |

126 | std::enable_if_t<std::is_convertible<U *const *, T const *>::value> |

127 | * = nullptr) |

128 | : Data(A.data()), Length(A.size()) {} |

129 | |

130 | /// Construct an ArrayRef<const T*> from a SmallVector<T*>. This is |

131 | /// templated in order to avoid instantiating SmallVectorTemplateCommon<T> |

132 | /// whenever we copy-construct an ArrayRef. |

133 | template <typename U, typename DummyT> |

134 | /*implicit*/ ArrayRef( |

135 | const SmallVectorTemplateCommon<U *, DummyT> &Vec, |

136 | std::enable_if_t<std::is_convertible<U *const *, T const *>::value> * = |

137 | nullptr) |

138 | : Data(Vec.data()), Length(Vec.size()) {} |

139 | |

140 | /// Construct an ArrayRef<const T*> from std::vector<T*>. This uses SFINAE |

141 | /// to ensure that only vectors of pointers can be converted. |

142 | template <typename U, typename A> |

143 | ArrayRef(const std::vector<U *, A> &Vec, |

144 | std::enable_if_t<std::is_convertible<U *const *, T const *>::value> |

145 | * = nullptr) |

146 | : Data(Vec.data()), Length(Vec.size()) {} |

147 | |

148 | /// @} |

149 | /// @name Simple Operations |

150 | /// @{ |

151 | |

152 | iterator begin() const { return Data; } |

153 | iterator end() const { return Data + Length; } |

154 | |

155 | reverse_iterator rbegin() const { return reverse_iterator(end()); } |

156 | reverse_iterator rend() const { return reverse_iterator(begin()); } |

157 | |

158 | /// empty - Check if the array is empty. |

159 | bool empty() const { return Length == 0; } |

160 | |

161 | const T *data() const { return Data; } |

162 | |

163 | /// size - Get the array size. |

164 | size_t size() const { return Length; } |

165 | |

166 | /// front - Get the first element. |

167 | const T &front() const { |

168 | assert(!empty()); |

169 | return Data[0]; |

170 | } |

171 | |

172 | /// back - Get the last element. |

173 | const T &back() const { |

174 | assert(!empty()); |

175 | return Data[Length-1]; |

176 | } |

177 | |

178 | // copy - Allocate copy in Allocator and return ArrayRef<T> to it. |

179 | template <typename Allocator> MutableArrayRef<T> copy(Allocator &A) { |

180 | T *Buff = A.template Allocate<T>(Length); |

181 | std::uninitialized_copy(begin(), end(), Buff); |

182 | return MutableArrayRef<T>(Buff, Length); |

183 | } |

184 | |

185 | /// equals - Check for element-wise equality. |

186 | bool equals(ArrayRef RHS) const { |

187 | if (Length != RHS.Length) |

188 | return false; |

189 | return std::equal(begin(), end(), RHS.begin()); |

190 | } |

191 | |

192 | /// slice(n, m) - Chop off the first N elements of the array, and keep M |

193 | /// elements in the array. |

194 | ArrayRef<T> slice(size_t N, size_t M) const { |

195 | assert(N+M <= size() && "Invalid specifier"); |

196 | return ArrayRef<T>(data()+N, M); |

197 | } |

198 | |

199 | /// slice(n) - Chop off the first N elements of the array. |

200 | ArrayRef<T> slice(size_t N) const { return slice(N, size() - N); } |

201 | |

202 | /// Drop the first \p N elements of the array. |

203 | ArrayRef<T> drop_front(size_t N = 1) const { |

204 | assert(size() >= N && "Dropping more elements than exist"); |

205 | return slice(N, size() - N); |

206 | } |

207 | |

208 | /// Drop the last \p N elements of the array. |

209 | ArrayRef<T> drop_back(size_t N = 1) const { |

210 | assert(size() >= N && "Dropping more elements than exist"); |

211 | return slice(0, size() - N); |

212 | } |

213 | |

214 | /// Return a copy of *this with the first N elements satisfying the |

215 | /// given predicate removed. |

216 | template <class PredicateT> ArrayRef<T> drop_while(PredicateT Pred) const { |

217 | return ArrayRef<T>(find_if_not(*this, Pred), end()); |

218 | } |

219 | |

220 | /// Return a copy of *this with the first N elements not satisfying |

221 | /// the given predicate removed. |

222 | template <class PredicateT> ArrayRef<T> drop_until(PredicateT Pred) const { |

223 | return ArrayRef<T>(find_if(*this, Pred), end()); |

224 | } |

225 | |

226 | /// Return a copy of *this with only the first \p N elements. |

227 | ArrayRef<T> take_front(size_t N = 1) const { |

228 | if (N >= size()) |

229 | return *this; |

230 | return drop_back(size() - N); |

231 | } |

232 | |

233 | /// Return a copy of *this with only the last \p N elements. |

234 | ArrayRef<T> take_back(size_t N = 1) const { |

235 | if (N >= size()) |

236 | return *this; |

237 | return drop_front(size() - N); |

238 | } |

239 | |

240 | /// Return the first N elements of this Array that satisfy the given |

241 | /// predicate. |

242 | template <class PredicateT> ArrayRef<T> take_while(PredicateT Pred) const { |

243 | return ArrayRef<T>(begin(), find_if_not(*this, Pred)); |

244 | } |

245 | |

246 | /// Return the first N elements of this Array that don't satisfy the |

247 | /// given predicate. |

248 | template <class PredicateT> ArrayRef<T> take_until(PredicateT Pred) const { |

249 | return ArrayRef<T>(begin(), find_if(*this, Pred)); |

250 | } |

251 | |

252 | /// @} |

253 | /// @name Operator Overloads |

254 | /// @{ |

255 | const T &operator[](size_t Index) const { |

256 | assert(Index < Length && "Invalid index!"); |

257 | return Data[Index]; |

258 | } |

259 | |

260 | /// Disallow accidental assignment from a temporary. |

261 | /// |

262 | /// The declaration here is extra complicated so that "arrayRef = {}" |

263 | /// continues to select the move assignment operator. |

264 | template <typename U> |

265 | std::enable_if_t<std::is_same<U, T>::value, ArrayRef<T>> & |

266 | operator=(U &&Temporary) = delete; |

267 | |

268 | /// Disallow accidental assignment from a temporary. |

269 | /// |

270 | /// The declaration here is extra complicated so that "arrayRef = {}" |

271 | /// continues to select the move assignment operator. |

272 | template <typename U> |

273 | std::enable_if_t<std::is_same<U, T>::value, ArrayRef<T>> & |

274 | operator=(std::initializer_list<U>) = delete; |

275 | |

276 | /// @} |

277 | /// @name Expensive Operations |

278 | /// @{ |

279 | std::vector<T> vec() const { |

280 | return std::vector<T>(Data, Data+Length); |

281 | } |

282 | |

283 | /// @} |

284 | /// @name Conversion operators |

285 | /// @{ |

286 | operator std::vector<T>() const { |

287 | return std::vector<T>(Data, Data+Length); |

288 | } |

289 | |

290 | /// @} |

291 | }; |

292 | |

293 | /// MutableArrayRef - Represent a mutable reference to an array (0 or more |

294 | /// elements consecutively in memory), i.e. a start pointer and a length. It |

295 | /// allows various APIs to take and modify consecutive elements easily and |

296 | /// conveniently. |

297 | /// |

298 | /// This class does not own the underlying data, it is expected to be used in |

299 | /// situations where the data resides in some other buffer, whose lifetime |

300 | /// extends past that of the MutableArrayRef. For this reason, it is not in |

301 | /// general safe to store a MutableArrayRef. |

302 | /// |

303 | /// This is intended to be trivially copyable, so it should be passed by |

304 | /// value. |

305 | template<typename T> |

306 | class [[nodiscard]] MutableArrayRef : public ArrayRef<T> { |

307 | public: |

308 | using value_type = T; |

309 | using pointer = value_type *; |

310 | using const_pointer = const value_type *; |

311 | using reference = value_type &; |

312 | using const_reference = const value_type &; |

313 | using iterator = pointer; |

314 | using const_iterator = const_pointer; |

315 | using reverse_iterator = std::reverse_iterator<iterator>; |

316 | using const_reverse_iterator = std::reverse_iterator<const_iterator>; |

317 | using size_type = size_t; |

318 | using difference_type = ptrdiff_t; |

319 | |

320 | /// Construct an empty MutableArrayRef. |

321 | /*implicit*/ MutableArrayRef() = default; |

322 | |

323 | /// Construct an empty MutableArrayRef from None. |

324 | /*implicit*/ MutableArrayRef(NoneType) : ArrayRef<T>() {} |

325 | |

326 | /// Construct a MutableArrayRef from a single element. |

327 | /*implicit*/ MutableArrayRef(T &OneElt) : ArrayRef<T>(OneElt) {} |

328 | |

329 | /// Construct a MutableArrayRef from a pointer and length. |

330 | /*implicit*/ MutableArrayRef(T *data, size_t length) |

331 | : ArrayRef<T>(data, length) {} |

332 | |

333 | /// Construct a MutableArrayRef from a range. |

334 | MutableArrayRef(T *begin, T *end) : ArrayRef<T>(begin, end) {} |

335 | |

336 | /// Construct a MutableArrayRef from a SmallVector. |

337 | /*implicit*/ MutableArrayRef(SmallVectorImpl<T> &Vec) |

338 | : ArrayRef<T>(Vec) {} |

339 | |

340 | /// Construct a MutableArrayRef from a std::vector. |

341 | /*implicit*/ MutableArrayRef(std::vector<T> &Vec) |

342 | : ArrayRef<T>(Vec) {} |

343 | |

344 | /// Construct a MutableArrayRef from a std::array |

345 | template <size_t N> |

346 | /*implicit*/ constexpr MutableArrayRef(std::array<T, N> &Arr) |

347 | : ArrayRef<T>(Arr) {} |

348 | |

349 | /// Construct a MutableArrayRef from a C array. |

350 | template <size_t N> |

351 | /*implicit*/ constexpr MutableArrayRef(T (&Arr)[N]) : ArrayRef<T>(Arr) {} |

352 | |

353 | T *data() const { return const_cast<T*>(ArrayRef<T>::data()); } |

354 | |

355 | iterator begin() const { return data(); } |

356 | iterator end() const { return data() + this->size(); } |

357 | |

358 | reverse_iterator rbegin() const { return reverse_iterator(end()); } |

359 | reverse_iterator rend() const { return reverse_iterator(begin()); } |

360 | |

361 | /// front - Get the first element. |

362 | T &front() const { |

363 | assert(!this->empty()); |

364 | return data()[0]; |

365 | } |

366 | |

367 | /// back - Get the last element. |

368 | T &back() const { |

369 | assert(!this->empty()); |

370 | return data()[this->size()-1]; |

371 | } |

372 | |

373 | /// slice(n, m) - Chop off the first N elements of the array, and keep M |

374 | /// elements in the array. |

375 | MutableArrayRef<T> slice(size_t N, size_t M) const { |

376 | assert(N + M <= this->size() && "Invalid specifier"); |

377 | return MutableArrayRef<T>(this->data() + N, M); |

378 | } |

379 | |

380 | /// slice(n) - Chop off the first N elements of the array. |

381 | MutableArrayRef<T> slice(size_t N) const { |

382 | return slice(N, this->size() - N); |

383 | } |

384 | |

385 | /// Drop the first \p N elements of the array. |

386 | MutableArrayRef<T> drop_front(size_t N = 1) const { |

387 | assert(this->size() >= N && "Dropping more elements than exist"); |

388 | return slice(N, this->size() - N); |

389 | } |

390 | |

391 | MutableArrayRef<T> drop_back(size_t N = 1) const { |

392 | assert(this->size() >= N && "Dropping more elements than exist"); |

393 | return slice(0, this->size() - N); |

394 | } |

395 | |

396 | /// Return a copy of *this with the first N elements satisfying the |

397 | /// given predicate removed. |

398 | template <class PredicateT> |

399 | MutableArrayRef<T> drop_while(PredicateT Pred) const { |

400 | return MutableArrayRef<T>(find_if_not(*this, Pred), end()); |

401 | } |

402 | |

403 | /// Return a copy of *this with the first N elements not satisfying |

404 | /// the given predicate removed. |

405 | template <class PredicateT> |

406 | MutableArrayRef<T> drop_until(PredicateT Pred) const { |

407 | return MutableArrayRef<T>(find_if(*this, Pred), end()); |

408 | } |

409 | |

410 | /// Return a copy of *this with only the first \p N elements. |

411 | MutableArrayRef<T> take_front(size_t N = 1) const { |

412 | if (N >= this->size()) |

413 | return *this; |

414 | return drop_back(this->size() - N); |

415 | } |

416 | |

417 | /// Return a copy of *this with only the last \p N elements. |

418 | MutableArrayRef<T> take_back(size_t N = 1) const { |

419 | if (N >= this->size()) |

420 | return *this; |

421 | return drop_front(this->size() - N); |

422 | } |

423 | |

424 | /// Return the first N elements of this Array that satisfy the given |

425 | /// predicate. |

426 | template <class PredicateT> |

427 | MutableArrayRef<T> take_while(PredicateT Pred) const { |

428 | return MutableArrayRef<T>(begin(), find_if_not(*this, Pred)); |

429 | } |

430 | |

431 | /// Return the first N elements of this Array that don't satisfy the |

432 | /// given predicate. |

433 | template <class PredicateT> |

434 | MutableArrayRef<T> take_until(PredicateT Pred) const { |

435 | return MutableArrayRef<T>(begin(), find_if(*this, Pred)); |

436 | } |

437 | |

438 | /// @} |

439 | /// @name Operator Overloads |

440 | /// @{ |

441 | T &operator[](size_t Index) const { |

442 | assert(Index < this->size() && "Invalid index!"); |

443 | return data()[Index]; |

444 | } |

445 | }; |

446 | |

447 | /// This is a MutableArrayRef that owns its array. |

448 | template <typename T> class OwningArrayRef : public MutableArrayRef<T> { |

449 | public: |

450 | OwningArrayRef() = default; |

451 | OwningArrayRef(size_t Size) : MutableArrayRef<T>(new T[Size], Size) {} |

452 | |

453 | OwningArrayRef(ArrayRef<T> Data) |

454 | : MutableArrayRef<T>(new T[Data.size()], Data.size()) { |

455 | std::copy(Data.begin(), Data.end(), this->begin()); |

456 | } |

457 | |

458 | OwningArrayRef(OwningArrayRef &&Other) { *this = std::move(Other); } |

459 | |

460 | OwningArrayRef &operator=(OwningArrayRef &&Other) { |

461 | delete[] this->data(); |

462 | this->MutableArrayRef<T>::operator=(Other); |

463 | Other.MutableArrayRef<T>::operator=(MutableArrayRef<T>()); |

464 | return *this; |

465 | } |

466 | |

467 | ~OwningArrayRef() { delete[] this->data(); } |

468 | }; |

469 | |

470 | /// @name ArrayRef Convenience constructors |

471 | /// @{ |

472 | |

473 | /// Construct an ArrayRef from a single element. |

474 | template<typename T> |

475 | ArrayRef<T> makeArrayRef(const T &OneElt) { |

476 | return OneElt; |

477 | } |

478 | |

479 | /// Construct an ArrayRef from a pointer and length. |

480 | template<typename T> |

481 | ArrayRef<T> makeArrayRef(const T *data, size_t length) { |

482 | return ArrayRef<T>(data, length); |

483 | } |

484 | |

485 | /// Construct an ArrayRef from a range. |

486 | template<typename T> |

487 | ArrayRef<T> makeArrayRef(const T *begin, const T *end) { |

488 | return ArrayRef<T>(begin, end); |

489 | } |

490 | |

491 | /// Construct an ArrayRef from a SmallVector. |

492 | template <typename T> |

493 | ArrayRef<T> makeArrayRef(const SmallVectorImpl<T> &Vec) { |

494 | return Vec; |

495 | } |

496 | |

497 | /// Construct an ArrayRef from a SmallVector. |

498 | template <typename T, unsigned N> |

499 | ArrayRef<T> makeArrayRef(const SmallVector<T, N> &Vec) { |

500 | return Vec; |

501 | } |

502 | |

503 | /// Construct an ArrayRef from a std::vector. |

504 | template<typename T> |

505 | ArrayRef<T> makeArrayRef(const std::vector<T> &Vec) { |

506 | return Vec; |

507 | } |

508 | |

509 | /// Construct an ArrayRef from a std::array. |

510 | template <typename T, std::size_t N> |

511 | ArrayRef<T> makeArrayRef(const std::array<T, N> &Arr) { |

512 | return Arr; |

513 | } |

514 | |

515 | /// Construct an ArrayRef from an ArrayRef (no-op) (const) |

516 | template <typename T> ArrayRef<T> makeArrayRef(const ArrayRef<T> &Vec) { |

517 | return Vec; |

518 | } |

519 | |

520 | /// Construct an ArrayRef from an ArrayRef (no-op) |

521 | template <typename T> ArrayRef<T> &makeArrayRef(ArrayRef<T> &Vec) { |

522 | return Vec; |

523 | } |

524 | |

525 | /// Construct an ArrayRef from a C array. |

526 | template<typename T, size_t N> |

527 | ArrayRef<T> makeArrayRef(const T (&Arr)[N]) { |

528 | return ArrayRef<T>(Arr); |

529 | } |

530 | |

531 | /// Construct a MutableArrayRef from a single element. |

532 | template<typename T> |

533 | MutableArrayRef<T> makeMutableArrayRef(T &OneElt) { |

534 | return OneElt; |

535 | } |

536 | |

537 | /// Construct a MutableArrayRef from a pointer and length. |

538 | template<typename T> |

539 | MutableArrayRef<T> makeMutableArrayRef(T *data, size_t length) { |

540 | return MutableArrayRef<T>(data, length); |

541 | } |

542 | |

543 | /// Construct a MutableArrayRef from a SmallVector. |

544 | template <typename T> |

545 | MutableArrayRef<T> makeMutableArrayRef(SmallVectorImpl<T> &Vec) { |

546 | return Vec; |

547 | } |

548 | |

549 | /// Construct a MutableArrayRef from a SmallVector. |

550 | template <typename T, unsigned N> |

551 | MutableArrayRef<T> makeMutableArrayRef(SmallVector<T, N> &Vec) { |

552 | return Vec; |

553 | } |

554 | |

555 | /// Construct a MutableArrayRef from a std::vector. |

556 | template<typename T> |

557 | MutableArrayRef<T> makeMutableArrayRef(std::vector<T> &Vec) { |

558 | return Vec; |

559 | } |

560 | |

561 | /// Construct a MutableArrayRef from a std::array. |

562 | template <typename T, std::size_t N> |

563 | MutableArrayRef<T> makeMutableArrayRef(std::array<T, N> &Arr) { |

564 | return Arr; |

565 | } |

566 | |

567 | /// Construct a MutableArrayRef from a MutableArrayRef (no-op) (const) |

568 | template <typename T> |

569 | MutableArrayRef<T> makeMutableArrayRef(const MutableArrayRef<T> &Vec) { |

570 | return Vec; |

571 | } |

572 | |

573 | /// Construct a MutableArrayRef from a C array. |

574 | template<typename T, size_t N> |

575 | MutableArrayRef<T> makeMutableArrayRef(T (&Arr)[N]) { |

576 | return MutableArrayRef<T>(Arr); |

577 | } |

578 | |

579 | /// @} |

580 | /// @name ArrayRef Comparison Operators |

581 | /// @{ |

582 | |

583 | template<typename T> |

584 | inline bool operator==(ArrayRef<T> LHS, ArrayRef<T> RHS) { |

585 | return LHS.equals(RHS); |

586 | } |

587 | |

588 | template <typename T> |

589 | inline bool operator==(SmallVectorImpl<T> &LHS, ArrayRef<T> RHS) { |

590 | return ArrayRef<T>(LHS).equals(RHS); |

591 | } |

592 | |

593 | template <typename T> |

594 | inline bool operator!=(ArrayRef<T> LHS, ArrayRef<T> RHS) { |

595 | return !(LHS == RHS); |

596 | } |

597 | |

598 | template <typename T> |

599 | inline bool operator!=(SmallVectorImpl<T> &LHS, ArrayRef<T> RHS) { |

600 | return !(LHS == RHS); |

601 | } |

602 | |

603 | /// @} |

604 | |

605 | template <typename T> hash_code hash_value(ArrayRef<T> S) { |

606 | return hash_combine_range(S.begin(), S.end()); |

607 | } |

608 | |

609 | // Provide DenseMapInfo for ArrayRefs. |

610 | template <typename T> struct DenseMapInfo<ArrayRef<T>, void> { |

611 | static inline ArrayRef<T> getEmptyKey() { |

612 | return ArrayRef<T>( |

613 | reinterpret_cast<const T *>(~static_cast<uintptr_t>(0)), size_t(0)); |

614 | } |

615 | |

616 | static inline ArrayRef<T> getTombstoneKey() { |

617 | return ArrayRef<T>( |

618 | reinterpret_cast<const T *>(~static_cast<uintptr_t>(1)), size_t(0)); |

619 | } |

620 | |

621 | static unsigned getHashValue(ArrayRef<T> Val) { |

622 | assert(Val.data() != getEmptyKey().data() && |

623 | "Cannot hash the empty key!"); |

624 | assert(Val.data() != getTombstoneKey().data() && |

625 | "Cannot hash the tombstone key!"); |

626 | return (unsigned)(hash_value(Val)); |

627 | } |

628 | |

629 | static bool isEqual(ArrayRef<T> LHS, ArrayRef<T> RHS) { |

630 | if (RHS.data() == getEmptyKey().data()) |

631 | return LHS.data() == getEmptyKey().data(); |

632 | if (RHS.data() == getTombstoneKey().data()) |

633 | return LHS.data() == getTombstoneKey().data(); |

634 | return LHS == RHS; |

635 | } |

636 | }; |

637 | |

638 | } // end namespace llvm |

639 | |

640 | #endif // LLVM_ADT_ARRAYREF_H |

641 |