1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
/* PR middle-end/92942 - missing -Wstringop-overflow for allocations with
a negative lower bound size
{ dg-do compile }
{ dg-options "-O2 -Wall" }
{ dg-require-effective-target alloca } */
#define SIZE_MAX __SIZE_MAX__
#define UINT8_MAX __UINT8_MAX__
#define UINT16_MAX __UINT16_MAX__
typedef __SIZE_TYPE__ size_t;
typedef __UINT8_TYPE__ uint8_t;
typedef __UINT16_TYPE__ uint16_t;
void* usr_alloc1 (size_t) __attribute__ ((alloc_size (1)));
void* usr_alloc2 (size_t, size_t) __attribute__ ((alloc_size (1, 2)));
void* malloc (size_t);
void* memcpy (void*, const void*, size_t);
void* memset (void*, int, size_t);
char* strcpy (char*, const char*);
void sink (void*);
void malloc_uint_range_strcpy (unsigned n)
{
void *p = malloc (5 < n ? 5 : n);
strcpy (p, "01234"); // { dg-warning "\\\[-Wstringop-overflow" }
sink (p);
strcpy (p, "0123");
sink (p);
}
void malloc_uint16_anti_range_memset (uint16_t n)
{
if (5 <= n && n <= 9) return;
void *p = malloc (n);
if (UINT16_MAX < SIZE_MAX)
{
size_t sz = (uint16_t)-1 + (size_t)1;
memset (p, 0, sz); // { dg-warning "\\\[-Wstringop-overflow" }
sink (p);
}
memset (p, 0, 1);
sink (p);
memset (p, 0, 5);
sink (p);
memset (p, 0, 6);
sink (p);
memset (p, 0, UINT16_MAX - 1);
sink (p);
memset (p, 0, UINT16_MAX);
sink (p);
}
void malloc_int_strcpy (int n)
{
void *p = malloc (7 < n ? 7 : n);
strcpy (p, "0123456"); // { dg-warning "\\\[-Wstringop-overflow" }
sink (p);
strcpy (p, "012345");
sink (p);
}
void vla_int_strcpy (int n)
{
char a[9 < n ? 9 : n];
strcpy (a, "012345678"); // { dg-warning "\\\[-Wstringop-overflow" }
sink (a);
strcpy (a, "01234567");
sink (a);
}
void usr_alloc1_int_strcpy (int n)
{
void *p = usr_alloc1 (7 < n ? 7 : n);
strcpy (p, "0123456"); // { dg-warning "\\\[-Wstringop-overflow" }
sink (p);
strcpy (p, "012345");
sink (p);
}
void usr_alloc2_cst_ir_strcpy (int n)
{
void *p = usr_alloc2 (1, 5 < n ? 5 : n);
strcpy (p, "01234"); // { dg-warning "\\\[-Wstringop-overflow" }
sink (p);
strcpy (p, "0123");
sink (p);
}
void usr_alloc2_ir_ir_strcpy (int m, int n)
{
void *p = usr_alloc2 (3 < n ? 3 : n, 5 < n ? 5 : n);
strcpy (p, "0123456789abcde"); // { dg-warning "\\\[-Wstringop-overflow" }
sink (p);
strcpy (p, "0123456789abcd");
sink (p);
}
void usr_alloc2_uint8_memset (uint8_t m, uint8_t n)
{
if (3 <= m && m <= 7) return;
if (5 <= n && n <= 9) return;
void *p = usr_alloc2 (m, n);
size_t sz = UINT8_MAX * UINT8_MAX + 1;
memset (p, 0, sz); // { dg-warning "\\\[-Wstringop-overflow" "" { xfail *-*-* } }
// { dg-warning "\\\[-Warray-bounds" "pr?????" { target *-*-* } .-1 }
sink (p);
memset (p, 0, sz - 1);
sink (p);
memset (p, 0, 64);
sink (p);
memset (p, 0, 63);
sink (p);
memset (p, 0, 16);
sink (p);
memset (p, 0, 15);
sink (p);
memset (p, 0, 14);
sink (p);
memset (p, 0, 3);
sink (p);
}
void malloc_int_memset (int n)
{
void *p = malloc (11 < n ? 11 : n);
memset (p, 0, 12); // { dg-warning "\\\[-Wstringop-overflow" }
sink (p);
memset (p, 0, 11);
sink (p);
}
void vla_int_memset (int n)
{
char a[13 < n ? 13 : n];
memset (a, 0, 14); // { dg-warning "\\\[-Wstringop-overflow" }
sink (a);
memset (a, 0, 13);
sink (a);
}
|
