1 // RUN: %clang_analyze_cc1 -analyzer-checker=core.BitwiseShift \
2 // RUN: -analyzer-checker=debug.ExprInspection \
3 // RUN: -analyzer-output=text -verify \
4 // RUN: -triple x86_64-pc-linux-gnu -x c %s \
5 // RUN: -Wno-shift-count-negative -Wno-shift-negative-value \
6 // RUN: -Wno-shift-count-overflow -Wno-shift-overflow \
7 // RUN: -Wno-shift-sign-overflow
8 //
9 // RUN: %clang_analyze_cc1 -analyzer-checker=core.BitwiseShift \
10 // RUN: -analyzer-checker=debug.ExprInspection \
11 // RUN: -analyzer-config core.BitwiseShift:Pedantic=true \
12 // RUN: -analyzer-output=text -verify \
13 // RUN: -triple x86_64-pc-linux-gnu -x c++ -std=c++20 %s \
14 // RUN: -Wno-shift-count-negative -Wno-shift-negative-value \
15 // RUN: -Wno-shift-count-overflow -Wno-shift-overflow \
16 // RUN: -Wno-shift-sign-overflow
17 //
18 // This test file verifies the default behavior of the BitwiseShift checker,
19 // which reports the serious logical defects, but doesn't warn on code that's
20 // legal under C++20 (or later) and widely accepted (but theoretically
21 // undefined) in other compilation modes.
22
23 // TEST NEGATIVE RIGHT OPERAND
24 //===----------------------------------------------------------------------===//
25
negative_right_operand_literal(void)26 int negative_right_operand_literal(void) {
27 return 2 << -2;
28 // expected-warning@-1 {{Right operand is negative in left shift}}
29 // expected-note@-2 {{The result of left shift is undefined because the right operand is negative}}
30 }
31
negative_right_operand_symbolic(int left,int right)32 int negative_right_operand_symbolic(int left, int right) {
33 // expected-note@+2 {{Assuming 'right' is < 0}}
34 // expected-note@+1 {{Taking false branch}}
35 if (right >= 0)
36 return 0;
37 return left >> right;
38 // expected-warning@-1 {{Right operand is negative in right shift}}
39 // expected-note@-2 {{The result of right shift is undefined because the right operand is negative}}
40 }
41
negative_right_operand_compound(short arg)42 int negative_right_operand_compound(short arg) {
43 // expected-note@+2 {{Assuming 'arg' is < 2}}
44 // expected-note@+1 {{Taking false branch}}
45 if (arg >= 2 )
46 return 0;
47 return 2 << (arg - 1 - 1 - 1);
48 // expected-warning@-1 {{Right operand is negative in left shift}}
49 // expected-note@-2 {{The result of left shift is undefined because the right operand is negative}}
50 }
51
52 // TEST TOO LARGE RIGHT OPERAND
53 //===----------------------------------------------------------------------===//
54
too_large_right_operand_literal(void)55 int too_large_right_operand_literal(void) {
56 return 2 << 32;
57 // expected-warning@-1 {{Left shift by '32' overflows the capacity of 'int'}}
58 // expected-note@-2 {{The result of left shift is undefined because the right operand '32' is not smaller than 32, the capacity of 'int'}}
59 }
60
too_large_right_operand_exact_symbolic(int arg)61 int too_large_right_operand_exact_symbolic(int arg) {
62 // expected-note@+4 {{Assuming 'arg' is > 33}}
63 // expected-note@+3 {{Left side of '||' is false}}
64 // expected-note@+2 {{Assuming 'arg' is < 35}}
65 // expected-note@+1 {{Taking false branch}}
66 if (arg <= 33 || arg >= 35)
67 return 0;
68 return 3 << arg;
69 // expected-warning@-1 {{Left shift by '34' overflows the capacity of 'int'}}
70 // expected-note@-2 {{The result of left shift is undefined because the right operand '34' is not smaller than 32, the capacity of 'int'}}
71 }
72
too_large_right_operand_exact_symbolic_2(char arg)73 int too_large_right_operand_exact_symbolic_2(char arg) {
74 // expected-note@+2 {{Assuming the condition is false}}
75 // expected-note@+1 {{Taking false branch}}
76 if (arg != ' ')
77 return 0;
78 return 3 << arg;
79 // expected-warning@-1 {{Left shift by '32' overflows the capacity of 'int'}}
80 // expected-note@-2 {{The result of left shift is undefined because the right operand '32' is not smaller than 32, the capacity of 'int'}}
81 }
82
too_large_right_operand_symbolic(int left,int right)83 int too_large_right_operand_symbolic(int left, int right) {
84 // expected-note@+2 {{Assuming 'right' is > 31}}
85 // expected-note@+1 {{Taking false branch}}
86 if (right <= 31)
87 return 0;
88 return left >> right;
89 // expected-warning@-1 {{Right shift overflows the capacity of 'int'}}
90 // expected-note@-2 {{The result of right shift is undefined because the right operand is >= 32, not smaller than 32, the capacity of 'int'}}
91 }
92
93 void clang_analyzer_value(int);
too_large_right_operand_compound(unsigned short arg)94 int too_large_right_operand_compound(unsigned short arg) {
95 // Note: this would be valid code with an 'unsigned int' because
96 // unsigned addition is allowed to overflow.
97 clang_analyzer_value(32+arg);
98 // expected-warning@-1 {{32s:{ [-2147483648, 2147483647] }}
99 // expected-note@-2 {{32s:{ [-2147483648, 2147483647] }}
100 return 1 << (32 + arg);
101 // expected-warning@-1 {{Left shift overflows the capacity of 'int'}}
102 // expected-note@-2 {{The result of left shift is undefined because the right operand is not smaller than 32, the capacity of 'int'}}
103 // FIXME: this message should be
104 // {{The result of left shift is undefined because the right operand is >= 32, not smaller than 32, the capacity of 'int'}}
105 // but for some reason neither the new logic, nor debug.ExprInspection and
106 // clang_analyzer_value reports this range information.
107 }
108
109 // TEST STATE UPDATES
110 //===----------------------------------------------------------------------===//
111
state_update(char a,int * p)112 void state_update(char a, int *p) {
113 // NOTE: with 'int a' this would not produce a bug report because the engine
114 // would not rule out an overflow.
115 *p += 1 << a;
116 // expected-note@-1 {{Assuming right operand of bit shift is non-negative but less than 32}}
117 *p += 1 << (a + 32);
118 // expected-warning@-1 {{Left shift overflows the capacity of 'int'}}
119 // expected-note@-2 {{The result of left shift is undefined because the right operand is not smaller than 32, the capacity of 'int'}}
120 }
121
state_update_2(char a,int * p)122 void state_update_2(char a, int *p) {
123 *p += 1234 >> (a + 32);
124 // expected-note@-1 {{Assuming right operand of bit shift is non-negative but less than 32}}
125 *p += 1234 >> a;
126 // expected-warning@-1 {{Right operand is negative in right shift}}
127 // expected-note@-2 {{The result of right shift is undefined because the right operand is negative}}
128 }
129
130 // TEST EXPRESSION TRACKING
131 //===----------------------------------------------------------------------===//
132 // Expression tracking a "generic" tool that's used by many other checkers,
133 // so this is just a minimal test to see that it's activated.
134
setValue(unsigned * p,unsigned newval)135 void setValue(unsigned *p, unsigned newval) {
136 *p = newval;
137 // expected-note@-1 {{The value 33 is assigned to 'right'}}
138 }
139
expression_tracked_back(void)140 int expression_tracked_back(void) {
141 unsigned left = 115; // expected-note {{'left' initialized to 115}}
142 unsigned right;
143 setValue(&right, 33);
144 // expected-note@-1 {{Calling 'setValue'}}
145 // expected-note@-2 {{Passing the value 33 via 2nd parameter 'newval'}}
146 // expected-note@-3 {{Returning from 'setValue'}}
147
148 return left << right;
149 // expected-warning@-1 {{Left shift by '33' overflows the capacity of 'unsigned int'}}
150 // expected-note@-2 {{The result of left shift is undefined because the right operand '33' is not smaller than 32, the capacity of 'unsigned int'}}
151 }
152
153 // TEST PERMISSIVENESS
154 //===----------------------------------------------------------------------===//
155
allow_overflows_and_negative_operands(void)156 int allow_overflows_and_negative_operands(void) {
157 // These are all legal under C++20 and many compilers accept them under
158 // earlier standards as well.
159 int int_min = 1 << 31; // no-warning
160 int this_overflows = 1027 << 30; // no-warning
161 return (-2 << 5) + (-3 >> 4); // no-warning
162 }
163
double_negative(void)164 int double_negative(void) {
165 return -2 >> -2;
166 // expected-warning@-1 {{Right operand is negative in right shift}}
167 // expected-note@-2 {{The result of right shift is undefined because the right operand is negative}}
168 }
169