1 //===-- sanitizer_vector.h -------------------------------------*- 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 file is shared between sanitizers run-time libraries. 10 // 11 //===----------------------------------------------------------------------===// 12 13 // Low-fat STL-like vector container. 14 15 #ifndef SANITIZER_VECTOR_H 16 #define SANITIZER_VECTOR_H 17 18 #include "sanitizer_common/sanitizer_allocator_internal.h" 19 #include "sanitizer_common/sanitizer_libc.h" 20 21 namespace __sanitizer { 22 23 template<typename T> 24 class Vector { 25 public: 26 Vector() : begin_(), end_(), last_() {} 27 28 ~Vector() { 29 if (begin_) 30 InternalFree(begin_); 31 } 32 33 void Reset() { 34 if (begin_) 35 InternalFree(begin_); 36 begin_ = 0; 37 end_ = 0; 38 last_ = 0; 39 } 40 41 uptr Size() const { 42 return end_ - begin_; 43 } 44 45 T &operator[](uptr i) { 46 DCHECK_LT(i, end_ - begin_); 47 return begin_[i]; 48 } 49 50 const T &operator[](uptr i) const { 51 DCHECK_LT(i, end_ - begin_); 52 return begin_[i]; 53 } 54 55 T *PushBack() { 56 EnsureSize(Size() + 1); 57 T *p = &end_[-1]; 58 internal_memset(p, 0, sizeof(*p)); 59 return p; 60 } 61 62 T *PushBack(const T& v) { 63 EnsureSize(Size() + 1); 64 T *p = &end_[-1]; 65 internal_memcpy(p, &v, sizeof(*p)); 66 return p; 67 } 68 69 void PopBack() { 70 DCHECK_GT(end_, begin_); 71 end_--; 72 } 73 74 void Resize(uptr size) { 75 if (size == 0) { 76 end_ = begin_; 77 return; 78 } 79 uptr old_size = Size(); 80 if (size <= old_size) { 81 end_ = begin_ + size; 82 return; 83 } 84 EnsureSize(size); 85 if (old_size < size) { 86 internal_memset(&begin_[old_size], 0, 87 sizeof(begin_[old_size]) * (size - old_size)); 88 } 89 } 90 91 private: 92 T *begin_; 93 T *end_; 94 T *last_; 95 96 void EnsureSize(uptr size) { 97 if (size <= Size()) 98 return; 99 if (size <= (uptr)(last_ - begin_)) { 100 end_ = begin_ + size; 101 return; 102 } 103 uptr cap0 = last_ - begin_; 104 uptr cap = cap0 * 5 / 4; // 25% growth 105 if (cap == 0) 106 cap = 16; 107 if (cap < size) 108 cap = size; 109 T *p = (T*)InternalAlloc(cap * sizeof(T)); 110 if (cap0) { 111 internal_memcpy(p, begin_, cap0 * sizeof(T)); 112 InternalFree(begin_); 113 } 114 begin_ = p; 115 end_ = begin_ + size; 116 last_ = begin_ + cap; 117 } 118 119 Vector(const Vector&); 120 void operator=(const Vector&); 121 }; 122 } // namespace __sanitizer 123 124 #endif // #ifndef SANITIZER_VECTOR_H 125