236 lines
3.5 KiB
Plaintext
236 lines
3.5 KiB
Plaintext
|
[case testIntNeq]
|
||
|
def f(x: int, y: int) -> bool:
|
||
|
return x != y
|
||
|
[out]
|
||
|
def f(x, y):
|
||
|
x, y :: int
|
||
|
r0 :: native_int
|
||
|
r1, r2 :: bit
|
||
|
r3 :: bool
|
||
|
r4, r5 :: bit
|
||
|
L0:
|
||
|
r0 = x & 1
|
||
|
r1 = r0 == 0
|
||
|
if r1 goto L1 else goto L2 :: bool
|
||
|
L1:
|
||
|
r2 = x != y
|
||
|
r3 = r2
|
||
|
goto L3
|
||
|
L2:
|
||
|
r4 = CPyTagged_IsEq_(x, y)
|
||
|
r5 = r4 ^ 1
|
||
|
r3 = r5
|
||
|
L3:
|
||
|
return r3
|
||
|
|
||
|
[case testShortIntComparisons]
|
||
|
def f(x: int) -> int:
|
||
|
if x == 3:
|
||
|
return 1
|
||
|
elif x != 4:
|
||
|
return 2
|
||
|
elif 5 == x:
|
||
|
return 3
|
||
|
elif 6 != x:
|
||
|
return 4
|
||
|
elif x < 4:
|
||
|
return 5
|
||
|
return 6
|
||
|
[out]
|
||
|
def f(x):
|
||
|
x :: int
|
||
|
r0, r1, r2, r3 :: bit
|
||
|
r4 :: native_int
|
||
|
r5, r6, r7 :: bit
|
||
|
L0:
|
||
|
r0 = x == 6
|
||
|
if r0 goto L1 else goto L2 :: bool
|
||
|
L1:
|
||
|
return 2
|
||
|
L2:
|
||
|
r1 = x != 8
|
||
|
if r1 goto L3 else goto L4 :: bool
|
||
|
L3:
|
||
|
return 4
|
||
|
L4:
|
||
|
r2 = 10 == x
|
||
|
if r2 goto L5 else goto L6 :: bool
|
||
|
L5:
|
||
|
return 6
|
||
|
L6:
|
||
|
r3 = 12 != x
|
||
|
if r3 goto L7 else goto L8 :: bool
|
||
|
L7:
|
||
|
return 8
|
||
|
L8:
|
||
|
r4 = x & 1
|
||
|
r5 = r4 != 0
|
||
|
if r5 goto L9 else goto L10 :: bool
|
||
|
L9:
|
||
|
r6 = CPyTagged_IsLt_(x, 8)
|
||
|
if r6 goto L11 else goto L12 :: bool
|
||
|
L10:
|
||
|
r7 = x < 8 :: signed
|
||
|
if r7 goto L11 else goto L12 :: bool
|
||
|
L11:
|
||
|
return 10
|
||
|
L12:
|
||
|
L13:
|
||
|
L14:
|
||
|
L15:
|
||
|
L16:
|
||
|
return 12
|
||
|
|
||
|
[case testIntMin]
|
||
|
def f(x: int, y: int) -> int:
|
||
|
return min(x, y)
|
||
|
[out]
|
||
|
def f(x, y):
|
||
|
x, y :: int
|
||
|
r0 :: native_int
|
||
|
r1 :: bit
|
||
|
r2 :: native_int
|
||
|
r3, r4, r5 :: bit
|
||
|
r6 :: bool
|
||
|
r7 :: bit
|
||
|
r8 :: int
|
||
|
L0:
|
||
|
r0 = y & 1
|
||
|
r1 = r0 == 0
|
||
|
r2 = x & 1
|
||
|
r3 = r2 == 0
|
||
|
r4 = r1 & r3
|
||
|
if r4 goto L1 else goto L2 :: bool
|
||
|
L1:
|
||
|
r5 = y < x :: signed
|
||
|
r6 = r5
|
||
|
goto L3
|
||
|
L2:
|
||
|
r7 = CPyTagged_IsLt_(y, x)
|
||
|
r6 = r7
|
||
|
L3:
|
||
|
if r6 goto L4 else goto L5 :: bool
|
||
|
L4:
|
||
|
r8 = y
|
||
|
goto L6
|
||
|
L5:
|
||
|
r8 = x
|
||
|
L6:
|
||
|
return r8
|
||
|
|
||
|
[case testIntFloorDivideByPowerOfTwo]
|
||
|
def divby1(x: int) -> int:
|
||
|
return x // 1
|
||
|
def divby2(x: int) -> int:
|
||
|
return x // 2
|
||
|
def divby3(x: int) -> int:
|
||
|
return x // 3
|
||
|
def divby4(x: int) -> int:
|
||
|
return x // 4
|
||
|
def divby8(x: int) -> int:
|
||
|
return x // 8
|
||
|
[out]
|
||
|
def divby1(x):
|
||
|
x, r0 :: int
|
||
|
L0:
|
||
|
r0 = CPyTagged_FloorDivide(x, 2)
|
||
|
return r0
|
||
|
def divby2(x):
|
||
|
x, r0 :: int
|
||
|
L0:
|
||
|
r0 = CPyTagged_Rshift(x, 2)
|
||
|
return r0
|
||
|
def divby3(x):
|
||
|
x, r0 :: int
|
||
|
L0:
|
||
|
r0 = CPyTagged_FloorDivide(x, 6)
|
||
|
return r0
|
||
|
def divby4(x):
|
||
|
x, r0 :: int
|
||
|
L0:
|
||
|
r0 = CPyTagged_Rshift(x, 4)
|
||
|
return r0
|
||
|
def divby8(x):
|
||
|
x, r0 :: int
|
||
|
L0:
|
||
|
r0 = CPyTagged_Rshift(x, 6)
|
||
|
return r0
|
||
|
|
||
|
[case testFinalConstantFolding]
|
||
|
from typing_extensions import Final
|
||
|
|
||
|
X: Final = -1
|
||
|
Y: Final = -(1 + 3*2)
|
||
|
Z: Final = Y + 1
|
||
|
|
||
|
class C:
|
||
|
A: Final = 1
|
||
|
B: Final = -1
|
||
|
|
||
|
def f1() -> int:
|
||
|
return X
|
||
|
|
||
|
def f2() -> int:
|
||
|
return X + Y
|
||
|
|
||
|
def f3() -> int:
|
||
|
return Z
|
||
|
|
||
|
def f4() -> int:
|
||
|
return C.A
|
||
|
|
||
|
def f5() -> int:
|
||
|
return C.B
|
||
|
[out]
|
||
|
def C.__mypyc_defaults_setup(__mypyc_self__):
|
||
|
__mypyc_self__ :: __main__.C
|
||
|
L0:
|
||
|
__mypyc_self__.A = 2
|
||
|
__mypyc_self__.B = -2
|
||
|
return 1
|
||
|
def f1():
|
||
|
L0:
|
||
|
return -2
|
||
|
def f2():
|
||
|
L0:
|
||
|
return -16
|
||
|
def f3():
|
||
|
L0:
|
||
|
return -12
|
||
|
def f4():
|
||
|
L0:
|
||
|
return 2
|
||
|
def f5():
|
||
|
L0:
|
||
|
return -2
|
||
|
|
||
|
[case testConvertIntegralToInt]
|
||
|
def bool_to_int(b: bool) -> int:
|
||
|
return int(b)
|
||
|
|
||
|
def int_to_int(n: int) -> int:
|
||
|
return int(n)
|
||
|
[out]
|
||
|
def bool_to_int(b):
|
||
|
b, r0 :: bool
|
||
|
r1 :: int
|
||
|
L0:
|
||
|
r0 = b << 1
|
||
|
r1 = extend r0: builtins.bool to builtins.int
|
||
|
return r1
|
||
|
def int_to_int(n):
|
||
|
n :: int
|
||
|
L0:
|
||
|
return n
|
||
|
|
||
|
[case testIntUnaryPlus]
|
||
|
def unary_plus(n: int) -> int:
|
||
|
x = +n
|
||
|
return x
|
||
|
[out]
|
||
|
def unary_plus(n):
|
||
|
n, x :: int
|
||
|
L0:
|
||
|
x = n
|
||
|
return x
|