]>
Commit | Line | Data |
---|---|---|
7b6bb8da | 1 | # Copyright 2010, 2011 Free Software Foundation, Inc. |
f4b8a18d KW |
2 | |
3 | # This program is free software; you can redistribute it and/or modify | |
4 | # it under the terms of the GNU General Public License as published by | |
5 | # the Free Software Foundation; either version 3 of the License, or | |
6 | # (at your option) any later version. | |
7 | # | |
8 | # This program is distributed in the hope that it will be useful, | |
9 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
10 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
11 | # GNU General Public License for more details. | |
12 | # | |
13 | # You should have received a copy of the GNU General Public License | |
14 | # along with this program. If not, see <http://www.gnu.org/licenses/>. */ | |
15 | # | |
16 | # Contributed by Ken Werner <ken.werner@de.ibm.com>. | |
17 | # | |
18 | # Tests GDBs support for OpenCL operators. | |
19 | ||
20 | if $tracelevel { | |
21 | strace $tracelevel | |
22 | } | |
23 | ||
24 | load_lib opencl.exp | |
25 | ||
26 | if { [skip_opencl_tests] } { | |
27 | return 0 | |
28 | } | |
29 | ||
30 | set testfile "operators" | |
31 | set clprogram [remote_download target ${srcdir}/${subdir}/${testfile}.cl] | |
32 | ||
33 | # Compile the generic OpenCL host app | |
34 | if { [gdb_compile_opencl_hostapp "${clprogram}" "${testfile}" "" ] != "" } { | |
35 | untested ${testfile}.exp | |
36 | return -1 | |
37 | } | |
38 | ||
39 | # Load the OpenCL app | |
40 | clean_restart ${testfile} | |
41 | ||
42 | # Set breakpoint at the OpenCL kernel | |
b2030fb5 | 43 | gdb_test "tbreak testkernel" \ |
d468832a KW |
44 | "" \ |
45 | "Set pending breakpoint" \ | |
46 | ".*Function \"testkernel\" not defined.*Make breakpoint pending.*y or \\\[n\\\]. $" \ | |
47 | "y" | |
f4b8a18d KW |
48 | |
49 | gdb_run_cmd | |
b2030fb5 | 50 | gdb_test "" ".*reakpoint.*1.*testkernel.*" "run" |
f4b8a18d | 51 | |
d468832a KW |
52 | # Continue to the marker |
53 | gdb_breakpoint [gdb_get_line_number "marker" "${clprogram}"] | |
54 | gdb_continue_to_breakpoint "marker" | |
55 | ||
f4b8a18d KW |
56 | # Retrieve some information about availability of OpenCL extensions |
57 | set have_cl_khr_fp64 [get_integer_valueof "have_cl_khr_fp64" 0] | |
58 | set have_cl_khr_fp16 [get_integer_valueof "have_cl_khr_fp16" 0] | |
59 | ||
60 | proc check_basic { name type isfloat } { | |
61 | gdb_test "print/d ${name}a" " = 2" | |
62 | gdb_test "print/d ${name}b" " = 1" | |
63 | gdb_test "print/d ${name}4a" " = \\{2, 4, 8, 16\\}" | |
64 | gdb_test "print/d ${name}4b" " = \\{1, 2, 8, 4\\}" | |
65 | ||
66 | gdb_test "ptype ${name}a" "type = ${type}" | |
67 | gdb_test "ptype ${name}b" "type = ${type}" | |
68 | gdb_test "ptype ${name}4a" "type = ${type} \\\[4\\\]" | |
69 | gdb_test "ptype ${name}4b" "type = ${type} \\\[4\\\]" | |
70 | ||
71 | if { ! ${isfloat} } { | |
72 | gdb_test "print/d u${name}a" " = 2" | |
73 | gdb_test "print/d u${name}b" " = 1" | |
74 | gdb_test "print/d u${name}4a" " = \\{2, 4, 8, 16\\}" | |
75 | gdb_test "print/d u${name}4b" " = \\{1, 2, 8, 4\\}" | |
76 | gdb_test "ptype u${name}a" "type = (unsigned ${type}|u${type})" | |
77 | gdb_test "ptype u${name}b" "type = (unsigned ${type}|u${type})" | |
78 | gdb_test "ptype u${name}4a" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
79 | gdb_test "ptype u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
80 | } | |
81 | } | |
82 | ||
83 | # Arithmetic operators | |
84 | proc check_arithmetic_ops { name type isfloat size } { | |
85 | # scalar with scalar | |
86 | gdb_test "print/d ${name}a + ${name}b" " = 3" | |
87 | gdb_test "print/d ${name}a - ${name}b" " = 1" | |
88 | gdb_test "print/d ${name}a * ${name}b" " = 2" | |
89 | gdb_test "print/d ${name}a / ${name}b" " = 2" | |
90 | # scalar with vector | |
91 | gdb_test "print/d ${name}a + ${name}4b" " = \\{3, 4, 10, 6\\}" | |
92 | gdb_test "print/d ${name}4a - ${name}b" " = \\{1, 3, 7, 15\\}" | |
93 | gdb_test "print/d ${name}4a * ${name}b" " = \\{2, 4, 8, 16\\}" | |
94 | gdb_test "print/d ${name}a / ${name}4b" " = \\{2, 1, 0, 0\\}" | |
95 | # vector with vector | |
96 | gdb_test "print/d ${name}4a + ${name}4b" " = \\{3, 6, 16, 20\\}" | |
97 | gdb_test "print/d ${name}4a - ${name}4b" " = \\{1, 2, 0, 12\\}" | |
98 | gdb_test "print/d ${name}4a * ${name}4b" " = \\{2, 8, 64, 64\\}" | |
99 | gdb_test "print/d ${name}4a / ${name}4b" " = \\{2, 2, 1, 4\\}" | |
100 | ||
101 | # scalar | |
102 | gdb_test "print/d ${name}a++" " = 2" | |
103 | gdb_test "print/d ++${name}a" " = 4" | |
104 | gdb_test "print/d ${name}a--" " = 4" | |
105 | gdb_test "print/d --${name}a" " = 2" | |
106 | gdb_test "print/d +${name}a" " = 2" | |
107 | gdb_test "print/d -${name}a" " = -2" | |
108 | # vector | |
109 | gdb_test "print/d ${name}4a++" " = \\{2, 4, 8, 16\\}" | |
110 | gdb_test "print/d ++${name}4a" " = \\{4, 6, 10, 18\\}" | |
111 | gdb_test "print/d ${name}4a--" " = \\{4, 6, 10, 18\\}" | |
112 | gdb_test "print/d --${name}4a" " = \\{2, 4, 8, 16\\}" | |
113 | gdb_test "print/d +${name}4a" " = \\{2, 4, 8, 16\\}" | |
114 | gdb_test "print/d -${name}4a" " = \\{-2, -4, -8, -16\\}" | |
115 | ||
116 | # scalar with vector | |
117 | gdb_test "ptype ${name}a + ${name}4b" "type = ${type} \\\[4\\\]" | |
118 | gdb_test "ptype ${name}4a - ${name}b" "type = ${type} \\\[4\\\]" | |
119 | gdb_test "ptype ${name}a * ${name}4b" "type = ${type} \\\[4\\\]" | |
120 | gdb_test "ptype ${name}4a / ${name}b" "type = ${type} \\\[4\\\]" | |
121 | # vector with vector | |
122 | gdb_test "ptype ${name}4a + ${name}4b" "type = ${type} \\\[4\\\]" | |
123 | gdb_test "ptype ${name}4a - ${name}4b" "type = ${type} \\\[4\\\]" | |
124 | gdb_test "ptype ${name}4a * ${name}4b" "type = ${type} \\\[4\\\]" | |
125 | gdb_test "ptype ${name}4a / ${name}4b" "type = ${type} \\\[4\\\]" | |
126 | ||
127 | # scalar | |
128 | gdb_test "ptype ${name}a++" "type = ${type}" | |
129 | gdb_test "ptype ++${name}a" "type = ${type}" | |
130 | gdb_test "ptype ${name}a--" "type = ${type}" | |
131 | gdb_test "ptype --${name}a" "type = ${type}" | |
132 | # vector | |
133 | gdb_test "ptype ${name}4a++" "type = ${type} \\\[4\\\]" | |
134 | gdb_test "ptype ++${name}4a" "type = ${type} \\\[4\\\]" | |
135 | gdb_test "ptype ${name}4a--" "type = ${type} \\\[4\\\]" | |
136 | gdb_test "ptype --${name}4a" "type = ${type} \\\[4\\\]" | |
137 | gdb_test "ptype +${name}4a" "type = ${type} \\\[4\\\]" | |
138 | gdb_test "ptype -${name}4a" "type = ${type} \\\[4\\\]" | |
139 | ||
140 | if { ${isfloat} } { | |
141 | # scalar with scalar | |
142 | gdb_test "ptype ${name}a + ${name}b" "type = ${type}" | |
143 | gdb_test "ptype ${name}a - ${name}b" "type = ${type}" | |
144 | gdb_test "ptype ${name}a * ${name}b" "type = ${type}" | |
145 | gdb_test "ptype ${name}a / ${name}b" "type = ${type}" | |
146 | # scalar | |
147 | gdb_test "ptype +${name}a" "type = ${type}" | |
148 | gdb_test "ptype -${name}a" "type = ${type}" | |
149 | } else { | |
150 | # scalar with scalar | |
151 | gdb_test "print/d ${name}a % ${name}b" " = 0" | |
152 | # scalar with vector | |
153 | gdb_test "print/d ${name}4a % ${name}b" " = \\{0, 0, 0, 0\\}" | |
154 | # vector with vector | |
155 | gdb_test "print/d ${name}4a % ${name}b" " = \\{0, 0, 0, 0\\}" | |
156 | ||
157 | # scalar with scalar | |
158 | gdb_test "print/d u${name}a + u${name}b" " = 3" | |
159 | gdb_test "print/d u${name}a - u${name}b" " = 1" | |
160 | gdb_test "print/d u${name}a * u${name}b" " = 2" | |
161 | gdb_test "print/d u${name}a / u${name}b" " = 2" | |
162 | gdb_test "print/d u${name}a % u${name}b" " = 0" | |
163 | # scalar with vector | |
164 | gdb_test "print/d u${name}a + u${name}4b" " = \\{3, 4, 10, 6\\}" | |
165 | gdb_test "print/d u${name}4a - u${name}b" " = \\{1, 3, 7, 15\\}" | |
166 | gdb_test "print/d u${name}4a * u${name}b" " = \\{2, 4, 8, 16\\}" | |
167 | gdb_test "print/d u${name}a / u${name}4b" " = \\{2, 1, 0, 0\\}" | |
168 | gdb_test "print/d u${name}4a % u${name}b" " = \\{0, 0, 0, 0\\}" | |
169 | # vector with vector | |
170 | gdb_test "print/d u${name}4a + u${name}4b" " = \\{3, 6, 16, 20\\}" | |
171 | gdb_test "print/d u${name}4a - u${name}4b" " = \\{1, 2, 0, 12\\}" | |
172 | gdb_test "print/d u${name}4a * u${name}4b" " = \\{2, 8, 64, 64\\}" | |
173 | gdb_test "print/d u${name}4a / u${name}4b" " = \\{2, 2, 1, 4\\}" | |
174 | gdb_test "print/d u${name}4a % u${name}4b" " = \\{0, 0, 0, 0\\}" | |
175 | ||
176 | # scalar | |
177 | gdb_test "print/d u${name}a++" " = 2" | |
178 | gdb_test "print/d ++u${name}a" " = 4" | |
179 | gdb_test "print/d u${name}a--" " = 4" | |
180 | gdb_test "print/d --u${name}a" " = 2" | |
181 | gdb_test "print/d +u${name}a" " = 2" | |
182 | gdb_test "print/x -u${name}a" " = 0x.*fe" | |
183 | # vector | |
184 | gdb_test "print/d u${name}4a++" " = \\{2, 4, 8, 16\\}" | |
185 | gdb_test "print/d ++u${name}4a" " = \\{4, 6, 10, 18\\}" | |
186 | gdb_test "print/d u${name}4a--" " = \\{4, 6, 10, 18\\}" | |
187 | gdb_test "print/d --u${name}4a" " = \\{2, 4, 8, 16\\}" | |
188 | gdb_test "print/d +u${name}4a" " = \\{2, 4, 8, 16\\}" | |
189 | gdb_test "print/x -u${name}4a" " = \\{0x.*fe, 0x.*fc, 0x.*f8, 0x.*f0\\}" | |
190 | ||
191 | # scalar with scalar | |
192 | if { ${size} < 4 } { | |
193 | gdb_test "ptype ${name}a + ${name}b" "type = int" | |
194 | gdb_test "ptype ${name}a - ${name}b" "type = int" | |
195 | gdb_test "ptype ${name}a * ${name}b" "type = int" | |
196 | gdb_test "ptype ${name}a / ${name}b" "type = int" | |
197 | gdb_test "ptype ${name}a % ${name}b" "type = int" | |
198 | gdb_test "ptype +${name}a" "type = int" | |
199 | gdb_test "ptype -${name}a" "type = int" | |
200 | gdb_test "ptype u${name}a + u${name}b" "type = int" | |
201 | gdb_test "ptype u${name}a - u${name}b" "type = int" | |
202 | gdb_test "ptype u${name}a * u${name}b" "type = int" | |
203 | gdb_test "ptype u${name}a / u${name}b" "type = int" | |
204 | gdb_test "ptype u${name}a % u${name}b" "type = int" | |
205 | gdb_test "ptype +u${name}a" "type = int" | |
206 | gdb_test "ptype -u${name}a" "type = int" | |
207 | } elseif { ${size} == 4 } { | |
208 | gdb_test "ptype ${name}a + ${name}b" "type = int" | |
209 | gdb_test "ptype ${name}a - ${name}b" "type = int" | |
210 | gdb_test "ptype ${name}a * ${name}b" "type = int" | |
211 | gdb_test "ptype ${name}a / ${name}b" "type = int" | |
212 | gdb_test "ptype ${name}a % ${name}b" "type = int" | |
213 | gdb_test "ptype +${name}a" "type = int" | |
214 | gdb_test "ptype -${name}a" "type = int" | |
215 | gdb_test "ptype u${name}a + u${name}b" "type = (unsigned int|uint)" | |
216 | gdb_test "ptype u${name}a - u${name}b" "type = (unsigned int|uint)" | |
217 | gdb_test "ptype u${name}a * u${name}b" "type = (unsigned int|uint)" | |
218 | gdb_test "ptype u${name}a / u${name}b" "type = (unsigned int|uint)" | |
219 | gdb_test "ptype u${name}a % u${name}b" "type = (unsigned int|uint)" | |
220 | gdb_test "ptype +u${name}a" "type = (unsigned int|uint)" | |
221 | gdb_test "ptype -u${name}a" "type = (unsigned int|uint)" | |
222 | } else { # ${size} == 8 | |
223 | gdb_test "ptype ${name}a + ${name}b" "type = long" | |
224 | gdb_test "ptype ${name}a - ${name}b" "type = long" | |
225 | gdb_test "ptype ${name}a * ${name}b" "type = long" | |
226 | gdb_test "ptype ${name}a / ${name}b" "type = long" | |
227 | gdb_test "ptype ${name}a % ${name}b" "type = long" | |
228 | gdb_test "ptype +${name}a" "type = long" | |
229 | gdb_test "ptype -${name}a" "type = long" | |
230 | gdb_test "ptype u${name}a + u${name}b" "type = (unsigned long|ulong)" | |
231 | gdb_test "ptype u${name}a - u${name}b" "type = (unsigned long|ulong)" | |
232 | gdb_test "ptype u${name}a * u${name}b" "type = (unsigned long|ulong)" | |
233 | gdb_test "ptype u${name}a / u${name}b" "type = (unsigned long|ulong)" | |
234 | gdb_test "ptype u${name}a % u${name}b" "type = (unsigned long|ulong)" | |
235 | # scalar | |
236 | gdb_test "ptype +u${name}a" "type = (unsigned long|ulong)" | |
237 | gdb_test "ptype -u${name}a" "type = (unsigned long|ulong)" | |
238 | } | |
239 | gdb_test "ptype u${name}a++" "type = (unsigned ${type}|u${type})" | |
240 | gdb_test "ptype ++u${name}a" "type = (unsigned ${type}|u${type})" | |
241 | gdb_test "ptype u${name}a--" "type = (unsigned ${type}|u${type})" | |
242 | gdb_test "ptype --u${name}a" "type = (unsigned ${type}|u${type})" | |
243 | # scalar with vector | |
244 | gdb_test "ptype ${name}a % ${name}4b" "type = ${type} \\\[4\\\]" | |
245 | gdb_test "ptype u${name}a + u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
246 | gdb_test "ptype u${name}4a - u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
247 | gdb_test "ptype u${name}a * u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
248 | gdb_test "ptype u${name}4a / u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
249 | gdb_test "ptype u${name}a % u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
250 | # vector with vector | |
251 | gdb_test "ptype ${name}4a % ${name}4b" "type = ${type} \\\[4\\\]" | |
252 | gdb_test "ptype u${name}4a + u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
253 | gdb_test "ptype u${name}4a - u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
254 | gdb_test "ptype u${name}4a * u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
255 | gdb_test "ptype u${name}4a / u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
256 | gdb_test "ptype u${name}4a % u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
257 | gdb_test "ptype u${name}4a++" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
258 | gdb_test "ptype ++u${name}4a" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
259 | gdb_test "ptype u${name}4a--" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
260 | gdb_test "ptype --u${name}4a" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
261 | gdb_test "ptype +u${name}4a" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
262 | gdb_test "ptype -u${name}4a" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
263 | } | |
264 | } | |
265 | ||
266 | # Relational operators | |
267 | proc check_relational_ops { name type isfloat size } { | |
268 | # scalar with scalar | |
269 | gdb_test "print/d ${name}a > ${name}b" " = 1" | |
270 | gdb_test "print/d ${name}b < ${name}a" " = 1" | |
271 | gdb_test "print/d ${name}b >= ${name}a" " = 0" | |
272 | gdb_test "print/d ${name}a <= ${name}b" " = 0" | |
273 | # scalar with vector | |
274 | gdb_test "print/d ${name}4a > ${name}b" " = \\{-1, -1, -1, -1\\}" | |
275 | gdb_test "print/d ${name}a < ${name}4b" " = \\{0, 0, -1, -1\\}" | |
276 | gdb_test "print/d ${name}4a >= ${name}b" " = \\{-1, -1, -1, -1\\}" | |
277 | gdb_test "print/d ${name}a <= ${name}4b" " = \\{0, -1, -1, -1\\}" | |
278 | # vector with vector | |
279 | gdb_test "print/d ${name}4a > ${name}4b" " = \\{-1, -1, 0, -1\\}" | |
280 | gdb_test "print/d ${name}4b < ${name}4a" " = \\{-1, -1, 0, -1\\}" | |
281 | gdb_test "print/d ${name}4b >= ${name}4a" " = \\{0, 0, -1, 0\\}" | |
282 | gdb_test "print/d ${name}4a <= ${name}4b" " = \\{0, 0, -1, 0\\}" | |
283 | ||
284 | # result type should be int for scalars | |
285 | gdb_test "ptype ${name}a < ${name}b" "type = int" | |
286 | gdb_test "ptype ${name}a > ${name}b" "type = int" | |
287 | gdb_test "ptype ${name}a <= ${name}b" "type = int" | |
288 | gdb_test "ptype ${name}a >= ${name}b" "type = int" | |
289 | ||
290 | if { ${isfloat} } { | |
291 | if { ${size} == 2 } { | |
292 | # result type should be short for half precision floating point vectors | |
293 | # scalar with vector | |
294 | gdb_test "ptype ${name}4a > ${name}b" "type = short \\\[4\\\]" | |
295 | gdb_test "ptype ${name}a < ${name}4b" "type = short \\\[4\\\]" | |
296 | gdb_test "ptype ${name}4a >= ${name}b" "type = short \\\[4\\\]" | |
297 | gdb_test "ptype ${name}a <= ${name}4b" "type = short \\\[4\\\]" | |
298 | # vector with vector | |
299 | gdb_test "ptype ${name}4a > ${name}4b" "type = short \\\[4\\\]" | |
300 | gdb_test "ptype ${name}4a < ${name}4b" "type = short \\\[4\\\]" | |
301 | gdb_test "ptype ${name}4a >= ${name}4b" "type = short \\\[4\\\]" | |
302 | gdb_test "ptype ${name}4a <= ${name}4b" "type = short \\\[4\\\]" | |
303 | } elseif { ${size} == 4 } { | |
304 | # result type should be int for single precision floating point vectors | |
305 | # scalar with vector | |
306 | gdb_test "ptype ${name}4a > ${name}b" "type = int \\\[4\\\]" | |
307 | gdb_test "ptype ${name}a < ${name}4b" "type = int \\\[4\\\]" | |
308 | gdb_test "ptype ${name}4a >= ${name}b" "type = int \\\[4\\\]" | |
309 | gdb_test "ptype ${name}a <= ${name}4b" "type = int \\\[4\\\]" | |
310 | # vector with vector | |
311 | gdb_test "ptype ${name}4a > ${name}4b" "type = int \\\[4\\\]" | |
312 | gdb_test "ptype ${name}4a < ${name}4b" "type = int \\\[4\\\]" | |
313 | gdb_test "ptype ${name}4a >= ${name}4b" "type = int \\\[4\\\]" | |
314 | gdb_test "ptype ${name}4a <= ${name}4b" "type = int \\\[4\\\]" | |
315 | } else { # ${size} == 8 | |
316 | # result type should be long for double precision floating point vectors | |
317 | # scalar with vector | |
318 | gdb_test "ptype ${name}4a > ${name}b" "type = long \\\[4\\\]" | |
319 | gdb_test "ptype ${name}a < ${name}4b" "type = long \\\[4\\\]" | |
320 | gdb_test "ptype ${name}4a >= ${name}b" "type = long \\\[4\\\]" | |
321 | gdb_test "ptype ${name}a <= ${name}4b" "type = long \\\[4\\\]" | |
322 | # vector with vector | |
323 | gdb_test "ptype ${name}4a > ${name}4b" "type = long \\\[4\\\]" | |
324 | gdb_test "ptype ${name}4a < ${name}4b" "type = long \\\[4\\\]" | |
325 | gdb_test "ptype ${name}4a >= ${name}4b" "type = long \\\[4\\\]" | |
326 | gdb_test "ptype ${name}4a <= ${name}4b" "type = long \\\[4\\\]" | |
327 | } | |
328 | } else { | |
329 | # scalar with scalar | |
330 | gdb_test "print/d u${name}a > u${name}b" " = 1" | |
331 | gdb_test "print/d u${name}b < u${name}a" " = 1" | |
332 | gdb_test "print/d u${name}b >= u${name}a" " = 0" | |
333 | gdb_test "print/d u${name}a <= u${name}b" " = 0" | |
334 | # scalar with vector | |
335 | gdb_test "print/d u${name}4a > u${name}b" " = \\{-1, -1, -1, -1\\}" | |
336 | gdb_test "print/d u${name}a < u${name}4b" " = \\{0, 0, -1, -1\\}" | |
337 | gdb_test "print/d u${name}4a >= u${name}b" " = \\{-1, -1, -1, -1\\}" | |
338 | gdb_test "print/d u${name}a <= u${name}4b" " = \\{0, -1, -1, -1\\}" | |
339 | # vector with vector | |
340 | gdb_test "print/d u${name}4a > u${name}4b" " = \\{-1, -1, 0, -1\\}" | |
341 | gdb_test "print/d u${name}4b < u${name}4a" " = \\{-1, -1, 0, -1\\}" | |
342 | gdb_test "print/d u${name}4b >= u${name}4a" " = \\{0, 0, -1, 0\\}" | |
343 | gdb_test "print/d u${name}4a <= u${name}4b" " = \\{0, 0, -1, 0\\}" | |
344 | ||
345 | # result type for unsigned operands is signed | |
346 | # scalar with scalar | |
347 | gdb_test "ptype u${name}a < u${name}b" "type = int" | |
348 | gdb_test "ptype u${name}a > u${name}b" "type = int" | |
349 | gdb_test "ptype u${name}a <= u${name}b" "type = int" | |
350 | gdb_test "ptype u${name}a >= u${name}b" "type = int" | |
351 | # scalar with vector | |
352 | gdb_test "ptype u${name}4a > u${name}b" "type = ${type} \\\[4\\\]" | |
353 | gdb_test "ptype u${name}a < u${name}4b" "type = ${type} \\\[4\\\]" | |
354 | gdb_test "ptype u${name}4a >= u${name}b" "type = ${type} \\\[4\\\]" | |
355 | gdb_test "ptype u${name}a <= u${name}4b" "type = ${type} \\\[4\\\]" | |
356 | # vector with vector | |
357 | gdb_test "ptype u${name}4a > u${name}4b" "type = ${type} \\\[4\\\]" | |
358 | gdb_test "ptype u${name}4a < u${name}4b" "type = ${type} \\\[4\\\]" | |
359 | gdb_test "ptype u${name}4a >= u${name}4b" "type = ${type} \\\[4\\\]" | |
360 | gdb_test "ptype u${name}4a <= u${name}4b" "type = ${type} \\\[4\\\]" | |
361 | } | |
362 | } | |
363 | ||
364 | # Equality operators | |
365 | proc check_equality_ops { name type isfloat size } { | |
366 | # scalar with scalar | |
367 | gdb_test "print/d ${name}a == ${name}b" " = 0" | |
368 | gdb_test "print/d ${name}a != ${name}b" " = 1" | |
369 | # scalar with vector | |
370 | gdb_test "print/d ${name}4a == ${name}b" " = \\{0, 0, 0, 0\\}" | |
371 | gdb_test "print/d ${name}a != ${name}4b" " = \\{-1, 0, -1, -1\\}" | |
372 | # vector with vector | |
373 | gdb_test "print/d ${name}4a == ${name}4b" " = \\{0, 0, -1, 0\\}" | |
374 | gdb_test "print/d ${name}4a != ${name}4b" " = \\{-1, -1, 0, -1\\}" | |
375 | ||
376 | # scalar with scalar | |
377 | gdb_test "ptype ${name}a == ${name}b" "type = int" | |
378 | gdb_test "ptype ${name}a != ${name}b" "type = int" | |
379 | ||
380 | if { ${isfloat} } { | |
381 | if { ${size} == 2 } { | |
382 | # result type should be short for half precision floating point vectors | |
383 | # scalar with vector | |
384 | gdb_test "ptype ${name}4a == ${name}b" "type = short \\\[4\\\]" | |
385 | gdb_test "ptype ${name}a != ${name}4b" "type = short \\\[4\\\]" | |
386 | # vector with vector | |
387 | gdb_test "ptype ${name}4a == ${name}4b" "type = short \\\[4\\\]" | |
388 | gdb_test "ptype ${name}4a != ${name}4b" "type = short \\\[4\\\]" | |
389 | } elseif { ${size} == 4 } { | |
390 | # result type should be int for single precision floating point vectors | |
391 | # scalar with vector | |
392 | gdb_test "ptype ${name}4a == ${name}b" "type = int \\\[4\\\]" | |
393 | gdb_test "ptype ${name}a != ${name}4b" "type = int \\\[4\\\]" | |
394 | # vector with vector | |
395 | gdb_test "ptype ${name}4a == ${name}4b" "type = int \\\[4\\\]" | |
396 | gdb_test "ptype ${name}4a != ${name}4b" "type = int \\\[4\\\]" | |
397 | } else { # ${size} == 8 | |
398 | # result type should be long for double precision floating point vectors | |
399 | # scalar with vector | |
400 | gdb_test "ptype ${name}4a == ${name}b" "type = long \\\[4\\\]" | |
401 | gdb_test "ptype ${name}a != ${name}4b" "type = long \\\[4\\\]" | |
402 | # vector with vector | |
403 | gdb_test "ptype ${name}4a == ${name}4b" "type = long \\\[4\\\]" | |
404 | gdb_test "ptype ${name}4a != ${name}4b" "type = long \\\[4\\\]" | |
405 | } | |
406 | } else { | |
407 | # scalar with scalar | |
408 | gdb_test "print/d u${name}a == u${name}b" " = 0" | |
409 | gdb_test "print/d u${name}a != u${name}b" " = 1" | |
410 | # scalar with vector | |
411 | gdb_test "print/d u${name}4a == u${name}b" " = \\{0, 0, 0, 0\\}" | |
412 | gdb_test "print/d u${name}a != u${name}4b" " = \\{-1, 0, -1, -1\\}" | |
413 | # vector with vector | |
414 | gdb_test "print/d u${name}4a == u${name}4b" " = \\{0, 0, -1, 0\\}" | |
415 | gdb_test "print/d u${name}4b != u${name}4a" " = \\{-1, -1, 0, -1\\}" | |
416 | ||
417 | # result type for unsigned operands is signed | |
418 | # scalar with scalar | |
419 | gdb_test "ptype u${name}a == u${name}b" "type = int" | |
420 | gdb_test "ptype u${name}a != u${name}b" "type = int" | |
421 | # scalar with vector | |
422 | gdb_test "ptype u${name}4a == u${name}b" "type = ${type} \\\[4\\\]" | |
423 | gdb_test "ptype u${name}a != u${name}4b" "type = ${type} \\\[4\\\]" | |
424 | # vector with vector | |
425 | gdb_test "ptype u${name}4a == u${name}4b" "type = ${type} \\\[4\\\]" | |
426 | gdb_test "ptype u${name}4a != u${name}4b" "type = ${type} \\\[4\\\]" | |
427 | } | |
428 | } | |
429 | ||
430 | # Shift operators | |
431 | proc check_shift_ops { name type size } { | |
432 | # scalar with scalar | |
433 | gdb_test "print/d ${name}a << ${name}b" " = 4" | |
434 | gdb_test "print/d ${name}a >> ${name}b" " = 1" | |
435 | gdb_test "print/d u${name}a << u${name}b" " = 4" | |
436 | gdb_test "print/d u${name}a >> u${name}b" " = 1" | |
437 | # scalar with vector | |
438 | gdb_test "print/d ${name}4a << ${name}b" " = \\{4, 8, 16, 32\\}" | |
439 | gdb_test "print/d ${name}4a >> ${name}b" " = \\{1, 2, 4, 8\\}" | |
440 | gdb_test "print/d u${name}4a << u${name}b" " = \\{4, 8, 16, 32\\}" | |
441 | gdb_test "print/d u${name}4a >> u${name}b" " = \\{1, 2, 4, 8\\}" | |
442 | # vector with vector | |
443 | if { ${size} == 1 } { | |
444 | gdb_test "print/d ${name}4a << ${name}4b" " = \\{4, 16, 0, 0\\}" | |
445 | gdb_test "print/d u${name}4a << u${name}4b" " = \\{4, 16, 0, 0\\}" | |
446 | } else { | |
447 | gdb_test "print/d ${name}4a << ${name}4b" " = \\{4, 16, 2048, 256\\}" | |
448 | gdb_test "print/d u${name}4a << u${name}4b" " = \\{4, 16, 2048, 256\\}" | |
449 | } | |
450 | gdb_test "print/d ${name}4a >> ${name}4b" " = \\{1, 1, 0, 1\\}" | |
451 | gdb_test "print/d u${name}4a >> u${name}4b" " = \\{1, 1, 0, 1\\}" | |
452 | ||
453 | # scalar with scalar | |
454 | if { ${size} < 4 } { | |
455 | gdb_test "ptype ${name}a << ${name}b" "type = int" | |
456 | gdb_test "ptype ${name}a >> ${name}b" "type = int" | |
457 | gdb_test "ptype u${name}a << u${name}b" "type = int" | |
458 | gdb_test "ptype u${name}a >> u${name}b" "type = int" | |
459 | } elseif { ${size} == 4 } { | |
460 | gdb_test "ptype ${name}a << ${name}b" "type = int" | |
461 | gdb_test "ptype ${name}a >> ${name}b" "type = int" | |
462 | gdb_test "ptype u${name}a << u${name}b" "type = (unsigned int|uint)" | |
463 | gdb_test "ptype u${name}a >> u${name}b" "type = (unsigned int|uint)" | |
464 | } else { # ${size} == 8 | |
465 | gdb_test "ptype ${name}a << ${name}b" "type = long" | |
466 | gdb_test "ptype ${name}a >> ${name}b" "type = long" | |
467 | gdb_test "ptype u${name}a << u${name}b" "type = (unsigned long|ulong)" | |
468 | gdb_test "ptype u${name}a >> u${name}b" "type = (unsigned long|ulong)" | |
469 | } | |
470 | # scalar with vector | |
471 | gdb_test "ptype ${name}4a << ${name}b" "type = ${type} \\\[4\\\]" | |
472 | gdb_test "ptype ${name}4a >> ${name}b" "type = ${type} \\\[4\\\]" | |
473 | gdb_test "ptype u${name}4a << u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
474 | gdb_test "ptype u${name}4a >> u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
475 | # vector with vector | |
476 | gdb_test "ptype ${name}4a << ${name}4b" "type = ${type} \\\[4\\\]" | |
477 | gdb_test "ptype ${name}4a >> ${name}4b" "type = ${type} \\\[4\\\]" | |
478 | gdb_test "ptype u${name}4a << u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
479 | gdb_test "ptype u${name}4a >> u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
480 | } | |
481 | ||
482 | # Bitwise operators | |
483 | proc check_bitwise_ops { name type size } { | |
484 | # scalar with scalar | |
485 | gdb_test "print/d ${name}a & ${name}b" " = 0" | |
486 | gdb_test "print/d ${name}a | ${name}b" " = 3" | |
487 | gdb_test "print/d ${name}a ^ ${name}b" " = 3" | |
488 | gdb_test "print/d u${name}a & u${name}b" " = 0" | |
489 | gdb_test "print/d u${name}a | u${name}b" " = 3" | |
490 | gdb_test "print/d u${name}a ^ u${name}b" " = 3" | |
491 | # scalar with vector | |
492 | gdb_test "print/d ${name}4a & ${name}b" " = \\{0, 0, 0, 0\\}" | |
493 | gdb_test "print/d ${name}a | ${name}4b" " = \\{3, 2, 10, 6\\}" | |
494 | gdb_test "print/d ${name}4a ^ ${name}b" " = \\{3, 5, 9, 17\\}" | |
495 | gdb_test "print/d u${name}4a & u${name}b" " = \\{0, 0, 0, 0\\}" | |
496 | gdb_test "print/d u${name}a | u${name}4b" " = \\{3, 2, 10, 6\\}" | |
497 | gdb_test "print/d u${name}4a ^ u${name}b" " = \\{3, 5, 9, 17\\}" | |
498 | # vector with vector | |
499 | gdb_test "print/d ${name}4a & ${name}4b" " = \\{0, 0, 8, 0\\}" | |
500 | gdb_test "print/d ${name}4a | ${name}4b" " = \\{3, 6, 8, 20\\}" | |
501 | gdb_test "print/d ${name}4a ^ ${name}4b" " = \\{3, 6, 0, 20\\}" | |
502 | gdb_test "print/d u${name}4a & u${name}4b" " = \\{0, 0, 8, 0\\}" | |
503 | gdb_test "print/d u${name}4a | u${name}4b" " = \\{3, 6, 8, 20\\}" | |
504 | gdb_test "print/d u${name}4a ^ u${name}4b" " = \\{3, 6, 0, 20\\}" | |
505 | ||
506 | # scalar with scalar | |
507 | if { ${size} < 4 } { | |
508 | gdb_test "ptype ${name}a & ${name}b" "type = int" | |
509 | gdb_test "ptype ${name}a | ${name}b" "type = int" | |
510 | gdb_test "ptype ${name}a ^ ${name}b" "type = int" | |
511 | gdb_test "ptype u${name}a & u${name}b" "type = int" | |
512 | gdb_test "ptype u${name}a | u${name}b" "type = int" | |
513 | gdb_test "ptype u${name}a ^ u${name}b" "type = int" | |
514 | } elseif { ${size} == 4 } { | |
515 | gdb_test "ptype ${name}a & ${name}b" "type = int" | |
516 | gdb_test "ptype ${name}a | ${name}b" "type = int" | |
517 | gdb_test "ptype ${name}a ^ ${name}b" "type = int" | |
518 | gdb_test "ptype u${name}a & u${name}b" "type = (unsigned int|uint)" | |
519 | gdb_test "ptype u${name}a | u${name}b" "type = (unsigned int|uint)" | |
520 | gdb_test "ptype u${name}a ^ u${name}b" "type = (unsigned int|uint)" | |
521 | } else { # ${size} == 8 | |
522 | gdb_test "ptype ${name}a & ${name}b" "type = long" | |
523 | gdb_test "ptype ${name}a | ${name}b" "type = long" | |
524 | gdb_test "ptype ${name}a ^ ${name}b" "type = long" | |
525 | gdb_test "ptype u${name}a & u${name}b" "type = (unsigned long|ulong)" | |
526 | gdb_test "ptype u${name}a | u${name}b" "type = (unsigned long|ulong)" | |
527 | gdb_test "ptype u${name}a ^ u${name}b" "type = (unsigned long|ulong)" | |
528 | } | |
529 | # scalar with vector | |
530 | gdb_test "ptype ${name}4a & ${name}b" "type = ${type} \\\[4\\\]" | |
531 | gdb_test "ptype ${name}a | ${name}4b" "type = ${type} \\\[4\\\]" | |
532 | gdb_test "ptype ${name}4a ^ ${name}b" "type = ${type} \\\[4\\\]" | |
533 | gdb_test "ptype u${name}4a & u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
534 | gdb_test "ptype u${name}a | u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
535 | gdb_test "ptype u${name}4a ^ u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
536 | # vector with vector | |
537 | gdb_test "ptype ${name}4a & ${name}4b" "type = ${type} \\\[4\\\]" | |
538 | gdb_test "ptype ${name}4a | ${name}4b" "type = ${type} \\\[4\\\]" | |
539 | gdb_test "ptype ${name}4a ^ ${name}4b" "type = ${type} \\\[4\\\]" | |
540 | gdb_test "ptype u${name}4a & u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
541 | gdb_test "ptype u${name}4a | u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
542 | gdb_test "ptype u${name}4a ^ u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
543 | ||
544 | # scalar | |
545 | if { ${size} < 8 } { | |
546 | gdb_test "print/x ~${name}a" " = 0xfffffffd" | |
547 | gdb_test "print/x ~u${name}a" " = 0xfffffffd" | |
548 | } else { | |
549 | gdb_test "print/x ~${name}a" " = 0xfffffffffffffffd" | |
550 | gdb_test "print/x ~u${name}a" " = 0xfffffffffffffffd" | |
551 | } | |
552 | # vector | |
553 | if { ${size} == 1 } { | |
554 | gdb_test "print/x ~${name}4a" " = \\{0xfd, 0xfb, 0xf7, 0xef\\}" | |
555 | gdb_test "print/x ~u${name}4a" " = \\{0xfd, 0xfb, 0xf7, 0xef\\}" | |
556 | } elseif { ${size} == 2 } { | |
557 | gdb_test "print/x ~${name}4a" " = \\{0xfffd, 0xfffb, 0xfff7, 0xffef\\}" | |
558 | gdb_test "print/x ~u${name}4a" " = \\{0xfffd, 0xfffb, 0xfff7, 0xffef\\}" | |
559 | } elseif { ${size} == 4 } { | |
560 | gdb_test "print/x ~${name}4a" " = \\{0xfffffffd, 0xfffffffb, 0xfffffff7, 0xffffffef\\}" | |
561 | gdb_test "print/x ~u${name}4a" " = \\{0xfffffffd, 0xfffffffb, 0xfffffff7, 0xffffffef\\}" | |
562 | } else { # ${size} == 8 | |
563 | gdb_test "print/x ~${name}4a" " = \\{0xfffffffffffffffd, 0xfffffffffffffffb, 0xfffffffffffffff7, 0xffffffffffffffef\\}" | |
564 | gdb_test "print/x ~u${name}4a" " = \\{0xfffffffffffffffd, 0xfffffffffffffffb, 0xfffffffffffffff7, 0xffffffffffffffef\\}" | |
565 | } | |
566 | # scalar | |
567 | if { ${size} < 4 } { | |
568 | gdb_test "ptype ~${name}a" "type = int" | |
569 | gdb_test "ptype ~u${name}a" "type = int" | |
570 | } elseif { ${size} == 4 } { | |
571 | gdb_test "ptype ~${name}a" "type = int" | |
572 | gdb_test "ptype ~u${name}a" "type = (unsigned int|uint)" | |
573 | } else { # ${size} == 8 | |
574 | gdb_test "ptype ~${name}a" "type = long" | |
575 | gdb_test "ptype ~u${name}a" "type = (unsigned long|ulong)" | |
576 | } | |
577 | # vector | |
578 | gdb_test "ptype ~${name}4a" "type = ${type} \\\[4\\\]" | |
579 | gdb_test "ptype ~u${name}4a" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
580 | } | |
581 | ||
582 | # Logical operators | |
583 | proc check_logical_ops { name type isfloat size } { | |
584 | # scalar | |
585 | gdb_test "print/d !${name}a " " = 0" | |
586 | gdb_test "print/d !!${name}a " " = 1" | |
587 | # vector | |
588 | gdb_test "print/d !${name}4a " " = \\{0, 0, 0, 0\\}" | |
589 | gdb_test "print/d !!${name}4a " " = \\{-1, -1, -1, -1\\}" | |
590 | ||
591 | # scalar with scalar | |
592 | gdb_test "print/d ${name}a && ${name}b" " = 1" | |
593 | gdb_test "print/d ${name}a && !${name}b" " = 0" | |
594 | gdb_test "print/d ${name}a || ${name}b" " = 1" | |
595 | gdb_test "print/d ${name}a || !${name}b" " = 1" | |
596 | gdb_test "print/d !${name}a || !${name}b" " = 0" | |
597 | ||
598 | # scalar with vector | |
599 | gdb_test "print/d ${name}4a && ${name}b" " = \\{-1, -1, -1, -1\\}" | |
600 | gdb_test "print/d ${name}4a && !${name}b" " = \\{0, 0, 0, 0\\}" | |
601 | gdb_test "print/d ${name}a || ${name}4b" " = \\{-1, -1, -1, -1\\}" | |
602 | gdb_test "print/d ${name}a || !${name}4b" " = \\{-1, -1, -1, -1\\}" | |
603 | gdb_test "print/d !${name}4a || !${name}b" " = \\{0, 0, 0, 0\\}" | |
604 | # vector with vector | |
605 | gdb_test "print/d ${name}4a && ${name}4b" " = \\{-1, -1, -1, -1\\}" | |
606 | gdb_test "print/d ${name}4a || ${name}4b" " = \\{-1, -1, -1, -1\\}" | |
607 | ||
608 | # result type should be int for scalars | |
609 | gdb_test "ptype !${name}a" "type = int" | |
610 | gdb_test "ptype ${name}a && ${name}b" "type = int" | |
611 | gdb_test "ptype ${name}a || ${name}b" "type = int" | |
612 | ||
613 | if { ${isfloat} } { | |
614 | if { ${size} == 2 } { | |
615 | # result type should be short for half precision floating point vectors | |
616 | # scalar with vector | |
617 | gdb_test "ptype ${name}4a && ${name}b" "type = short \\\[4\\\]" | |
618 | gdb_test "ptype ${name}a || ${name}4b" "type = short \\\[4\\\]" | |
619 | # vector with vector | |
620 | gdb_test "ptype !${name}4a" "type = short \\\[4\\\]" | |
621 | gdb_test "ptype ${name}4a && ${name}4b" "type = short \\\[4\\\]" | |
622 | gdb_test "ptype ${name}4a || ${name}4b" "type = short \\\[4\\\]" | |
623 | } elseif { ${size} == 4 } { | |
624 | # result type should be int for single precision floating point vectors | |
625 | # scalar with vector | |
626 | gdb_test "ptype ${name}4a && ${name}b" "type = int \\\[4\\\]" | |
627 | gdb_test "ptype ${name}a || ${name}4b" "type = int \\\[4\\\]" | |
628 | # vector with vector | |
629 | gdb_test "ptype !${name}4a" "type = int \\\[4\\\]" | |
630 | gdb_test "ptype ${name}4a && ${name}4b" "type = int \\\[4\\\]" | |
631 | gdb_test "ptype ${name}4a || ${name}4b" "type = int \\\[4\\\]" | |
632 | } else { # ${size} == 8 | |
633 | # result type should be long for double precision floating point vectors | |
634 | # scalar with vector | |
635 | gdb_test "ptype ${name}4a && ${name}b" "type = long \\\[4\\\]" | |
636 | gdb_test "ptype ${name}a || ${name}4b" "type = long \\\[4\\\]" | |
637 | # vector with vector | |
638 | gdb_test "ptype !${name}4a" "type = long \\\[4\\\]" | |
639 | gdb_test "ptype ${name}4a && ${name}4b" "type = long \\\[4\\\]" | |
640 | gdb_test "ptype ${name}4a || ${name}4b" "type = long \\\[4\\\]" | |
641 | } | |
642 | } else { | |
643 | # unsigned scalar | |
644 | gdb_test "print/d !u${name}a " " = 0" | |
645 | gdb_test "print/d !!u${name}a " " = 1" | |
646 | # unsigned vector | |
647 | gdb_test "print/d !u${name}4a " " = \\{0, 0, 0, 0\\}" | |
648 | gdb_test "print/d !!u${name}4a " " = \\{-1, -1, -1, -1\\}" | |
649 | ||
650 | # scalar with scalar | |
651 | gdb_test "print/d u${name}a && u${name}b" " = 1" | |
652 | gdb_test "print/d u${name}a || u${name}b" " = 1" | |
653 | # scalar with vector | |
654 | gdb_test "print/d u${name}4a && u${name}b" " = \\{-1, -1, -1, -1\\}" | |
655 | gdb_test "print/d u${name}a || u${name}4b" " = \\{-1, -1, -1, -1\\}" | |
656 | # vector with vector | |
657 | gdb_test "print/d u${name}4a && u${name}4b" " = \\{-1, -1, -1, -1\\}" | |
658 | gdb_test "print/d u${name}4a || u${name}4b" " = \\{-1, -1, -1, -1\\}" | |
659 | ||
660 | # scalar | |
661 | gdb_test "ptype !u${name}a" "type = int" | |
662 | # vector | |
663 | gdb_test "ptype !${name}4a" "type = ${type} \\\[4\\\]" | |
664 | gdb_test "ptype !u${name}4a" "type = ${type} \\\[4\\\]" | |
665 | ||
666 | # scalar with vector | |
667 | gdb_test "ptype ${name}4a && ${name}b" "type = ${type} \\\[4\\\]" | |
668 | gdb_test "ptype ${name}a || ${name}4b" "type = ${type} \\\[4\\\]" | |
669 | # result type for unsigned vector operand is signed | |
670 | gdb_test "ptype u${name}4a && u${name}b" "type = ${type} \\\[4\\\]" | |
671 | gdb_test "ptype u${name}a || u${name}4b" "type = ${type} \\\[4\\\]" | |
672 | # vector with vector | |
673 | gdb_test "ptype ${name}4a && ${name}4b" "type = ${type} \\\[4\\\]" | |
674 | gdb_test "ptype ${name}4a || ${name}4b" "type = ${type} \\\[4\\\]" | |
675 | # result type for unsigned vector operand is signed | |
676 | gdb_test "ptype u${name}4a && u${name}4b" "type = ${type} \\\[4\\\]" | |
677 | gdb_test "ptype u${name}4a || u${name}4b" "type = ${type} \\\[4\\\]" | |
678 | } | |
679 | } | |
680 | ||
681 | # Conditional operator | |
682 | proc check_conditional_op { name type isfloat } { | |
683 | # scalar with scalar | |
684 | gdb_test "print/d ${name}a ? ${name}b : ${name}a" " = 1" | |
685 | gdb_test "print/d !${name}a ? ${name}b : ${name}a" " = 2" | |
686 | # scalar with vector | |
687 | gdb_test "print/d ${name}4a ? ${name}4b : ${name}a" " = \\{1, 2, 8, 4\\}" | |
688 | gdb_test "print/d ${name}4a ? ${name}b : ${name}4a" " = \\{1, 1, 1, 1\\}" | |
689 | gdb_test "print/d ${name}4a > 4 ? 1 : ${name}4a" " = \\{2, 4, 1, 1\\}" | |
690 | gdb_test "print/d ${name}4a > 4 ? ${name}4b : ${name}a" " = \\{2, 2, 8, 4\\}" | |
691 | # vector with vector | |
692 | gdb_test "print/d ${name}4a ? ${name}4b : ${name}4a" " = \\{1, 2, 8, 4\\}" | |
693 | gdb_test "print/d ${name}4a > 4 ? ${name}4b : ${name}4a" " = \\{2, 4, 8, 4\\}" | |
694 | ||
695 | # scalar with scalar | |
696 | gdb_test "ptype ${name}a ? ${name}b : ${name}a" "type = ${type}" | |
697 | # scalar with vector | |
698 | gdb_test "ptype ${name}4a ? ${name}4b : ${name}a" "type = ${type} \\\[4\\\]" | |
699 | gdb_test "ptype ${name}4a ? ${name}b : ${name}4a" "type = ${type} \\\[4\\\]" | |
700 | # vector with vector | |
701 | gdb_test "ptype ${name}4a ? ${name}4b : ${name}4a" "type = ${type} \\\[4\\\]" | |
702 | ||
703 | if { !${isfloat} } { | |
704 | # scalar with scalar | |
705 | gdb_test "print/d u${name}a ? u${name}b : u${name}a" " = 1" | |
706 | gdb_test "print/d !u${name}a ? u${name}b : u${name}a" " = 2" | |
707 | # scalar with vector | |
708 | gdb_test "print/d u${name}4a ? u${name}4b : u${name}a" " = \\{1, 2, 8, 4\\}" | |
709 | gdb_test "print/d u${name}4a ? u${name}b : u${name}4a" " = \\{1, 1, 1, 1\\}" | |
710 | gdb_test "print/d u${name}4a > 4 ? 1 : u${name}4a" " = \\{2, 4, 1, 1\\}" | |
711 | gdb_test "print/d u${name}4a > 4 ? u${name}4b : u${name}a" " = \\{2, 2, 8, 4\\}" | |
712 | # vector with vector | |
713 | gdb_test "print/d u${name}4a ? u${name}4b : u${name}4a" " = \\{1, 2, 8, 4\\}" | |
714 | gdb_test "print/d u${name}4a > 4 ? u${name}4b : u${name}4a" " = \\{2, 4, 8, 4\\}" | |
715 | ||
716 | # scalar with scalar | |
717 | gdb_test "ptype u${name}a ? u${name}b : u${name}a" "type = (unsigned ${type}|u${type})" | |
718 | # scalar with vector | |
719 | gdb_test "ptype u${name}4a ? u${name}4b : u${name}a" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
720 | gdb_test "ptype u${name}4a ? u${name}b : u${name}4a" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
721 | # vector with vector | |
722 | gdb_test "ptype u${name}4a ? u${name}4b : u${name}4a" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
723 | } | |
724 | } | |
725 | ||
726 | # Assignment operators | |
727 | proc check_assignment_ops { name type isfloat size } { | |
728 | # scalar with scalar | |
729 | gdb_test "print/d ${name}a = ${name}b" " = 1" | |
730 | gdb_test "print/d ${name}a = 2" " = 2" | |
731 | gdb_test "print/d ${name}a += ${name}b" " = 3" | |
732 | gdb_test "print/d ${name}a -= ${name}b" " = 2" | |
733 | gdb_test "print/d ${name}b *= ${name}a" " = 2" | |
734 | gdb_test "print/d ${name}b /= ${name}a" " = 1" | |
735 | # scalar with vector | |
736 | gdb_test "print/d ${name}4a = ${name}b" " = \\{1, 1, 1, 1\\}" | |
737 | gdb_test "print/d ${name}4a = \{2, 4, 8, 16\}" " = \\{2, 4, 8, 16\\}" | |
738 | gdb_test "print/d ${name}4a += ${name}b" " = \\{3, 5, 9, 17\\}" | |
739 | gdb_test "print/d ${name}4a -= ${name}b" " = \\{2, 4, 8, 16\\}" | |
740 | gdb_test "print/d ${name}4b *= ${name}a" " = \\{2, 4, 16, 8\\}" | |
741 | gdb_test "print/d ${name}4b /= ${name}a" " = \\{1, 2, 8, 4\\}" | |
742 | # vector with vector | |
743 | gdb_test "print/d ${name}4a = ${name}4b" " = \\{1, 2, 8, 4\\}" | |
744 | gdb_test "print/d ${name}4a = \{2, 4, 8, 16\}" " = \\{2, 4, 8, 16\\}" | |
745 | gdb_test "print/d ${name}4a += ${name}4b" " = \\{3, 6, 16, 20\\}" | |
746 | gdb_test "print/d ${name}4a -= ${name}4b" " = \\{2, 4, 8, 16\\}" | |
747 | gdb_test "print/d ${name}4b *= ${name}4a" " = \\{2, 8, 64, 64\\}" | |
748 | gdb_test "print/d ${name}4b /= ${name}4a" " = \\{1, 2, 8, 4\\}" | |
749 | ||
750 | # scalar with scalar | |
751 | gdb_test "ptype ${name}a = ${name}b" "type = ${type}" | |
752 | gdb_test "ptype ${name}a += ${name}b" "type = ${type}" | |
753 | gdb_test "ptype ${name}a -= ${name}b" "type = ${type}" | |
754 | gdb_test "ptype ${name}a *= ${name}b" "type = ${type}" | |
755 | gdb_test "ptype ${name}a /= ${name}b" "type = ${type}" | |
756 | # scalar with vector | |
757 | gdb_test "ptype ${name}4a = ${name}b" "type = ${type} \\\[4\\\]" | |
758 | gdb_test "ptype ${name}4a += ${name}b" "type = ${type} \\\[4\\\]" | |
759 | gdb_test "ptype ${name}4a -= ${name}b" "type = ${type} \\\[4\\\]" | |
760 | gdb_test "ptype ${name}4b *= ${name}a" "type = ${type} \\\[4\\\]" | |
761 | gdb_test "ptype ${name}4b /= ${name}a" "type = ${type} \\\[4\\\]" | |
762 | # vector with vector | |
763 | gdb_test "ptype ${name}4a = ${name}4b" "type = ${type} \\\[4\\\]" | |
764 | gdb_test "ptype ${name}4a += ${name}4b" "type = ${type} \\\[4\\\]" | |
765 | gdb_test "ptype ${name}4a -= ${name}4b" "type = ${type} \\\[4\\\]" | |
766 | gdb_test "ptype ${name}4b *= ${name}4a" "type = ${type} \\\[4\\\]" | |
767 | gdb_test "ptype ${name}4b /= ${name}4a" "type = ${type} \\\[4\\\]" | |
768 | ||
769 | if { !${isfloat} } { | |
770 | # scalar with scalar | |
771 | gdb_test "print/d ${name}a %= ${name}b" " = 0" | |
772 | gdb_test "print/d ${name}a = 2" " = 2" | |
773 | gdb_test "print/d ${name}a <<= ${name}b" " = 4" | |
774 | gdb_test "print/d ${name}a = 2" " = 2" | |
775 | gdb_test "print/d ${name}a >>= ${name}b" " = 1" | |
776 | gdb_test "print/d ${name}a = 2" " = 2" | |
777 | gdb_test "print/d ${name}a &= ${name}b" " = 0" | |
778 | gdb_test "print/d ${name}a = 2" " = 2" | |
779 | gdb_test "print/d ${name}a |= ${name}b" " = 3" | |
780 | gdb_test "print/d ${name}a = 2" " = 2" | |
781 | gdb_test "print/d ${name}a ^= ${name}b" " = 3" | |
782 | gdb_test "print/d ${name}a = 2" " = 2" | |
783 | # scalar with vector | |
784 | gdb_test "print/d ${name}4b %= ${name}a" " = \\{1, 0, 0, 0\\}" | |
785 | gdb_test "print/d ${name}4b = \{1, 2, 8, 4\}" " = \\{1, 2, 8, 4\\}" | |
786 | gdb_test "print/d ${name}4a <<= ${name}b" " = \\{4, 8, 16, 32\\}" | |
787 | gdb_test "print/d ${name}4a >>= ${name}b" " = \\{2, 4, 8, 16\\}" | |
788 | gdb_test "print/d ${name}4a &= ${name}b" " = \\{0, 0, 0, 0\\}" | |
789 | gdb_test "print/d ${name}4a = \{2, 4, 8, 16\}" " = \\{2, 4, 8, 16\\}" | |
790 | gdb_test "print/d ${name}4a |= ${name}b" " = \\{3, 5, 9, 17\\}" | |
791 | gdb_test "print/d ${name}4a = \{2, 4, 8, 16\}" " = \\{2, 4, 8, 16\\}" | |
792 | gdb_test "print/d ${name}4a ^= ${name}b" " = \\{3, 5, 9, 17\\}" | |
793 | gdb_test "print/d ${name}4a = \{2, 4, 8, 16\}" " = \\{2, 4, 8, 16\\}" | |
794 | # vector with vector | |
795 | gdb_test "print/d ${name}4b %= ${name}4a" " = \\{1, 2, 0, 4\\}" | |
796 | gdb_test "print/d ${name}4b = \{1, 2, 8, 4\}" " = \\{1, 2, 8, 4\\}" | |
797 | if { ${size} == 1 } { | |
798 | gdb_test "print/d ${name}4a <<= ${name}4b" " = \\{4, 16, 0, 0\\}" | |
799 | gdb_test "print/d ${name}4a >>= ${name}4b" " = \\{2, 4, 0, 0\\}" | |
800 | gdb_test "print/d ${name}4a = \{2, 4, 8, 16\}" " = \\{2, 4, 8, 16\\}" | |
801 | } else { | |
802 | gdb_test "print/d ${name}4a <<= ${name}4b" " = \\{4, 16, 2048, 256\\}" | |
803 | gdb_test "print/d ${name}4a >>= ${name}4b" " = \\{2, 4, 8, 16\\}" | |
804 | } | |
805 | gdb_test "print/d ${name}4a &= ${name}4b" " = \\{0, 0, 8, 0\\}" | |
806 | gdb_test "print/d ${name}4a = \{2, 4, 8, 16\}" " = \\{2, 4, 8, 16\\}" | |
807 | gdb_test "print/d ${name}4a |= ${name}4b" " = \\{3, 6, 8, 20\\}" | |
808 | gdb_test "print/d ${name}4a = \{2, 4, 8, 16\}" " = \\{2, 4, 8, 16\\}" | |
809 | gdb_test "print/d ${name}4a ^= ${name}4b" " = \\{3, 6, 0, 20\\}" | |
810 | gdb_test "print/d ${name}4a = \{2, 4, 8, 16\}" " = \\{2, 4, 8, 16\\}" | |
811 | ||
812 | # scalar with scalar | |
813 | gdb_test "ptype ${name}a %= ${name}b" "type = ${type}" | |
814 | gdb_test "ptype ${name}a <<= ${name}b" "type = ${type}" | |
815 | gdb_test "ptype ${name}a >>= ${name}b" "type = ${type}" | |
816 | gdb_test "ptype ${name}a &= ${name}b" "type = ${type}" | |
817 | gdb_test "ptype ${name}a |= ${name}b" "type = ${type}" | |
818 | gdb_test "ptype ${name}a ^= ${name}b" "type = ${type}" | |
819 | # scalar with vector | |
820 | gdb_test "ptype ${name}4a %= ${name}b" "type = ${type} \\\[4\\\]" | |
821 | gdb_test "ptype ${name}4a <<= ${name}b" "type = ${type} \\\[4\\\]" | |
822 | gdb_test "ptype ${name}4a >>= ${name}b" "type = ${type} \\\[4\\\]" | |
823 | gdb_test "ptype ${name}4a &= ${name}b" "type = ${type} \\\[4\\\]" | |
824 | gdb_test "ptype ${name}4a |= ${name}b" "type = ${type} \\\[4\\\]" | |
825 | gdb_test "ptype ${name}4a ^= ${name}b" "type = ${type} \\\[4\\\]" | |
826 | # vector with vector | |
827 | gdb_test "ptype ${name}4a %= ${name}4b" "type = ${type} \\\[4\\\]" | |
828 | gdb_test "ptype ${name}4a <<= ${name}4b" "type = ${type} \\\[4\\\]" | |
829 | gdb_test "ptype ${name}4a >>= ${name}4b" "type = ${type} \\\[4\\\]" | |
830 | gdb_test "ptype ${name}4a &= ${name}4b" "type = ${type} \\\[4\\\]" | |
831 | gdb_test "ptype ${name}4a |= ${name}4b" "type = ${type} \\\[4\\\]" | |
832 | gdb_test "ptype ${name}4a ^= ${name}4b" "type = ${type} \\\[4\\\]" | |
833 | ||
834 | # scalar with scalar | |
835 | gdb_test "print/d u${name}a = u${name}b" " = 1" | |
836 | gdb_test "print/d u${name}a = 2" " = 2" | |
837 | gdb_test "print/d u${name}a += u${name}b" " = 3" | |
838 | gdb_test "print/d u${name}a -= u${name}b" " = 2" | |
839 | gdb_test "print/d u${name}b *= u${name}a" " = 2" | |
840 | gdb_test "print/d u${name}b /= u${name}a" " = 1" | |
841 | gdb_test "print/d u${name}a %= u${name}b" " = 0" | |
842 | gdb_test "print/d u${name}a = 2" " = 2" | |
843 | gdb_test "print/d u${name}a <<= u${name}b" " = 4" | |
844 | gdb_test "print/d u${name}a = 2" " = 2" | |
845 | gdb_test "print/d u${name}a >>= u${name}b" " = 1" | |
846 | gdb_test "print/d u${name}a = 2" " = 2" | |
847 | gdb_test "print/d u${name}a &= u${name}b" " = 0" | |
848 | gdb_test "print/d u${name}a = 2" " = 2" | |
849 | gdb_test "print/d u${name}a |= u${name}b" " = 3" | |
850 | gdb_test "print/d u${name}a = 2" " = 2" | |
851 | gdb_test "print/d u${name}a ^= u${name}b" " = 3" | |
852 | gdb_test "print/d u${name}a = 2" " = 2" | |
853 | # scalar with vector | |
854 | gdb_test "print/d u${name}4a = u${name}b" " = \\{1, 1, 1, 1\\}" | |
855 | gdb_test "print/d u${name}4a = \{2, 4, 8, 16\}" " = \\{2, 4, 8, 16\\}" | |
856 | gdb_test "print/d u${name}4a += u${name}b" " = \\{3, 5, 9, 17\\}" | |
857 | gdb_test "print/d u${name}4a -= u${name}b" " = \\{2, 4, 8, 16\\}" | |
858 | gdb_test "print/d u${name}4b *= u${name}a" " = \\{2, 4, 16, 8\\}" | |
859 | gdb_test "print/d u${name}4b /= u${name}a" " = \\{1, 2, 8, 4\\}" | |
860 | gdb_test "print/d u${name}4b %= u${name}a" " = \\{1, 0, 0, 0\\}" | |
861 | gdb_test "print/d u${name}4b = \{1, 2, 8, 4\}" " = \\{1, 2, 8, 4\\}" | |
862 | gdb_test "print/d u${name}4a <<= u${name}b" " = \\{4, 8, 16, 32\\}" | |
863 | gdb_test "print/d u${name}4a >>= u${name}b" " = \\{2, 4, 8, 16\\}" | |
864 | gdb_test "print/d u${name}4a &= u${name}b" " = \\{0, 0, 0, 0\\}" | |
865 | gdb_test "print/d u${name}4a = \{2, 4, 8, 16\}" " = \\{2, 4, 8, 16\\}" | |
866 | gdb_test "print/d u${name}4a |= u${name}b" " = \\{3, 5, 9, 17\\}" | |
867 | gdb_test "print/d u${name}4a = \{2, 4, 8, 16\}" " = \\{2, 4, 8, 16\\}" | |
868 | gdb_test "print/d u${name}4a ^= u${name}b" " = \\{3, 5, 9, 17\\}" | |
869 | gdb_test "print/d u${name}4a = \{2, 4, 8, 16\}" " = \\{2, 4, 8, 16\\}" | |
870 | # vector with vector | |
871 | gdb_test "print/d u${name}4a = u${name}4b" " = \\{1, 2, 8, 4\\}" | |
872 | gdb_test "print/d u${name}4a = \{2, 4, 8, 16\}" " = \\{2, 4, 8, 16\\}" | |
873 | gdb_test "print/d u${name}4a += u${name}4b" " = \\{3, 6, 16, 20\\}" | |
874 | gdb_test "print/d u${name}4a -= u${name}4b" " = \\{2, 4, 8, 16\\}" | |
875 | gdb_test "print/d u${name}4b *= u${name}4a" " = \\{2, 8, 64, 64\\}" | |
876 | gdb_test "print/d u${name}4b /= u${name}4a" " = \\{1, 2, 8, 4\\}" | |
877 | gdb_test "print/d u${name}4b %= u${name}4a" " = \\{1, 2, 0, 4\\}" | |
878 | gdb_test "print/d u${name}4b = \{1, 2, 8, 4\}" " = \\{1, 2, 8, 4\\}" | |
879 | if { ${size} == 1 } { | |
880 | gdb_test "print/d u${name}4a <<= u${name}4b" " = \\{4, 16, 0, 0\\}" | |
881 | gdb_test "print/d u${name}4a >>= u${name}4b" " = \\{2, 4, 0, 0\\}" | |
882 | gdb_test "print/d u${name}4a = \{2, 4, 8, 16\}" " = \\{2, 4, 8, 16\\}" | |
883 | } else { | |
884 | gdb_test "print/d u${name}4a <<= u${name}4b" " = \\{4, 16, 2048, 256\\}" | |
885 | gdb_test "print/d u${name}4a >>= u${name}4b" " = \\{2, 4, 8, 16\\}" | |
886 | } | |
887 | gdb_test "print/d u${name}4a &= u${name}4b" " = \\{0, 0, 8, 0\\}" | |
888 | gdb_test "print/d u${name}4a = \{2, 4, 8, 16\}" " = \\{2, 4, 8, 16\\}" | |
889 | gdb_test "print/d u${name}4a |= u${name}4b" " = \\{3, 6, 8, 20\\}" | |
890 | gdb_test "print/d u${name}4a = \{2, 4, 8, 16\}" " = \\{2, 4, 8, 16\\}" | |
891 | gdb_test "print/d u${name}4a ^= u${name}4b" " = \\{3, 6, 0, 20\\}" | |
892 | gdb_test "print/d u${name}4a = \{2, 4, 8, 16\}" " = \\{2, 4, 8, 16\\}" | |
893 | ||
894 | # scalar with scalar | |
895 | gdb_test "ptype u${name}a = u${name}b" "type = (unsigned ${type}|u${type})" | |
896 | gdb_test "ptype u${name}a += u${name}b" "type = (unsigned ${type}|u${type})" | |
897 | gdb_test "ptype u${name}a -= u${name}b" "type = (unsigned ${type}|u${type})" | |
898 | gdb_test "ptype u${name}a *= u${name}b" "type = (unsigned ${type}|u${type})" | |
899 | gdb_test "ptype u${name}a /= u${name}b" "type = (unsigned ${type}|u${type})" | |
900 | gdb_test "ptype u${name}a %= u${name}b" "type = (unsigned ${type}|u${type})" | |
901 | gdb_test "ptype u${name}a <<= u${name}b" "type = (unsigned ${type}|u${type})" | |
902 | gdb_test "ptype u${name}a >>= u${name}b" "type = (unsigned ${type}|u${type})" | |
903 | gdb_test "ptype u${name}a &= u${name}b" "type = (unsigned ${type}|u${type})" | |
904 | gdb_test "ptype u${name}a |= u${name}b" "type = (unsigned ${type}|u${type})" | |
905 | gdb_test "ptype u${name}a ^= u${name}b" "type = (unsigned ${type}|u${type})" | |
906 | # scalar with vector | |
907 | gdb_test "ptype u${name}4a = u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
908 | gdb_test "ptype u${name}4a += u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
909 | gdb_test "ptype u${name}4a -= u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
910 | gdb_test "ptype u${name}4b *= u${name}a" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
911 | gdb_test "ptype u${name}4b /= u${name}a" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
912 | gdb_test "ptype u${name}4a %= u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
913 | gdb_test "ptype u${name}4a <<= u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
914 | gdb_test "ptype u${name}4a >>= u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
915 | gdb_test "ptype u${name}4a &= u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
916 | gdb_test "ptype u${name}4a |= u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
917 | gdb_test "ptype u${name}4a ^= u${name}b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
918 | # vector with vector | |
919 | gdb_test "ptype u${name}4a = u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
920 | gdb_test "ptype u${name}4a += u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
921 | gdb_test "ptype u${name}4a -= u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
922 | gdb_test "ptype u${name}4b *= u${name}4a" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
923 | gdb_test "ptype u${name}4b /= u${name}4a" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
924 | gdb_test "ptype u${name}4a %= u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
925 | gdb_test "ptype u${name}4a <<= u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
926 | gdb_test "ptype u${name}4a >>= u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
927 | gdb_test "ptype u${name}4a &= u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
928 | gdb_test "ptype u${name}4a |= u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
929 | gdb_test "ptype u${name}4a ^= u${name}4b" "type = (unsigned ${type}|u${type}) \\\[4\\\]" | |
930 | } | |
931 | } | |
932 | ||
933 | proc do_check { name type isfloat size } { | |
934 | check_basic ${name} ${type} ${isfloat} | |
935 | check_arithmetic_ops ${name} ${type} ${isfloat} ${size} | |
936 | check_relational_ops ${name} ${type} ${isfloat} ${size} | |
937 | check_equality_ops ${name} ${type} ${isfloat} ${size} | |
938 | if { !${isfloat} } { | |
939 | check_shift_ops ${name} ${type} ${size} | |
940 | check_bitwise_ops ${name} ${type} ${size} | |
941 | } | |
942 | check_logical_ops ${name} ${type} ${isfloat} ${size} | |
943 | check_conditional_op ${name} ${type} ${isfloat} | |
944 | check_assignment_ops ${name} ${type} ${isfloat} ${size} | |
945 | } | |
946 | ||
947 | do_check "c" "char" 0 1 | |
948 | do_check "s" "short" 0 2 | |
949 | do_check "i" "int" 0 4 | |
950 | do_check "l" "long" 0 8 | |
951 | if { ${have_cl_khr_fp16} } { | |
952 | do_check "h" "half" 1 2 | |
953 | } | |
954 | do_check "f" "float" 1 4 | |
955 | if { ${have_cl_khr_fp64} } { | |
956 | do_check "d" "double" 1 8 | |
957 | } | |
958 | # Delete the OpenCL program source | |
959 | remote_file target delete ${clprogram} |