Commit d1e68c3ca8

@@ -143,7 +143,7 @@ StructLiteralField = "." Symbol "=" Expression
 
 PrefixOp = "!" | "-" | "~" | "*" | ("&" option("const") option("volatile")) | "?" | "%" | "%%" | "??" | "-%"
 
-PrimaryExpression = Number | String | CharLiteral | KeywordLiteral | GroupedExpression | GotoExpression | BlockExpression(BlockOrExpression) | Symbol | ("@" Symbol FnCallExpression) | ArrayType | (option("extern") FnProto) | AsmExpression | ("error" "." Symbol) | ContainerDecl
+PrimaryExpression = Integer | Float | String | CharLiteral | KeywordLiteral | GroupedExpression | GotoExpression | BlockExpression(BlockOrExpression) | Symbol | ("@" Symbol FnCallExpression) | ArrayType | (option("extern") FnProto) | AsmExpression | ("error" "." Symbol) | ContainerDecl
 
 ArrayType = "[" option(Expression) "]" option("const") TypeExpr
 

@@ -13,7 +13,8 @@
 #include "zig_llvm.hpp"
 #include "hash_map.hpp"
 #include "errmsg.hpp"
-#include "bignum.hpp"
+#include "bigint.hpp"
+#include "bigfloat.hpp"
 #include "target.hpp"
 
 struct AstNode;
@@ -215,6 +216,11 @@ struct ConstGlobalRefs {
     LLVMValueRef llvm_global;
 };
 
+enum ConstNumLitKind {
+    ConstNumLitKindInt,
+    ConstNumLitKindFloat,
+};
+
 struct ConstExprValue {
     TypeTableEntry *type;
     ConstValSpecial special;
@@ -222,7 +228,8 @@ struct ConstExprValue {
 
     union {
         // populated if special == ConstValSpecialStatic
-        BigNum x_bignum;
+        BigInt x_bigint;
+        BigFloat x_bigfloat;
         bool x_bool;
         ConstFn x_fn;
         ConstBoundFnValue x_bound_fn;
@@ -347,7 +354,8 @@ enum NodeType {
     NodeTypeTestDecl,
     NodeTypeBinOpExpr,
     NodeTypeUnwrapErrorExpr,
-    NodeTypeNumberLiteral,
+    NodeTypeFloatLiteral,
+    NodeTypeIntLiteral,
     NodeTypeStringLiteral,
     NodeTypeCharLiteral,
     NodeTypeSymbol,
@@ -748,14 +756,18 @@ struct AstNodeCharLiteral {
     uint8_t value;
 };
 
-struct AstNodeNumberLiteral {
-    BigNum *bignum;
+struct AstNodeFloatLiteral {
+    BigFloat *bigfloat;
 
     // overflow is true if when parsing the number, we discovered it would not
-    // fit without losing data in a uint64_t or double
+    // fit without losing data in a double
     bool overflow;
 };
 
+struct AstNodeIntLiteral {
+    BigInt *bigint;
+};
+
 struct AstNodeStructValueField {
     Buf *name;
     AstNode *expr;
@@ -854,7 +866,8 @@ struct AstNode {
         AstNodeStructField struct_field;
         AstNodeStringLiteral string_literal;
         AstNodeCharLiteral char_literal;
-        AstNodeNumberLiteral number_literal;
+        AstNodeFloatLiteral float_literal;
+        AstNodeIntLiteral int_literal;
         AstNodeContainerInitExpr container_init_expr;
         AstNodeStructValueField struct_val_field;
         AstNodeNullLiteral null_literal;

@@ -2194,7 +2194,8 @@ void scan_decls(CodeGen *g, ScopeDecls *decls_scope, AstNode *node) {
         case NodeTypeFnCallExpr:
         case NodeTypeArrayAccessExpr:
         case NodeTypeSliceExpr:
-        case NodeTypeNumberLiteral:
+        case NodeTypeFloatLiteral:
+        case NodeTypeIntLiteral:
         case NodeTypeStringLiteral:
         case NodeTypeCharLiteral:
         case NodeTypeBoolLiteral:
@@ -3247,10 +3248,17 @@ static uint32_t hash_const_val(ConstExprValue *const_val) {
         case TypeTableEntryIdInt:
         case TypeTableEntryIdNumLitInt:
         case TypeTableEntryIdEnumTag:
-            return ((uint32_t)(bignum_to_twos_complement(&const_val->data.x_bignum) % UINT32_MAX)) * (uint32_t)1331471175;
+            {
+                uint32_t result = 1331471175;
+                for (size_t i = 0; i < const_val->data.x_bigint.digit_count; i += 1) {
+                    uint64_t digit = bigint_ptr(&const_val->data.x_bigint)[i];
+                    result ^= ((uint32_t)(digit >> 32)) ^ (uint32_t)(result);
+                }
+                return result;
+            }
         case TypeTableEntryIdFloat:
         case TypeTableEntryIdNumLitFloat:
-            return (uint32_t)(const_val->data.x_bignum.data.x_float * (uint32_t)UINT32_MAX);
+            return (uint32_t)(const_val->data.x_bigfloat.value * (uint32_t)UINT32_MAX);
         case TypeTableEntryIdArgTuple:
             return (uint32_t)const_val->data.x_arg_tuple.start_index * (uint32_t)281907309 +
                 (uint32_t)const_val->data.x_arg_tuple.end_index * (uint32_t)2290442768;
@@ -3473,7 +3481,7 @@ void init_const_str_lit(CodeGen *g, ConstExprValue *const_val, Buf *str) {
         ConstExprValue *this_char = &const_val->data.x_array.s_none.elements[i];
         this_char->special = ConstValSpecialStatic;
         this_char->type = g->builtin_types.entry_u8;
-        bignum_init_unsigned(&this_char->data.x_bignum, (uint8_t)buf_ptr(str)[i]);
+        bigint_init_unsigned(&this_char->data.x_bigint, (uint8_t)buf_ptr(str)[i]);
     }
 }
 
@@ -3494,12 +3502,12 @@ void init_const_c_str_lit(CodeGen *g, ConstExprValue *const_val, Buf *str) {
         ConstExprValue *this_char = &array_val->data.x_array.s_none.elements[i];
         this_char->special = ConstValSpecialStatic;
         this_char->type = g->builtin_types.entry_u8;
-        bignum_init_unsigned(&this_char->data.x_bignum, (uint8_t)buf_ptr(str)[i]);
+        bigint_init_unsigned(&this_char->data.x_bigint, (uint8_t)buf_ptr(str)[i]);
     }
     ConstExprValue *null_char = &array_val->data.x_array.s_none.elements[len_with_null - 1];
     null_char->special = ConstValSpecialStatic;
     null_char->type = g->builtin_types.entry_u8;
-    bignum_init_unsigned(&null_char->data.x_bignum, 0);
+    bigint_init_unsigned(&null_char->data.x_bigint, 0);
 
     // then make the pointer point to it
     const_val->special = ConstValSpecialStatic;
@@ -3518,8 +3526,8 @@ ConstExprValue *create_const_c_str_lit(CodeGen *g, Buf *str) {
 void init_const_unsigned_negative(ConstExprValue *const_val, TypeTableEntry *type, uint64_t x, bool negative) {
     const_val->special = ConstValSpecialStatic;
     const_val->type = type;
-    bignum_init_unsigned(&const_val->data.x_bignum, x);
-    const_val->data.x_bignum.is_negative = negative;
+    bigint_init_unsigned(&const_val->data.x_bigint, x);
+    const_val->data.x_bigint.is_negative = negative;
 }
 
 ConstExprValue *create_const_unsigned_negative(TypeTableEntry *type, uint64_t x, bool negative) {
@@ -3539,7 +3547,7 @@ ConstExprValue *create_const_usize(CodeGen *g, uint64_t x) {
 void init_const_signed(ConstExprValue *const_val, TypeTableEntry *type, int64_t x) {
     const_val->special = ConstValSpecialStatic;
     const_val->type = type;
-    bignum_init_signed(&const_val->data.x_bignum, x);
+    bigint_init_signed(&const_val->data.x_bigint, x);
 }
 
 ConstExprValue *create_const_signed(TypeTableEntry *type, int64_t x) {
@@ -3551,7 +3559,7 @@ ConstExprValue *create_const_signed(TypeTableEntry *type, int64_t x) {
 void init_const_float(ConstExprValue *const_val, TypeTableEntry *type, double value) {
     const_val->special = ConstValSpecialStatic;
     const_val->type = type;
-    bignum_init_float(&const_val->data.x_bignum, value);
+    bigfloat_init_float(&const_val->data.x_bigfloat, value);
 }
 
 ConstExprValue *create_const_float(TypeTableEntry *type, double value) {
@@ -3788,12 +3796,13 @@ bool const_values_equal(ConstExprValue *a, ConstExprValue *b) {
             return a->data.x_fn.fn_entry == b->data.x_fn.fn_entry;
         case TypeTableEntryIdBool:
             return a->data.x_bool == b->data.x_bool;
-        case TypeTableEntryIdInt:
         case TypeTableEntryIdFloat:
         case TypeTableEntryIdNumLitFloat:
+            return bigfloat_cmp(&a->data.x_bigfloat, &b->data.x_bigfloat) == CmpEQ;
+        case TypeTableEntryIdInt:
         case TypeTableEntryIdNumLitInt:
         case TypeTableEntryIdEnumTag:
-            return bignum_cmp_eq(&a->data.x_bignum, &b->data.x_bignum);
+            return bigint_cmp(&a->data.x_bigint, &b->data.x_bigint) == CmpEQ;
         case TypeTableEntryIdPointer:
             if (a->data.x_ptr.special != b->data.x_ptr.special)
                 return false;
@@ -3876,58 +3885,47 @@ bool const_values_equal(ConstExprValue *a, ConstExprValue *b) {
     zig_unreachable();
 }
 
-uint64_t max_unsigned_val(TypeTableEntry *type_entry) {
-    assert(type_entry->id == TypeTableEntryIdInt);
-    if (type_entry->data.integral.bit_count == 64) {
-        return UINT64_MAX;
-    } else {
-        return (((uint64_t)1) << type_entry->data.integral.bit_count) - 1;
+void eval_min_max_value_int(CodeGen *g, TypeTableEntry *int_type, BigInt *bigint, bool is_max) {
+    assert(int_type->id == TypeTableEntryIdInt);
+    if (int_type->data.integral.bit_count == 0) {
+        bigint_init_unsigned(bigint, 0);
+        return;
     }
-}
+    if (is_max) {
+        // is_signed=true   (1 << (bit_count - 1)) - 1
+        // is_signed=false  (1 << (bit_count - 0)) - 1
+        BigInt one = {0};
+        bigint_init_unsigned(&one, 1);
 
-static int64_t max_signed_val(TypeTableEntry *type_entry) {
-    assert(type_entry->id == TypeTableEntryIdInt);
+        size_t shift_amt = int_type->data.integral.bit_count - (int_type->data.integral.is_signed ? 1 : 0);
+        BigInt bit_count_bi = {0};
+        bigint_init_unsigned(&bit_count_bi, shift_amt);
 
-    if (type_entry->data.integral.bit_count == 64) {
-        return INT64_MAX;
-    } else {
-        return (((uint64_t)1) << (type_entry->data.integral.bit_count - 1)) - 1;
-    }
-}
+        BigInt shifted_bi = {0};
+        bigint_shl(&shifted_bi, &one, &bit_count_bi);
 
-int64_t min_signed_val(TypeTableEntry *type_entry) {
-    assert(type_entry->id == TypeTableEntryIdInt);
-    if (type_entry->data.integral.bit_count == 64) {
-        return INT64_MIN;
-    } else {
-        return -((int64_t)(((uint64_t)1) << (type_entry->data.integral.bit_count - 1)));
-    }
-}
+        bigint_sub(bigint, &shifted_bi, &one);
+    } else if (int_type->data.integral.is_signed) {
+        // - (1 << (bit_count - 1))
+        BigInt one = {0};
+        bigint_init_unsigned(&one, 1);
 
-void eval_min_max_value_int(CodeGen *g, TypeTableEntry *int_type, BigNum *bignum, bool is_max) {
-    assert(int_type->id == TypeTableEntryIdInt);
-    if (is_max) {
-        if (int_type->data.integral.is_signed) {
-            int64_t val = max_signed_val(int_type);
-            bignum_init_signed(bignum, val);
-        } else {
-            uint64_t val = max_unsigned_val(int_type);
-            bignum_init_unsigned(bignum, val);
-        }
+        BigInt bit_count_bi = {0};
+        bigint_init_unsigned(&bit_count_bi, int_type->data.integral.bit_count - 1);
+
+        BigInt shifted_bi = {0};
+        bigint_shl(&shifted_bi, &one, &bit_count_bi);
+
+        bigint_negate(bigint, &shifted_bi);
     } else {
-        if (int_type->data.integral.is_signed) {
-            int64_t val = min_signed_val(int_type);
-            bignum_init_signed(bignum, val);
-        } else {
-            bignum_init_unsigned(bignum, 0);
-        }
+        bigint_init_unsigned(bigint, 0);
     }
 }
 
 void eval_min_max_value(CodeGen *g, TypeTableEntry *type_entry, ConstExprValue *const_val, bool is_max) {
     if (type_entry->id == TypeTableEntryIdInt) {
         const_val->special = ConstValSpecialStatic;
-        eval_min_max_value_int(g, type_entry, &const_val->data.x_bignum, is_max);
+        eval_min_max_value_int(g, type_entry, &const_val->data.x_bigint, is_max);
     } else if (type_entry->id == TypeTableEntryIdFloat) {
         zig_panic("TODO analyze_min_max_value float");
     } else if (type_entry->id == TypeTableEntryIdBool) {
@@ -3967,32 +3965,15 @@ void render_const_value(CodeGen *g, Buf *buf, ConstExprValue *const_val) {
             buf_appendf(buf, "{}");
             return;
         case TypeTableEntryIdNumLitFloat:
-            buf_appendf(buf, "%f", const_val->data.x_bignum.data.x_float);
+        case TypeTableEntryIdFloat:
+            bigfloat_write_buf(buf, &const_val->data.x_bigfloat);
             return;
         case TypeTableEntryIdNumLitInt:
-            {
-                BigNum *bignum = &const_val->data.x_bignum;
-                const char *negative_str = bignum->is_negative ? "-" : "";
-                buf_appendf(buf, "%s%" ZIG_PRI_llu, negative_str, bignum->data.x_uint);
-                return;
-            }
-        case TypeTableEntryIdMetaType:
-            buf_appendf(buf, "%s", buf_ptr(&const_val->data.x_type->name));
-            return;
         case TypeTableEntryIdInt:
-            {
-                BigNum *bignum = &const_val->data.x_bignum;
-                assert(bignum->kind == BigNumKindInt);
-                const char *negative_str = bignum->is_negative ? "-" : "";
-                buf_appendf(buf, "%s%" ZIG_PRI_llu, negative_str, bignum->data.x_uint);
-            }
+            bigint_write_buf(buf, &const_val->data.x_bigint, 10);
             return;
-        case TypeTableEntryIdFloat:
-            {
-                BigNum *bignum = &const_val->data.x_bignum;
-                assert(bignum->kind == BigNumKindFloat);
-                buf_appendf(buf, "%f", bignum->data.x_float);
-            }
+        case TypeTableEntryIdMetaType:
+            buf_appendf(buf, "%s", buf_ptr(&const_val->data.x_type->name));
             return;
         case TypeTableEntryIdUnreachable:
             buf_appendf(buf, "@unreachable()");
@@ -4060,7 +4041,7 @@ void render_const_value(CodeGen *g, Buf *buf, ConstExprValue *const_val) {
                     buf_append_char(buf, '"');
                     for (uint64_t i = 0; i < len; i += 1) {
                         ConstExprValue *child_value = &const_val->data.x_array.s_none.elements[i];
-                        uint64_t big_c = child_value->data.x_bignum.data.x_uint;
+                        uint64_t big_c = bigint_as_unsigned(&child_value->data.x_bigint);
                         assert(big_c <= UINT8_MAX);
                         uint8_t c = (uint8_t)big_c;
                         if (c == '"') {
@@ -4146,7 +4127,8 @@ void render_const_value(CodeGen *g, Buf *buf, ConstExprValue *const_val) {
         case TypeTableEntryIdEnumTag:
             {
                 TypeTableEntry *enum_type = type_entry->data.enum_tag.enum_type;
-                TypeEnumField *field = &enum_type->data.enumeration.fields[const_val->data.x_bignum.data.x_uint];
+                size_t field_index = bigint_as_unsigned(&const_val->data.x_bigint);
+                TypeEnumField *field = &enum_type->data.enumeration.fields[field_index];
                 buf_appendf(buf, "%s.%s", buf_ptr(&enum_type->name), buf_ptr(field->name));
                 return;
             }

@@ -84,9 +84,7 @@ void complete_enum(CodeGen *g, TypeTableEntry *enum_type);
 bool ir_get_var_is_comptime(VariableTableEntry *var);
 bool const_values_equal(ConstExprValue *a, ConstExprValue *b);
 void eval_min_max_value(CodeGen *g, TypeTableEntry *type_entry, ConstExprValue *const_val, bool is_max);
-void eval_min_max_value_int(CodeGen *g, TypeTableEntry *int_type, BigNum *bignum, bool is_max);
-int64_t min_signed_val(TypeTableEntry *type_entry);
-uint64_t max_unsigned_val(TypeTableEntry *type_entry);
+void eval_min_max_value_int(CodeGen *g, TypeTableEntry *int_type, BigInt *bigint, bool is_max);
 
 void render_const_value(CodeGen *g, Buf *buf, ConstExprValue *const_val);
 void define_local_param_variables(CodeGen *g, FnTableEntry *fn_table_entry, VariableTableEntry **arg_vars);

@@ -182,8 +182,10 @@ static const char *node_type_str(NodeType node_type) {
             return "ErrorValueDecl";
         case NodeTypeTestDecl:
             return "TestDecl";
-        case NodeTypeNumberLiteral:
-            return "NumberLiteral";
+        case NodeTypeIntLiteral:
+            return "IntLiteral";
+        case NodeTypeFloatLiteral:
+            return "FloatLiteral";
         case NodeTypeStringLiteral:
             return "StringLiteral";
         case NodeTypeCharLiteral:
@@ -536,17 +538,20 @@ static void render_node_extra(AstRender *ar, AstNode *node, bool grouped) {
             render_node_ungrouped(ar, node->data.bin_op_expr.op2);
             if (!grouped) fprintf(ar->f, ")");
             break;
-        case NodeTypeNumberLiteral:
-            switch (node->data.number_literal.bignum->kind) {
-                case BigNumKindInt:
-                    {
-                        const char *negative_str = node->data.number_literal.bignum->is_negative ? "-" : "";
-                        fprintf(ar->f, "%s%" ZIG_PRI_llu, negative_str, node->data.number_literal.bignum->data.x_uint);
-                    }
-                    break;
-                case BigNumKindFloat:
-                    fprintf(ar->f, "%f", node->data.number_literal.bignum->data.x_float);
-                    break;
+        case NodeTypeFloatLiteral:
+            {
+                Buf rendered_buf = BUF_INIT;
+                buf_resize(&rendered_buf, 0);
+                bigfloat_write_buf(&rendered_buf, node->data.float_literal.bigfloat);
+                fprintf(ar->f, "%s", buf_ptr(&rendered_buf));
+            }
+            break;
+        case NodeTypeIntLiteral:
+            {
+                Buf rendered_buf = BUF_INIT;
+                buf_resize(&rendered_buf, 0);
+                bigint_write_buf(&rendered_buf, node->data.int_literal.bigint, 10);
+                fprintf(ar->f, "%s", buf_ptr(&rendered_buf));
             }
             break;
         case NodeTypeStringLiteral:

@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) 2017 Andrew Kelley
+ *
+ * This file is part of zig, which is MIT licensed.
+ * See http://opensource.org/licenses/MIT
+ */
+
+#include "bigfloat.hpp"
+#include "bigint.hpp"
+#include "buffer.hpp"
+#include <math.h>
+#include <errno.h>
+
+void bigfloat_init_float(BigFloat *dest, long double x) {
+    dest->value = x;
+}
+
+void bigfloat_init_bigfloat(BigFloat *dest, const BigFloat *x) {
+    dest->value = x->value;
+}
+
+void bigfloat_init_bigint(BigFloat *dest, const BigInt *op) {
+    dest->value = 0.0;
+    if (op->digit_count == 0)
+        return;
+
+    long double base = (long double)UINT64_MAX;
+    const uint64_t *digits = bigint_ptr(op);
+
+    for (size_t i = op->digit_count - 1;;) {
+        uint64_t digit = digits[i];
+        dest->value *= base;
+        dest->value += (long double)digit;
+
+        if (i == 0) {
+            if (op->is_negative) {
+                dest->value = -dest->value;
+            }
+            return;
+        }
+        i -= 1;
+    }
+}
+
+int bigfloat_init_buf_base10(BigFloat *dest, const uint8_t *buf_ptr, size_t buf_len) {
+    char *str_begin = (char *)buf_ptr;
+    char *str_end;
+    errno = 0;
+    dest->value = strtold(str_begin, &str_end);
+    if (errno) {
+        return ErrorOverflow;
+    }
+    assert(str_end <= ((char*)buf_ptr) + buf_len);
+    return 0;
+}
+
+void bigfloat_add(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) {
+    dest->value = op1->value + op2->value;
+}
+
+void bigfloat_negate(BigFloat *dest, const BigFloat *op) {
+    dest->value = -op->value;
+}
+
+void bigfloat_sub(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) {
+    dest->value = op1->value - op2->value;
+}
+
+void bigfloat_mul(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) {
+    dest->value = op1->value * op2->value;
+}
+
+void bigfloat_div(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) {
+    dest->value = op1->value / op2->value;
+}
+
+void bigfloat_div_trunc(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) {
+    dest->value = op1->value / op2->value;
+    if (dest->value >= 0.0) {
+        dest->value = floorl(dest->value);
+    } else {
+        dest->value = ceill(dest->value);
+    }
+}
+
+void bigfloat_div_floor(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) {
+    dest->value = floorl(op1->value / op2->value);
+}
+
+void bigfloat_rem(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) {
+    dest->value = fmodl(op1->value, op2->value);
+}
+
+void bigfloat_mod(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) {
+    dest->value = fmodl(fmodl(op1->value, op2->value) + op2->value, op2->value);
+}
+
+void bigfloat_write_buf(Buf *buf, const BigFloat *op) {
+    buf_appendf(buf, "%Lf", op->value);
+}
+
+Cmp bigfloat_cmp(const BigFloat *op1, const BigFloat *op2) {
+    if (op1->value > op2->value) {
+        return CmpGT;
+    } else if (op1->value < op2->value) {
+        return CmpLT;
+    } else {
+        return CmpEQ;
+    }
+}
+
+// TODO this is wrong when compiler running on big endian systems. caught by tests
+void bigfloat_write_ieee597(const BigFloat *op, uint8_t *buf, size_t bit_count, bool is_big_endian) {
+    if (bit_count == 32) {
+        float f32 = op->value;
+        memcpy(buf, &f32, 4);
+    } else if (bit_count == 64) {
+        double f64 = op->value;
+        memcpy(buf, &f64, 8);
+    } else {
+        zig_unreachable();
+    }
+}
+
+// TODO this is wrong when compiler running on big endian systems. caught by tests
+void bigfloat_read_ieee597(BigFloat *dest, const uint8_t *buf, size_t bit_count, bool is_big_endian) {
+    if (bit_count == 32) {
+        float f32;
+        memcpy(&f32, buf, 4);
+        dest->value = f32;
+    } else if (bit_count == 64) {
+        double f64;
+        memcpy(&f64, buf, 8);
+        dest->value = f64;
+    } else {
+        zig_unreachable();
+    }
+}
+
+double bigfloat_to_double(const BigFloat *bigfloat) {
+    return bigfloat->value;
+}
+
+Cmp bigfloat_cmp_zero(const BigFloat *bigfloat) {
+    if (bigfloat->value < 0.0) {
+        return CmpLT;
+    } else if (bigfloat->value > 0.0) {
+        return CmpGT;
+    } else {
+        return CmpEQ;
+    }
+}

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2017 Andrew Kelley
+ *
+ * This file is part of zig, which is MIT licensed.
+ * See http://opensource.org/licenses/MIT
+ */
+
+#ifndef ZIG_BIGFLOAT_HPP
+#define ZIG_BIGFLOAT_HPP
+
+#include "bigint.hpp"
+#include "error.hpp"
+#include <stdint.h>
+#include <stddef.h>
+
+struct BigFloat {
+    long double value;
+};
+
+struct Buf;
+
+void bigfloat_init_float(BigFloat *dest, long double x);
+void bigfloat_init_bigfloat(BigFloat *dest, const BigFloat *x);
+void bigfloat_init_bigint(BigFloat *dest, const BigInt *op);
+int bigfloat_init_buf_base10(BigFloat *dest, const uint8_t *buf_ptr, size_t buf_len);
+
+double bigfloat_to_double(const BigFloat *bigfloat);
+
+void bigfloat_add(BigFloat *dest, const BigFloat *op1, const BigFloat *op2);
+void bigfloat_negate(BigFloat *dest, const BigFloat *op);
+void bigfloat_sub(BigFloat *dest, const BigFloat *op1, const BigFloat *op2);
+void bigfloat_mul(BigFloat *dest, const BigFloat *op1, const BigFloat *op2);
+void bigfloat_div(BigFloat *dest, const BigFloat *op1, const BigFloat *op2);
+void bigfloat_div_trunc(BigFloat *dest, const BigFloat *op1, const BigFloat *op2);
+void bigfloat_div_floor(BigFloat *dest, const BigFloat *op1, const BigFloat *op2);
+void bigfloat_rem(BigFloat *dest, const BigFloat *op1, const BigFloat *op2);
+void bigfloat_mod(BigFloat *dest, const BigFloat *op1, const BigFloat *op2);
+void bigfloat_write_buf(Buf *buf, const BigFloat *op);
+Cmp bigfloat_cmp(const BigFloat *op1, const BigFloat *op2);
+void bigfloat_write_ieee597(const BigFloat *op, uint8_t *buf, size_t bit_count, bool is_big_endian);
+void bigfloat_read_ieee597(BigFloat *dest, const uint8_t *buf, size_t bit_count, bool is_big_endian);
+
+
+// convenience functions
+Cmp bigfloat_cmp_zero(const BigFloat *bigfloat);
+
+#endif

@@ -0,0 +1,1088 @@
+/*
+ * Copyright (c) 2017 Andrew Kelley
+ *
+ * This file is part of zig, which is MIT licensed.
+ * See http://opensource.org/licenses/MIT
+ */
+
+#include "bigfloat.hpp"
+#include "bigint.hpp"
+#include "buffer.hpp"
+#include "list.hpp"
+#include "os.hpp"
+
+static void bigint_normalize(BigInt *dest) {
+    const uint64_t *digits = bigint_ptr(dest);
+
+    size_t last_nonzero_digit = SIZE_MAX;
+    for (size_t i = 0; i < dest->digit_count; i += 1) {
+        uint64_t digit = digits[i];
+        if (digit != 0) {
+            last_nonzero_digit = i;
+        }
+    }
+    if (last_nonzero_digit == SIZE_MAX) {
+        dest->is_negative = false;
+        dest->digit_count = 0;
+    } else {
+        dest->digit_count = last_nonzero_digit + 1;
+        if (last_nonzero_digit == 0) {
+            dest->data.digit = digits[0];
+        }
+    }
+}
+
+static uint8_t digit_to_char(uint8_t digit, bool uppercase) {
+    if (digit <= 9) {
+        return digit + '0';
+    } else if (digit <= 35) {
+        return digit + (uppercase ? 'A' : 'a');
+    } else {
+        zig_unreachable();
+    }
+}
+
+size_t bigint_bits_needed(const BigInt *op) {
+    size_t full_bits = op->digit_count * 64;
+    size_t leading_zero_count = bigint_clz(op, full_bits);
+    size_t bits_needed = full_bits - leading_zero_count;
+    return bits_needed + op->is_negative;
+}
+
+static void to_twos_complement(BigInt *dest, const BigInt *op, size_t bit_count) {
+    if (bit_count == 0 || op->digit_count == 0) {
+        bigint_init_unsigned(dest, 0);
+        return;
+    }
+    if (op->is_negative) {
+        BigInt negated = {0};
+        bigint_negate(&negated, op);
+
+        BigInt inverted = {0};
+        bigint_not(&inverted, &negated, bit_count, false);
+
+        BigInt one = {0};
+        bigint_init_unsigned(&one, 1);
+
+        bigint_add(dest, &inverted, &one);
+        return;
+    }
+
+    dest->is_negative = false;
+    const uint64_t *op_digits = bigint_ptr(op);
+    if (op->digit_count == 1) {
+        dest->data.digit = op_digits[0];
+        if (bit_count < 64) {
+            dest->data.digit &= (1ULL << bit_count) - 1;
+        }
+        dest->digit_count = 1;
+        bigint_normalize(dest);
+        return;
+    }
+    size_t digits_to_copy = bit_count / 64;
+    size_t leftover_bits = bit_count % 64;
+    dest->digit_count = digits_to_copy + ((leftover_bits == 0) ? 0 : 1);
+    dest->data.digits = allocate_nonzero<uint64_t>(dest->digit_count);
+    for (size_t i = 0; i < digits_to_copy; i += 1) {
+        uint64_t digit = (i < op->digit_count) ? op_digits[i] : 0;
+        dest->data.digits[i] = digit;
+    }
+    if (leftover_bits != 0) {
+        uint64_t digit = (digits_to_copy < op->digit_count) ? op_digits[digits_to_copy] : 0;
+        dest->data.digits[digits_to_copy] = digit & ((1ULL << leftover_bits) - 1);
+    }
+    bigint_normalize(dest);
+}
+
+static bool bit_at_index(const BigInt *bi, size_t index) {
+    size_t digit_index = bi->digit_count - (index / 64) - 1;
+    size_t digit_bit_index = index % 64;
+    const uint64_t *digits = bigint_ptr(bi);
+    uint64_t digit = digits[digit_index];
+    return ((digit >> digit_bit_index) & 0x1) == 0x1;
+}
+
+static void from_twos_complement(BigInt *dest, const BigInt *src, size_t bit_count, bool is_signed) {
+    assert(!src->is_negative);
+
+    if (bit_count == 0 || src->digit_count == 0) {
+        bigint_init_unsigned(dest, 0);
+        return;
+    }
+
+    if (is_signed && bit_at_index(src, bit_count - 1)) {
+        BigInt negative_one = {0};
+        bigint_init_signed(&negative_one, -1);
+
+        BigInt minus_one = {0};
+        bigint_add(&minus_one, src, &negative_one);
+
+        BigInt inverted = {0};
+        bigint_not(&inverted, &minus_one, bit_count, false);
+
+        bigint_negate(dest, &inverted);
+        return;
+
+    }
+
+    bigint_init_bigint(dest, src);
+}
+
+void bigint_init_unsigned(BigInt *dest, uint64_t x) {
+    if (x == 0) {
+        dest->digit_count = 0;
+        dest->is_negative = false;
+        return;
+    }
+    dest->digit_count = 1;
+    dest->data.digit = x;
+    dest->is_negative = false;
+}
+
+void bigint_init_signed(BigInt *dest, int64_t x) {
+    if (x >= 0) {
+        return bigint_init_unsigned(dest, x);
+    }
+    dest->is_negative = true;
+    dest->digit_count = 1;
+    dest->data.digit = ((uint64_t)(-(x + 1))) + 1;
+}
+
+void bigint_init_bigint(BigInt *dest, const BigInt *src) {
+    if (src->digit_count == 0) {
+        return bigint_init_unsigned(dest, 0);
+    } else if (src->digit_count == 1) {
+        dest->digit_count = 1;
+        dest->data.digit = src->data.digit;
+        dest->is_negative = src->is_negative;
+        return;
+    }
+    dest->is_negative = src->is_negative;
+    dest->digit_count = src->digit_count;
+    dest->data.digits = allocate_nonzero<uint64_t>(dest->digit_count);
+    memcpy(dest->data.digits, src->data.digits, sizeof(uint64_t) * dest->digit_count);
+}
+
+void bigint_init_bigfloat(BigInt *dest, const BigFloat *op) {
+    if (op->value >= 0) {
+        bigint_init_unsigned(dest, op->value);
+    } else {
+        bigint_init_unsigned(dest, -op->value);
+        dest->is_negative = true;
+    }
+}
+
+bool bigint_fits_in_bits(const BigInt *bn, size_t bit_count, bool is_signed) {
+    assert(bn->digit_count != 1 || bn->data.digit != 0);
+    if (bit_count == 0) {
+        return bigint_cmp_zero(bn) == CmpEQ;
+    }
+    if (bn->digit_count == 0) {
+        return true;
+    }
+
+    if (!is_signed) {
+        size_t full_bits = bn->digit_count * 64;
+        size_t leading_zero_count = bigint_clz(bn, full_bits);
+        return bit_count >= full_bits - leading_zero_count;
+    }
+
+    BigInt one = {0};
+    bigint_init_unsigned(&one, 1);
+
+    BigInt shl_amt = {0};
+    bigint_init_unsigned(&shl_amt, bit_count - 1);
+
+    BigInt max_value_plus_one = {0};
+    bigint_shl(&max_value_plus_one, &one, &shl_amt);
+
+    BigInt max_value = {0};
+    bigint_sub(&max_value, &max_value_plus_one, &one);
+
+    BigInt min_value = {0};
+    bigint_negate(&min_value, &max_value_plus_one);
+
+    Cmp min_cmp = bigint_cmp(bn, &min_value);
+    Cmp max_cmp = bigint_cmp(bn, &max_value);
+
+    return (min_cmp == CmpGT || min_cmp == CmpEQ) && (max_cmp == CmpLT || max_cmp == CmpEQ);
+}
+
+void bigint_write_twos_complement(const BigInt *big_int, uint8_t *buf, size_t bit_count, bool is_big_endian) {
+    if (bit_count == 0)
+        return;
+
+    BigInt twos_comp = {0};
+    to_twos_complement(&twos_comp, big_int, bit_count);
+
+    const uint64_t *twos_comp_digits = bigint_ptr(&twos_comp);
+
+    size_t bits_in_last_digit = bit_count % 64;
+    size_t bytes_in_last_digit = (bits_in_last_digit + 7) / 8;
+    size_t unwritten_byte_count = 8 - bytes_in_last_digit;
+
+    if (is_big_endian) {
+        size_t last_digit_index = (bit_count - 1) / 64;
+        size_t digit_index = last_digit_index;
+        size_t buf_index = 0;
+        for (;;) {
+            uint64_t x = (digit_index < twos_comp.digit_count) ? twos_comp_digits[digit_index] : 0;
+
+            for (size_t byte_index = 7;;) {
+                uint8_t byte = x & 0xff;
+                if (digit_index == last_digit_index) {
+                    buf[buf_index + byte_index - unwritten_byte_count] = byte;
+                    if (byte_index == unwritten_byte_count) break;
+                } else {
+                    buf[buf_index + byte_index] = byte;
+                }
+
+                if (byte_index == 0) break;
+                byte_index -= 1;
+                x >>= 8;
+            }
+
+            if (digit_index == 0) break;
+            digit_index -= 1;
+            if (digit_index == last_digit_index) {
+                buf_index += bytes_in_last_digit;
+            } else {
+                buf_index += 8;
+            }
+        }
+    } else {
+        size_t digit_count = (bit_count + 63) / 64;
+        size_t buf_index = 0;
+        for (size_t digit_index = 0; digit_index < digit_count; digit_index += 1) {
+            uint64_t x = (digit_index < twos_comp.digit_count) ? twos_comp_digits[digit_index] : 0;
+
+            for (size_t byte_index = 0; byte_index < 8; byte_index += 1) {
+                uint8_t byte = x & 0xff;
+                buf[buf_index] = byte;
+                buf_index += 1;
+                if (buf_index >= unwritten_byte_count) {
+                    break;
+                }
+                x >>= 8;
+            }
+        }
+    }
+}
+
+
+void bigint_read_twos_complement(BigInt *dest, const uint8_t *buf, size_t bit_count, bool is_big_endian,
+        bool is_signed)
+{
+    if (bit_count == 0) {
+        bigint_init_unsigned(dest, 0);
+        return;
+    }
+
+    dest->digit_count = (bit_count + 63) / 64;
+    uint64_t *digits;
+    if (dest->digit_count == 1) {
+        digits = &dest->data.digit;
+    } else {
+        digits = allocate_nonzero<uint64_t>(dest->digit_count);
+        dest->data.digits = digits;
+    }
+
+    size_t bits_in_last_digit = bit_count % 64;
+    if (bits_in_last_digit == 0) {
+        bits_in_last_digit = 64;
+    }
+    size_t bytes_in_last_digit = (bits_in_last_digit + 7) / 8;
+    size_t unread_byte_count = 8 - bytes_in_last_digit;
+
+    if (is_big_endian) {
+        size_t buf_index = 0;
+        uint64_t digit = 0;
+        for (size_t byte_index = unread_byte_count; byte_index < 8; byte_index += 1) {
+            uint8_t byte = buf[buf_index];
+            buf_index += 1;
+            digit <<= 8;
+            digit |= byte;
+        }
+        digits[dest->digit_count - 1] = digit;
+        for (size_t digit_index = 1; digit_index < dest->digit_count; digit_index += 1) {
+            digit = 0;
+            for (size_t byte_index = 0; byte_index < 8; byte_index += 1) {
+                uint8_t byte = buf[buf_index];
+                buf_index += 1;
+                digit <<= 8;
+                digit |= byte;
+            }
+            digits[dest->digit_count - 1 - digit_index] = digit;
+        }
+    } else {
+        size_t buf_index = 0;
+        for (size_t digit_index = 0; digit_index < dest->digit_count; digit_index += 1) {
+            uint64_t digit = 0;
+            size_t end_byte_index = (digit_index == dest->digit_count - 1) ? bytes_in_last_digit : 8;
+            for (size_t byte_index = 0; byte_index < end_byte_index; byte_index += 1) {
+                uint64_t byte = buf[buf_index];
+                buf_index += 1;
+
+                digit |= byte << (8 * byte_index);
+            }
+            digits[digit_index] = digit;
+        }
+    }
+
+    if (is_signed) {
+        bigint_normalize(dest);
+        BigInt tmp = {0};
+        bigint_init_bigint(&tmp, dest);
+        from_twos_complement(dest, &tmp, bit_count, true);
+    } else {
+        dest->is_negative = false;
+        bigint_normalize(dest);
+    }
+}
+
+static bool add_u64_overflow(uint64_t op1, uint64_t op2, uint64_t *result) {
+    return __builtin_uaddll_overflow((unsigned long long)op1, (unsigned long long)op2,
+            (unsigned long long *)result);
+}
+
+static bool sub_u64_overflow(uint64_t op1, uint64_t op2, uint64_t *result) {
+    return __builtin_usubll_overflow((unsigned long long)op1, (unsigned long long)op2,
+            (unsigned long long *)result);
+}
+
+static bool mul_u64_overflow(uint64_t op1, uint64_t op2, uint64_t *result) {
+    return __builtin_umulll_overflow((unsigned long long)op1, (unsigned long long)op2,
+            (unsigned long long *)result);
+}
+
+void bigint_add(BigInt *dest, const BigInt *op1, const BigInt *op2) {
+    if (op1->digit_count == 0) {
+        return bigint_init_bigint(dest, op2);
+    }
+    if (op2->digit_count == 0) {
+        return bigint_init_bigint(dest, op1);
+    }
+    if (op1->is_negative == op2->is_negative) {
+        dest->is_negative = op1->is_negative;
+
+        const uint64_t *op1_digits = bigint_ptr(op1);
+        const uint64_t *op2_digits = bigint_ptr(op2);
+        uint64_t overflow = add_u64_overflow(op1_digits[0], op2_digits[0], &dest->data.digit);
+        if (overflow == 0 && op1->digit_count == 1 && op2->digit_count == 1) {
+            dest->digit_count = 1;
+            bigint_normalize(dest);
+            return;
+        }
+        // TODO this code path is untested
+        size_t i = 1;
+        uint64_t first_digit = dest->data.digit;
+        dest->data.digits = allocate_nonzero<uint64_t>(max(op1->digit_count, op2->digit_count) + 1);
+        dest->data.digits[0] = first_digit;
+
+        for (;;) {
+            bool found_digit = false;
+            uint64_t x = overflow;
+            overflow = 0;
+
+            if (i < op1->digit_count) {
+                found_digit = true;
+                uint64_t digit = op1_digits[i];
+                overflow += add_u64_overflow(x, digit, &x);
+            }
+
+            if (i < op2->digit_count) {
+                found_digit = true;
+                uint64_t digit = op2_digits[i];
+                overflow += add_u64_overflow(x, digit, &x);
+            }
+
+            dest->data.digits[i] = x;
+            x += 1;
+
+            if (!found_digit) {
+                break;
+            }
+        }
+        if (overflow > 0) {
+            dest->data.digits[i] = overflow;
+        }
+        bigint_normalize(dest);
+        return;
+    }
+    const BigInt *op_pos;
+    const BigInt *op_neg;
+    if (op1->is_negative) {
+        op_neg = op1;
+        op_pos = op2;
+    } else {
+        op_pos = op1;
+        op_neg = op2;
+    }
+
+    BigInt op_neg_abs = {0};
+    bigint_negate(&op_neg_abs, op_neg);
+    const BigInt *bigger_op;
+    const BigInt *smaller_op;
+    switch (bigint_cmp(op_pos, &op_neg_abs)) {
+        case CmpEQ:
+            bigint_init_unsigned(dest, 0);
+            return;
+        case CmpLT:
+            bigger_op = &op_neg_abs;
+            smaller_op = op_pos;
+            dest->is_negative = true;
+            break;
+        case CmpGT:
+            bigger_op = op_pos;
+            smaller_op = &op_neg_abs;
+            dest->is_negative = false;
+            break;
+    }
+    const uint64_t *bigger_op_digits = bigint_ptr(bigger_op);
+    const uint64_t *smaller_op_digits = bigint_ptr(smaller_op);
+    uint64_t overflow = sub_u64_overflow(bigger_op_digits[0], smaller_op_digits[0], &dest->data.digit);
+    if (overflow == 0 && bigger_op->digit_count == 1 && smaller_op->digit_count == 1) {
+        dest->digit_count = 1;
+        bigint_normalize(dest);
+        return;
+    }
+    uint64_t first_digit = dest->data.digit;
+    dest->data.digits = allocate_nonzero<uint64_t>(bigger_op->digit_count);
+    dest->data.digits[0] = first_digit;
+    size_t i = 1;
+
+    for (;;) {
+        bool found_digit = false;
+        uint64_t x = bigger_op_digits[i];
+        uint64_t prev_overflow = overflow;
+        overflow = 0;
+
+        if (i < smaller_op->digit_count) {
+            found_digit = true;
+            uint64_t digit = smaller_op_digits[i];
+            overflow += sub_u64_overflow(x, digit, &x);
+        }
+        if (sub_u64_overflow(x, prev_overflow, &x)) {
+            found_digit = true;
+            overflow += 1;
+        }
+        dest->data.digits[i] = x;
+        i += 1;
+
+        if (!found_digit)
+            break;
+    }
+    assert(overflow == 0);
+    dest->digit_count = i;
+    bigint_normalize(dest);
+}
+
+void bigint_add_wrap(BigInt *dest, const BigInt *op1, const BigInt *op2, size_t bit_count, bool is_signed) {
+    BigInt unwrapped = {0};
+    bigint_add(&unwrapped, op1, op2);
+    bigint_truncate(dest, &unwrapped, bit_count, is_signed);
+}
+
+void bigint_sub(BigInt *dest, const BigInt *op1, const BigInt *op2) {
+    BigInt op2_negated = {0};
+    bigint_negate(&op2_negated, op2);
+    return bigint_add(dest, op1, &op2_negated);
+}
+
+void bigint_sub_wrap(BigInt *dest, const BigInt *op1, const BigInt *op2, size_t bit_count, bool is_signed) {
+    BigInt op2_negated = {0};
+    bigint_negate(&op2_negated, op2);
+    return bigint_add_wrap(dest, op1, &op2_negated, bit_count, is_signed);
+}
+
+static void mul_overflow(uint64_t x, uint64_t y, uint64_t *result, uint64_t *carry) {
+    if (!mul_u64_overflow(x, y, result)) {
+        *carry = 0;
+        return;
+    }
+    zig_panic("TODO bigint_mul with big numbers");
+
+    //unsigned __int128 big_x = x;
+    //unsigned __int128 big_y = y;
+    //unsigned __int128 big_result = big_x * big_y;
+    //*carry = big_result >> 64;
+}
+
+void bigint_mul(BigInt *dest, const BigInt *op1, const BigInt *op2) {
+    if (op1->digit_count == 0 || op2->digit_count == 0) {
+        return bigint_init_unsigned(dest, 0);
+    }
+    const uint64_t *op1_digits = bigint_ptr(op1);
+    const uint64_t *op2_digits = bigint_ptr(op2);
+
+    uint64_t carry;
+    mul_overflow(op1_digits[0], op2_digits[0], &dest->data.digit, &carry);
+    if (carry == 0 && op1->digit_count == 1 && op2->digit_count == 1) {
+        dest->is_negative = (op1->is_negative != op2->is_negative);
+        dest->digit_count = 1;
+        bigint_normalize(dest);
+        return;
+    }
+    zig_panic("TODO bigint_mul with big numbers");
+}
+
+void bigint_mul_wrap(BigInt *dest, const BigInt *op1, const BigInt *op2, size_t bit_count, bool is_signed) {
+    BigInt unwrapped = {0};
+    bigint_mul(&unwrapped, op1, op2);
+    bigint_truncate(dest, &unwrapped, bit_count, is_signed);
+}
+
+void bigint_div_trunc(BigInt *dest, const BigInt *op1, const BigInt *op2) {
+    assert(op2->digit_count != 0); // division by zero
+    if (op1->digit_count == 0) {
+        bigint_init_unsigned(dest, 0);
+        return;
+    }
+    if (op1->digit_count != 1 || op2->digit_count != 1) {
+        zig_panic("TODO bigint div_trunc with >1 digits");
+    }
+    const uint64_t *op1_digits = bigint_ptr(op1);
+    const uint64_t *op2_digits = bigint_ptr(op2);
+    dest->data.digit = op1_digits[0] / op2_digits[0];
+    dest->digit_count = 1;
+    dest->is_negative = op1->is_negative != op2->is_negative;
+    bigint_normalize(dest);
+}
+
+void bigint_div_floor(BigInt *dest, const BigInt *op1, const BigInt *op2) {
+    if (op1->is_negative != op2->is_negative) {
+        bigint_div_trunc(dest, op1, op2);
+        BigInt mult_again = {0};
+        bigint_mul(&mult_again, dest, op2);
+        mult_again.is_negative = op1->is_negative;
+        if (bigint_cmp(&mult_again, op1) != CmpEQ) {
+            BigInt tmp = {0};
+            bigint_init_bigint(&tmp, dest);
+            BigInt neg_one = {0};
+            bigint_init_signed(&neg_one, -1);
+            bigint_add(dest, &tmp, &neg_one);
+        }
+        bigint_normalize(dest);
+    } else {
+        bigint_div_trunc(dest, op1, op2);
+    }
+}
+
+void bigint_rem(BigInt *dest, const BigInt *op1, const BigInt *op2) {
+    assert(op2->digit_count != 0); // division by zero
+    if (op1->digit_count == 0) {
+        bigint_init_unsigned(dest, 0);
+        return;
+    }
+    const uint64_t *op1_digits = bigint_ptr(op1);
+    const uint64_t *op2_digits = bigint_ptr(op2);
+    if (op2->digit_count == 2 && op2_digits[0] == 0 && op2_digits[1] == 1) {
+        // special case this divisor
+        bigint_init_unsigned(dest, op1_digits[0]);
+        dest->is_negative = op1->is_negative;
+        bigint_normalize(dest);
+        return;
+    }
+    if (op1->digit_count != 1 || op2->digit_count != 1) {
+        zig_panic("TODO bigint rem with >1 digits");
+    }
+    dest->data.digit = op1_digits[0] % op2_digits[0];
+    dest->digit_count = 1;
+    dest->is_negative = op1->is_negative;
+    bigint_normalize(dest);
+}
+
+void bigint_mod(BigInt *dest, const BigInt *op1, const BigInt *op2) {
+    if (op1->is_negative) {
+        BigInt first_rem;
+        bigint_rem(&first_rem, op1, op2);
+        first_rem.is_negative = !op2->is_negative;
+        BigInt op2_minus_rem;
+        bigint_add(&op2_minus_rem, op2, &first_rem);
+        bigint_rem(dest, &op2_minus_rem, op2);
+        dest->is_negative = false;
+    } else {
+        bigint_rem(dest, op1, op2);
+        dest->is_negative = false;
+    }
+}
+
+void bigint_or(BigInt *dest, const BigInt *op1, const BigInt *op2) {
+    if (op1->digit_count == 0) {
+        return bigint_init_bigint(dest, op2);
+    }
+    if (op2->digit_count == 0) {
+        return bigint_init_bigint(dest, op1);
+    }
+    if (op1->is_negative || op2->is_negative) {
+        // TODO this code path is untested
+        size_t big_bit_count = max(bigint_bits_needed(op1), bigint_bits_needed(op2));
+
+        BigInt twos_comp_op1 = {0};
+        to_twos_complement(&twos_comp_op1, op1, big_bit_count);
+
+        BigInt twos_comp_op2 = {0};
+        to_twos_complement(&twos_comp_op2, op2, big_bit_count);
+
+        BigInt twos_comp_dest = {0};
+        bigint_or(&twos_comp_dest, &twos_comp_op1, &twos_comp_op2);
+
+        from_twos_complement(dest, &twos_comp_dest, big_bit_count, true);
+    } else {
+        dest->is_negative = false;
+        const uint64_t *op1_digits = bigint_ptr(op1);
+        const uint64_t *op2_digits = bigint_ptr(op2);
+        if (op1->digit_count == 1 && op2->digit_count == 1) {
+            dest->digit_count = 1;
+            dest->data.digit = op1_digits[0] | op2_digits[0];
+            bigint_normalize(dest);
+            return;
+        }
+        // TODO this code path is untested
+        uint64_t first_digit = dest->data.digit;
+        dest->digit_count = max(op1->digit_count, op2->digit_count);
+        dest->data.digits = allocate_nonzero<uint64_t>(dest->digit_count);
+        dest->data.digits[0] = first_digit;
+        size_t i = 1;
+        for (; i < dest->digit_count; i += 1) {
+            uint64_t digit = 0;
+            if (i < op1->digit_count) {
+                digit |= op1_digits[i];
+            }
+            if (i < op2->digit_count) {
+                digit |= op2_digits[i];
+            }
+            dest->data.digits[i] = digit;
+        }
+        bigint_normalize(dest);
+    }
+}
+
+void bigint_and(BigInt *dest, const BigInt *op1, const BigInt *op2) {
+    if (op1->digit_count == 0 || op2->digit_count == 0) {
+        return bigint_init_unsigned(dest, 0);
+    }
+    if (op1->is_negative || op2->is_negative) {
+        // TODO this code path is untested
+        size_t big_bit_count = max(bigint_bits_needed(op1), bigint_bits_needed(op2));
+
+        BigInt twos_comp_op1 = {0};
+        to_twos_complement(&twos_comp_op1, op1, big_bit_count);
+
+        BigInt twos_comp_op2 = {0};
+        to_twos_complement(&twos_comp_op2, op2, big_bit_count);
+
+        BigInt twos_comp_dest = {0};
+        bigint_and(&twos_comp_dest, &twos_comp_op1, &twos_comp_op2);
+
+        from_twos_complement(dest, &twos_comp_dest, big_bit_count, true);
+    } else {
+        dest->is_negative = false;
+        const uint64_t *op1_digits = bigint_ptr(op1);
+        const uint64_t *op2_digits = bigint_ptr(op2);
+        if (op1->digit_count == 1 && op2->digit_count == 1) {
+            dest->digit_count = 1;
+            dest->data.digit = op1_digits[0] & op2_digits[0];
+            bigint_normalize(dest);
+            return;
+        }
+        // TODO this code path is untested
+        uint64_t first_digit = dest->data.digit;
+        dest->digit_count = max(op1->digit_count, op2->digit_count);
+        dest->data.digits = allocate_nonzero<uint64_t>(dest->digit_count);
+        dest->data.digits[0] = first_digit;
+        size_t i = 1;
+        for (; i < op1->digit_count && i < op2->digit_count; i += 1) {
+            dest->data.digits[i] = op1_digits[i] & op2_digits[i];
+        }
+        for (; i < dest->digit_count; i += 1) {
+            dest->data.digits[i] = 0;
+        }
+        bigint_normalize(dest);
+    }
+}
+
+void bigint_xor(BigInt *dest, const BigInt *op1, const BigInt *op2) {
+    if (op1->is_negative || op2->is_negative) {
+        // TODO this code path is untested
+        size_t big_bit_count = max(bigint_bits_needed(op1), bigint_bits_needed(op2));
+
+        BigInt twos_comp_op1 = {0};
+        to_twos_complement(&twos_comp_op1, op1, big_bit_count);
+
+        BigInt twos_comp_op2 = {0};
+        to_twos_complement(&twos_comp_op2, op2, big_bit_count);
+
+        BigInt twos_comp_dest = {0};
+        bigint_xor(&twos_comp_dest, &twos_comp_op1, &twos_comp_op2);
+
+        from_twos_complement(dest, &twos_comp_dest, big_bit_count, true);
+    } else {
+        dest->is_negative = false;
+        const uint64_t *op1_digits = bigint_ptr(op1);
+        const uint64_t *op2_digits = bigint_ptr(op2);
+        if (op1->digit_count == 1 && op2->digit_count == 1) {
+            dest->digit_count = 1;
+            dest->data.digit = op1_digits[0] ^ op2_digits[0];
+            bigint_normalize(dest);
+            return;
+        }
+        // TODO this code path is untested
+        uint64_t first_digit = dest->data.digit;
+        dest->digit_count = max(op1->digit_count, op2->digit_count);
+        dest->data.digits = allocate_nonzero<uint64_t>(dest->digit_count);
+        dest->data.digits[0] = first_digit;
+        size_t i = 1;
+        for (; i < op1->digit_count && i < op2->digit_count; i += 1) {
+            dest->data.digits[i] = op1_digits[i] ^ op2_digits[i];
+        }
+        for (; i < dest->digit_count; i += 1) {
+            if (i < op1->digit_count) {
+                dest->data.digits[i] = op1_digits[i];
+            }
+            if (i < op2->digit_count) {
+                dest->data.digits[i] = op2_digits[i];
+            }
+        }
+        bigint_normalize(dest);
+    }
+}
+
+void bigint_shl(BigInt *dest, const BigInt *op1, const BigInt *op2) {
+    assert(!op2->is_negative);
+
+    if (op2->digit_count == 0) {
+        bigint_init_bigint(dest, op1);
+        return;
+    }
+
+    if (op1->digit_count == 0) {
+        bigint_init_unsigned(dest, 0);
+        return;
+    }
+
+    if (op2->digit_count != 1) {
+        zig_panic("TODO shift left by amount greater than 64 bit integer");
+    }
+
+    const uint64_t *op1_digits = bigint_ptr(op1);
+    uint64_t shift_amt = bigint_as_unsigned(op2);
+
+    if (op1->digit_count == 1) {
+        dest->data.digit = op1_digits[0] << shift_amt;
+        if (dest->data.digit > op1_digits[0]) {
+            dest->digit_count = 1;
+            dest->is_negative = op1->is_negative;
+            return;
+        }
+    }
+
+    uint64_t digit_shift_count = shift_amt / 64;
+    uint64_t leftover_shift_count = shift_amt % 64;
+
+    dest->data.digits = allocate<uint64_t>(op1->digit_count + digit_shift_count + 1);
+    dest->digit_count = digit_shift_count;
+    uint64_t carry = 0;
+    for (size_t i = 0; i < op1->digit_count; i += 1) {
+        uint64_t digit = op1_digits[i];
+        dest->data.digits[dest->digit_count] = carry | (digit << leftover_shift_count);
+        dest->digit_count += 1;
+        if (leftover_shift_count > 0) {
+            carry = digit >> (64 - leftover_shift_count);
+        } else {
+            carry = 0;
+        }
+    }
+    dest->data.digits[dest->digit_count] = carry;
+    dest->digit_count += 1;
+    dest->is_negative = op1->is_negative;
+    bigint_normalize(dest);
+}
+
+void bigint_shl_wrap(BigInt *dest, const BigInt *op1, const BigInt *op2, size_t bit_count, bool is_signed) {
+    BigInt unwrapped = {0};
+    bigint_shl(&unwrapped, op1, op2);
+    bigint_truncate(dest, &unwrapped, bit_count, is_signed);
+}
+
+void bigint_shr(BigInt *dest, const BigInt *op1, const BigInt *op2) {
+    assert(!op2->is_negative);
+
+    if (op1->digit_count == 0) {
+        return bigint_init_unsigned(dest, 0);
+    }
+
+    if (op2->digit_count == 0) {
+        return bigint_init_bigint(dest, op1);
+    }
+
+    if (op2->digit_count != 1) {
+        zig_panic("TODO shift right by amount greater than 64 bit integer");
+    }
+
+    const uint64_t *op1_digits = bigint_ptr(op1);
+    uint64_t shift_amt = bigint_as_unsigned(op2);
+
+    if (op1->digit_count == 1) {
+        dest->data.digit = op1_digits[0] >> shift_amt;
+        dest->digit_count = 1;
+        dest->is_negative = op1->is_negative;
+        bigint_normalize(dest);
+        return;
+    }
+
+    // TODO this code path is untested
+    size_t digit_shift_count = shift_amt / 64;
+    size_t leftover_shift_count = shift_amt % 64;
+
+    if (digit_shift_count >= op1->digit_count) {
+        return bigint_init_unsigned(dest, 0);
+    }
+
+    dest->digit_count = op1->digit_count - digit_shift_count;
+    dest->data.digits = allocate<uint64_t>(dest->digit_count);
+    uint64_t carry = 0;
+    for (size_t op_digit_index = op1->digit_count - 1;;) {
+        uint64_t digit = op1_digits[op_digit_index];
+        size_t dest_digit_index = op_digit_index - digit_shift_count;
+        dest->data.digits[dest_digit_index] = carry | (digit >> leftover_shift_count);
+        carry = (0xffffffffffffffffULL << leftover_shift_count) & digit;
+
+        if (dest_digit_index == 0) { break; }
+        op_digit_index -= 1;
+    }
+    dest->is_negative = op1->is_negative;
+    bigint_normalize(dest);
+}
+
+void bigint_negate(BigInt *dest, const BigInt *op) {
+    bigint_init_bigint(dest, op);
+    dest->is_negative = !dest->is_negative;
+    bigint_normalize(dest);
+}
+
+void bigint_negate_wrap(BigInt *dest, const BigInt *op, size_t bit_count) {
+    BigInt zero;
+    bigint_init_unsigned(&zero, 0);
+    bigint_sub_wrap(dest, &zero, op, bit_count, true);
+}
+
+void bigint_not(BigInt *dest, const BigInt *op, size_t bit_count, bool is_signed) {
+    if (bit_count == 0) {
+        bigint_init_unsigned(dest, 0);
+        return;
+    }
+
+    if (is_signed) {
+        BigInt twos_comp = {0};
+        to_twos_complement(&twos_comp, op, bit_count);
+
+        BigInt inverted = {0};
+        bigint_not(&inverted, &twos_comp, bit_count, false);
+
+        from_twos_complement(dest, &inverted, bit_count, true);
+        return;
+    }
+
+    assert(!op->is_negative);
+
+    dest->is_negative = false;
+    const uint64_t *op_digits = bigint_ptr(op);
+    if (bit_count <= 64) {
+        dest->digit_count = 1;
+        if (op->digit_count == 0) {
+            if (bit_count == 64) {
+                dest->data.digit = UINT64_MAX;
+            } else {
+                dest->data.digit = (1ULL << bit_count) - 1;
+            }
+        } else if (op->digit_count == 1) {
+            dest->data.digit = ~op_digits[0];
+            if (bit_count != 64) {
+                uint64_t mask = (1ULL << bit_count) - 1;
+                dest->data.digit &= mask;
+            }
+        }
+        bigint_normalize(dest);
+        return;
+    }
+    // TODO this code path is untested
+    dest->digit_count = bit_count / 64;
+    assert(dest->digit_count >= op->digit_count);
+    dest->data.digits = allocate_nonzero<uint64_t>(dest->digit_count);
+    size_t i = 0;
+    for (; i < op->digit_count; i += 1) {
+        dest->data.digits[i] = ~op_digits[i];
+    }
+    for (; i < dest->digit_count; i += 1) {
+        dest->data.digits[i] = 0xffffffffffffffffULL;
+    }
+    size_t digit_index = dest->digit_count - (bit_count / 64) - 1;
+    size_t digit_bit_index = bit_count % 64;
+    if (digit_index < dest->digit_count) {
+        uint64_t mask = (1ULL << digit_bit_index) - 1;
+        dest->data.digits[digit_index] &= mask;
+    }
+    bigint_normalize(dest);
+}
+
+void bigint_truncate(BigInt *dest, const BigInt *op, size_t bit_count, bool is_signed) {
+    BigInt twos_comp;
+    to_twos_complement(&twos_comp, op, bit_count);
+    from_twos_complement(dest, &twos_comp, bit_count, is_signed);
+}
+
+Cmp bigint_cmp(const BigInt *op1, const BigInt *op2) {
+    if (op1->is_negative && !op2->is_negative) {
+        return CmpLT;
+    } else if (!op1->is_negative && op2->is_negative) {
+        return CmpGT;
+    } else if (op1->digit_count > op2->digit_count) {
+        return op1->is_negative ? CmpLT : CmpGT;
+    } else if (op2->digit_count > op1->digit_count) {
+        return op1->is_negative ? CmpGT : CmpLT;
+    } else if (op1->digit_count == 0) {
+        return CmpEQ;
+    }
+    const uint64_t *op1_digits = bigint_ptr(op1);
+    const uint64_t *op2_digits = bigint_ptr(op2);
+    for (size_t i = op1->digit_count - 1; ;) {
+        uint64_t op1_digit = op1_digits[i];
+        uint64_t op2_digit = op2_digits[i];
+
+        if (op1_digit > op2_digit) {
+            return op1->is_negative ? CmpLT : CmpGT;
+        }
+        if (op1_digit < op2_digit) {
+            return op1->is_negative ? CmpGT : CmpLT;
+        }
+
+        if (i == 0) {
+            return CmpEQ;
+        }
+        i -= 1;
+    }
+}
+
+void bigint_write_buf(Buf *buf, const BigInt *op, uint64_t base) {
+    if (op->digit_count == 0) {
+        buf_append_char(buf, '0');
+        return;
+    }
+    if (op->is_negative) {
+        buf_append_char(buf, '-');
+    }
+    if (op->digit_count == 1 && base == 10) {
+        buf_appendf(buf, "%" ZIG_PRI_u64, op->data.digit);
+        return;
+    }
+    // TODO this code path is untested
+    size_t first_digit_index = buf_len(buf);
+
+    BigInt digit_bi = {0};
+    BigInt a1 = {0};
+    BigInt a2 = {0};
+
+    BigInt *a = &a1;
+    BigInt *other_a = &a2;
+    bigint_init_bigint(a, op);
+
+    BigInt base_bi = {0};
+    bigint_init_unsigned(&base_bi, 10);
+
+    for (;;) {
+        bigint_rem(&digit_bi, a, &base_bi);
+        uint8_t digit = bigint_as_unsigned(&digit_bi);
+        buf_append_char(buf, digit_to_char(digit, false));
+        bigint_div_trunc(other_a, a, &base_bi);
+        {
+            BigInt *tmp = a;
+            a = other_a;
+            other_a = tmp;
+        }
+        if (bigint_cmp_zero(a) == CmpEQ) {
+            break;
+        }
+    }
+
+    // reverse
+    for (size_t i = first_digit_index; i < buf_len(buf); i += 1) {
+        size_t other_i = buf_len(buf) + first_digit_index - i - 1;
+        uint8_t tmp = buf_ptr(buf)[i];
+        buf_ptr(buf)[i] = buf_ptr(buf)[other_i];
+        buf_ptr(buf)[other_i] = tmp;
+    }
+}
+
+size_t bigint_ctz(const BigInt *bi, size_t bit_count) {
+    if (bit_count == 0)
+        return 0;
+    if (bi->digit_count == 0)
+        return bit_count;
+
+    BigInt twos_comp = {0};
+    to_twos_complement(&twos_comp, bi, bit_count);
+
+    size_t count = 0;
+    for (size_t i = 0; i < bit_count; i += 1) {
+        if (bit_at_index(&twos_comp, i))
+            return count;
+        count += 1;
+    }
+    return count;
+}
+
+size_t bigint_clz(const BigInt *bi, size_t bit_count) {
+    if (bi->is_negative || bit_count == 0)
+        return 0;
+    if (bi->digit_count == 0)
+        return bit_count;
+
+    size_t count = 0;
+    for (size_t i = bit_count - 1;;) {
+        if (bit_at_index(bi, i))
+            return count;
+        count += 1;
+
+        if (i == 0) break;
+        i -= 1;
+    }
+    return count;
+}
+
+uint64_t bigint_as_unsigned(const BigInt *bigint) {
+    assert(!bigint->is_negative);
+    if (bigint->digit_count == 0) {
+        return 0;
+    } else if (bigint->digit_count == 1) {
+        return bigint->data.digit;
+    } else {
+        zig_unreachable();
+    }
+}
+
+int64_t bigint_as_signed(const BigInt *bigint) {
+    if (bigint->digit_count == 0) {
+        return 0;
+    } else if (bigint->digit_count == 1) {
+        if (bigint->is_negative) {
+            // TODO this code path is untested
+            if (bigint->data.digit <= 9223372036854775808ULL) {
+                return (-((int64_t)(bigint->data.digit - 1))) - 1;
+            } else {
+                zig_unreachable();
+            }
+        } else {
+            return bigint->data.digit;
+        }
+    } else {
+        zig_unreachable();
+    }
+}
+
+Cmp bigint_cmp_zero(const BigInt *op) {
+    if (op->digit_count == 0) {
+        return CmpEQ;
+    }
+    return op->is_negative ? CmpLT : CmpGT;
+}

@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2017 Andrew Kelley
+ *
+ * This file is part of zig, which is MIT licensed.
+ * See http://opensource.org/licenses/MIT
+ */
+
+#ifndef ZIG_BIGINT_HPP
+#define ZIG_BIGINT_HPP
+
+#include <stdint.h>
+#include <stddef.h>
+
+struct BigInt {
+    size_t digit_count;
+    union {
+        uint64_t digit;
+        uint64_t *digits; // Least significant digit first
+    } data;
+    bool is_negative;
+};
+
+struct Buf;
+struct BigFloat;
+
+enum Cmp {
+    CmpLT,
+    CmpGT,
+    CmpEQ,
+};
+
+void bigint_init_unsigned(BigInt *dest, uint64_t x);
+void bigint_init_signed(BigInt *dest, int64_t x);
+void bigint_init_bigint(BigInt *dest, const BigInt *src);
+void bigint_init_bigfloat(BigInt *dest, const BigFloat *op);
+
+// panics if number won't fit
+uint64_t bigint_as_unsigned(const BigInt *bigint);
+int64_t bigint_as_signed(const BigInt *bigint);
+
+static inline const uint64_t *bigint_ptr(const BigInt *bigint) {
+    if (bigint->digit_count == 1) {
+        return &bigint->data.digit;
+    } else {
+        return bigint->data.digits;
+    }
+}
+
+bool bigint_fits_in_bits(const BigInt *bn, size_t bit_count, bool is_signed);
+void bigint_write_twos_complement(const BigInt *big_int, uint8_t *buf, size_t bit_count, bool is_big_endian);
+void bigint_read_twos_complement(BigInt *dest, const uint8_t *buf, size_t bit_count, bool is_big_endian,
+        bool is_signed);
+void bigint_add(BigInt *dest, const BigInt *op1, const BigInt *op2);
+void bigint_add_wrap(BigInt *dest, const BigInt *op1, const BigInt *op2, size_t bit_count, bool is_signed);
+void bigint_sub(BigInt *dest, const BigInt *op1, const BigInt *op2);
+void bigint_sub_wrap(BigInt *dest, const BigInt *op1, const BigInt *op2, size_t bit_count, bool is_signed);
+void bigint_mul(BigInt *dest, const BigInt *op1, const BigInt *op2);
+void bigint_mul_wrap(BigInt *dest, const BigInt *op1, const BigInt *op2, size_t bit_count, bool is_signed);
+void bigint_div_trunc(BigInt *dest, const BigInt *op1, const BigInt *op2);
+void bigint_div_floor(BigInt *dest, const BigInt *op1, const BigInt *op2);
+void bigint_rem(BigInt *dest, const BigInt *op1, const BigInt *op2);
+void bigint_mod(BigInt *dest, const BigInt *op1, const BigInt *op2);
+
+void bigint_or(BigInt *dest, const BigInt *op1, const BigInt *op2);
+void bigint_and(BigInt *dest, const BigInt *op1, const BigInt *op2);
+void bigint_xor(BigInt *dest, const BigInt *op1, const BigInt *op2);
+
+void bigint_shl(BigInt *dest, const BigInt *op1, const BigInt *op2);
+void bigint_shl_wrap(BigInt *dest, const BigInt *op1, const BigInt *op2, size_t bit_count, bool is_signed);
+void bigint_shr(BigInt *dest, const BigInt *op1, const BigInt *op2);
+
+void bigint_negate(BigInt *dest, const BigInt *op);
+void bigint_negate_wrap(BigInt *dest, const BigInt *op, size_t bit_count);
+void bigint_not(BigInt *dest, const BigInt *op, size_t bit_count, bool is_signed);
+void bigint_truncate(BigInt *dest, const BigInt *op, size_t bit_count, bool is_signed);
+
+Cmp bigint_cmp(const BigInt *op1, const BigInt *op2);
+
+void bigint_write_buf(Buf *buf, const BigInt *op, uint64_t base);
+
+size_t bigint_ctz(const BigInt *bi, size_t bit_count);
+size_t bigint_clz(const BigInt *bi, size_t bit_count);
+
+size_t bigint_bits_needed(const BigInt *op);
+
+
+// convenience functions
+Cmp bigint_cmp_zero(const BigInt *op);
+
+#endif

@@ -1,535 +0,0 @@
-/*
- * Copyright (c) 2016 Andrew Kelley
- *
- * This file is part of zig, which is MIT licensed.
- * See http://opensource.org/licenses/MIT
- */
-
-#include "bignum.hpp"
-#include "buffer.hpp"
-#include "os.hpp"
-
-#include <assert.h>
-#include <math.h>
-#include <inttypes.h>
-
-static void bignum_normalize(BigNum *bn) {
-    assert(bn->kind == BigNumKindInt);
-    if (bn->data.x_uint == 0) {
-        bn->is_negative = false;
-    }
-}
-
-void bignum_init_float(BigNum *dest, double x) {
-    dest->kind = BigNumKindFloat;
-    dest->is_negative = false;
-    dest->data.x_float = x;
-}
-
-void bignum_init_unsigned(BigNum *dest, uint64_t x) {
-    dest->kind = BigNumKindInt;
-    dest->is_negative = false;
-    dest->data.x_uint = x;
-}
-
-void bignum_init_signed(BigNum *dest, int64_t x) {
-    dest->kind = BigNumKindInt;
-    if (x < 0) {
-        dest->is_negative = true;
-        dest->data.x_uint = ((uint64_t)(-(x + 1))) + 1;
-    } else {
-        dest->is_negative = false;
-        dest->data.x_uint = x;
-    }
-}
-
-void bignum_init_bignum(BigNum *dest, BigNum *src) {
-    safe_memcpy(dest, src, 1);
-}
-
-static int u64_log2(uint64_t x) {
-    int result = 0;
-    for (; x != 0; x >>= 1) {
-        result += 1;
-    }
-    return result;
-}
-
-bool bignum_fits_in_bits(BigNum *bn, int bit_count, bool is_signed) {
-    assert(bn->kind == BigNumKindInt);
-
-    if (is_signed) {
-        uint64_t max_neg;
-        uint64_t max_pos;
-        if (bit_count < 64) {
-            max_neg = (1ULL << (bit_count - 1));
-            max_pos = max_neg - 1;
-        } else {
-            max_pos = ((uint64_t)INT64_MAX);
-            max_neg = max_pos + 1;
-        }
-        uint64_t max_val = bn->is_negative ? max_neg : max_pos;
-        return bn->data.x_uint <= max_val;
-    } else {
-        if (bn->is_negative) {
-            return bn->data.x_uint == 0;
-        } else {
-            int required_bit_count = u64_log2(bn->data.x_uint);
-            return bit_count >= required_bit_count;
-        }
-    }
-}
-
-void bignum_truncate(BigNum *bn, int bit_count) {
-    assert(bn->kind == BigNumKindInt);
-    // TODO handle case when negative = true
-    if (bit_count < 64) {
-        bn->data.x_uint &= (1LL << bit_count) - 1;
-    }
-}
-
-uint64_t bignum_to_twos_complement(BigNum *bn) {
-    assert(bn->kind == BigNumKindInt);
-
-    if (bn->is_negative) {
-        int64_t x = bn->data.x_uint;
-        return -x;
-    } else {
-        return bn->data.x_uint;
-    }
-}
-
-// returns true if overflow happened
-bool bignum_add(BigNum *dest, BigNum *op1, BigNum *op2) {
-    assert(op1->kind == op2->kind);
-    dest->kind = op1->kind;
-
-    if (dest->kind == BigNumKindFloat) {
-        dest->data.x_float = op1->data.x_float + op2->data.x_float;
-        return false;
-    }
-
-    if (op1->is_negative == op2->is_negative) {
-        dest->is_negative = op1->is_negative;
-        return __builtin_uaddll_overflow(op1->data.x_uint, op2->data.x_uint, &dest->data.x_uint);
-    } else if (!op1->is_negative && op2->is_negative) {
-        if (__builtin_usubll_overflow(op1->data.x_uint, op2->data.x_uint, &dest->data.x_uint)) {
-            dest->data.x_uint = (UINT64_MAX - dest->data.x_uint) + 1;
-            dest->is_negative = true;
-            bignum_normalize(dest);
-            return false;
-        } else {
-            bignum_normalize(dest);
-            return false;
-        }
-    } else {
-        return bignum_add(dest, op2, op1);
-    }
-}
-
-void bignum_negate(BigNum *dest, BigNum *op) {
-    dest->kind = op->kind;
-
-    if (dest->kind == BigNumKindFloat) {
-        dest->data.x_float = -op->data.x_float;
-    } else {
-        dest->data.x_uint = op->data.x_uint;
-        dest->is_negative = !op->is_negative;
-        bignum_normalize(dest);
-    }
-}
-
-void bignum_not(BigNum *dest, BigNum *op, int bit_count, bool is_signed) {
-    assert(op->kind == BigNumKindInt);
-    uint64_t bits = ~bignum_to_twos_complement(op);
-    if (bit_count < 64) {
-        bits &= (1LL << bit_count) - 1;
-    }
-    if (is_signed)
-        bignum_init_signed(dest, bits);
-    else
-        bignum_init_unsigned(dest, bits);
-}
-
-void bignum_cast_to_float(BigNum *dest, BigNum *op) {
-    assert(op->kind == BigNumKindInt);
-    dest->kind = BigNumKindFloat;
-
-    dest->data.x_float = (double)op->data.x_uint;
-
-    if (op->is_negative) {
-        dest->data.x_float = -dest->data.x_float;
-    }
-}
-
-void bignum_cast_to_int(BigNum *dest, BigNum *op) {
-    assert(op->kind == BigNumKindFloat);
-    dest->kind = BigNumKindInt;
-
-    if (op->data.x_float >= 0) {
-        dest->data.x_uint = (unsigned long long)op->data.x_float;
-        dest->is_negative = false;
-    } else {
-        dest->data.x_uint = (unsigned long long)-op->data.x_float;
-        dest->is_negative = true;
-    }
-}
-
-bool bignum_sub(BigNum *dest, BigNum *op1, BigNum *op2) {
-    BigNum op2_negated;
-    bignum_negate(&op2_negated, op2);
-    return bignum_add(dest, op1, &op2_negated);
-}
-
-bool bignum_mul(BigNum *dest, BigNum *op1, BigNum *op2) {
-    assert(op1->kind == op2->kind);
-    dest->kind = op1->kind;
-
-    if (dest->kind == BigNumKindFloat) {
-        dest->data.x_float = op1->data.x_float * op2->data.x_float;
-        return false;
-    }
-
-    if (__builtin_umulll_overflow(op1->data.x_uint, op2->data.x_uint, &dest->data.x_uint)) {
-        return true;
-    }
-
-    dest->is_negative = op1->is_negative != op2->is_negative;
-    bignum_normalize(dest);
-    return false;
-}
-
-bool bignum_div(BigNum *dest, BigNum *op1, BigNum *op2) {
-    assert(op1->kind == op2->kind);
-    dest->kind = op1->kind;
-
-    if (dest->kind == BigNumKindFloat) {
-        dest->data.x_float = op1->data.x_float / op2->data.x_float;
-    } else {
-        return bignum_div_trunc(dest, op1, op2);
-    }
-    return false;
-}
-
-bool bignum_div_trunc(BigNum *dest, BigNum *op1, BigNum *op2) {
-    assert(op1->kind == op2->kind);
-    dest->kind = op1->kind;
-
-    if (dest->kind == BigNumKindFloat) {
-        double result = op1->data.x_float / op2->data.x_float;
-        if (result >= 0) {
-            dest->data.x_float = floor(result);
-        } else {
-            dest->data.x_float = ceil(result);
-        }
-    } else {
-        dest->data.x_uint = op1->data.x_uint / op2->data.x_uint;
-        dest->is_negative = op1->is_negative != op2->is_negative;
-        bignum_normalize(dest);
-    }
-    return false;
-}
-
-bool bignum_div_floor(BigNum *dest, BigNum *op1, BigNum *op2) {
-    assert(op1->kind == op2->kind);
-    dest->kind = op1->kind;
-
-    if (dest->kind == BigNumKindFloat) {
-        dest->data.x_float = floor(op1->data.x_float / op2->data.x_float);
-    } else {
-        if (op1->is_negative != op2->is_negative) {
-            uint64_t result = op1->data.x_uint / op2->data.x_uint;
-            if (result * op2->data.x_uint == op1->data.x_uint) {
-                dest->data.x_uint = result;
-            } else {
-                dest->data.x_uint = result + 1;
-            }
-            dest->is_negative = true;
-        } else {
-            dest->data.x_uint = op1->data.x_uint / op2->data.x_uint;
-            dest->is_negative = false;
-        }
-    }
-    return false;
-}
-
-bool bignum_rem(BigNum *dest, BigNum *op1, BigNum *op2) {
-    assert(op1->kind == op2->kind);
-    dest->kind = op1->kind;
-
-    if (dest->kind == BigNumKindFloat) {
-        dest->data.x_float = fmod(op1->data.x_float, op2->data.x_float);
-    } else {
-        dest->data.x_uint = op1->data.x_uint % op2->data.x_uint;
-        dest->is_negative = op1->is_negative;
-        bignum_normalize(dest);
-    }
-    return false;
-}
-
-bool bignum_mod(BigNum *dest, BigNum *op1, BigNum *op2) {
-    assert(op1->kind == op2->kind);
-    dest->kind = op1->kind;
-
-    if (dest->kind == BigNumKindFloat) {
-        dest->data.x_float = fmod(fmod(op1->data.x_float, op2->data.x_float) + op2->data.x_float, op2->data.x_float);
-    } else {
-        if (op1->is_negative) {
-            dest->data.x_uint = (op2->data.x_uint - op1->data.x_uint % op2->data.x_uint) % op2->data.x_uint;
-        } else {
-            dest->data.x_uint = op1->data.x_uint % op2->data.x_uint;
-        }
-        dest->is_negative = false;
-        bignum_normalize(dest);
-    }
-    return false;
-}
-
-bool bignum_or(BigNum *dest, BigNum *op1, BigNum *op2) {
-    assert(op1->kind == BigNumKindInt);
-    assert(op2->kind == BigNumKindInt);
-
-    assert(!op1->is_negative);
-    assert(!op2->is_negative);
-
-    dest->kind = BigNumKindInt;
-    dest->data.x_uint = op1->data.x_uint | op2->data.x_uint;
-    return false;
-}
-
-bool bignum_and(BigNum *dest, BigNum *op1, BigNum *op2) {
-    assert(op1->kind == BigNumKindInt);
-    assert(op2->kind == BigNumKindInt);
-
-    assert(!op1->is_negative);
-    assert(!op2->is_negative);
-
-    dest->kind = BigNumKindInt;
-    dest->data.x_uint = op1->data.x_uint & op2->data.x_uint;
-    return false;
-}
-
-bool bignum_xor(BigNum *dest, BigNum *op1, BigNum *op2) {
-    assert(op1->kind == BigNumKindInt);
-    assert(op2->kind == BigNumKindInt);
-
-    assert(!op1->is_negative);
-    assert(!op2->is_negative);
-
-    dest->kind = BigNumKindInt;
-    dest->data.x_uint = op1->data.x_uint ^ op2->data.x_uint;
-    return false;
-}
-
-bool bignum_shl(BigNum *dest, BigNum *op1, BigNum *op2) {
-    assert(op1->kind == BigNumKindInt);
-    assert(op2->kind == BigNumKindInt);
-
-    assert(!op1->is_negative);
-    assert(!op2->is_negative);
-
-    dest->kind = BigNumKindInt;
-    dest->data.x_uint = op1->data.x_uint << op2->data.x_uint;
-    return false;
-}
-
-bool bignum_shr(BigNum *dest, BigNum *op1, BigNum *op2) {
-    assert(op1->kind == BigNumKindInt);
-    assert(op2->kind == BigNumKindInt);
-
-    assert(!op1->is_negative);
-    assert(!op2->is_negative);
-
-    dest->kind = BigNumKindInt;
-    dest->data.x_uint = op1->data.x_uint >> op2->data.x_uint;
-    return false;
-}
-
-
-Buf *bignum_to_buf(BigNum *bn) {
-    if (bn->kind == BigNumKindFloat) {
-        return buf_sprintf("%f", bn->data.x_float);
-    } else {
-        const char *neg = bn->is_negative ? "-" : "";
-        return buf_sprintf("%s%" ZIG_PRI_llu "", neg, bn->data.x_uint);
-    }
-}
-
-bool bignum_cmp_eq(BigNum *op1, BigNum *op2) {
-    assert(op1->kind == op2->kind);
-    if (op1->kind == BigNumKindFloat) {
-        return op1->data.x_float == op2->data.x_float;
-    } else {
-        return op1->data.x_uint == op2->data.x_uint &&
-            (op1->is_negative == op2->is_negative || op1->data.x_uint == 0);
-    }
-}
-
-bool bignum_cmp_neq(BigNum *op1, BigNum *op2) {
-    return !bignum_cmp_eq(op1, op2);
-}
-
-bool bignum_cmp_lt(BigNum *op1, BigNum *op2) {
-    return !bignum_cmp_gte(op1, op2);
-}
-
-bool bignum_cmp_gt(BigNum *op1, BigNum *op2) {
-    return !bignum_cmp_lte(op1, op2);
-}
-
-bool bignum_cmp_lte(BigNum *op1, BigNum *op2) {
-    assert(op1->kind == op2->kind);
-    if (op1->kind == BigNumKindFloat) {
-        return (op1->data.x_float <= op2->data.x_float);
-    }
-
-    // assume normalized is_negative
-    if (!op1->is_negative && !op2->is_negative) {
-        return op1->data.x_uint <= op2->data.x_uint;
-    } else if (op1->is_negative && op2->is_negative) {
-        return op1->data.x_uint >= op2->data.x_uint;
-    } else if (op1->is_negative && !op2->is_negative) {
-        return true;
-    } else {
-        return false;
-    }
-}
-
-bool bignum_cmp_gte(BigNum *op1, BigNum *op2) {
-    assert(op1->kind == op2->kind);
-
-    if (op1->kind == BigNumKindFloat) {
-        return (op1->data.x_float >= op2->data.x_float);
-    }
-
-    // assume normalized is_negative
-    if (!op1->is_negative && !op2->is_negative) {
-        return op1->data.x_uint >= op2->data.x_uint;
-    } else if (op1->is_negative && op2->is_negative) {
-        return op1->data.x_uint <= op2->data.x_uint;
-    } else if (op1->is_negative && !op2->is_negative) {
-        return false;
-    } else {
-        return true;
-    }
-}
-
-bool bignum_increment_by_scalar(BigNum *bignum, uint64_t scalar) {
-    assert(bignum->kind == BigNumKindInt);
-    assert(!bignum->is_negative);
-    return __builtin_uaddll_overflow(bignum->data.x_uint, scalar, &bignum->data.x_uint);
-}
-
-bool bignum_multiply_by_scalar(BigNum *bignum, uint64_t scalar) {
-    assert(bignum->kind == BigNumKindInt);
-    assert(!bignum->is_negative);
-    return __builtin_umulll_overflow(bignum->data.x_uint, scalar, &bignum->data.x_uint);
-}
-
-uint32_t bignum_ctz(BigNum *bignum, uint32_t bit_count) {
-    assert(bignum->kind == BigNumKindInt);
-
-    uint64_t x = bignum_to_twos_complement(bignum);
-    uint32_t result = 0;
-    for (uint32_t i = 0; i < bit_count; i += 1) {
-        if ((x & 0x1) != 0)
-            break;
-
-        result += 1;
-        x = x >> 1;
-    }
-    return result;
-}
-
-uint32_t bignum_clz(BigNum *bignum, uint32_t bit_count) {
-    assert(bignum->kind == BigNumKindInt);
-
-    if (bit_count == 0)
-        return 0;
-
-    uint64_t x = bignum_to_twos_complement(bignum);
-    uint64_t mask = ((uint64_t)1) << ((uint64_t)bit_count - 1);
-    uint32_t result = 0;
-    for (uint32_t i = 0; i < bit_count; i += 1) {
-        if ((x & mask) != 0)
-            break;
-
-        result += 1;
-        x = x << 1;
-    }
-    return result;
-}
-
-void bignum_write_twos_complement(BigNum *bn, uint8_t *buf, int bit_count, bool is_big_endian) {
-    assert(bn->kind == BigNumKindInt);
-    uint64_t x = bignum_to_twos_complement(bn);
-
-    int byte_count = (bit_count + 7) / 8;
-    for (int i = 0; i < byte_count; i += 1) {
-        uint8_t le_byte = (x >> (i * 8)) & 0xff;
-        if (is_big_endian) {
-            buf[byte_count - i - 1] = le_byte;
-        } else {
-            buf[i] = le_byte;
-        }
-    }
-}
-
-void bignum_read_twos_complement(BigNum *bn, uint8_t *buf, int bit_count, bool is_big_endian, bool is_signed) {
-    int byte_count = (bit_count + 7) / 8;
-
-    uint64_t twos_comp = 0;
-    for (int i = 0; i < byte_count; i += 1) {
-        uint8_t be_byte;
-        if (is_big_endian) {
-            be_byte = buf[i];
-        } else {
-            be_byte = buf[byte_count - i - 1];
-        }
-
-        twos_comp <<= 8;
-        twos_comp |= be_byte;
-    }
-
-    uint8_t be_byte = buf[is_big_endian ? 0 : byte_count - 1];
-    if (is_signed && ((be_byte >> 7) & 0x1) != 0) {
-        bn->is_negative = true;
-        uint64_t mask = 0;
-        for (int i = 0; i < bit_count; i += 1) {
-            mask <<= 1;
-            mask |= 1;
-        }
-        bn->data.x_uint = ((~twos_comp) & mask) + 1;
-    } else {
-        bn->data.x_uint = twos_comp;
-    }
-    bn->kind = BigNumKindInt;
-}
-
-void bignum_write_ieee597(BigNum *bn, uint8_t *buf, int bit_count, bool is_big_endian) {
-    assert(bn->kind == BigNumKindFloat);
-    if (bit_count == 32) {
-        float f32 = bn->data.x_float;
-        memcpy(buf, &f32, 4);
-    } else if (bit_count == 64) {
-        double f64 = bn->data.x_float;
-        memcpy(buf, &f64, 8);
-    } else {
-        zig_unreachable();
-    }
-}
-
-void bignum_read_ieee597(BigNum *bn, uint8_t *buf, int bit_count, bool is_big_endian) {
-    bn->kind = BigNumKindFloat;
-    if (bit_count == 32) {
-        float f32;
-        memcpy(&f32, buf, 4);
-        bn->data.x_float = f32;
-    } else if (bit_count == 64) {
-        double f64;
-        memcpy(&f64, buf, 8);
-        bn->data.x_float = f64;
-    } else {
-        zig_unreachable();
-    }
-}