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
|
// RUN: %clang_cc1 -std=c++20 -Wunsafe-buffer-usage \
// RUN: -fsafe-buffer-usage-suggestions -verify %s
[[clang::unsafe_buffer_usage]]
void deprecatedFunction3();
void deprecatedFunction4(int z);
void someFunction();
[[clang::unsafe_buffer_usage]]
void overloading(int* x);
void overloading(char c[]);
void overloading(int* x, int size);
[[clang::unsafe_buffer_usage]]
void deprecatedFunction4(int z);
void caller(int z, int* x, int size, char c[]) {
deprecatedFunction3(); // expected-warning{{function introduces unsafe buffer manipulation}}
deprecatedFunction4(z); // expected-warning{{function introduces unsafe buffer manipulation}}
someFunction();
overloading(x); // expected-warning{{function introduces unsafe buffer manipulation}}
overloading(x, size);
overloading(c);
}
[[clang::unsafe_buffer_usage]]
void overloading(char c[]);
// Test variadics
[[clang::unsafe_buffer_usage]]
void testVariadics(int *ptr, ...);
template<typename T, typename... Args>
[[clang::unsafe_buffer_usage]]
T adder(T first, Args... args);
template <typename T>
void foo(T t) {}
template<>
[[clang::unsafe_buffer_usage]]
void foo<int *>(int *t) {}
void caller1(int *p, int *q) {
testVariadics(p, q); // expected-warning{{function introduces unsafe buffer manipulation}}
adder(p, q); // expected-warning{{function introduces unsafe buffer manipulation}}
int x;
foo(x);
foo(&x); // expected-warning{{function introduces unsafe buffer manipulation}}
}
// Test virtual functions
class BaseClass {
public:
[[clang::unsafe_buffer_usage]]
virtual void func() {}
virtual void func1() {}
};
class DerivedClass : public BaseClass {
public:
void func() {}
[[clang::unsafe_buffer_usage]]
void func1() {}
};
void testInheritance() {
DerivedClass DC;
DC.func();
DC.func1(); // expected-warning{{function introduces unsafe buffer manipulation}}
BaseClass *BC;
BC->func(); // expected-warning{{function introduces unsafe buffer manipulation}}
BC->func1();
BC = &DC;
BC->func(); // expected-warning{{function introduces unsafe buffer manipulation}}
BC->func1();
}
class UnsafeMembers {
public:
UnsafeMembers() {}
[[clang::unsafe_buffer_usage]]
UnsafeMembers(int) {}
[[clang::unsafe_buffer_usage]]
explicit operator int() { return 0; }
[[clang::unsafe_buffer_usage]]
void Method() {}
[[clang::unsafe_buffer_usage]]
void operator()() {}
[[clang::unsafe_buffer_usage]]
int operator+(UnsafeMembers) { return 0; }
};
template <class... Vs>
int testFoldExpression(Vs&&... v) {
return (... + v); // expected-warning{{function introduces unsafe buffer manipulation}}
}
// https://github.com/llvm/llvm-project/issues/80482
void testClassMembers() {
UnsafeMembers(3); // expected-warning{{function introduces unsafe buffer manipulation}}
(void)static_cast<int>(UnsafeMembers()); // expected-warning{{function introduces unsafe buffer manipulation}}
UnsafeMembers().Method(); // expected-warning{{function introduces unsafe buffer manipulation}}
UnsafeMembers()(); // expected-warning{{function introduces unsafe buffer manipulation}}
testFoldExpression(UnsafeMembers(), UnsafeMembers());
}
|
