Source file
test/codegen/comparisons.go
1
2
3
4
5
6
7 package codegen
8
9 import (
10 "cmp"
11 "unsafe"
12 )
13
14
15
16
17
18
19
20
21
22
23 func CompareString1(s string) bool {
24
25
26
27
28 return s == "xx"
29 }
30
31 func CompareString2(s string) bool {
32
33
34
35
36 return s == "xxxx"
37 }
38
39 func CompareString3(s string) bool {
40
41
42
43
44 return s == "xxxxxxxx"
45 }
46
47
48
49 func CompareArray1(a, b [2]byte) bool {
50
51
52
53
54 return a == b
55 }
56
57 func CompareArray2(a, b [3]uint16) bool {
58
59
60 return a == b
61 }
62
63 func CompareArray3(a, b [3]int16) bool {
64
65
66 return a == b
67 }
68
69 func CompareArray4(a, b [12]int8) bool {
70
71
72 return a == b
73 }
74
75 func CompareArray5(a, b [15]byte) bool {
76
77 return a == b
78 }
79
80
81 func CompareArray6(a, b unsafe.Pointer) bool {
82
83
84
85
86 return *((*[4]byte)(a)) != *((*[4]byte)(b))
87 }
88
89
90
91 type T1 struct {
92 a [8]byte
93 }
94
95 func CompareStruct1(s1, s2 T1) bool {
96
97
98 return s1 == s2
99 }
100
101 type T2 struct {
102 a [16]byte
103 }
104
105 func CompareStruct2(s1, s2 T2) bool {
106
107
108 return s1 == s2
109 }
110
111
112
113
114 type T3 struct {
115 a [24]byte
116 }
117
118 func CompareStruct3(s1, s2 T3) bool {
119
120
121 return s1 == s2
122 }
123
124 type T4 struct {
125 a [32]byte
126 }
127
128 func CompareStruct4(s1, s2 T4) bool {
129
130
131 return s1 == s2
132 }
133
134
135
136
137
138
139
140 var r bool
141
142 func CmpFold(x uint32) {
143
144 r = x > 4
145 }
146
147
148
149
150 func CmpMem1(p int, q *int) bool {
151
152 return p < *q
153 }
154
155 func CmpMem2(p *int, q int) bool {
156
157 return *p < q
158 }
159
160 func CmpMem3(p *int) bool {
161
162 return *p < 7
163 }
164
165 func CmpMem4(p *int) bool {
166
167 return 7 < *p
168 }
169
170 func CmpMem5(p **int) {
171
172 *p = nil
173 }
174
175 func CmpMem6(a []int) int {
176
177
178 if a[1] > a[2] {
179 return 1
180 } else {
181 return 2
182 }
183 }
184
185
186
187 func CmpZero1(a int32, ptr *int) {
188 if a < 0 {
189 *ptr = 0
190 }
191 }
192
193 func CmpZero2(a int64, ptr *int) {
194 if a < 0 {
195 *ptr = 0
196 }
197 }
198
199 func CmpZero3(a int32, ptr *int) {
200 if a >= 0 {
201 *ptr = 0
202 }
203 }
204
205 func CmpZero4(a int64, ptr *int) {
206 if a >= 0 {
207 *ptr = 0
208 }
209 }
210
211 func CmpToZero(a, b, d int32, e, f int64, deOptC0, deOptC1 bool) int32 {
212
213
214
215
216 c0 := a&b < 0
217
218
219 c1 := a+b < 0
220
221 c2 := a^b < 0
222
223
224 c3 := e&f < 0
225
226 c4 := e+f < 0
227
228
229
230 c5 := b+d == 0
231
232
233
234
235 c6 := a&d >= 0
236
237 c7 := e&(f<<3) < 0
238
239 c8 := e+(f<<3) < 0
240
241 c9 := e&(-19) < 0
242 if c0 {
243 return 1
244 } else if c1 {
245 return 2
246 } else if c2 {
247 return 3
248 } else if c3 {
249 return 4
250 } else if c4 {
251 return 5
252 } else if c5 {
253 return 6
254 } else if c6 {
255 return 7
256 } else if c7 {
257 return 9
258 } else if c8 {
259 return 10
260 } else if c9 {
261 return 11
262 } else if deOptC0 {
263 return b + d
264 } else if deOptC1 {
265 return a & d
266 } else {
267 return 0
268 }
269 }
270
271 func CmpLogicalToZero(a, b, c uint32, d, e uint64) uint64 {
272
273
274
275 if a&63 == 0 {
276 return 1
277 }
278
279
280
281 if d&255 == 0 {
282 return 1
283 }
284
285
286
287 if d&e == 0 {
288 return 1
289 }
290
291
292 if d|e == 0 {
293 return 1
294 }
295
296
297
298 if e^d == 0 {
299 return 1
300 }
301 return 0
302 }
303
304
305
306
307
308
309
310 func CmpToZero_ex1(a int64, e int32) int {
311
312 if a+3 < 0 {
313 return 1
314 }
315
316
317 if a+5 <= 0 {
318 return 1
319 }
320
321
322 if a+13 >= 0 {
323 return 2
324 }
325
326
327 if a-7 < 0 {
328 return 3
329 }
330
331
332 if a-11 >= 0 {
333 return 4
334 }
335
336
337 if a-19 > 0 {
338 return 4
339 }
340
341
342
343 if e+3 < 0 {
344 return 5
345 }
346
347
348
349 if e+13 >= 0 {
350 return 6
351 }
352
353
354
355 if e-7 < 0 {
356 return 7
357 }
358
359
360
361 if e-11 >= 0 {
362 return 8
363 }
364
365 return 0
366 }
367
368
369
370 func CmpToZero_ex2(a, b, c int64, e, f, g int32) int {
371
372 if a+b < 0 {
373 return 1
374 }
375
376
377 if a+c <= 0 {
378 return 1
379 }
380
381
382 if b+c >= 0 {
383 return 2
384 }
385
386
387
388 if e+f < 0 {
389 return 5
390 }
391
392
393
394 if f+g >= 0 {
395 return 6
396 }
397 return 0
398 }
399
400
401 func CmpToZero_ex3(a, b, c, d int64, e, f, g, h int32) int {
402
403 if a+b*c < 0 {
404 return 1
405 }
406
407
408 if b+c*d >= 0 {
409 return 2
410 }
411
412
413
414 if e+f*g > 0 {
415 return 5
416 }
417
418
419
420 if f+g*h <= 0 {
421 return 6
422 }
423 return 0
424 }
425
426
427 func CmpToZero_ex4(a, b, c, d int64, e, f, g, h int32) int {
428
429 if a-b*c > 0 {
430 return 1
431 }
432
433
434 if b-c*d >= 0 {
435 return 2
436 }
437
438
439 if e-f*g < 0 {
440 return 5
441 }
442
443
444 if f-g*h >= 0 {
445 return 6
446 }
447 return 0
448 }
449
450 func CmpToZero_ex5(e, f int32, u uint32) int {
451
452 if e+f<<1 > 0 {
453 return 1
454 }
455
456
457 if f-int32(u>>2) >= 0 {
458 return 2
459 }
460 return 0
461 }
462
463 func UintLtZero(a uint8, b uint16, c uint32, d uint64) int {
464
465
466 if a < 0 || b < 0 || c < 0 || d < 0 {
467 return 1
468 }
469 return 0
470 }
471
472 func UintGeqZero(a uint8, b uint16, c uint32, d uint64) int {
473
474
475 if a >= 0 || b >= 0 || c >= 0 || d >= 0 {
476 return 1
477 }
478 return 0
479 }
480
481 func UintGtZero(a uint8, b uint16, c uint32, d uint64) int {
482
483 if a > 0 || b > 0 || c > 0 || d > 0 {
484 return 1
485 }
486 return 0
487 }
488
489 func UintLeqZero(a uint8, b uint16, c uint32, d uint64) int {
490
491 if a <= 0 || b <= 0 || c <= 0 || d <= 0 {
492 return 1
493 }
494 return 0
495 }
496
497 func UintLtOne(a uint8, b uint16, c uint32, d uint64) int {
498
499 if a < 1 || b < 1 || c < 1 || d < 1 {
500 return 1
501 }
502 return 0
503 }
504
505 func UintGeqOne(a uint8, b uint16, c uint32, d uint64) int {
506
507 if a >= 1 || b >= 1 || c >= 1 || d >= 1 {
508 return 1
509 }
510 return 0
511 }
512
513 func CmpToZeroU_ex1(a uint8, b uint16, c uint32, d uint64) int {
514
515 if 0 < a {
516 return 1
517 }
518
519 if 0 < b {
520 return 1
521 }
522
523 if 0 < c {
524 return 1
525 }
526
527 if 0 < d {
528 return 1
529 }
530 return 0
531 }
532
533 func CmpToZeroU_ex2(a uint8, b uint16, c uint32, d uint64) int {
534
535 if a <= 0 {
536 return 1
537 }
538
539 if b <= 0 {
540 return 1
541 }
542
543 if c <= 0 {
544 return 1
545 }
546
547 if d <= 0 {
548 return 1
549 }
550 return 0
551 }
552
553 func CmpToOneU_ex1(a uint8, b uint16, c uint32, d uint64) int {
554
555 if a < 1 {
556 return 1
557 }
558
559 if b < 1 {
560 return 1
561 }
562
563 if c < 1 {
564 return 1
565 }
566
567 if d < 1 {
568 return 1
569 }
570 return 0
571 }
572
573 func CmpToOneU_ex2(a uint8, b uint16, c uint32, d uint64) int {
574
575 if 1 <= a {
576 return 1
577 }
578
579 if 1 <= b {
580 return 1
581 }
582
583 if 1 <= c {
584 return 1
585 }
586
587 if 1 <= d {
588 return 1
589 }
590 return 0
591 }
592
593
594
595 func equalConstString1() bool {
596 a := string("A")
597 b := string("Z")
598
599
600
601 return a == b
602 }
603
604 func equalVarString1(a string) bool {
605 b := string("Z")
606
607
608
609 return a[:1] == b
610 }
611
612 func equalConstString2() bool {
613 a := string("AA")
614 b := string("ZZ")
615
616
617
618 return a == b
619 }
620
621 func equalVarString2(a string) bool {
622 b := string("ZZ")
623
624
625
626 return a[:2] == b
627 }
628
629 func equalConstString4() bool {
630 a := string("AAAA")
631 b := string("ZZZZ")
632
633
634
635 return a == b
636 }
637
638 func equalVarString4(a string) bool {
639 b := string("ZZZZ")
640
641
642
643 return a[:4] == b
644 }
645
646 func equalConstString8() bool {
647 a := string("AAAAAAAA")
648 b := string("ZZZZZZZZ")
649
650
651
652 return a == b
653 }
654
655 func equalVarString8(a string) bool {
656 b := string("ZZZZZZZZ")
657
658
659
660 return a[:8] == b
661 }
662
663 func cmpToCmn(a, b, c, d int) int {
664 var c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11 int
665
666 if a < -8 {
667 c1 = 1
668 }
669
670 if a+1 == 0 {
671 c2 = 1
672 }
673
674 if a+3 != 0 {
675 c3 = 1
676 }
677
678 if a+b == 0 {
679 c4 = 1
680 }
681
682 if b+c != 0 {
683 c5 = 1
684 }
685
686 if a == -c {
687 c6 = 1
688 }
689
690 if b != -d {
691 c7 = 1
692 }
693
694 if a*b+c == 0 {
695 c8 = 1
696 }
697
698 if a*c+b != 0 {
699 c9 = 1
700 }
701
702 if b*c-a == 0 {
703 c10 = 1
704 }
705
706 if a*d-b != 0 {
707 c11 = 1
708 }
709 return c1 + c2 + c3 + c4 + c5 + c6 + c7 + c8 + c9 + c10 + c11
710 }
711
712 func cmpToCmnLessThan(a, b, c, d int) int {
713 var c1, c2, c3, c4 int
714
715 if a+1 < 0 {
716 c1 = 1
717 }
718
719 if a+b < 0 {
720 c2 = 1
721 }
722
723 if a*b+c < 0 {
724 c3 = 1
725 }
726
727 if a-b*c < 0 {
728 c4 = 1
729 }
730 return c1 + c2 + c3 + c4
731 }
732
733 func cmpToCmnGreaterThanEqual(a, b, c, d int) int {
734 var c1, c2, c3, c4 int
735
736 if a+1 >= 0 {
737 c1 = 1
738 }
739
740 if a+b >= 0 {
741 c2 = 1
742 }
743
744 if a*b+c >= 0 {
745 c3 = 1
746 }
747
748 if a-b*c >= 0 {
749 c4 = 1
750 }
751 return c1 + c2 + c3 + c4
752 }
753
754 func cmp1(val string) bool {
755 var z string
756
757 return z == val
758 }
759
760 func cmp2(val string) bool {
761 var z string
762
763 return val == z
764 }
765
766 func cmp3(val string) bool {
767 z := "food"
768
769 return z == val
770 }
771
772 func cmp4(val string) bool {
773 z := "food"
774
775 return val == z
776 }
777
778 func cmp5[T comparable](val T) bool {
779 var z T
780
781 return z == val
782 }
783
784 func cmp6[T comparable](val T) bool {
785 var z T
786
787 return val == z
788 }
789
790 func cmp7() {
791 cmp5[string]("")
792 cmp6[string]("")
793 }
794
795 type Point struct {
796 X, Y int
797 }
798
799
800
801
802
803 func invertLessThanNoov(p1, p2, p3 Point) bool {
804
805 return (p1.X-p3.X)*(p2.Y-p3.Y)-(p2.X-p3.X)*(p1.Y-p3.Y) < 0
806 }
807
808 func cmpstring1(x, y string) int {
809
810 if x < y {
811 return -1
812 }
813
814 if x > y {
815 return +1
816 }
817 return 0
818 }
819 func cmpstring2(x, y string) int {
820
821
822
823
824
825
826 return cmp.Compare(x, y)
827 }
828
View as plain text