[pypy-svn] r10424 - in pypy/dist/pypy/translator/llvm: . test
cfbolz at codespeak.net
cfbolz at codespeak.net
Fri Apr 8 04:05:05 CEST 2005
Author: cfbolz
Date: Fri Apr 8 04:05:05 2005
New Revision: 10424
Modified:
pypy/dist/pypy/translator/llvm/make_runtime.py
pypy/dist/pypy/translator/llvm/operations.ll
pypy/dist/pypy/translator/llvm/test/llvmsnippet.py
pypy/dist/pypy/translator/llvm/test/test_genllvm.py
Log:
Added a function to make_runtime that generates operators.ll with all possible combinations of types.
Modified: pypy/dist/pypy/translator/llvm/make_runtime.py
==============================================================================
--- pypy/dist/pypy/translator/llvm/make_runtime.py (original)
+++ pypy/dist/pypy/translator/llvm/make_runtime.py Fri Apr 8 04:05:05 2005
@@ -134,7 +134,135 @@
f.write(code)
f.close()
+MAP_ARITHM_OPS = [("add", ("add", None, None)),
+ ("inplace_add", ("add", None, None)),
+ ("sub", ("sub", None, None)),
+ ("inplace_sub", ("sub", None, None)),
+ ("mul", ("mul", None, None)),
+ ("inplace_mul", ("mul", None, None)),
+ ("div", ("div", None, None)),
+ ("inplace_div", ("div", None, None)),
+ ("floordiv", ("div", "int", None)),
+ ("inplace_floordiv", ("div", "int", None)),
+ ("truediv", ("div", "double", "double")),
+ ("inplace_truediv", ("div", "double", "double")),
+ ("mod", ("rem", None, None)),
+ ("inplace_mod", ("rem", None, None))
+ ]
+
+MAP_LOGICAL_OPS = [("and_", ("and", None, None)),
+ ("inplace_and", ("and", None, None)),
+ ("or_", ("or", None, None)),
+ ("inplace_or", ("or", None, None)),
+ ("xor", ("xor", None, None)),
+ ("inplace_xor", ("xor", None, None))
+ ]
+
+MAP_COMPAR_OPS = [("is_", "seteq"),
+ ("eq", "seteq"),
+ ("lt", "setlt"),
+ ("le", "setle"),
+ ("ge", "setge"),
+ ("gt", "setgt")]
+
+types = ((0, "double"), (1, "uint"), (2, "int"), (3, "bool"))
+
+def make_binary_ops():
+ code = ["implementation\n"]
+ def normalize_type(t1, t, var):
+ if t1 != t:
+ code.append("\t%%%s = cast %s %%%s to %s\n" % (var, t1, var, t))
+ for type1 in types:
+ for type2 in types:
+ #Arithmetic operators
+ for op, (llvmop, calctype, rettype) in MAP_ARITHM_OPS:
+ if calctype is None:
+ calctype = min(type1, type2)[1]
+ if rettype is None:
+ rettype = min(type1, type2)[1]
+ if calctype == "bool":
+ calctype = rettype = "int"
+ code.append("internal %s %%std.%s(%s %%a, %s %%b) {\n" %
+ (rettype, op, type1[1], type2[1]))
+ normalize_type(type1[1], calctype, "a")
+ normalize_type(type2[1], calctype, "b")
+ code.append("\t%%r = %s %s %%a, %%b\n" %
+ (llvmop, calctype))
+ normalize_type(calctype, rettype, "r")
+ code.append("\tret %s %%r\n}\n\n" % rettype)
+ calctype = min(type1, type2)[1]
+ #Comparison operators
+ for op, llvmop in MAP_COMPAR_OPS:
+ code.append("internal bool %%std.%s(%s %%a, %s %%b) {\n" %
+ (op, type1[1], type2[1]))
+ normalize_type(type1[1], calctype, "a")
+ normalize_type(type2[1], calctype, "b")
+ code.append("\t%%r = %s %s %%a, %%b\n" %
+ (llvmop, calctype))
+ code.append("\tret bool %r\n}\n\n")
+ code.append("internal bool %%std.neq(%s %%a, %s %%b) {\n" %
+ (type1[1], type2[1]))
+ normalize_type(type1[1], calctype, "a")
+ normalize_type(type2[1], calctype, "b")
+ code.append("\t%%r = %s %s %%a, %%b\n" %
+ (llvmop, calctype))
+ code.append("\t%r1 = xor bool %r, true\n\tret bool %r1\n}\n\n")
+ #Logical operators
+ for type1 in types[1:]:
+ for type2 in types[1:]:
+ for op, (llvmop, calctype, rettype) in MAP_LOGICAL_OPS:
+ if calctype is None:
+ calctype = min(type1, type2)[1]
+ if rettype is None:
+ rettype = min(type1, type2)[1]
+ code.append("internal %s %%std.%s(%s %%a, %s %%b) {\n" %
+ (rettype, op, type1[1], type2[1]))
+ normalize_type(type1[1], calctype, "a")
+ normalize_type(type2[1], calctype, "b")
+ code.append("\t%%r = %s %s %%a, %%b\n" %
+ (llvmop, calctype))
+ normalize_type(calctype, rettype, "r")
+ code.append("\tret %s %%r\n}\n\n" % rettype)
+ #Shift
+ for type1 in types[1:-1]:
+ for type2 in types[1:-1]:
+ for op, llvmop in (("lshift", "shl"), ("rshift", "shr")):
+ code.append("internal %s %%std.%s(%s %%a, %s %%b) {\n" %
+ (type1[1], op, type1[1], type2[1]))
+ code.append("\t%%b = cast %s %%b to ubyte\n" % type2[1])
+ code.append("\t%%r = %s %s %%a, ubyte %%b\n" %
+ (llvmop, type1[1]))
+ code.append("\tret %s %%r\n}\n\n" % type1[1])
+ return code
+
+def make_unary_ops():
+ code = []
+ def normalize_type(t1, t, var):
+ if t1 != t:
+ code.append("\t%%%s = cast %s %%%s to %s\n" % (var, t1, var, t))
+ for type1 in types:
+ #"casts" int, bool
+ for type2 in ("int", "bool"):
+ code.append("internal %s %%std.%s(%s %%a) {\n" %
+ (type2, type2, type1[1]))
+ code.append("\t%%r = cast %s %%a to %s\n" % (type1[1], type2))
+ code.append("\tret %s %%r\n}\n\n" % type2)
+ #is_true
+ code.append("internal bool %%std.is_true(%s %%a) {\n" % type1[1])
+ code.append("\t%%r = cast %s %%a to bool\n" % type1[1])
+ code.append("\tret bool %r\n}\n\n")
+ return code
+
+
+def make_operations():
+ code = make_binary_ops()
+ code += make_unary_ops()
+ f = open(autopath.this_dir + "/operations.ll", "w")
+ f.write("".join(code))
+ f.close()
+
if __name__ == '__main__':
+ make_operations()
make_list_template()
make_int_list()
Modified: pypy/dist/pypy/translator/llvm/operations.ll
==============================================================================
--- pypy/dist/pypy/translator/llvm/operations.ll (original)
+++ pypy/dist/pypy/translator/llvm/operations.ll Fri Apr 8 04:05:05 2005
@@ -1,226 +1,2183 @@
+implementation
+internal double %std.add(double %a, double %b) {
+ %r = add double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_add(double %a, double %b) {
+ %r = add double %a, %b
+ ret double %r
+}
+
+internal double %std.sub(double %a, double %b) {
+ %r = sub double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_sub(double %a, double %b) {
+ %r = sub double %a, %b
+ ret double %r
+}
+
+internal double %std.mul(double %a, double %b) {
+ %r = mul double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_mul(double %a, double %b) {
+ %r = mul double %a, %b
+ ret double %r
+}
+
+internal double %std.div(double %a, double %b) {
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_div(double %a, double %b) {
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.floordiv(double %a, double %b) {
+ %a = cast double %a to int
+ %b = cast double %b to int
+ %r = div int %a, %b
+ %r = cast int %r to double
+ ret double %r
+}
+
+internal double %std.inplace_floordiv(double %a, double %b) {
+ %a = cast double %a to int
+ %b = cast double %b to int
+ %r = div int %a, %b
+ %r = cast int %r to double
+ ret double %r
+}
+
+internal double %std.truediv(double %a, double %b) {
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_truediv(double %a, double %b) {
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.mod(double %a, double %b) {
+ %r = rem double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_mod(double %a, double %b) {
+ %r = rem double %a, %b
+ ret double %r
+}
+
+internal bool %std.is_(double %a, double %b) {
+ %r = seteq double %a, %b
+ ret bool %r
+}
+
+internal bool %std.eq(double %a, double %b) {
+ %r = seteq double %a, %b
+ ret bool %r
+}
+
+internal bool %std.lt(double %a, double %b) {
+ %r = setlt double %a, %b
+ ret bool %r
+}
+
+internal bool %std.le(double %a, double %b) {
+ %r = setle double %a, %b
+ ret bool %r
+}
+
+internal bool %std.ge(double %a, double %b) {
+ %r = setge double %a, %b
+ ret bool %r
+}
+
+internal bool %std.gt(double %a, double %b) {
+ %r = setgt double %a, %b
+ ret bool %r
+}
+
+internal bool %std.neq(double %a, double %b) {
+ %r = setgt double %a, %b
+ %r1 = xor bool %r, true
+ ret bool %r1
+}
+
+internal double %std.add(double %a, uint %b) {
+ %b = cast uint %b to double
+ %r = add double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_add(double %a, uint %b) {
+ %b = cast uint %b to double
+ %r = add double %a, %b
+ ret double %r
+}
+
+internal double %std.sub(double %a, uint %b) {
+ %b = cast uint %b to double
+ %r = sub double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_sub(double %a, uint %b) {
+ %b = cast uint %b to double
+ %r = sub double %a, %b
+ ret double %r
+}
+
+internal double %std.mul(double %a, uint %b) {
+ %b = cast uint %b to double
+ %r = mul double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_mul(double %a, uint %b) {
+ %b = cast uint %b to double
+ %r = mul double %a, %b
+ ret double %r
+}
+
+internal double %std.div(double %a, uint %b) {
+ %b = cast uint %b to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_div(double %a, uint %b) {
+ %b = cast uint %b to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.floordiv(double %a, uint %b) {
+ %a = cast double %a to int
+ %b = cast uint %b to int
+ %r = div int %a, %b
+ %r = cast int %r to double
+ ret double %r
+}
+
+internal double %std.inplace_floordiv(double %a, uint %b) {
+ %a = cast double %a to int
+ %b = cast uint %b to int
+ %r = div int %a, %b
+ %r = cast int %r to double
+ ret double %r
+}
+
+internal double %std.truediv(double %a, uint %b) {
+ %b = cast uint %b to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_truediv(double %a, uint %b) {
+ %b = cast uint %b to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.mod(double %a, uint %b) {
+ %b = cast uint %b to double
+ %r = rem double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_mod(double %a, uint %b) {
+ %b = cast uint %b to double
+ %r = rem double %a, %b
+ ret double %r
+}
+
+internal bool %std.is_(double %a, uint %b) {
+ %b = cast uint %b to double
+ %r = seteq double %a, %b
+ ret bool %r
+}
+
+internal bool %std.eq(double %a, uint %b) {
+ %b = cast uint %b to double
+ %r = seteq double %a, %b
+ ret bool %r
+}
+
+internal bool %std.lt(double %a, uint %b) {
+ %b = cast uint %b to double
+ %r = setlt double %a, %b
+ ret bool %r
+}
+
+internal bool %std.le(double %a, uint %b) {
+ %b = cast uint %b to double
+ %r = setle double %a, %b
+ ret bool %r
+}
+
+internal bool %std.ge(double %a, uint %b) {
+ %b = cast uint %b to double
+ %r = setge double %a, %b
+ ret bool %r
+}
+
+internal bool %std.gt(double %a, uint %b) {
+ %b = cast uint %b to double
+ %r = setgt double %a, %b
+ ret bool %r
+}
+
+internal bool %std.neq(double %a, uint %b) {
+ %b = cast uint %b to double
+ %r = setgt double %a, %b
+ %r1 = xor bool %r, true
+ ret bool %r1
+}
+
+internal double %std.add(double %a, int %b) {
+ %b = cast int %b to double
+ %r = add double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_add(double %a, int %b) {
+ %b = cast int %b to double
+ %r = add double %a, %b
+ ret double %r
+}
+
+internal double %std.sub(double %a, int %b) {
+ %b = cast int %b to double
+ %r = sub double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_sub(double %a, int %b) {
+ %b = cast int %b to double
+ %r = sub double %a, %b
+ ret double %r
+}
+
+internal double %std.mul(double %a, int %b) {
+ %b = cast int %b to double
+ %r = mul double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_mul(double %a, int %b) {
+ %b = cast int %b to double
+ %r = mul double %a, %b
+ ret double %r
+}
+
+internal double %std.div(double %a, int %b) {
+ %b = cast int %b to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_div(double %a, int %b) {
+ %b = cast int %b to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.floordiv(double %a, int %b) {
+ %a = cast double %a to int
+ %r = div int %a, %b
+ %r = cast int %r to double
+ ret double %r
+}
+
+internal double %std.inplace_floordiv(double %a, int %b) {
+ %a = cast double %a to int
+ %r = div int %a, %b
+ %r = cast int %r to double
+ ret double %r
+}
+
+internal double %std.truediv(double %a, int %b) {
+ %b = cast int %b to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_truediv(double %a, int %b) {
+ %b = cast int %b to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.mod(double %a, int %b) {
+ %b = cast int %b to double
+ %r = rem double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_mod(double %a, int %b) {
+ %b = cast int %b to double
+ %r = rem double %a, %b
+ ret double %r
+}
+
+internal bool %std.is_(double %a, int %b) {
+ %b = cast int %b to double
+ %r = seteq double %a, %b
+ ret bool %r
+}
+
+internal bool %std.eq(double %a, int %b) {
+ %b = cast int %b to double
+ %r = seteq double %a, %b
+ ret bool %r
+}
+
+internal bool %std.lt(double %a, int %b) {
+ %b = cast int %b to double
+ %r = setlt double %a, %b
+ ret bool %r
+}
+
+internal bool %std.le(double %a, int %b) {
+ %b = cast int %b to double
+ %r = setle double %a, %b
+ ret bool %r
+}
+
+internal bool %std.ge(double %a, int %b) {
+ %b = cast int %b to double
+ %r = setge double %a, %b
+ ret bool %r
+}
+
+internal bool %std.gt(double %a, int %b) {
+ %b = cast int %b to double
+ %r = setgt double %a, %b
+ ret bool %r
+}
+
+internal bool %std.neq(double %a, int %b) {
+ %b = cast int %b to double
+ %r = setgt double %a, %b
+ %r1 = xor bool %r, true
+ ret bool %r1
+}
+
+internal double %std.add(double %a, bool %b) {
+ %b = cast bool %b to double
+ %r = add double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_add(double %a, bool %b) {
+ %b = cast bool %b to double
+ %r = add double %a, %b
+ ret double %r
+}
+
+internal double %std.sub(double %a, bool %b) {
+ %b = cast bool %b to double
+ %r = sub double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_sub(double %a, bool %b) {
+ %b = cast bool %b to double
+ %r = sub double %a, %b
+ ret double %r
+}
+
+internal double %std.mul(double %a, bool %b) {
+ %b = cast bool %b to double
+ %r = mul double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_mul(double %a, bool %b) {
+ %b = cast bool %b to double
+ %r = mul double %a, %b
+ ret double %r
+}
+
+internal double %std.div(double %a, bool %b) {
+ %b = cast bool %b to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_div(double %a, bool %b) {
+ %b = cast bool %b to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.floordiv(double %a, bool %b) {
+ %a = cast double %a to int
+ %b = cast bool %b to int
+ %r = div int %a, %b
+ %r = cast int %r to double
+ ret double %r
+}
+
+internal double %std.inplace_floordiv(double %a, bool %b) {
+ %a = cast double %a to int
+ %b = cast bool %b to int
+ %r = div int %a, %b
+ %r = cast int %r to double
+ ret double %r
+}
+
+internal double %std.truediv(double %a, bool %b) {
+ %b = cast bool %b to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_truediv(double %a, bool %b) {
+ %b = cast bool %b to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.mod(double %a, bool %b) {
+ %b = cast bool %b to double
+ %r = rem double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_mod(double %a, bool %b) {
+ %b = cast bool %b to double
+ %r = rem double %a, %b
+ ret double %r
+}
+
+internal bool %std.is_(double %a, bool %b) {
+ %b = cast bool %b to double
+ %r = seteq double %a, %b
+ ret bool %r
+}
+
+internal bool %std.eq(double %a, bool %b) {
+ %b = cast bool %b to double
+ %r = seteq double %a, %b
+ ret bool %r
+}
+
+internal bool %std.lt(double %a, bool %b) {
+ %b = cast bool %b to double
+ %r = setlt double %a, %b
+ ret bool %r
+}
+
+internal bool %std.le(double %a, bool %b) {
+ %b = cast bool %b to double
+ %r = setle double %a, %b
+ ret bool %r
+}
+
+internal bool %std.ge(double %a, bool %b) {
+ %b = cast bool %b to double
+ %r = setge double %a, %b
+ ret bool %r
+}
+
+internal bool %std.gt(double %a, bool %b) {
+ %b = cast bool %b to double
+ %r = setgt double %a, %b
+ ret bool %r
+}
+
+internal bool %std.neq(double %a, bool %b) {
+ %b = cast bool %b to double
+ %r = setgt double %a, %b
+ %r1 = xor bool %r, true
+ ret bool %r1
+}
+
+internal double %std.add(uint %a, double %b) {
+ %a = cast uint %a to double
+ %r = add double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_add(uint %a, double %b) {
+ %a = cast uint %a to double
+ %r = add double %a, %b
+ ret double %r
+}
+
+internal double %std.sub(uint %a, double %b) {
+ %a = cast uint %a to double
+ %r = sub double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_sub(uint %a, double %b) {
+ %a = cast uint %a to double
+ %r = sub double %a, %b
+ ret double %r
+}
+
+internal double %std.mul(uint %a, double %b) {
+ %a = cast uint %a to double
+ %r = mul double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_mul(uint %a, double %b) {
+ %a = cast uint %a to double
+ %r = mul double %a, %b
+ ret double %r
+}
+
+internal double %std.div(uint %a, double %b) {
+ %a = cast uint %a to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_div(uint %a, double %b) {
+ %a = cast uint %a to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.floordiv(uint %a, double %b) {
+ %a = cast uint %a to int
+ %b = cast double %b to int
+ %r = div int %a, %b
+ %r = cast int %r to double
+ ret double %r
+}
+
+internal double %std.inplace_floordiv(uint %a, double %b) {
+ %a = cast uint %a to int
+ %b = cast double %b to int
+ %r = div int %a, %b
+ %r = cast int %r to double
+ ret double %r
+}
+
+internal double %std.truediv(uint %a, double %b) {
+ %a = cast uint %a to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_truediv(uint %a, double %b) {
+ %a = cast uint %a to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.mod(uint %a, double %b) {
+ %a = cast uint %a to double
+ %r = rem double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_mod(uint %a, double %b) {
+ %a = cast uint %a to double
+ %r = rem double %a, %b
+ ret double %r
+}
+
+internal bool %std.is_(uint %a, double %b) {
+ %a = cast uint %a to double
+ %r = seteq double %a, %b
+ ret bool %r
+}
+
+internal bool %std.eq(uint %a, double %b) {
+ %a = cast uint %a to double
+ %r = seteq double %a, %b
+ ret bool %r
+}
+
+internal bool %std.lt(uint %a, double %b) {
+ %a = cast uint %a to double
+ %r = setlt double %a, %b
+ ret bool %r
+}
+
+internal bool %std.le(uint %a, double %b) {
+ %a = cast uint %a to double
+ %r = setle double %a, %b
+ ret bool %r
+}
+
+internal bool %std.ge(uint %a, double %b) {
+ %a = cast uint %a to double
+ %r = setge double %a, %b
+ ret bool %r
+}
+
+internal bool %std.gt(uint %a, double %b) {
+ %a = cast uint %a to double
+ %r = setgt double %a, %b
+ ret bool %r
+}
+
+internal bool %std.neq(uint %a, double %b) {
+ %a = cast uint %a to double
+ %r = setgt double %a, %b
+ %r1 = xor bool %r, true
+ ret bool %r1
+}
+
+internal uint %std.add(uint %a, uint %b) {
+ %r = add uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.inplace_add(uint %a, uint %b) {
+ %r = add uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.sub(uint %a, uint %b) {
+ %r = sub uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.inplace_sub(uint %a, uint %b) {
+ %r = sub uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.mul(uint %a, uint %b) {
+ %r = mul uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.inplace_mul(uint %a, uint %b) {
+ %r = mul uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.div(uint %a, uint %b) {
+ %r = div uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.inplace_div(uint %a, uint %b) {
+ %r = div uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.floordiv(uint %a, uint %b) {
+ %a = cast uint %a to int
+ %b = cast uint %b to int
+ %r = div int %a, %b
+ %r = cast int %r to uint
+ ret uint %r
+}
+
+internal uint %std.inplace_floordiv(uint %a, uint %b) {
+ %a = cast uint %a to int
+ %b = cast uint %b to int
+ %r = div int %a, %b
+ %r = cast int %r to uint
+ ret uint %r
+}
+
+internal double %std.truediv(uint %a, uint %b) {
+ %a = cast uint %a to double
+ %b = cast uint %b to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_truediv(uint %a, uint %b) {
+ %a = cast uint %a to double
+ %b = cast uint %b to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal uint %std.mod(uint %a, uint %b) {
+ %r = rem uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.inplace_mod(uint %a, uint %b) {
+ %r = rem uint %a, %b
+ ret uint %r
+}
+
+internal bool %std.is_(uint %a, uint %b) {
+ %r = seteq uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.eq(uint %a, uint %b) {
+ %r = seteq uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.lt(uint %a, uint %b) {
+ %r = setlt uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.le(uint %a, uint %b) {
+ %r = setle uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.ge(uint %a, uint %b) {
+ %r = setge uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.gt(uint %a, uint %b) {
+ %r = setgt uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.neq(uint %a, uint %b) {
+ %r = setgt uint %a, %b
+ %r1 = xor bool %r, true
+ ret bool %r1
+}
+
+internal uint %std.add(uint %a, int %b) {
+ %b = cast int %b to uint
+ %r = add uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.inplace_add(uint %a, int %b) {
+ %b = cast int %b to uint
+ %r = add uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.sub(uint %a, int %b) {
+ %b = cast int %b to uint
+ %r = sub uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.inplace_sub(uint %a, int %b) {
+ %b = cast int %b to uint
+ %r = sub uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.mul(uint %a, int %b) {
+ %b = cast int %b to uint
+ %r = mul uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.inplace_mul(uint %a, int %b) {
+ %b = cast int %b to uint
+ %r = mul uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.div(uint %a, int %b) {
+ %b = cast int %b to uint
+ %r = div uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.inplace_div(uint %a, int %b) {
+ %b = cast int %b to uint
+ %r = div uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.floordiv(uint %a, int %b) {
+ %a = cast uint %a to int
+ %r = div int %a, %b
+ %r = cast int %r to uint
+ ret uint %r
+}
+
+internal uint %std.inplace_floordiv(uint %a, int %b) {
+ %a = cast uint %a to int
+ %r = div int %a, %b
+ %r = cast int %r to uint
+ ret uint %r
+}
+
+internal double %std.truediv(uint %a, int %b) {
+ %a = cast uint %a to double
+ %b = cast int %b to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_truediv(uint %a, int %b) {
+ %a = cast uint %a to double
+ %b = cast int %b to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal uint %std.mod(uint %a, int %b) {
+ %b = cast int %b to uint
+ %r = rem uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.inplace_mod(uint %a, int %b) {
+ %b = cast int %b to uint
+ %r = rem uint %a, %b
+ ret uint %r
+}
+
+internal bool %std.is_(uint %a, int %b) {
+ %b = cast int %b to uint
+ %r = seteq uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.eq(uint %a, int %b) {
+ %b = cast int %b to uint
+ %r = seteq uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.lt(uint %a, int %b) {
+ %b = cast int %b to uint
+ %r = setlt uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.le(uint %a, int %b) {
+ %b = cast int %b to uint
+ %r = setle uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.ge(uint %a, int %b) {
+ %b = cast int %b to uint
+ %r = setge uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.gt(uint %a, int %b) {
+ %b = cast int %b to uint
+ %r = setgt uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.neq(uint %a, int %b) {
+ %b = cast int %b to uint
+ %r = setgt uint %a, %b
+ %r1 = xor bool %r, true
+ ret bool %r1
+}
+
+internal uint %std.add(uint %a, bool %b) {
+ %b = cast bool %b to uint
+ %r = add uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.inplace_add(uint %a, bool %b) {
+ %b = cast bool %b to uint
+ %r = add uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.sub(uint %a, bool %b) {
+ %b = cast bool %b to uint
+ %r = sub uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.inplace_sub(uint %a, bool %b) {
+ %b = cast bool %b to uint
+ %r = sub uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.mul(uint %a, bool %b) {
+ %b = cast bool %b to uint
+ %r = mul uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.inplace_mul(uint %a, bool %b) {
+ %b = cast bool %b to uint
+ %r = mul uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.div(uint %a, bool %b) {
+ %b = cast bool %b to uint
+ %r = div uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.inplace_div(uint %a, bool %b) {
+ %b = cast bool %b to uint
+ %r = div uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.floordiv(uint %a, bool %b) {
+ %a = cast uint %a to int
+ %b = cast bool %b to int
+ %r = div int %a, %b
+ %r = cast int %r to uint
+ ret uint %r
+}
+
+internal uint %std.inplace_floordiv(uint %a, bool %b) {
+ %a = cast uint %a to int
+ %b = cast bool %b to int
+ %r = div int %a, %b
+ %r = cast int %r to uint
+ ret uint %r
+}
+
+internal double %std.truediv(uint %a, bool %b) {
+ %a = cast uint %a to double
+ %b = cast bool %b to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_truediv(uint %a, bool %b) {
+ %a = cast uint %a to double
+ %b = cast bool %b to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal uint %std.mod(uint %a, bool %b) {
+ %b = cast bool %b to uint
+ %r = rem uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.inplace_mod(uint %a, bool %b) {
+ %b = cast bool %b to uint
+ %r = rem uint %a, %b
+ ret uint %r
+}
+
+internal bool %std.is_(uint %a, bool %b) {
+ %b = cast bool %b to uint
+ %r = seteq uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.eq(uint %a, bool %b) {
+ %b = cast bool %b to uint
+ %r = seteq uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.lt(uint %a, bool %b) {
+ %b = cast bool %b to uint
+ %r = setlt uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.le(uint %a, bool %b) {
+ %b = cast bool %b to uint
+ %r = setle uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.ge(uint %a, bool %b) {
+ %b = cast bool %b to uint
+ %r = setge uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.gt(uint %a, bool %b) {
+ %b = cast bool %b to uint
+ %r = setgt uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.neq(uint %a, bool %b) {
+ %b = cast bool %b to uint
+ %r = setgt uint %a, %b
+ %r1 = xor bool %r, true
+ ret bool %r1
+}
+
+internal double %std.add(int %a, double %b) {
+ %a = cast int %a to double
+ %r = add double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_add(int %a, double %b) {
+ %a = cast int %a to double
+ %r = add double %a, %b
+ ret double %r
+}
+
+internal double %std.sub(int %a, double %b) {
+ %a = cast int %a to double
+ %r = sub double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_sub(int %a, double %b) {
+ %a = cast int %a to double
+ %r = sub double %a, %b
+ ret double %r
+}
+
+internal double %std.mul(int %a, double %b) {
+ %a = cast int %a to double
+ %r = mul double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_mul(int %a, double %b) {
+ %a = cast int %a to double
+ %r = mul double %a, %b
+ ret double %r
+}
+
+internal double %std.div(int %a, double %b) {
+ %a = cast int %a to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_div(int %a, double %b) {
+ %a = cast int %a to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.floordiv(int %a, double %b) {
+ %b = cast double %b to int
+ %r = div int %a, %b
+ %r = cast int %r to double
+ ret double %r
+}
+
+internal double %std.inplace_floordiv(int %a, double %b) {
+ %b = cast double %b to int
+ %r = div int %a, %b
+ %r = cast int %r to double
+ ret double %r
+}
+
+internal double %std.truediv(int %a, double %b) {
+ %a = cast int %a to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_truediv(int %a, double %b) {
+ %a = cast int %a to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.mod(int %a, double %b) {
+ %a = cast int %a to double
+ %r = rem double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_mod(int %a, double %b) {
+ %a = cast int %a to double
+ %r = rem double %a, %b
+ ret double %r
+}
+
+internal bool %std.is_(int %a, double %b) {
+ %a = cast int %a to double
+ %r = seteq double %a, %b
+ ret bool %r
+}
+
+internal bool %std.eq(int %a, double %b) {
+ %a = cast int %a to double
+ %r = seteq double %a, %b
+ ret bool %r
+}
+
+internal bool %std.lt(int %a, double %b) {
+ %a = cast int %a to double
+ %r = setlt double %a, %b
+ ret bool %r
+}
+
+internal bool %std.le(int %a, double %b) {
+ %a = cast int %a to double
+ %r = setle double %a, %b
+ ret bool %r
+}
+
+internal bool %std.ge(int %a, double %b) {
+ %a = cast int %a to double
+ %r = setge double %a, %b
+ ret bool %r
+}
+
+internal bool %std.gt(int %a, double %b) {
+ %a = cast int %a to double
+ %r = setgt double %a, %b
+ ret bool %r
+}
+
+internal bool %std.neq(int %a, double %b) {
+ %a = cast int %a to double
+ %r = setgt double %a, %b
+ %r1 = xor bool %r, true
+ ret bool %r1
+}
+
+internal uint %std.add(int %a, uint %b) {
+ %a = cast int %a to uint
+ %r = add uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.inplace_add(int %a, uint %b) {
+ %a = cast int %a to uint
+ %r = add uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.sub(int %a, uint %b) {
+ %a = cast int %a to uint
+ %r = sub uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.inplace_sub(int %a, uint %b) {
+ %a = cast int %a to uint
+ %r = sub uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.mul(int %a, uint %b) {
+ %a = cast int %a to uint
+ %r = mul uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.inplace_mul(int %a, uint %b) {
+ %a = cast int %a to uint
+ %r = mul uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.div(int %a, uint %b) {
+ %a = cast int %a to uint
+ %r = div uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.inplace_div(int %a, uint %b) {
+ %a = cast int %a to uint
+ %r = div uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.floordiv(int %a, uint %b) {
+ %b = cast uint %b to int
+ %r = div int %a, %b
+ %r = cast int %r to uint
+ ret uint %r
+}
+
+internal uint %std.inplace_floordiv(int %a, uint %b) {
+ %b = cast uint %b to int
+ %r = div int %a, %b
+ %r = cast int %r to uint
+ ret uint %r
+}
+
+internal double %std.truediv(int %a, uint %b) {
+ %a = cast int %a to double
+ %b = cast uint %b to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_truediv(int %a, uint %b) {
+ %a = cast int %a to double
+ %b = cast uint %b to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal uint %std.mod(int %a, uint %b) {
+ %a = cast int %a to uint
+ %r = rem uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.inplace_mod(int %a, uint %b) {
+ %a = cast int %a to uint
+ %r = rem uint %a, %b
+ ret uint %r
+}
+
+internal bool %std.is_(int %a, uint %b) {
+ %a = cast int %a to uint
+ %r = seteq uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.eq(int %a, uint %b) {
+ %a = cast int %a to uint
+ %r = seteq uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.lt(int %a, uint %b) {
+ %a = cast int %a to uint
+ %r = setlt uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.le(int %a, uint %b) {
+ %a = cast int %a to uint
+ %r = setle uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.ge(int %a, uint %b) {
+ %a = cast int %a to uint
+ %r = setge uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.gt(int %a, uint %b) {
+ %a = cast int %a to uint
+ %r = setgt uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.neq(int %a, uint %b) {
+ %a = cast int %a to uint
+ %r = setgt uint %a, %b
+ %r1 = xor bool %r, true
+ ret bool %r1
+}
+
+internal int %std.add(int %a, int %b) {
+ %r = add int %a, %b
+ ret int %r
+}
+
+internal int %std.inplace_add(int %a, int %b) {
+ %r = add int %a, %b
+ ret int %r
+}
+
+internal int %std.sub(int %a, int %b) {
+ %r = sub int %a, %b
+ ret int %r
+}
+
+internal int %std.inplace_sub(int %a, int %b) {
+ %r = sub int %a, %b
+ ret int %r
+}
+
+internal int %std.mul(int %a, int %b) {
+ %r = mul int %a, %b
+ ret int %r
+}
+
+internal int %std.inplace_mul(int %a, int %b) {
+ %r = mul int %a, %b
+ ret int %r
+}
+
+internal int %std.div(int %a, int %b) {
+ %r = div int %a, %b
+ ret int %r
+}
+
+internal int %std.inplace_div(int %a, int %b) {
+ %r = div int %a, %b
+ ret int %r
+}
+
+internal int %std.floordiv(int %a, int %b) {
+ %r = div int %a, %b
+ ret int %r
+}
+
+internal int %std.inplace_floordiv(int %a, int %b) {
+ %r = div int %a, %b
+ ret int %r
+}
+
+internal double %std.truediv(int %a, int %b) {
+ %a = cast int %a to double
+ %b = cast int %b to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_truediv(int %a, int %b) {
+ %a = cast int %a to double
+ %b = cast int %b to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal int %std.mod(int %a, int %b) {
+ %r = rem int %a, %b
+ ret int %r
+}
+
+internal int %std.inplace_mod(int %a, int %b) {
+ %r = rem int %a, %b
+ ret int %r
+}
+
+internal bool %std.is_(int %a, int %b) {
+ %r = seteq int %a, %b
+ ret bool %r
+}
+
+internal bool %std.eq(int %a, int %b) {
+ %r = seteq int %a, %b
+ ret bool %r
+}
+
+internal bool %std.lt(int %a, int %b) {
+ %r = setlt int %a, %b
+ ret bool %r
+}
+
+internal bool %std.le(int %a, int %b) {
+ %r = setle int %a, %b
+ ret bool %r
+}
+
+internal bool %std.ge(int %a, int %b) {
+ %r = setge int %a, %b
+ ret bool %r
+}
+
+internal bool %std.gt(int %a, int %b) {
+ %r = setgt int %a, %b
+ ret bool %r
+}
+
+internal bool %std.neq(int %a, int %b) {
+ %r = setgt int %a, %b
+ %r1 = xor bool %r, true
+ ret bool %r1
+}
+
+internal int %std.add(int %a, bool %b) {
+ %b = cast bool %b to int
+ %r = add int %a, %b
+ ret int %r
+}
+
+internal int %std.inplace_add(int %a, bool %b) {
+ %b = cast bool %b to int
+ %r = add int %a, %b
+ ret int %r
+}
+
+internal int %std.sub(int %a, bool %b) {
+ %b = cast bool %b to int
+ %r = sub int %a, %b
+ ret int %r
+}
+
+internal int %std.inplace_sub(int %a, bool %b) {
+ %b = cast bool %b to int
+ %r = sub int %a, %b
+ ret int %r
+}
+
+internal int %std.mul(int %a, bool %b) {
+ %b = cast bool %b to int
+ %r = mul int %a, %b
+ ret int %r
+}
+
+internal int %std.inplace_mul(int %a, bool %b) {
+ %b = cast bool %b to int
+ %r = mul int %a, %b
+ ret int %r
+}
+
+internal int %std.div(int %a, bool %b) {
+ %b = cast bool %b to int
+ %r = div int %a, %b
+ ret int %r
+}
+
+internal int %std.inplace_div(int %a, bool %b) {
+ %b = cast bool %b to int
+ %r = div int %a, %b
+ ret int %r
+}
+
+internal int %std.floordiv(int %a, bool %b) {
+ %b = cast bool %b to int
+ %r = div int %a, %b
+ ret int %r
+}
+
+internal int %std.inplace_floordiv(int %a, bool %b) {
+ %b = cast bool %b to int
+ %r = div int %a, %b
+ ret int %r
+}
+
+internal double %std.truediv(int %a, bool %b) {
+ %a = cast int %a to double
+ %b = cast bool %b to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_truediv(int %a, bool %b) {
+ %a = cast int %a to double
+ %b = cast bool %b to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal int %std.mod(int %a, bool %b) {
+ %b = cast bool %b to int
+ %r = rem int %a, %b
+ ret int %r
+}
+
+internal int %std.inplace_mod(int %a, bool %b) {
+ %b = cast bool %b to int
+ %r = rem int %a, %b
+ ret int %r
+}
+
+internal bool %std.is_(int %a, bool %b) {
+ %b = cast bool %b to int
+ %r = seteq int %a, %b
+ ret bool %r
+}
+
+internal bool %std.eq(int %a, bool %b) {
+ %b = cast bool %b to int
+ %r = seteq int %a, %b
+ ret bool %r
+}
+
+internal bool %std.lt(int %a, bool %b) {
+ %b = cast bool %b to int
+ %r = setlt int %a, %b
+ ret bool %r
+}
+
+internal bool %std.le(int %a, bool %b) {
+ %b = cast bool %b to int
+ %r = setle int %a, %b
+ ret bool %r
+}
+
+internal bool %std.ge(int %a, bool %b) {
+ %b = cast bool %b to int
+ %r = setge int %a, %b
+ ret bool %r
+}
+
+internal bool %std.gt(int %a, bool %b) {
+ %b = cast bool %b to int
+ %r = setgt int %a, %b
+ ret bool %r
+}
+
+internal bool %std.neq(int %a, bool %b) {
+ %b = cast bool %b to int
+ %r = setgt int %a, %b
+ %r1 = xor bool %r, true
+ ret bool %r1
+}
+
+internal double %std.add(bool %a, double %b) {
+ %a = cast bool %a to double
+ %r = add double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_add(bool %a, double %b) {
+ %a = cast bool %a to double
+ %r = add double %a, %b
+ ret double %r
+}
+
+internal double %std.sub(bool %a, double %b) {
+ %a = cast bool %a to double
+ %r = sub double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_sub(bool %a, double %b) {
+ %a = cast bool %a to double
+ %r = sub double %a, %b
+ ret double %r
+}
+
+internal double %std.mul(bool %a, double %b) {
+ %a = cast bool %a to double
+ %r = mul double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_mul(bool %a, double %b) {
+ %a = cast bool %a to double
+ %r = mul double %a, %b
+ ret double %r
+}
+
+internal double %std.div(bool %a, double %b) {
+ %a = cast bool %a to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_div(bool %a, double %b) {
+ %a = cast bool %a to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.floordiv(bool %a, double %b) {
+ %a = cast bool %a to int
+ %b = cast double %b to int
+ %r = div int %a, %b
+ %r = cast int %r to double
+ ret double %r
+}
+
+internal double %std.inplace_floordiv(bool %a, double %b) {
+ %a = cast bool %a to int
+ %b = cast double %b to int
+ %r = div int %a, %b
+ %r = cast int %r to double
+ ret double %r
+}
+
+internal double %std.truediv(bool %a, double %b) {
+ %a = cast bool %a to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_truediv(bool %a, double %b) {
+ %a = cast bool %a to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.mod(bool %a, double %b) {
+ %a = cast bool %a to double
+ %r = rem double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_mod(bool %a, double %b) {
+ %a = cast bool %a to double
+ %r = rem double %a, %b
+ ret double %r
+}
+
+internal bool %std.is_(bool %a, double %b) {
+ %a = cast bool %a to double
+ %r = seteq double %a, %b
+ ret bool %r
+}
+
+internal bool %std.eq(bool %a, double %b) {
+ %a = cast bool %a to double
+ %r = seteq double %a, %b
+ ret bool %r
+}
+
+internal bool %std.lt(bool %a, double %b) {
+ %a = cast bool %a to double
+ %r = setlt double %a, %b
+ ret bool %r
+}
+
+internal bool %std.le(bool %a, double %b) {
+ %a = cast bool %a to double
+ %r = setle double %a, %b
+ ret bool %r
+}
+
+internal bool %std.ge(bool %a, double %b) {
+ %a = cast bool %a to double
+ %r = setge double %a, %b
+ ret bool %r
+}
+
+internal bool %std.gt(bool %a, double %b) {
+ %a = cast bool %a to double
+ %r = setgt double %a, %b
+ ret bool %r
+}
+
+internal bool %std.neq(bool %a, double %b) {
+ %a = cast bool %a to double
+ %r = setgt double %a, %b
+ %r1 = xor bool %r, true
+ ret bool %r1
+}
+
+internal uint %std.add(bool %a, uint %b) {
+ %a = cast bool %a to uint
+ %r = add uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.inplace_add(bool %a, uint %b) {
+ %a = cast bool %a to uint
+ %r = add uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.sub(bool %a, uint %b) {
+ %a = cast bool %a to uint
+ %r = sub uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.inplace_sub(bool %a, uint %b) {
+ %a = cast bool %a to uint
+ %r = sub uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.mul(bool %a, uint %b) {
+ %a = cast bool %a to uint
+ %r = mul uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.inplace_mul(bool %a, uint %b) {
+ %a = cast bool %a to uint
+ %r = mul uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.div(bool %a, uint %b) {
+ %a = cast bool %a to uint
+ %r = div uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.inplace_div(bool %a, uint %b) {
+ %a = cast bool %a to uint
+ %r = div uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.floordiv(bool %a, uint %b) {
+ %a = cast bool %a to int
+ %b = cast uint %b to int
+ %r = div int %a, %b
+ %r = cast int %r to uint
+ ret uint %r
+}
+
+internal uint %std.inplace_floordiv(bool %a, uint %b) {
+ %a = cast bool %a to int
+ %b = cast uint %b to int
+ %r = div int %a, %b
+ %r = cast int %r to uint
+ ret uint %r
+}
+
+internal double %std.truediv(bool %a, uint %b) {
+ %a = cast bool %a to double
+ %b = cast uint %b to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal double %std.inplace_truediv(bool %a, uint %b) {
+ %a = cast bool %a to double
+ %b = cast uint %b to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal uint %std.mod(bool %a, uint %b) {
+ %a = cast bool %a to uint
+ %r = rem uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.inplace_mod(bool %a, uint %b) {
+ %a = cast bool %a to uint
+ %r = rem uint %a, %b
+ ret uint %r
+}
+
+internal bool %std.is_(bool %a, uint %b) {
+ %a = cast bool %a to uint
+ %r = seteq uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.eq(bool %a, uint %b) {
+ %a = cast bool %a to uint
+ %r = seteq uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.lt(bool %a, uint %b) {
+ %a = cast bool %a to uint
+ %r = setlt uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.le(bool %a, uint %b) {
+ %a = cast bool %a to uint
+ %r = setle uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.ge(bool %a, uint %b) {
+ %a = cast bool %a to uint
+ %r = setge uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.gt(bool %a, uint %b) {
+ %a = cast bool %a to uint
+ %r = setgt uint %a, %b
+ ret bool %r
+}
+
+internal bool %std.neq(bool %a, uint %b) {
+ %a = cast bool %a to uint
+ %r = setgt uint %a, %b
+ %r1 = xor bool %r, true
+ ret bool %r1
+}
+
+internal int %std.add(bool %a, int %b) {
+ %a = cast bool %a to int
+ %r = add int %a, %b
+ ret int %r
+}
+
+internal int %std.inplace_add(bool %a, int %b) {
+ %a = cast bool %a to int
+ %r = add int %a, %b
+ ret int %r
+}
+
+internal int %std.sub(bool %a, int %b) {
+ %a = cast bool %a to int
+ %r = sub int %a, %b
+ ret int %r
+}
+
+internal int %std.inplace_sub(bool %a, int %b) {
+ %a = cast bool %a to int
+ %r = sub int %a, %b
+ ret int %r
+}
+
+internal int %std.mul(bool %a, int %b) {
+ %a = cast bool %a to int
+ %r = mul int %a, %b
+ ret int %r
+}
+
+internal int %std.inplace_mul(bool %a, int %b) {
+ %a = cast bool %a to int
+ %r = mul int %a, %b
+ ret int %r
+}
+
+internal int %std.div(bool %a, int %b) {
+ %a = cast bool %a to int
+ %r = div int %a, %b
+ ret int %r
+}
+
+internal int %std.inplace_div(bool %a, int %b) {
+ %a = cast bool %a to int
+ %r = div int %a, %b
+ ret int %r
+}
+
+internal int %std.floordiv(bool %a, int %b) {
+ %a = cast bool %a to int
+ %r = div int %a, %b
+ ret int %r
+}
+
+internal int %std.inplace_floordiv(bool %a, int %b) {
+ %a = cast bool %a to int
+ %r = div int %a, %b
+ ret int %r
+}
+
+internal double %std.truediv(bool %a, int %b) {
+ %a = cast bool %a to double
+ %b = cast int %b to double
+ %r = div double %a, %b
+ ret double %r
+}
-implementation
+internal double %std.inplace_truediv(bool %a, int %b) {
+ %a = cast bool %a to double
+ %b = cast int %b to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal int %std.mod(bool %a, int %b) {
+ %a = cast bool %a to int
+ %r = rem int %a, %b
+ ret int %r
+}
+
+internal int %std.inplace_mod(bool %a, int %b) {
+ %a = cast bool %a to int
+ %r = rem int %a, %b
+ ret int %r
+}
+
+internal bool %std.is_(bool %a, int %b) {
+ %a = cast bool %a to int
+ %r = seteq int %a, %b
+ ret bool %r
+}
-;implementation of space operations for simple types
+internal bool %std.eq(bool %a, int %b) {
+ %a = cast bool %a to int
+ %r = seteq int %a, %b
+ ret bool %r
+}
+internal bool %std.lt(bool %a, int %b) {
+ %a = cast bool %a to int
+ %r = setlt int %a, %b
+ ret bool %r
+}
-declare void %llvm.memmove(sbyte*, sbyte*, uint, uint)
-declare void %llvm.memcpy(sbyte*, sbyte*, uint, uint)
-declare void %llvm.memset(sbyte*, ubyte, uint, uint)
+internal bool %std.le(bool %a, int %b) {
+ %a = cast bool %a to int
+ %r = setle int %a, %b
+ ret bool %r
+}
+internal bool %std.ge(bool %a, int %b) {
+ %a = cast bool %a to int
+ %r = setge int %a, %b
+ ret bool %r
+}
+internal bool %std.gt(bool %a, int %b) {
+ %a = cast bool %a to int
+ %r = setgt int %a, %b
+ ret bool %r
+}
+internal bool %std.neq(bool %a, int %b) {
+ %a = cast bool %a to int
+ %r = setgt int %a, %b
+ %r1 = xor bool %r, true
+ ret bool %r1
+}
-;Basic operations for ints
-internal int %std.add(int %a, int %b) {
+internal int %std.add(bool %a, bool %b) {
+ %a = cast bool %a to int
+ %b = cast bool %b to int
%r = add int %a, %b
ret int %r
}
-internal int %std.inplace_add(int %a, int %b) {
- %r = add int %a, %b
+internal int %std.inplace_add(bool %a, bool %b) {
+ %a = cast bool %a to int
+ %b = cast bool %b to int
+ %r = add int %a, %b
ret int %r
}
-internal int %std.sub(int %a, int %b) {
+internal int %std.sub(bool %a, bool %b) {
+ %a = cast bool %a to int
+ %b = cast bool %b to int
%r = sub int %a, %b
ret int %r
}
-internal int %std.inplace_sub(int %a, int %b) {
+internal int %std.inplace_sub(bool %a, bool %b) {
+ %a = cast bool %a to int
+ %b = cast bool %b to int
%r = sub int %a, %b
ret int %r
}
-internal int %std.mul(int %a, int %b) {
- %r = mul int %a, %b
+internal int %std.mul(bool %a, bool %b) {
+ %a = cast bool %a to int
+ %b = cast bool %b to int
+ %r = mul int %a, %b
ret int %r
}
-internal int %std.inplace_mul(int %a, int %b) {
+internal int %std.inplace_mul(bool %a, bool %b) {
+ %a = cast bool %a to int
+ %b = cast bool %b to int
%r = mul int %a, %b
ret int %r
}
-internal int %std.div(int %a, int %b) {
+internal int %std.div(bool %a, bool %b) {
+ %a = cast bool %a to int
+ %b = cast bool %b to int
%r = div int %a, %b
ret int %r
}
-internal int %std.inplace_div(int %a, int %b) {
+internal int %std.inplace_div(bool %a, bool %b) {
+ %a = cast bool %a to int
+ %b = cast bool %b to int
%r = div int %a, %b
ret int %r
}
-internal int %std.floordiv(int %a, int %b) {
+internal bool %std.floordiv(bool %a, bool %b) {
+ %a = cast bool %a to int
+ %b = cast bool %b to int
%r = div int %a, %b
- ret int %r
+ %r = cast int %r to bool
+ ret bool %r
}
-internal int %std.inplace_floordiv(int %a, int %b) {
+internal bool %std.inplace_floordiv(bool %a, bool %b) {
+ %a = cast bool %a to int
+ %b = cast bool %b to int
%r = div int %a, %b
- ret int %r
+ %r = cast int %r to bool
+ ret bool %r
}
-internal int %std.mod(int %a, int %b) {
- %r = rem int %a, %b
- ret int %r
+internal double %std.truediv(bool %a, bool %b) {
+ %a = cast bool %a to double
+ %b = cast bool %b to double
+ %r = div double %a, %b
+ ret double %r
}
-internal int %std.inplace_mod(int %a, int %b) {
- %r = rem int %a, %b
+internal double %std.inplace_truediv(bool %a, bool %b) {
+ %a = cast bool %a to double
+ %b = cast bool %b to double
+ %r = div double %a, %b
+ ret double %r
+}
+
+internal int %std.mod(bool %a, bool %b) {
+ %a = cast bool %a to int
+ %b = cast bool %b to int
+ %r = rem int %a, %b
ret int %r
}
-;Basic operations for doubles
-internal double %std.add(double %a, double %b) {
- %r = add double %a, %b
- ret double %r
+internal int %std.inplace_mod(bool %a, bool %b) {
+ %a = cast bool %a to int
+ %b = cast bool %b to int
+ %r = rem int %a, %b
+ ret int %r
}
-internal double %std.inplace_add(double %a, double %b) {
- %r = add double %a, %b
- ret double %r
+internal bool %std.is_(bool %a, bool %b) {
+ %r = seteq bool %a, %b
+ ret bool %r
}
-internal double %std.sub(double %a, double %b) {
- %r = sub double %a, %b
- ret double %r
+internal bool %std.eq(bool %a, bool %b) {
+ %r = seteq bool %a, %b
+ ret bool %r
}
-internal double %std.inplace_sub(double %a, double %b) {
- %r = sub double %a, %b
- ret double %r
+internal bool %std.lt(bool %a, bool %b) {
+ %r = setlt bool %a, %b
+ ret bool %r
}
-internal double %std.mul(double %a, double %b) {
- %r = mul double %a, %b
- ret double %r
+internal bool %std.le(bool %a, bool %b) {
+ %r = setle bool %a, %b
+ ret bool %r
}
-internal double %std.inplace_mul(double %a, double %b) {
- %r = mul double %a, %b
- ret double %r
+internal bool %std.ge(bool %a, bool %b) {
+ %r = setge bool %a, %b
+ ret bool %r
}
-internal double %std.div(double %a, double %b) {
- %r = div double %a, %b
- ret double %r
+internal bool %std.gt(bool %a, bool %b) {
+ %r = setgt bool %a, %b
+ ret bool %r
}
-internal double %std.inplace_div(double %a, double %b) {
- %r = div double %a, %b
- ret double %r
+internal bool %std.neq(bool %a, bool %b) {
+ %r = setgt bool %a, %b
+ %r1 = xor bool %r, true
+ ret bool %r1
}
-internal double %std.floordiv(double %a, double %b) {
- %r = div double %a, %b
- ret double %r
+internal uint %std.and_(uint %a, uint %b) {
+ %r = and uint %a, %b
+ ret uint %r
}
-internal double %std.inplace_floordiv(double %a, double %b) {
- %r = div double %a, %b
- ret double %r
+internal uint %std.inplace_and(uint %a, uint %b) {
+ %r = and uint %a, %b
+ ret uint %r
}
-internal double %std.mod(double %a, double %b) {
- %r = rem double %a, %b
- ret double %r
+internal uint %std.or_(uint %a, uint %b) {
+ %r = or uint %a, %b
+ ret uint %r
}
-internal double %std.inplace_mod(double %a, double %b) {
- %r = rem double %a, %b
- ret double %r
+internal uint %std.inplace_or(uint %a, uint %b) {
+ %r = or uint %a, %b
+ ret uint %r
}
-;Basic comparisons for doubles
+internal uint %std.xor(uint %a, uint %b) {
+ %r = xor uint %a, %b
+ ret uint %r
+}
-internal bool %std.is(double %a, double %b) {
- %r = seteq double %a, %b
- ret bool %r
+internal uint %std.inplace_xor(uint %a, uint %b) {
+ %r = xor uint %a, %b
+ ret uint %r
}
-internal bool %std.is_true(double %a) {
- %b = cast double %a to bool
- ret bool %b
+internal uint %std.and_(uint %a, int %b) {
+ %b = cast int %b to uint
+ %r = and uint %a, %b
+ ret uint %r
}
-internal bool %std.eq(double %a, double %b) {
- %r = seteq double %a, %b
- ret bool %r
+internal uint %std.inplace_and(uint %a, int %b) {
+ %b = cast int %b to uint
+ %r = and uint %a, %b
+ ret uint %r
}
-internal bool %std.neq(double %a, double %b) {
- %r = seteq double %a, %b
- %r1 = xor bool %r, true
- ret bool %r1
+internal uint %std.or_(uint %a, int %b) {
+ %b = cast int %b to uint
+ %r = or uint %a, %b
+ ret uint %r
}
-internal bool %std.lt(double %a, double %b) {
- %r = setlt double %a, %b
- ret bool %r
+internal uint %std.inplace_or(uint %a, int %b) {
+ %b = cast int %b to uint
+ %r = or uint %a, %b
+ ret uint %r
}
-internal bool %std.gt(double %a, double %b) {
- %r = setgt double %a, %b
- ret bool %r
+internal uint %std.xor(uint %a, int %b) {
+ %b = cast int %b to uint
+ %r = xor uint %a, %b
+ ret uint %r
}
-internal bool %std.le(double %a, double %b) {
- %r = setle double %a, %b
- ret bool %r
+internal uint %std.inplace_xor(uint %a, int %b) {
+ %b = cast int %b to uint
+ %r = xor uint %a, %b
+ ret uint %r
}
-internal bool %std.ge(double %a, double %b) {
- %r = setge double %a, %b
- ret bool %r
+internal uint %std.and_(uint %a, bool %b) {
+ %b = cast bool %b to uint
+ %r = and uint %a, %b
+ ret uint %r
}
-;Basic comparisons for ints
+internal uint %std.inplace_and(uint %a, bool %b) {
+ %b = cast bool %b to uint
+ %r = and uint %a, %b
+ ret uint %r
+}
-internal bool %std.is(int %a, int %b) {
- %r = seteq int %a, %b
- ret bool %r
+internal uint %std.or_(uint %a, bool %b) {
+ %b = cast bool %b to uint
+ %r = or uint %a, %b
+ ret uint %r
}
-internal bool %std.is_true(int %a) {
- %b = cast int %a to bool
- ret bool %b
+internal uint %std.inplace_or(uint %a, bool %b) {
+ %b = cast bool %b to uint
+ %r = or uint %a, %b
+ ret uint %r
}
-internal bool %std.eq(int %a, int %b) {
- %r = seteq int %a, %b
- ret bool %r
+internal uint %std.xor(uint %a, bool %b) {
+ %b = cast bool %b to uint
+ %r = xor uint %a, %b
+ ret uint %r
}
-internal bool %std.neq(int %a, int %b) {
- %r = seteq int %a, %b
- %r1 = xor bool %r, true
- ret bool %r1
+internal uint %std.inplace_xor(uint %a, bool %b) {
+ %b = cast bool %b to uint
+ %r = xor uint %a, %b
+ ret uint %r
}
-internal bool %std.lt(int %a, int %b) {
- %r = setlt int %a, %b
- ret bool %r
+internal uint %std.and_(int %a, uint %b) {
+ %a = cast int %a to uint
+ %r = and uint %a, %b
+ ret uint %r
}
-internal bool %std.gt(int %a, int %b) {
- %r = setgt int %a, %b
- ret bool %r
+internal uint %std.inplace_and(int %a, uint %b) {
+ %a = cast int %a to uint
+ %r = and uint %a, %b
+ ret uint %r
}
-internal bool %std.le(int %a, int %b) {
- %r = setle int %a, %b
- ret bool %r
+internal uint %std.or_(int %a, uint %b) {
+ %a = cast int %a to uint
+ %r = or uint %a, %b
+ ret uint %r
}
-internal bool %std.ge(int %a, int %b) {
- %r = setge int %a, %b
- ret bool %r
+internal uint %std.inplace_or(int %a, uint %b) {
+ %a = cast int %a to uint
+ %r = or uint %a, %b
+ ret uint %r
}
+internal uint %std.xor(int %a, uint %b) {
+ %a = cast int %a to uint
+ %r = xor uint %a, %b
+ ret uint %r
+}
-;Logical operations for ints
+internal uint %std.inplace_xor(int %a, uint %b) {
+ %a = cast int %a to uint
+ %r = xor uint %a, %b
+ ret uint %r
+}
internal int %std.and_(int %a, int %b) {
%r = and int %a, %b
@@ -232,7 +2189,7 @@
ret int %r
}
-internal int %std.or(int %a, int %b) {
+internal int %std.or_(int %a, int %b) {
%r = or int %a, %b
ret int %r
}
@@ -252,31 +2209,249 @@
ret int %r
}
+internal int %std.and_(int %a, bool %b) {
+ %b = cast bool %b to int
+ %r = and int %a, %b
+ ret int %r
+}
+
+internal int %std.inplace_and(int %a, bool %b) {
+ %b = cast bool %b to int
+ %r = and int %a, %b
+ ret int %r
+}
+
+internal int %std.or_(int %a, bool %b) {
+ %b = cast bool %b to int
+ %r = or int %a, %b
+ ret int %r
+}
+
+internal int %std.inplace_or(int %a, bool %b) {
+ %b = cast bool %b to int
+ %r = or int %a, %b
+ ret int %r
+}
+
+internal int %std.xor(int %a, bool %b) {
+ %b = cast bool %b to int
+ %r = xor int %a, %b
+ ret int %r
+}
+
+internal int %std.inplace_xor(int %a, bool %b) {
+ %b = cast bool %b to int
+ %r = xor int %a, %b
+ ret int %r
+}
+
+internal uint %std.and_(bool %a, uint %b) {
+ %a = cast bool %a to uint
+ %r = and uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.inplace_and(bool %a, uint %b) {
+ %a = cast bool %a to uint
+ %r = and uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.or_(bool %a, uint %b) {
+ %a = cast bool %a to uint
+ %r = or uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.inplace_or(bool %a, uint %b) {
+ %a = cast bool %a to uint
+ %r = or uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.xor(bool %a, uint %b) {
+ %a = cast bool %a to uint
+ %r = xor uint %a, %b
+ ret uint %r
+}
+
+internal uint %std.inplace_xor(bool %a, uint %b) {
+ %a = cast bool %a to uint
+ %r = xor uint %a, %b
+ ret uint %r
+}
+
+internal int %std.and_(bool %a, int %b) {
+ %a = cast bool %a to int
+ %r = and int %a, %b
+ ret int %r
+}
+
+internal int %std.inplace_and(bool %a, int %b) {
+ %a = cast bool %a to int
+ %r = and int %a, %b
+ ret int %r
+}
+
+internal int %std.or_(bool %a, int %b) {
+ %a = cast bool %a to int
+ %r = or int %a, %b
+ ret int %r
+}
+
+internal int %std.inplace_or(bool %a, int %b) {
+ %a = cast bool %a to int
+ %r = or int %a, %b
+ ret int %r
+}
+
+internal int %std.xor(bool %a, int %b) {
+ %a = cast bool %a to int
+ %r = xor int %a, %b
+ ret int %r
+}
+
+internal int %std.inplace_xor(bool %a, int %b) {
+ %a = cast bool %a to int
+ %r = xor int %a, %b
+ ret int %r
+}
+
+internal bool %std.and_(bool %a, bool %b) {
+ %r = and bool %a, %b
+ ret bool %r
+}
+
+internal bool %std.inplace_and(bool %a, bool %b) {
+ %r = and bool %a, %b
+ ret bool %r
+}
+
+internal bool %std.or_(bool %a, bool %b) {
+ %r = or bool %a, %b
+ ret bool %r
+}
+
+internal bool %std.inplace_or(bool %a, bool %b) {
+ %r = or bool %a, %b
+ ret bool %r
+}
+
+internal bool %std.xor(bool %a, bool %b) {
+ %r = xor bool %a, %b
+ ret bool %r
+}
+
+internal bool %std.inplace_xor(bool %a, bool %b) {
+ %r = xor bool %a, %b
+ ret bool %r
+}
+
+internal uint %std.lshift(uint %a, uint %b) {
+ %b = cast uint %b to ubyte
+ %r = shl uint %a, ubyte %b
+ ret uint %r
+}
+
+internal uint %std.rshift(uint %a, uint %b) {
+ %b = cast uint %b to ubyte
+ %r = shr uint %a, ubyte %b
+ ret uint %r
+}
+
+internal uint %std.lshift(uint %a, int %b) {
+ %b = cast int %b to ubyte
+ %r = shl uint %a, ubyte %b
+ ret uint %r
+}
+
+internal uint %std.rshift(uint %a, int %b) {
+ %b = cast int %b to ubyte
+ %r = shr uint %a, ubyte %b
+ ret uint %r
+}
+
+internal int %std.lshift(int %a, uint %b) {
+ %b = cast uint %b to ubyte
+ %r = shl int %a, ubyte %b
+ ret int %r
+}
+
+internal int %std.rshift(int %a, uint %b) {
+ %b = cast uint %b to ubyte
+ %r = shr int %a, ubyte %b
+ ret int %r
+}
+
internal int %std.lshift(int %a, int %b) {
- %shift = cast int %b to ubyte
- %r = shl int %a, ubyte %shift
+ %b = cast int %b to ubyte
+ %r = shl int %a, ubyte %b
ret int %r
}
internal int %std.rshift(int %a, int %b) {
- %shift = cast int %b to ubyte
- %r = shr int %a, ubyte %shift
+ %b = cast int %b to ubyte
+ %r = shr int %a, ubyte %b
ret int %r
}
+internal int %std.int(double %a) {
+ %r = cast double %a to int
+ ret int %r
+}
-;bools
-internal bool %std.is_true(bool %a) {
- ret bool %a
+internal bool %std.bool(double %a) {
+ %r = cast double %a to bool
+ ret bool %r
+}
+
+internal bool %std.is_true(double %a) {
+ %r = cast double %a to bool
+ ret bool %r
+}
+
+internal int %std.int(uint %a) {
+ %r = cast uint %a to int
+ ret int %r
+}
+
+internal bool %std.bool(uint %a) {
+ %r = cast uint %a to bool
+ ret bool %r
+}
+
+internal bool %std.is_true(uint %a) {
+ %r = cast uint %a to bool
+ ret bool %r
+}
+
+internal int %std.int(int %a) {
+ %r = cast int %a to int
+ ret int %r
+}
+
+internal bool %std.bool(int %a) {
+ %r = cast int %a to bool
+ ret bool %r
}
-internal bool %std.and(bool %a, bool %b) {
- %r = and bool %a, %b
+internal bool %std.is_true(int %a) {
+ %r = cast int %a to bool
+ ret bool %r
+}
+
+internal int %std.int(bool %a) {
+ %r = cast bool %a to int
+ ret int %r
+}
+
+internal bool %std.bool(bool %a) {
+ %r = cast bool %a to bool
ret bool %r
}
-internal bool %std.or(bool %a, bool %b) {
- %r = or bool %a, %b
+internal bool %std.is_true(bool %a) {
+ %r = cast bool %a to bool
ret bool %r
}
Modified: pypy/dist/pypy/translator/llvm/test/llvmsnippet.py
==============================================================================
--- pypy/dist/pypy/translator/llvm/test/llvmsnippet.py (original)
+++ pypy/dist/pypy/translator/llvm/test/llvmsnippet.py Fri Apr 8 04:05:05 2005
@@ -47,6 +47,8 @@
def float_f1(x):
return x + 1.0
+def float_int_bool(x):
+ return x * (2 + True)
#array snippets
@@ -311,8 +313,10 @@
self.n = n
def raises(i):
- if i:
- raise MyException, 10
+ if i == 3:
+ raise MyException, 12
+ if i == 4:
+ raise IndexError
return 1
def catches(i):
Modified: pypy/dist/pypy/translator/llvm/test/test_genllvm.py
==============================================================================
--- pypy/dist/pypy/translator/llvm/test/test_genllvm.py (original)
+++ pypy/dist/pypy/translator/llvm/test/test_genllvm.py Fri Apr 8 04:05:05 2005
@@ -1,3 +1,4 @@
+from __future__ import division
import autopath
import py
@@ -124,7 +125,10 @@
def test_float_f1(self):
f = compile_function(llvmsnippet.float_f1, [float])
assert f(1.0) == 2.0
-
+
+ def test_float_int_bool(self):
+ f = compile_function(llvmsnippet.float_int_bool, [float])
+ assert f(3.0) == 9.0
class TestLLVMArray(object):
def setup_method(self, method):
More information about the Pypy-commit
mailing list