1 // This is a fake system header with divide-by-zero bugs introduced in
2 // c++ std library functions. We use these bugs to test hard-coded
3 // suppression of diagnostics within standard library functions that are known
4 // to produce false positives.
5
6 #pragma clang system_header
7
8 typedef unsigned char uint8_t;
9
10 typedef __typeof__(sizeof(int)) size_t;
11 void *memmove(void *s1, const void *s2, size_t n);
12
13 namespace std {
14
15 template <class _Tp>
16 class allocator {
17 public:
deallocate(void * p)18 void deallocate(void *p) {
19 ::delete p;
20 }
21 };
22
23 template <class _Alloc>
24 class allocator_traits {
25 public:
deallocate(void * p)26 static void deallocate(void *p) {
27 _Alloc().deallocate(p);
28 }
29 };
30
31 template <class _Tp, class _Alloc>
32 class __list_imp
33 {};
34
35 template <class _Tp, class _Alloc = allocator<_Tp> >
36 class list
37 : private __list_imp<_Tp, _Alloc>
38 {
39 public:
pop_front()40 void pop_front() {
41 // Fake use-after-free.
42 // No warning is expected as we are suppressing warning coming
43 // out of std::list.
44 int z = 0;
45 z = 5/z;
46 }
47 bool empty() const;
48 };
49
50 // basic_string
51 template<class _CharT, class _Alloc = allocator<_CharT> >
52 class __attribute__ ((__type_visibility__("default"))) basic_string {
53 bool isLong;
54 union {
55 _CharT localStorage[4];
56 _CharT *externalStorage;
57
assignExternal(_CharT * newExternal)58 void assignExternal(_CharT *newExternal) {
59 externalStorage = newExternal;
60 }
61 } storage;
62
63 typedef allocator_traits<_Alloc> __alloc_traits;
64
65 public:
66 basic_string();
67
push_back(int c)68 void push_back(int c) {
69 // Fake error trigger.
70 // No warning is expected as we are suppressing warning coming
71 // out of std::basic_string.
72 int z = 0;
73 z = 5/z;
74 }
75
getBuffer()76 _CharT *getBuffer() {
77 return isLong ? storage.externalStorage : storage.localStorage;
78 }
79
80 basic_string &operator +=(int c) {
81 // Fake deallocate stack-based storage.
82 // No warning is expected as we are suppressing warnings within
83 // std::basic_string.
84 __alloc_traits::deallocate(getBuffer());
85 }
86
87 basic_string &operator =(const basic_string &other) {
88 // Fake deallocate stack-based storage, then use the variable in the
89 // same union.
90 // No warning is expected as we are suppressing warnings within
91 // std::basic_string.
92 __alloc_traits::deallocate(getBuffer());
93 storage.assignExternal(new _CharT[4]);
94 }
95 };
96
97 template<class _Engine, class _UIntType>
98 class __independent_bits_engine {
99 public:
100 // constructors and seeding functions
101 __independent_bits_engine(_Engine& __e, size_t __w);
102 };
103
104 template<class _Engine, class _UIntType>
105 __independent_bits_engine<_Engine, _UIntType>
__independent_bits_engine(_Engine & __e,size_t __w)106 ::__independent_bits_engine(_Engine& __e, size_t __w)
107 {
108 // Fake error trigger.
109 // No warning is expected as we are suppressing warning coming
110 // out of std::__independent_bits_engine.
111 int z = 0;
112 z = 5/z;
113 }
114
115 #if __has_feature(cxx_decltype)
116 typedef decltype(nullptr) nullptr_t;
117
118 template<class _Tp>
119 class shared_ptr
120 {
121 public:
122 constexpr shared_ptr(nullptr_t);
123 explicit shared_ptr(_Tp* __p);
124
shared_ptr(shared_ptr && __r)125 shared_ptr(shared_ptr&& __r) { }
126
127 ~shared_ptr();
128
129 shared_ptr& operator=(shared_ptr&& __r) {
130 // Fake error trigger.
131 // No warning is expected as we are suppressing warning coming
132 // out of std::shared_ptr.
133 int z = 0;
134 z = 5/z;
135 }
136 };
137
138 template<class _Tp>
139 inline
140 constexpr
shared_ptr(nullptr_t)141 shared_ptr<_Tp>::shared_ptr(nullptr_t) {
142 }
143
144 #endif // __has_feature(cxx_decltype)
145 }
146
147