[asan and libcxx] Add missing instrumentation in vector::insert

[zaks.anna]

Summary

Ensures that the vector::insert's specialization for non-forward_iterators is instrumented with ASan.

[EricWF]

Thanks for the patch, it LGTM.

test/std/containers/sequences/vector/asan.pass.cpp

24

Could you use support/test_iterators.h instead?

https://github.com/llvm-mirror/libcxx/blob/master/test/support/test_iterators.h

[mclow.lists]

I can commit this (with changes to the test to use our test iterators) if you want.

include/vector

1913

This looks exactly right.

[zaks.anna]

I can commit this (with changes to the test to use our test iterators) if you want.

That would be great!
Thanks.

[EricWF]

@mclow.lists ping? It would be nice if this made it into 3.7.

[EricWF]

Committed as r242617. Thanks.

include/vector

         " referring to this vector");
 #endif
     difference_type __off = __position - begin();
     pointer __p = this->__begin_ + __off;
     allocator_type& __a = this->__alloc();
     pointer __old_last = this->__end_;
     for (; this->__end_ != this->__end_cap() && __first != __last; ++__first)
     {
+        __RAII_IncreaseAnnotator __annotator(*this);
         __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_),
                                   *__first);
         ++this->__end_;
+        __annotator.__done();
     }
     __split_buffer<value_type, allocator_type&> __v(__a);
     if (__first != __last)
     {
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif  // _LIBCPP_NO_EXCEPTIONS
             __v.__construct_at_end(__first, __last);

test/std/containers/sequences/vector/asan.pass.cpp

 #include <cstdlib>
 
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 #ifndef _LIBCPP_HAS_NO_ASAN
 extern "C" void __asan_set_error_exit_code(int);
 
+// This is a Toy iterator that ensures that the vector::insert
+// specialization for non-forward_iterators is taken.
+class MyInputIter : public std::iterator<std::input_iterator_tag, int> {
+public:
+    MyInputIter(int* ptr) : ptr_(ptr) {}
+    friend bool operator!=(const MyInputIter& i1, const MyInputIter& i2) {
+        return i1.ptr_ != i2.ptr_;
+    }
+    MyInputIter& operator++() { ++ptr_; return *this; }
+    int operator*() const { return *ptr_; }
+private:
+    int* ptr_;
+};
+
 int main()
 {
 #if __cplusplus >= 201103L
     {
         typedef int T;
         typedef std::vector<T, min_allocator<T>> C;
         const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         C c(std::begin(t), std::end(t));
         c.reserve(2*c.size());
         T foo = c[c.size()];    // bad, but not caught by ASAN
     }
 #endif
-    
+    {
+        // Sould not trigger ASan.
+        std::vector<int> v;
+        v.reserve(1);
+        int i = 42;
+        v.insert(v.begin(), MyInputIter(&i), MyInputIter(&i + 1));
+        assert(v[0] == 42);
+        assert(is_contiguous_container_asan_correct(v));
+    }
+
     __asan_set_error_exit_code(0);
     {
         typedef int T;
         typedef std::vector<T> C;
         const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         C c(std::begin(t), std::end(t));
         c.reserve(2*c.size());
         assert(is_contiguous_container_asan_correct(c)); 
         assert(!__sanitizer_verify_contiguous_container ( c.data(), c.data() + 1, c.data() + c.capacity()));
         T foo = c[c.size()];    // should trigger ASAN
         assert(false);          // if we got here, ASAN didn't trigger
     }
 }
 #else
 int main () { return 0; }
 #endif