system-header-simulator-cxx.h revision 651f13cea278ec967336033dd032faef0e9fc2ec 
1// Like the compiler, the static analyzer treats some functions differently if
2// they come from a system header -- for example, it is assumed that system
3// functions do not arbitrarily free() their parameters, and that some bugs
4// found in system headers cannot be fixed by the user and should be
5// suppressed.
6#pragma clang system_header
7
8typedef unsigned char uint8_t;
9
10namespace std {
11  template <class T1, class T2>
12  struct pair {
13    T1 first;
14    T2 second;
15
16    pair() : first(), second() {}
17    pair(const T1 &a, const T2 &b) : first(a), second(b) {}
18
19    template<class U1, class U2>
20    pair(const pair<U1, U2> &other) : first(other.first), second(other.second) {}
21  };
22
23  typedef __typeof__(sizeof(int)) size_t;
24
25  template<typename T>
26  class vector {
27    T *_start;
28    T *_finish;
29    T *_end_of_storage;
30  public:
31    vector() : _start(0), _finish(0), _end_of_storage(0) {}
32    ~vector();
33
34    size_t size() const {
35      return size_t(_finish - _start);
36    }
37
38    void push_back();
39    T pop_back();
40
41    T &operator[](size_t n) {
42      return _start[n];
43    }
44
45    const T &operator[](size_t n) const {
46      return _start[n];
47    }
48
49    T *begin() { return _start; }
50    const T *begin() const { return _start; }
51
52    T *end() { return _finish; }
53    const T *end() const { return _finish; }
54  };
55
56  class exception {
57  public:
58    exception() throw();
59    virtual ~exception() throw();
60    virtual const char *what() const throw() {
61      return 0;
62    }
63  };
64
65  class bad_alloc : public exception {
66    public:
67    bad_alloc() throw();
68    bad_alloc(const bad_alloc&) throw();
69    bad_alloc& operator=(const bad_alloc&) throw();
70    virtual const char* what() const throw() {
71      return 0;
72    }
73  };
74
75  struct nothrow_t {};
76
77  extern const nothrow_t nothrow;
78
79  // libc++'s implementation
80  template <class _E>
81  class initializer_list
82  {
83    const _E* __begin_;
84    size_t    __size_;
85
86    initializer_list(const _E* __b, size_t __s)
87      : __begin_(__b),
88        __size_(__s)
89    {}
90
91  public:
92    typedef _E        value_type;
93    typedef const _E& reference;
94    typedef const _E& const_reference;
95    typedef size_t    size_type;
96
97    typedef const _E* iterator;
98    typedef const _E* const_iterator;
99
100    initializer_list() : __begin_(0), __size_(0) {}
101
102    size_t    size()  const {return __size_;}
103    const _E* begin() const {return __begin_;}
104    const _E* end()   const {return __begin_ + __size_;}
105  };
106
107  template<class InputIter, class OutputIter>
108  OutputIter copy(InputIter II, InputIter IE, OutputIter OI) {
109    while (II != IE)
110      *OI++ = *II++;
111    return OI;
112  }
113
114  struct input_iterator_tag { };
115  struct output_iterator_tag { };
116  struct forward_iterator_tag : public input_iterator_tag { };
117  struct bidirectional_iterator_tag : public forward_iterator_tag { };
118  struct random_access_iterator_tag : public bidirectional_iterator_tag { };
119
120  template <class _Tp>
121  class allocator {
122  public:
123    void deallocate(void *p) {
124      ::delete p;
125    }
126  };
127
128  template <class _Alloc>
129  class allocator_traits {
130  public:
131    static void deallocate(void *p) {
132      _Alloc().deallocate(p);
133    }
134  };
135
136  template <class _Tp, class _Alloc>
137  class __list_imp
138  {};
139
140  template <class _Tp, class _Alloc = allocator<_Tp> >
141  class list
142  : private __list_imp<_Tp, _Alloc>
143  {
144  public:
145    void pop_front() {
146      // Fake use-after-free.
147      // No warning is expected as we are suppressing warning coming
148      // out of std::list.
149      int z = 0;
150      z = 5/z;
151    }
152    bool empty() const;
153  };
154
155  // basic_string
156  template<class _CharT, class _Alloc = allocator<_CharT> >
157  class __attribute__ ((__type_visibility__("default"))) basic_string {
158    bool isLong;
159    union {
160      _CharT localStorage[4];
161      _CharT *externalStorage;
162
163      void assignExternal(_CharT *newExternal) {
164        externalStorage = newExternal;
165      }
166    } storage;
167
168    typedef allocator_traits<_Alloc> __alloc_traits;
169
170  public:
171    basic_string();
172
173    void push_back(int c) {
174      // Fake error trigger.
175      // No warning is expected as we are suppressing warning coming
176      // out of std::basic_string.
177      int z = 0;
178      z = 5/z;
179    }
180
181    _CharT *getBuffer() {
182      return isLong ? storage.externalStorage : storage.localStorage;
183    }
184
185    basic_string &operator +=(int c) {
186      // Fake deallocate stack-based storage.
187      // No warning is expected as we are suppressing warnings within
188      // std::basic_string.
189      __alloc_traits::deallocate(getBuffer());
190    }
191
192    basic_string &operator =(const basic_string &other) {
193      // Fake deallocate stack-based storage, then use the variable in the
194      // same union.
195      // No warning is expected as we are suppressing warnings within
196      // std::basic_string.
197      __alloc_traits::deallocate(getBuffer());
198      storage.assignExternal(new _CharT[4]);
199    }
200  };
201}
202
203void* operator new(std::size_t, const std::nothrow_t&) throw();
204void* operator new[](std::size_t, const std::nothrow_t&) throw();
205void operator delete(void*, const std::nothrow_t&) throw();
206void operator delete[](void*, const std::nothrow_t&) throw();
207
208void* operator new (std::size_t size, void* ptr) throw() { return ptr; };
209void* operator new[] (std::size_t size, void* ptr) throw() { return ptr; };
210void operator delete (void* ptr, void*) throw() {};
211void operator delete[] (void* ptr, void*) throw() {};
212