|
150
|
1 ; RUN: opt -O3 -S < %s | FileCheck %s
|
|
|
2
|
|
|
3 ; Test to verify that constants aren't folded when the rounding mode is unknown.
|
|
|
4 ; CHECK-LABEL: @f1
|
|
|
5 ; CHECK: call double @llvm.experimental.constrained.fdiv.f64
|
|
|
6 define double @f1() #0 {
|
|
|
7 entry:
|
|
|
8 %div = call double @llvm.experimental.constrained.fdiv.f64(
|
|
|
9 double 1.000000e+00,
|
|
|
10 double 1.000000e+01,
|
|
|
11 metadata !"round.dynamic",
|
|
|
12 metadata !"fpexcept.strict") #0
|
|
|
13 ret double %div
|
|
|
14 }
|
|
|
15
|
|
|
16 ; Verify that 'a - 0' isn't simplified to 'a' when the rounding mode is unknown.
|
|
|
17 ;
|
|
|
18 ; double f2(double a) {
|
|
|
19 ; // Because the result of '0 - 0' is negative zero if rounding mode is
|
|
|
20 ; // downward, this shouldn't be simplified.
|
|
|
21 ; return a - 0.0;
|
|
|
22 ; }
|
|
|
23 ;
|
|
|
24 ; CHECK-LABEL: @f2
|
|
|
25 ; CHECK: call double @llvm.experimental.constrained.fsub.f64
|
|
|
26 define double @f2(double %a) #0 {
|
|
|
27 entry:
|
|
|
28 %div = call double @llvm.experimental.constrained.fsub.f64(
|
|
|
29 double %a, double 0.000000e+00,
|
|
|
30 metadata !"round.dynamic",
|
|
|
31 metadata !"fpexcept.strict") #0
|
|
|
32 ret double %div
|
|
|
33 }
|
|
|
34
|
|
|
35 ; Verify that '-((-a)*b)' isn't simplified to 'a*b' when the rounding mode is
|
|
|
36 ; unknown.
|
|
|
37 ;
|
|
|
38 ; double f3(double a, double b) {
|
|
|
39 ; // Because the intermediate value involved in this calculation may require
|
|
|
40 ; // rounding, this shouldn't be simplified.
|
|
|
41 ; return -((-a)*b);
|
|
|
42 ; }
|
|
|
43 ;
|
|
|
44 ; CHECK-LABEL: @f3
|
|
|
45 ; CHECK: call double @llvm.experimental.constrained.fsub.f64
|
|
|
46 ; CHECK: call double @llvm.experimental.constrained.fmul.f64
|
|
|
47 ; CHECK: call double @llvm.experimental.constrained.fsub.f64
|
|
|
48 define double @f3(double %a, double %b) #0 {
|
|
|
49 entry:
|
|
|
50 %sub = call double @llvm.experimental.constrained.fsub.f64(
|
|
|
51 double -0.000000e+00, double %a,
|
|
|
52 metadata !"round.dynamic",
|
|
|
53 metadata !"fpexcept.strict") #0
|
|
|
54 %mul = call double @llvm.experimental.constrained.fmul.f64(
|
|
|
55 double %sub, double %b,
|
|
|
56 metadata !"round.dynamic",
|
|
|
57 metadata !"fpexcept.strict") #0
|
|
|
58 %ret = call double @llvm.experimental.constrained.fsub.f64(
|
|
|
59 double -0.000000e+00,
|
|
|
60 double %mul,
|
|
|
61 metadata !"round.dynamic",
|
|
|
62 metadata !"fpexcept.strict") #0
|
|
|
63 ret double %ret
|
|
|
64 }
|
|
|
65
|
|
|
66 ; Verify that FP operations are not performed speculatively when FP exceptions
|
|
|
67 ; are not being ignored.
|
|
|
68 ;
|
|
|
69 ; double f4(int n, double a) {
|
|
|
70 ; // Because a + 1 may overflow, this should not be simplified.
|
|
|
71 ; if (n > 0)
|
|
|
72 ; return a + 1.0;
|
|
|
73 ; return a;
|
|
|
74 ; }
|
|
|
75 ;
|
|
|
76 ;
|
|
|
77 ; CHECK-LABEL: @f4
|
|
|
78 ; CHECK-NOT: select
|
|
|
79 ; CHECK: br i1 %cmp
|
|
|
80 define double @f4(i32 %n, double %a) #0 {
|
|
|
81 entry:
|
|
|
82 %cmp = icmp sgt i32 %n, 0
|
|
|
83 br i1 %cmp, label %if.then, label %if.end
|
|
|
84
|
|
|
85 if.then:
|
|
|
86 %add = call double @llvm.experimental.constrained.fadd.f64(
|
|
|
87 double 1.000000e+00, double %a,
|
|
|
88 metadata !"round.dynamic",
|
|
|
89 metadata !"fpexcept.strict") #0
|
|
|
90 br label %if.end
|
|
|
91
|
|
|
92 if.end:
|
|
|
93 %a.0 = phi double [%add, %if.then], [ %a, %entry ]
|
|
|
94 ret double %a.0
|
|
|
95 }
|
|
|
96
|
|
|
97 ; Verify that sqrt(42.0) isn't simplified when the rounding mode is unknown.
|
|
|
98 ; CHECK-LABEL: f5
|
|
|
99 ; CHECK: call double @llvm.experimental.constrained.sqrt
|
|
|
100 define double @f5() #0 {
|
|
|
101 entry:
|
|
|
102 %result = call double @llvm.experimental.constrained.sqrt.f64(double 42.0,
|
|
|
103 metadata !"round.dynamic",
|
|
|
104 metadata !"fpexcept.strict") #0
|
|
|
105 ret double %result
|
|
|
106 }
|
|
|
107
|
|
|
108 ; Verify that pow(42.1, 3.0) isn't simplified when the rounding mode is unknown.
|
|
|
109 ; CHECK-LABEL: f6
|
|
|
110 ; CHECK: call double @llvm.experimental.constrained.pow
|
|
|
111 define double @f6() #0 {
|
|
|
112 entry:
|
|
|
113 %result = call double @llvm.experimental.constrained.pow.f64(double 42.1,
|
|
|
114 double 3.0,
|
|
|
115 metadata !"round.dynamic",
|
|
|
116 metadata !"fpexcept.strict") #0
|
|
|
117 ret double %result
|
|
|
118 }
|
|
|
119
|
|
|
120 ; Verify that powi(42.1, 3) isn't simplified when the rounding mode is unknown.
|
|
|
121 ; CHECK-LABEL: f7
|
|
|
122 ; CHECK: call double @llvm.experimental.constrained.powi
|
|
|
123 define double @f7() #0 {
|
|
|
124 entry:
|
|
|
125 %result = call double @llvm.experimental.constrained.powi.f64(double 42.1,
|
|
|
126 i32 3,
|
|
|
127 metadata !"round.dynamic",
|
|
|
128 metadata !"fpexcept.strict") #0
|
|
|
129 ret double %result
|
|
|
130 }
|
|
|
131
|
|
|
132 ; Verify that sin(42.0) isn't simplified when the rounding mode is unknown.
|
|
|
133 ; CHECK-LABEL: f8
|
|
|
134 ; CHECK: call double @llvm.experimental.constrained.sin
|
|
|
135 define double @f8() #0 {
|
|
|
136 entry:
|
|
|
137 %result = call double @llvm.experimental.constrained.sin.f64(double 42.0,
|
|
|
138 metadata !"round.dynamic",
|
|
|
139 metadata !"fpexcept.strict") #0
|
|
|
140 ret double %result
|
|
|
141 }
|
|
|
142
|
|
|
143 ; Verify that cos(42.0) isn't simplified when the rounding mode is unknown.
|
|
|
144 ; CHECK-LABEL: f9
|
|
|
145 ; CHECK: call double @llvm.experimental.constrained.cos
|
|
|
146 define double @f9() #0 {
|
|
|
147 entry:
|
|
|
148 %result = call double @llvm.experimental.constrained.cos.f64(double 42.0,
|
|
|
149 metadata !"round.dynamic",
|
|
|
150 metadata !"fpexcept.strict") #0
|
|
|
151 ret double %result
|
|
|
152 }
|
|
|
153
|
|
|
154 ; Verify that exp(42.0) isn't simplified when the rounding mode is unknown.
|
|
|
155 ; CHECK-LABEL: f10
|
|
|
156 ; CHECK: call double @llvm.experimental.constrained.exp
|
|
|
157 define double @f10() #0 {
|
|
|
158 entry:
|
|
|
159 %result = call double @llvm.experimental.constrained.exp.f64(double 42.0,
|
|
|
160 metadata !"round.dynamic",
|
|
|
161 metadata !"fpexcept.strict") #0
|
|
|
162 ret double %result
|
|
|
163 }
|
|
|
164
|
|
|
165 ; Verify that exp2(42.1) isn't simplified when the rounding mode is unknown.
|
|
|
166 ; CHECK-LABEL: f11
|
|
|
167 ; CHECK: call double @llvm.experimental.constrained.exp2
|
|
|
168 define double @f11() #0 {
|
|
|
169 entry:
|
|
|
170 %result = call double @llvm.experimental.constrained.exp2.f64(double 42.1,
|
|
|
171 metadata !"round.dynamic",
|
|
|
172 metadata !"fpexcept.strict") #0
|
|
|
173 ret double %result
|
|
|
174 }
|
|
|
175
|
|
|
176 ; Verify that log(42.0) isn't simplified when the rounding mode is unknown.
|
|
|
177 ; CHECK-LABEL: f12
|
|
|
178 ; CHECK: call double @llvm.experimental.constrained.log
|
|
|
179 define double @f12() #0 {
|
|
|
180 entry:
|
|
|
181 %result = call double @llvm.experimental.constrained.log.f64(double 42.0,
|
|
|
182 metadata !"round.dynamic",
|
|
|
183 metadata !"fpexcept.strict") #0
|
|
|
184 ret double %result
|
|
|
185 }
|
|
|
186
|
|
|
187 ; Verify that log10(42.0) isn't simplified when the rounding mode is unknown.
|
|
|
188 ; CHECK-LABEL: f13
|
|
|
189 ; CHECK: call double @llvm.experimental.constrained.log10
|
|
|
190 define double @f13() #0 {
|
|
|
191 entry:
|
|
|
192 %result = call double @llvm.experimental.constrained.log10.f64(double 42.0,
|
|
|
193 metadata !"round.dynamic",
|
|
|
194 metadata !"fpexcept.strict") #0
|
|
|
195 ret double %result
|
|
|
196 }
|
|
|
197
|
|
|
198 ; Verify that log2(42.0) isn't simplified when the rounding mode is unknown.
|
|
|
199 ; CHECK-LABEL: f14
|
|
|
200 ; CHECK: call double @llvm.experimental.constrained.log2
|
|
|
201 define double @f14() #0 {
|
|
|
202 entry:
|
|
|
203 %result = call double @llvm.experimental.constrained.log2.f64(double 42.0,
|
|
|
204 metadata !"round.dynamic",
|
|
|
205 metadata !"fpexcept.strict") #0
|
|
|
206 ret double %result
|
|
|
207 }
|
|
|
208
|
|
|
209 ; Verify that rint(42.1) isn't simplified when the rounding mode is unknown.
|
|
|
210 ; CHECK-LABEL: f15
|
|
|
211 ; CHECK: call double @llvm.experimental.constrained.rint
|
|
|
212 define double @f15() #0 {
|
|
|
213 entry:
|
|
|
214 %result = call double @llvm.experimental.constrained.rint.f64(double 42.1,
|
|
|
215 metadata !"round.dynamic",
|
|
|
216 metadata !"fpexcept.strict") #0
|
|
|
217 ret double %result
|
|
|
218 }
|
|
|
219
|
|
|
220 ; Verify that nearbyint(42.1) isn't simplified when the rounding mode is
|
|
|
221 ; unknown.
|
|
|
222 ; CHECK-LABEL: f16
|
|
|
223 ; CHECK: call double @llvm.experimental.constrained.nearbyint
|
|
|
224 define double @f16() #0 {
|
|
|
225 entry:
|
|
|
226 %result = call double @llvm.experimental.constrained.nearbyint.f64(
|
|
|
227 double 42.1,
|
|
|
228 metadata !"round.dynamic",
|
|
|
229 metadata !"fpexcept.strict") #0
|
|
|
230 ret double %result
|
|
|
231 }
|
|
|
232
|
|
|
233 ; Verify that fma(42.1) isn't simplified when the rounding mode is
|
|
|
234 ; unknown.
|
|
|
235 ; CHECK-LABEL: f17
|
|
|
236 ; CHECK: call double @llvm.experimental.constrained.fma
|
|
|
237 define double @f17() #0 {
|
|
|
238 entry:
|
|
|
239 %result = call double @llvm.experimental.constrained.fma.f64(double 42.1, double 42.1, double 42.1,
|
|
|
240 metadata !"round.dynamic",
|
|
|
241 metadata !"fpexcept.strict") #0
|
|
|
242 ret double %result
|
|
|
243 }
|
|
|
244
|
|
|
245 ; Verify that fptoui(42.1) isn't simplified when the rounding mode is
|
|
|
246 ; unknown.
|
|
|
247 ; CHECK-LABEL: f18
|
|
|
248 ; CHECK: call zeroext i32 @llvm.experimental.constrained.fptoui
|
|
|
249 define zeroext i32 @f18() #0 {
|
|
|
250 entry:
|
|
|
251 %result = call zeroext i32 @llvm.experimental.constrained.fptoui.i32.f64(
|
|
|
252 double 42.1,
|
|
|
253 metadata !"fpexcept.strict") #0
|
|
|
254 ret i32 %result
|
|
|
255 }
|
|
|
256
|
|
|
257 ; Verify that fptosi(42.1) isn't simplified when the rounding mode is
|
|
|
258 ; unknown.
|
|
|
259 ; CHECK-LABEL: f19
|
|
|
260 ; CHECK: call i32 @llvm.experimental.constrained.fptosi
|
|
|
261 define i32 @f19() #0 {
|
|
|
262 entry:
|
|
|
263 %result = call i32 @llvm.experimental.constrained.fptosi.i32.f64(double 42.1,
|
|
|
264 metadata !"fpexcept.strict") #0
|
|
|
265 ret i32 %result
|
|
|
266 }
|
|
|
267
|
|
|
268 ; Verify that fptrunc(42.1) isn't simplified when the rounding mode is
|
|
|
269 ; unknown.
|
|
|
270 ; CHECK-LABEL: f20
|
|
|
271 ; CHECK: call float @llvm.experimental.constrained.fptrunc
|
|
|
272 define float @f20() #0 {
|
|
|
273 entry:
|
|
|
274 %result = call float @llvm.experimental.constrained.fptrunc.f32.f64(
|
|
|
275 double 42.1,
|
|
|
276 metadata !"round.dynamic",
|
|
|
277 metadata !"fpexcept.strict") #0
|
|
|
278 ret float %result
|
|
|
279 }
|
|
|
280
|
|
|
281 ; Verify that fpext(42.1) isn't simplified when the rounding mode is
|
|
|
282 ; unknown.
|
|
|
283 ; CHECK-LABEL: f21
|
|
|
284 ; CHECK: call double @llvm.experimental.constrained.fpext
|
|
|
285 define double @f21() #0 {
|
|
|
286 entry:
|
|
|
287 %result = call double @llvm.experimental.constrained.fpext.f64.f32(float 42.0,
|
|
|
288 metadata !"fpexcept.strict") #0
|
|
|
289 ret double %result
|
|
|
290 }
|
|
|
291
|
|
|
292 ; Verify that lrint(42.1) isn't simplified when the rounding mode is unknown.
|
|
|
293 ; CHECK-LABEL: f22
|
|
|
294 ; CHECK: call i32 @llvm.experimental.constrained.lrint
|
|
|
295 define i32 @f22() #0 {
|
|
|
296 entry:
|
|
|
297 %result = call i32 @llvm.experimental.constrained.lrint.i32.f64(double 42.1,
|
|
|
298 metadata !"round.dynamic",
|
|
|
299 metadata !"fpexcept.strict") #0
|
|
|
300 ret i32 %result
|
|
|
301 }
|
|
|
302
|
|
|
303 ; Verify that lrintf(42.0) isn't simplified when the rounding mode is unknown.
|
|
|
304 ; CHECK-LABEL: f23
|
|
|
305 ; CHECK: call i32 @llvm.experimental.constrained.lrint
|
|
|
306 define i32 @f23() #0 {
|
|
|
307 entry:
|
|
|
308 %result = call i32 @llvm.experimental.constrained.lrint.i32.f32(float 42.0,
|
|
|
309 metadata !"round.dynamic",
|
|
|
310 metadata !"fpexcept.strict") #0
|
|
|
311 ret i32 %result
|
|
|
312 }
|
|
|
313
|
|
|
314 ; Verify that llrint(42.1) isn't simplified when the rounding mode is unknown.
|
|
|
315 ; CHECK-LABEL: f24
|
|
|
316 ; CHECK: call i64 @llvm.experimental.constrained.llrint
|
|
|
317 define i64 @f24() #0 {
|
|
|
318 entry:
|
|
|
319 %result = call i64 @llvm.experimental.constrained.llrint.i64.f64(double 42.1,
|
|
|
320 metadata !"round.dynamic",
|
|
|
321 metadata !"fpexcept.strict") #0
|
|
|
322 ret i64 %result
|
|
|
323 }
|
|
|
324
|
|
|
325 ; Verify that llrint(42.0) isn't simplified when the rounding mode is unknown.
|
|
|
326 ; CHECK-LABEL: f25
|
|
|
327 ; CHECK: call i64 @llvm.experimental.constrained.llrint
|
|
|
328 define i64 @f25() #0 {
|
|
|
329 entry:
|
|
|
330 %result = call i64 @llvm.experimental.constrained.llrint.i64.f32(float 42.0,
|
|
|
331 metadata !"round.dynamic",
|
|
|
332 metadata !"fpexcept.strict") #0
|
|
|
333 ret i64 %result
|
|
|
334 }
|
|
|
335
|
|
|
336 ; Verify that lround(42.1) isn't simplified when the rounding mode is unknown.
|
|
|
337 ; CHECK-LABEL: f26
|
|
|
338 ; CHECK: call i32 @llvm.experimental.constrained.lround
|
|
|
339 define i32 @f26() #0 {
|
|
|
340 entry:
|
|
|
341 %result = call i32 @llvm.experimental.constrained.lround.i32.f64(double 42.1,
|
|
|
342 metadata !"fpexcept.strict") #0
|
|
|
343 ret i32 %result
|
|
|
344 }
|
|
|
345
|
|
|
346 ; Verify that lround(42.0) isn't simplified when the rounding mode is unknown.
|
|
|
347 ; CHECK-LABEL: f27
|
|
|
348 ; CHECK: call i32 @llvm.experimental.constrained.lround
|
|
|
349 define i32 @f27() #0 {
|
|
|
350 entry:
|
|
|
351 %result = call i32 @llvm.experimental.constrained.lround.i32.f32(float 42.0,
|
|
|
352 metadata !"fpexcept.strict") #0
|
|
|
353 ret i32 %result
|
|
|
354 }
|
|
|
355
|
|
|
356 ; Verify that llround(42.1) isn't simplified when the rounding mode is unknown.
|
|
|
357 ; CHECK-LABEL: f28
|
|
|
358 ; CHECK: call i64 @llvm.experimental.constrained.llround
|
|
|
359 define i64 @f28() #0 {
|
|
|
360 entry:
|
|
|
361 %result = call i64 @llvm.experimental.constrained.llround.i64.f64(double 42.1,
|
|
|
362 metadata !"fpexcept.strict") #0
|
|
|
363 ret i64 %result
|
|
|
364 }
|
|
|
365
|
|
|
366 ; Verify that llround(42.0) isn't simplified when the rounding mode is unknown.
|
|
|
367 ; CHECK-LABEL: f29
|
|
|
368 ; CHECK: call i64 @llvm.experimental.constrained.llround
|
|
|
369 define i64 @f29() #0 {
|
|
|
370 entry:
|
|
|
371 %result = call i64 @llvm.experimental.constrained.llround.i64.f32(float 42.0,
|
|
|
372 metadata !"fpexcept.strict") #0
|
|
|
373 ret i64 %result
|
|
|
374 }
|
|
|
375
|
|
|
376 ; Verify that sitofp(42) isn't simplified when the rounding mode is unknown.
|
|
|
377 ; CHECK-LABEL: @f30
|
|
|
378 ; CHECK: call double @llvm.experimental.constrained.sitofp
|
|
|
379 define double @f30() #0 {
|
|
|
380 entry:
|
|
|
381 %result = call double @llvm.experimental.constrained.sitofp.f64.i32(i32 42,
|
|
|
382 metadata !"round.dynamic",
|
|
|
383 metadata !"fpexcept.strict") #0
|
|
|
384 ret double %result
|
|
|
385 }
|
|
|
386
|
|
|
387 ; Verify that uitofp(42) isn't simplified when the rounding mode is unknown.
|
|
|
388 ; CHECK-LABEL: @f31
|
|
|
389 ; CHECK: call double @llvm.experimental.constrained.uitofp
|
|
|
390 define double @f31() #0 {
|
|
|
391 entry:
|
|
|
392 %result = call double @llvm.experimental.constrained.uitofp.f64.i32(i32 42,
|
|
|
393 metadata !"round.dynamic",
|
|
|
394 metadata !"fpexcept.strict") #0
|
|
|
395 ret double %result
|
|
|
396 }
|
|
|
397
|
|
|
398 attributes #0 = { strictfp }
|
|
|
399
|
|
|
400 @llvm.fp.env = thread_local global i8 zeroinitializer, section "llvm.metadata"
|
|
|
401 declare double @llvm.experimental.constrained.fdiv.f64(double, double, metadata, metadata)
|
|
|
402 declare double @llvm.experimental.constrained.fmul.f64(double, double, metadata, metadata)
|
|
|
403 declare double @llvm.experimental.constrained.fadd.f64(double, double, metadata, metadata)
|
|
|
404 declare double @llvm.experimental.constrained.fsub.f64(double, double, metadata, metadata)
|
|
|
405 declare double @llvm.experimental.constrained.sqrt.f64(double, metadata, metadata)
|
|
|
406 declare double @llvm.experimental.constrained.pow.f64(double, double, metadata, metadata)
|
|
|
407 declare double @llvm.experimental.constrained.powi.f64(double, i32, metadata, metadata)
|
|
|
408 declare double @llvm.experimental.constrained.sin.f64(double, metadata, metadata)
|
|
|
409 declare double @llvm.experimental.constrained.cos.f64(double, metadata, metadata)
|
|
|
410 declare double @llvm.experimental.constrained.exp.f64(double, metadata, metadata)
|
|
|
411 declare double @llvm.experimental.constrained.exp2.f64(double, metadata, metadata)
|
|
|
412 declare double @llvm.experimental.constrained.log.f64(double, metadata, metadata)
|
|
|
413 declare double @llvm.experimental.constrained.log10.f64(double, metadata, metadata)
|
|
|
414 declare double @llvm.experimental.constrained.log2.f64(double, metadata, metadata)
|
|
|
415 declare double @llvm.experimental.constrained.rint.f64(double, metadata, metadata)
|
|
|
416 declare double @llvm.experimental.constrained.nearbyint.f64(double, metadata, metadata)
|
|
|
417 declare double @llvm.experimental.constrained.fma.f64(double, double, double, metadata, metadata)
|
|
|
418 declare i32 @llvm.experimental.constrained.fptosi.i32.f64(double, metadata)
|
|
|
419 declare i32 @llvm.experimental.constrained.fptoui.i32.f64(double, metadata)
|
|
|
420 declare float @llvm.experimental.constrained.fptrunc.f32.f64(double, metadata, metadata)
|
|
|
421 declare double @llvm.experimental.constrained.fpext.f64.f32(float, metadata)
|
|
|
422 declare i32 @llvm.experimental.constrained.lrint.i32.f64(double, metadata, metadata)
|
|
|
423 declare i32 @llvm.experimental.constrained.lrint.i32.f32(float, metadata, metadata)
|
|
|
424 declare i64 @llvm.experimental.constrained.llrint.i64.f64(double, metadata, metadata)
|
|
|
425 declare i64 @llvm.experimental.constrained.llrint.i64.f32(float, metadata, metadata)
|
|
|
426 declare i32 @llvm.experimental.constrained.lround.i32.f64(double, metadata)
|
|
|
427 declare i32 @llvm.experimental.constrained.lround.i32.f32(float, metadata)
|
|
|
428 declare i64 @llvm.experimental.constrained.llround.i64.f64(double, metadata)
|
|
|
429 declare i64 @llvm.experimental.constrained.llround.i64.f32(float, metadata)
|
|
|
430 declare double @llvm.experimental.constrained.sitofp.f64.i32(i32, metadata, metadata)
|
|
|
431 declare double @llvm.experimental.constrained.uitofp.f64.i32(i32, metadata, metadata)
|
