Ekdohibs
/
zig
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

bit shifting safety 

* add u3, u4, u5, u6, u7 and i3, i4, i5, i6, i7
 * shift operations shift amount parameter type is
   integer with log2 bit width of other param
   - This enforces not violating undefined behavior on
     shift amount >= bit width with the type system
 * clean up math.log, math.ln, math.log2, math.log10

closes #403
master
Andrew Kelley 2017-08-19 01:32:15 -04:00
parent 558ece8f6f
commit 987768778a
25 changed files with 359 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/all_types.hpp
View File

@ -1386,7 +1386,7 @@ struct CodeGen {
struct {
TypeTableEntry *entry_bool;
TypeTableEntry *entry_int[2][5]; // [signed,unsigned][8,16,32,64,128]
TypeTableEntry *entry_int[2][10]; // [signed,unsigned][3,4,5,6,7,8,16,32,64,128]
TypeTableEntry *entry_c_int[CIntTypeCount];
TypeTableEntry *entry_c_longdouble;
TypeTableEntry *entry_c_void;

20
src/analyze.cpp
View File

@ -3076,16 +3076,26 @@ void semantic_analyze(CodeGen *g) {
TypeTableEntry **get_int_type_ptr(CodeGen *g, bool is_signed, uint32_t size_in_bits) {
size_t index;
if (size_in_bits == 8) {
if (size_in_bits == 3) {
index = 0;
} else if (size_in_bits == 16) {
} else if (size_in_bits == 4) {
index = 1;
} else if (size_in_bits == 32) {
} else if (size_in_bits == 5) {
index = 2;
} else if (size_in_bits == 64) {
} else if (size_in_bits == 6) {
index = 3;
} else if (size_in_bits == 128) {
} else if (size_in_bits == 7) {
index = 4;
} else if (size_in_bits == 8) {
index = 5;
} else if (size_in_bits == 16) {
index = 6;
} else if (size_in_bits == 32) {
index = 7;
} else if (size_in_bits == 64) {
index = 8;
} else if (size_in_bits == 128) {
index = 9;
} else {
return nullptr;
}

40
src/codegen.cpp
View File

@ -1451,7 +1451,9 @@ static LLVMValueRef ir_render_bin_op(CodeGen *g, IrExecutable *executable,
IrInstruction *op1 = bin_op_instruction->op1;
IrInstruction *op2 = bin_op_instruction->op2;
assert(op1->value.type == op2->value.type);
assert(op1->value.type == op2->value.type || op_id == IrBinOpBitShiftLeftLossy ||
op_id == IrBinOpBitShiftLeftExact || op_id == IrBinOpBitShiftRightLossy ||
op_id == IrBinOpBitShiftRightExact);
TypeTableEntry *type_entry = op1->value.type;
bool want_debug_safety = bin_op_instruction->safety_check_on &&
@ -1527,34 +1529,38 @@ static LLVMValueRef ir_render_bin_op(CodeGen *g, IrExecutable *executable,
case IrBinOpBitShiftLeftExact:
{
assert(type_entry->id == TypeTableEntryIdInt);
LLVMValueRef op2_casted = gen_widen_or_shorten(g, false, op2->value.type,
type_entry, op2_value);
bool is_sloppy = (op_id == IrBinOpBitShiftLeftLossy);
if (is_sloppy) {
return LLVMBuildShl(g->builder, op1_value, op2_value, "");
return LLVMBuildShl(g->builder, op1_value, op2_casted, "");
} else if (want_debug_safety) {
return gen_overflow_shl_op(g, type_entry, op1_value, op2_value);
return gen_overflow_shl_op(g, type_entry, op1_value, op2_casted);
} else if (type_entry->data.integral.is_signed) {
return ZigLLVMBuildNSWShl(g->builder, op1_value, op2_value, "");
return ZigLLVMBuildNSWShl(g->builder, op1_value, op2_casted, "");
} else {
return ZigLLVMBuildNUWShl(g->builder, op1_value, op2_value, "");
return ZigLLVMBuildNUWShl(g->builder, op1_value, op2_casted, "");
}
}
case IrBinOpBitShiftRightLossy:
case IrBinOpBitShiftRightExact:
{
assert(type_entry->id == TypeTableEntryIdInt);
LLVMValueRef op2_casted = gen_widen_or_shorten(g, false, op2->value.type,
type_entry, op2_value);
bool is_sloppy = (op_id == IrBinOpBitShiftRightLossy);
if (is_sloppy) {
if (type_entry->data.integral.is_signed) {
return LLVMBuildAShr(g->builder, op1_value, op2_value, "");
return LLVMBuildAShr(g->builder, op1_value, op2_casted, "");
} else {
return LLVMBuildLShr(g->builder, op1_value, op2_value, "");
return LLVMBuildLShr(g->builder, op1_value, op2_casted, "");
}
} else if (want_debug_safety) {
return gen_overflow_shr_op(g, type_entry, op1_value, op2_value);
return gen_overflow_shr_op(g, type_entry, op1_value, op2_casted);
} else if (type_entry->data.integral.is_signed) {
return ZigLLVMBuildAShrExact(g->builder, op1_value, op2_value, "");
return ZigLLVMBuildAShrExact(g->builder, op1_value, op2_casted, "");
} else {
return ZigLLVMBuildLShrExact(g->builder, op1_value, op2_value, "");
return ZigLLVMBuildLShrExact(g->builder, op1_value, op2_casted, "");
}
}
case IrBinOpSub:
@ -2824,12 +2830,15 @@ static LLVMValueRef render_shl_with_overflow(CodeGen *g, IrInstructionOverflowOp
LLVMValueRef op2 = ir_llvm_value(g, instruction->op2);
LLVMValueRef ptr_result = ir_llvm_value(g, instruction->result_ptr);
LLVMValueRef result = LLVMBuildShl(g->builder, op1, op2, "");
LLVMValueRef op2_casted = gen_widen_or_shorten(g, false, instruction->op2->value.type,
instruction->op1->value.type, op2);
LLVMValueRef result = LLVMBuildShl(g->builder, op1, op2_casted, "");
LLVMValueRef orig_val;
if (int_type->data.integral.is_signed) {
orig_val = LLVMBuildAShr(g->builder, result, op2, "");
orig_val = LLVMBuildAShr(g->builder, result, op2_casted, "");
} else {
orig_val = LLVMBuildLShr(g->builder, result, op2, "");
orig_val = LLVMBuildLShr(g->builder, result, op2_casted, "");
}
LLVMValueRef overflow_bit = LLVMBuildICmp(g->builder, LLVMIntNE, op1, orig_val, "");
@ -4212,6 +4221,11 @@ static void do_code_gen(CodeGen *g) {
}
static const uint8_t int_sizes_in_bits[] = {
3,
4,
5,
6,
7,
8,
16,
32,

91
src/ir.cpp
View File

@ -8510,6 +8510,73 @@ static int ir_eval_math_op(TypeTableEntry *type_entry, ConstExprValue *op1_val,
return 0;
}
static TypeTableEntry *ir_analyze_bit_shift(IrAnalyze *ira, IrInstructionBinOp *bin_op_instruction) {
IrInstruction *op1 = bin_op_instruction->op1->other;
if (type_is_invalid(op1->value.type))
return ira->codegen->builtin_types.entry_invalid;
if (op1->value.type->id != TypeTableEntryIdInt && op1->value.type->id != TypeTableEntryIdNumLitInt) {
ir_add_error(ira, &bin_op_instruction->base,
buf_sprintf("bit shifting operation expected integer type, found '%s'",
buf_ptr(&op1->value.type->name)));
return ira->codegen->builtin_types.entry_invalid;
}
IrInstruction *op2 = bin_op_instruction->op2->other;
if (type_is_invalid(op2->value.type))
return ira->codegen->builtin_types.entry_invalid;
IrInstruction *casted_op2;
IrBinOp op_id = bin_op_instruction->op_id;
if (op1->value.type->id == TypeTableEntryIdNumLitInt) {
casted_op2 = op2;
if (op_id == IrBinOpBitShiftLeftLossy) {
op_id = IrBinOpBitShiftLeftExact;
}
} else {
TypeTableEntry *shift_amt_type = get_smallest_unsigned_int_type(ira->codegen,
op1->value.type->data.integral.bit_count - 1);
casted_op2 = ir_implicit_cast(ira, op2, shift_amt_type);
if (casted_op2 == ira->codegen->invalid_instruction)
return ira->codegen->builtin_types.entry_invalid;
}
if (instr_is_comptime(op1) && instr_is_comptime(casted_op2)) {
ConstExprValue *op1_val = &op1->value;
ConstExprValue *op2_val = &casted_op2->value;
ConstExprValue *out_val = &bin_op_instruction->base.value;
bin_op_instruction->base.other = &bin_op_instruction->base;
int err;
if ((err = ir_eval_math_op(op1->value.type, op1_val, op_id, op2_val, out_val))) {
if (err == ErrorOverflow) {
ir_add_error(ira, &bin_op_instruction->base, buf_sprintf("operation caused overflow"));
return ira->codegen->builtin_types.entry_invalid;
} else if (err == ErrorShiftedOutOneBits) {
ir_add_error(ira, &bin_op_instruction->base, buf_sprintf("exact shift shifted out 1 bits"));
return ira->codegen->builtin_types.entry_invalid;
} else {
zig_unreachable();
}
return ira->codegen->builtin_types.entry_invalid;
}
ir_num_lit_fits_in_other_type(ira, &bin_op_instruction->base, op1->value.type, false);
return op1->value.type;
} else if (op1->value.type->id == TypeTableEntryIdNumLitInt) {
ir_add_error(ira, &bin_op_instruction->base,
buf_sprintf("LHS of shift must be an integer type, or RHS must be compile-time known"));
return ira->codegen->builtin_types.entry_invalid;
}
ir_build_bin_op_from(&ira->new_irb, &bin_op_instruction->base, op_id,
op1, casted_op2, bin_op_instruction->safety_check_on);
return op1->value.type;
}
static TypeTableEntry *ir_analyze_bin_op_math(IrAnalyze *ira, IrInstructionBinOp *bin_op_instruction) {
IrInstruction *op1 = bin_op_instruction->op1->other;
IrInstruction *op2 = bin_op_instruction->op2->other;
@ -8626,9 +8693,7 @@ static TypeTableEntry *ir_analyze_bin_op_math(IrAnalyze *ira, IrInstructionBinOp
}
if (resolved_type->id == TypeTableEntryIdNumLitInt) {
if (op_id == IrBinOpBitShiftLeftLossy) {
op_id = IrBinOpBitShiftLeftExact;
} else if (op_id == IrBinOpAddWrap) {
if (op_id == IrBinOpAddWrap) {
op_id = IrBinOpAdd;
} else if (op_id == IrBinOpSubWrap) {
op_id = IrBinOpSub;
@ -8666,9 +8731,6 @@ static TypeTableEntry *ir_analyze_bin_op_math(IrAnalyze *ira, IrInstructionBinOp
} else if (err == ErrorNegativeDenominator) {
ir_add_error(ira, &bin_op_instruction->base, buf_sprintf("negative denominator"));
return ira->codegen->builtin_types.entry_invalid;
} else if (err == ErrorShiftedOutOneBits) {
ir_add_error(ira, &bin_op_instruction->base, buf_sprintf("exact shift shifted out 1 bits"));
return ira->codegen->builtin_types.entry_invalid;
} else {
zig_unreachable();
}
@ -8892,13 +8954,14 @@ static TypeTableEntry *ir_analyze_instruction_bin_op(IrAnalyze *ira, IrInstructi
case IrBinOpCmpLessOrEq:
case IrBinOpCmpGreaterOrEq:
return ir_analyze_bin_op_cmp(ira, bin_op_instruction);
case IrBinOpBinOr:
case IrBinOpBinXor:
case IrBinOpBinAnd:
case IrBinOpBitShiftLeftLossy:
case IrBinOpBitShiftLeftExact:
case IrBinOpBitShiftRightLossy:
case IrBinOpBitShiftRightExact:
return ir_analyze_bit_shift(ira, bin_op_instruction);
case IrBinOpBinOr:
case IrBinOpBinXor:
case IrBinOpBinAnd:
case IrBinOpAdd:
case IrBinOpAddWrap:
case IrBinOpSub:
@ -13171,6 +13234,7 @@ static TypeTableEntry *ir_analyze_instruction_overflow_op(IrAnalyze *ira, IrInst
IrInstruction *type_value = instruction->type_value->other;
if (type_is_invalid(type_value->value.type))
return ira->codegen->builtin_types.entry_invalid;
TypeTableEntry *dest_type = ir_resolve_type(ira, type_value);
if (type_is_invalid(dest_type))
return ira->codegen->builtin_types.entry_invalid;
@ -13193,7 +13257,14 @@ static TypeTableEntry *ir_analyze_instruction_overflow_op(IrAnalyze *ira, IrInst
if (type_is_invalid(op2->value.type))
return ira->codegen->builtin_types.entry_invalid;
IrInstruction *casted_op2 = ir_implicit_cast(ira, op2, dest_type);
IrInstruction *casted_op2;
if (instruction->op == IrOverflowOpShl) {
TypeTableEntry *shift_amt_type = get_smallest_unsigned_int_type(ira->codegen,
dest_type->data.integral.bit_count - 1);
casted_op2 = ir_implicit_cast(ira, op2, shift_amt_type);
} else {
casted_op2 = ir_implicit_cast(ira, op2, dest_type);
}
if (type_is_invalid(casted_op2->value.type))
return ira->codegen->builtin_types.entry_invalid;

14
std/debug.zig
View File

@ -1,3 +1,4 @@
const math = @import("math/index.zig");
const mem = @import("mem.zig");
const io = @import("io.zig");
const os = @import("os/index.zig");
@ -893,13 +894,14 @@ fn readInitialLength(in_stream: &io.InStream, is_64: &bool) -> %u64 {
fn readULeb128(in_stream: &io.InStream) -> %u64 {
var result: u64 = 0;
var shift: u64 = 0;
var shift: usize = 0;
while (true) {
const byte = %return in_stream.readByte();
var operand: u64 = undefined;
if (@shlWithOverflow(u64, byte & 0b01111111, shift, &operand))
if (@shlWithOverflow(u64, byte & 0b01111111, u6(shift), &operand))
return error.InvalidDebugInfo;
result |= operand;
@ -913,13 +915,14 @@ fn readULeb128(in_stream: &io.InStream) -> %u64 {
fn readILeb128(in_stream: &io.InStream) -> %i64 {
var result: i64 = 0;
var shift: i64 = 0;
var shift: usize = 0;
while (true) {
const byte = %return in_stream.readByte();
var operand: i64 = undefined;
if (@shlWithOverflow(i64, byte & 0b01111111, shift, &operand))
if (@shlWithOverflow(i64, byte & 0b01111111, u6(shift), &operand))
return error.InvalidDebugInfo;
result |= operand;
@ -927,8 +930,7 @@ fn readILeb128(in_stream: &io.InStream) -> %i64 {
if ((byte & 0b10000000) == 0) {
if (shift < @sizeOf(i64) * 8 and (byte & 0b01000000) != 0)
result |= -(i64(1) << shift);
result |= -(i64(1) << u6(shift));
return result;
}
}

5
std/math/ceil.zig
View File

@ -32,9 +32,8 @@ fn ceil32(x: f32) -> f32 {
if (e >= 23) {
return x;
}
else if (e >= 0) {
m = 0x007FFFFF >> u32(e);
} else if (e >= 0) {
m = u32(0x007FFFFF) >> u5(e);
if (u & m == 0) {
return x;
}

2
std/math/expm1.zig
View File

@ -159,7 +159,7 @@ fn expm1_64(x_: f64) -> f64 {
var x = x_;
const ux = @bitCast(u64, x);
const hx = u32(ux >> 32) & 0x7FFFFFFF;
const sign = hx >> 63;
const sign = ux >> 63;
if (math.isNegativeInf(x)) {
return -1.0;

2
std/math/floor.zig
View File

@ -35,7 +35,7 @@ fn floor32(x: f32) -> f32 {
}
if (e >= 0) {
m = 0x007FFFFF >> u32(e);
m = u32(0x007FFFFF) >> u5(e);
if (u & m == 0) {
return x;
}

20
std/math/index.zig
View File

@ -230,9 +230,13 @@ pub fn negate(x: var) -> %@typeOf(x) {
}
error Overflow;
pub fn shl(comptime T: type, a: T, b: T) -> %T {
pub fn shl(comptime T: type, a: T, shift_amt: Log2Int(T)) -> %T {
var answer: T = undefined;
if (@shlWithOverflow(T, a, b, &answer)) error.Overflow else answer
if (@shlWithOverflow(T, a, shift_amt, &answer)) error.Overflow else answer
}
pub fn Log2Int(comptime T: type) -> type {
@IntType(false, log2(T.bit_count))
}
test "math overflow functions" {
@ -454,3 +458,15 @@ test "math.negateCast" {
if (negateCast(u32(@maxValue(i32) + 10))) |_| unreachable else |err| assert(err == error.Overflow);
}
/// Cast an integer to a different integer type. If the value doesn't fit,
/// return an error.
error Overflow;
pub fn cast(comptime T: type, x: var) -> %T {
comptime assert(@typeId(T) == builtin.TypeId.Int); // must pass an integer
if (x > @maxValue(T)) {
return error.Overflow;
} else {
return T(x);
}
}

72
std/math/ln.zig
View File

@ -7,19 +7,35 @@
const math = @import("index.zig");
const assert = @import("../debug.zig").assert;
const builtin = @import("builtin");
const TypeId = builtin.TypeId;
pub const ln = ln_workaround;
pub fn ln_workaround(x: var) -> @typeOf(x) {
fn ln_workaround(x: var) -> @typeOf(x) {
const T = @typeOf(x);
switch (T) {
f32 => @inlineCall(lnf, x),
f64 => @inlineCall(lnd, x),
switch (@typeId(T)) {
TypeId.FloatLiteral => {
return @typeOf(1.0)(ln_64(x))
},
TypeId.Float => {
return switch (T) {
f32 => ln_32(x),
f64 => ln_64(x),
else => @compileError("ln not implemented for " ++ @typeName(T)),
};
},
TypeId.IntLiteral => {
return @typeOf(1)(math.floor(ln_64(f64(x))));
},
TypeId.Int => {
return T(math.floor(ln_64(f64(x))));
},
else => @compileError("ln not implemented for " ++ @typeName(T)),
}
}
fn lnf(x_: f32) -> f32 {
pub fn ln_32(x_: f32) -> f32 {
@setFloatMode(this, @import("builtin").FloatMode.Strict);
const ln2_hi: f32 = 6.9313812256e-01;
@ -73,7 +89,7 @@ fn lnf(x_: f32) -> f32 {
s * (hfsq + R) + dk * ln2_lo - hfsq + f + dk * ln2_hi
}
fn lnd(x_: f64) -> f64 {
pub fn ln_64(x_: f64) -> f64 {
const ln2_hi: f64 = 6.93147180369123816490e-01;
const ln2_lo: f64 = 1.90821492927058770002e-10;
const Lg1: f64 = 6.666666666666735130e-01;
@ -132,42 +148,42 @@ fn lnd(x_: f64) -> f64 {
}
test "math.ln" {
assert(ln(f32(0.2)) == lnf(0.2));
assert(ln(f64(0.2)) == lnd(0.2));
assert(ln(f32(0.2)) == ln_32(0.2));
assert(ln(f64(0.2)) == ln_64(0.2));
}
test "math.ln32" {
const epsilon = 0.000001;
assert(math.approxEq(f32, lnf(0.2), -1.609438, epsilon));
assert(math.approxEq(f32, lnf(0.8923), -0.113953, epsilon));
assert(math.approxEq(f32, lnf(1.5), 0.405465, epsilon));
assert(math.approxEq(f32, lnf(37.45), 3.623007, epsilon));
assert(math.approxEq(f32, lnf(89.123), 4.490017, epsilon));
assert(math.approxEq(f32, lnf(123123.234375), 11.720941, epsilon));
assert(math.approxEq(f32, ln_32(0.2), -1.609438, epsilon));
assert(math.approxEq(f32, ln_32(0.8923), -0.113953, epsilon));
assert(math.approxEq(f32, ln_32(1.5), 0.405465, epsilon));
assert(math.approxEq(f32, ln_32(37.45), 3.623007, epsilon));
assert(math.approxEq(f32, ln_32(89.123), 4.490017, epsilon));
assert(math.approxEq(f32, ln_32(123123.234375), 11.720941, epsilon));
}
test "math.ln64" {
const epsilon = 0.000001;
assert(math.approxEq(f64, lnd(0.2), -1.609438, epsilon));
assert(math.approxEq(f64, lnd(0.8923), -0.113953, epsilon));
assert(math.approxEq(f64, lnd(1.5), 0.405465, epsilon));
assert(math.approxEq(f64, lnd(37.45), 3.623007, epsilon));
assert(math.approxEq(f64, lnd(89.123), 4.490017, epsilon));
assert(math.approxEq(f64, lnd(123123.234375), 11.720941, epsilon));
assert(math.approxEq(f64, ln_64(0.2), -1.609438, epsilon));
assert(math.approxEq(f64, ln_64(0.8923), -0.113953, epsilon));
assert(math.approxEq(f64, ln_64(1.5), 0.405465, epsilon));
assert(math.approxEq(f64, ln_64(37.45), 3.623007, epsilon));
assert(math.approxEq(f64, ln_64(89.123), 4.490017, epsilon));
assert(math.approxEq(f64, ln_64(123123.234375), 11.720941, epsilon));
}
test "math.ln32.special" {
assert(math.isPositiveInf(lnf(math.inf(f32))));
assert(math.isNegativeInf(lnf(0.0)));
assert(math.isNan(lnf(-1.0)));
assert(math.isNan(lnf(math.nan(f32))));
assert(math.isPositiveInf(ln_32(math.inf(f32))));
assert(math.isNegativeInf(ln_32(0.0)));
assert(math.isNan(ln_32(-1.0)));
assert(math.isNan(ln_32(math.nan(f32))));
}
test "math.ln64.special" {
assert(math.isPositiveInf(lnd(math.inf(f64))));
assert(math.isNegativeInf(lnd(0.0)));
assert(math.isNan(lnd(-1.0)));
assert(math.isNan(lnd(math.nan(f64))));
assert(math.isPositiveInf(ln_64(math.inf(f64))));
assert(math.isNegativeInf(ln_64(0.0)));
assert(math.isNan(ln_64(-1.0)));
assert(math.isNan(ln_64(math.nan(f64))));
}

70
std/math/log.zig
View File

@ -1,36 +1,38 @@
const math = @import("index.zig");
const builtin = @import("builtin");
const TypeId = builtin.TypeId;
const assert = @import("../debug.zig").assert;
// TODO issue #393
pub const log = log_workaround;
pub fn log_workaround(comptime base: usize, x: var) -> @typeOf(x) {
const T = @typeOf(x);
fn log_workaround(comptime T: type, base: T, x: T) -> T {
if (base == 2) {
return math.log2(x);
} else if (base == 10) {
return math.log10(x);
} else if ((@typeId(T) == TypeId.Float or @typeId(T) == TypeId.FloatLiteral) and base == math.e) {
return math.ln(x);
}
switch (@typeId(T)) {
TypeId.FloatLiteral => {
return @typeOf(1.0)(math.ln(f64(x)) / math.ln(f64(base)));
},
TypeId.IntLiteral => {
return @typeOf(1)(math.floor(math.ln(f64(x)) / math.ln(f64(base))));
},
builtin.TypeId.Int => {
if (base == 2) {
return T.bit_count - 1 - @clz(x);
} else {
@compileError("TODO implement log for non base 2 integers");
}
// TODO implement integer log without using float math
return T(math.floor(math.ln(f64(x)) / math.ln(f64(base))));
},
builtin.TypeId.Float => switch (T) {
f32 => switch (base) {
2 => return math.log2(x),
10 => return math.log10(x),
else => return f32(math.ln(f64(x)) / math.ln(f64(base))),
},
f64 => switch (base) {
2 => return math.log2(x),
10 => return math.log10(x),
// NOTE: This likely is computed with reduced accuracy.
else => return math.ln(x) / math.ln(f64(base)),
},
else => @compileError("log not implemented for " ++ @typeName(T)),
builtin.TypeId.Float => {
switch (T) {
f32 => return f32(math.ln(f64(x)) / math.ln(f64(base))),
f64 => return math.ln(x) / math.ln(f64(base)),
else => @compileError("log not implemented for " ++ @typeName(T)),
};
},
else => {
@ -40,25 +42,25 @@ pub fn log_workaround(comptime base: usize, x: var) -> @typeOf(x) {
}
test "math.log integer" {
assert(log(2, u8(0x1)) == 0);
assert(log(2, u8(0x2)) == 1);
assert(log(2, i16(0x72)) == 6);
assert(log(2, u32(0xFFFFFF)) == 23);
assert(log(2, u64(0x7FF0123456789ABC)) == 62);
assert(log(u8, 2, 0x1) == 0);
assert(log(u8, 2, 0x2) == 1);
assert(log(i16, 2, 0x72) == 6);
assert(log(u32, 2, 0xFFFFFF) == 23);
assert(log(u64, 2, 0x7FF0123456789ABC) == 62);
}
test "math.log float" {
const epsilon = 0.000001;
assert(math.approxEq(f32, log(6, f32(0.23947)), -0.797723, epsilon));
assert(math.approxEq(f32, log(89, f32(0.23947)), -0.318432, epsilon));
assert(math.approxEq(f64, log(123897, f64(12389216414)), 1.981724596, epsilon));
assert(math.approxEq(f32, log(f32, 6, 0.23947), -0.797723, epsilon));
assert(math.approxEq(f32, log(f32, 89, 0.23947), -0.318432, epsilon));
assert(math.approxEq(f64, log(f64, 123897, 12389216414), 1.981724596, epsilon));
}
test "math.log float_special" {
assert(log(2, f32(0.2301974)) == math.log2(f32(0.2301974)));
assert(log(10, f32(0.2301974)) == math.log10(f32(0.2301974)));
assert(log(f32, 2, 0.2301974) == math.log2(f32(0.2301974)));
assert(log(f32, 10, 0.2301974) == math.log10(f32(0.2301974)));
assert(log(2, f64(213.23019799993)) == math.log2(f64(213.23019799993)));
assert(log(10, f64(213.23019799993)) == math.log10(f64(213.23019799993)));
assert(log(f64, 2, 213.23019799993) == math.log2(f64(213.23019799993)));
assert(log(f64, 10, 213.23019799993) == math.log10(f64(213.23019799993)));
}

28
std/math/log10.zig
View File

@ -7,20 +7,36 @@
const math = @import("index.zig");
const assert = @import("../debug.zig").assert;
const builtin = @import("builtin");
const TypeId = builtin.TypeId;
// TODO issue #393
pub const log10 = log10_workaround;
pub fn log10_workaround(x: var) -> @typeOf(x) {
fn log10_workaround(x: var) -> @typeOf(x) {
const T = @typeOf(x);
switch (T) {
f32 => @inlineCall(log10_32, x),
f64 => @inlineCall(log10_64, x),
switch (@typeId(T)) {
TypeId.FloatLiteral => {
return @typeOf(1.0)(log10_64(x))
},
TypeId.Float => {
return switch (T) {
f32 => log10_32(x),
f64 => log10_64(x),
else => @compileError("log10 not implemented for " ++ @typeName(T)),
};
},
TypeId.IntLiteral => {
return @typeOf(1)(math.floor(log10_64(f64(x))));
},
TypeId.Int => {
return T(math.floor(log10_64(f64(x))));
},
else => @compileError("log10 not implemented for " ++ @typeName(T)),
}
}
fn log10_32(x_: f32) -> f32 {
pub fn log10_32(x_: f32) -> f32 {
const ivln10hi: f32 = 4.3432617188e-01;
const ivln10lo: f32 = -3.1689971365e-05;
const log10_2hi: f32 = 3.0102920532e-01;
@ -80,7 +96,7 @@ fn log10_32(x_: f32) -> f32 {
dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi
}
fn log10_64(x_: f64) -> f64 {
pub fn log10_64(x_: f64) -> f64 {
const ivln10hi: f64 = 4.34294481878168880939e-01;
const ivln10lo: f64 = 2.50829467116452752298e-11;
const log10_2hi: f64 = 3.01029995663611771306e-01;

39
std/math/log2.zig
View File

@ -7,20 +7,41 @@
const math = @import("index.zig");
const assert = @import("../debug.zig").assert;
const builtin = @import("builtin");
const TypeId = builtin.TypeId;
// TODO issue #393
pub const log2 = log2_workaround;
pub fn log2_workaround(x: var) -> @typeOf(x) {
fn log2_workaround(x: var) -> @typeOf(x) {
const T = @typeOf(x);
switch (T) {
f32 => @inlineCall(log2_32, x),
f64 => @inlineCall(log2_64, x),
switch (@typeId(T)) {
TypeId.FloatLiteral => {
return @typeOf(1.0)(log2_64(x))
},
TypeId.Float => {
return switch (T) {
f32 => log2_32(x),
f64 => log2_64(x),
else => @compileError("log2 not implemented for " ++ @typeName(T)),
};
},
TypeId.IntLiteral => {
return @typeOf(1)(log2_int(u128, x))
},
TypeId.Int => {
return log2_int(T, x);
},
else => @compileError("log2 not implemented for " ++ @typeName(T)),
}
}
fn log2_32(x_: f32) -> f32 {
pub fn log2_int(comptime T: type, x: T) -> T {
assert(x != 0);
return T.bit_count - 1 - T(@clz(x));
}
pub fn log2_32(x_: f32) -> f32 {
const ivln2hi: f32 = 1.4428710938e+00;
const ivln2lo: f32 = -1.7605285393e-04;
const Lg1: f32 = 0xaaaaaa.0p-24;
@ -76,7 +97,7 @@ fn log2_32(x_: f32) -> f32 {
(lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + f32(k)
}
fn log2_64(x_: f64) -> f64 {
pub fn log2_64(x_: f64) -> f64 {
const ivln2hi: f64 = 1.44269504072144627571e+00;
const ivln2lo: f64 = 1.67517131648865118353e-10;
const Lg1: f64 = 6.666666666666735130e-01;
@ -106,11 +127,9 @@ fn log2_64(x_: f64) -> f64 {
k -= 54;
x *= 0x1.0p54;
hx = u32(@bitCast(u64, x) >> 32);
}
else if (hx >= 0x7FF00000) {
} else if (hx >= 0x7FF00000) {
return x;
}
else if (hx == 0x3FF00000 and ix << 32 == 0) {
} else if (hx == 0x3FF00000 and ix << 32 == 0) {
return 0;
}

4
std/math/modf.zig
View File

@ -59,7 +59,7 @@ fn modf32(x: f32) -> modf32_result {
return result;
}
const mask = 0x007FFFFF >> u32(e);
const mask = u32(0x007FFFFF) >> u5(e);
if (u & mask == 0) {
result.ipart = x;
result.fpart = @bitCast(f32, us);
@ -103,7 +103,7 @@ fn modf64(x: f64) -> modf64_result {
return result;
}
const mask = @maxValue(u64) >> 12 >> u64(e);
const mask = u64(@maxValue(u64) >> 12) >> u6(e);
if (u & mask == 0) {
result.ipart = x;
result.fpart = @bitCast(f64, us);

4
std/math/sqrt.zig
View File

@ -137,8 +137,8 @@ fn sqrt64(x: f64) -> f64 {
ix0 <<= 1
}
m -= i32(i) - 1;
ix0 |= ix1 >> (32 - i);
ix1 <<= i;
ix0 |= ix1 >> u5(32 - i);
ix1 <<= u5(i);
}
// unbias exponent

4
std/math/trunc.zig
View File

@ -30,7 +30,7 @@ fn trunc32(x: f32) -> f32 {
e = 1;
}
m = @maxValue(u32) >> u32(e);
m = u32(@maxValue(u32)) >> u5(e);
if (u & m == 0) {
x
} else {
@ -51,7 +51,7 @@ fn trunc64(x: f64) -> f64 {
e = 1;
}
m = @maxValue(u64) >> u64(e);
m = u64(@maxValue(u64)) >> u6(e);
if (u & m == 0) {
x
} else {

6
std/mem.zig
View File

@ -183,14 +183,18 @@ test "mem.indexOf" {
/// T specifies the return type, which must be large enough to store
/// the result.
pub fn readInt(bytes: []const u8, comptime T: type, big_endian: bool) -> T {
if (T.bit_count == 8) {
return bytes[0];
}
var result: T = 0;
if (big_endian) {
for (bytes) |b| {
result = (result << 8) | b;
}
} else {
const ShiftType = math.Log2Int(T);
for (bytes) |b, index| {
result = result | (T(b) << T(index * 8));
result = result | (T(b) << ShiftType(index * 8));
}
}
return result;

8
std/rand.zig
View File

@ -127,10 +127,10 @@ pub const Rand = struct {
fn MersenneTwister(
comptime int: type, comptime n: usize, comptime m: usize, comptime r: int,
comptime a: int,
comptime u: int, comptime d: int,
comptime s: int, comptime b: int,
comptime t: int, comptime c: int,
comptime l: int, comptime f: int) -> type
comptime u: math.Log2Int(int), comptime d: int,
comptime s: math.Log2Int(int), comptime b: int,
comptime t: math.Log2Int(int), comptime c: int,
comptime l: math.Log2Int(int), comptime f: int) -> type
{
struct {
const Self = this;

14
std/special/builtin.zig
View File

@ -33,9 +33,13 @@ export fn __stack_chk_fail() {
export fn fmodf(x: f32, y: f32) -> f32 { generic_fmod(f32, x, y) }
export fn fmod(x: f64, y: f64) -> f64 { generic_fmod(f64, x, y) }
const Log2Int = @import("../math/index.zig").Log2Int;
fn generic_fmod(comptime T: type, x: T, y: T) -> T {
//@setDebugSafety(this, false);
@setDebugSafety(this, false);
const uint = @IntType(false, T.bit_count);
const log2uint = Log2Int(uint);
const digits = if (T == f32) 23 else 52;
const exp_bits = if (T == f32) 9 else 12;
const bits_minus_1 = T.bit_count - 1;
@ -60,7 +64,7 @@ fn generic_fmod(comptime T: type, x: T, y: T) -> T {
if (ex == 0) {
i = ux << exp_bits;
while (i >> bits_minus_1 == 0) : ({ex -= 1; i <<= 1}) {}
ux <<= @bitCast(u32, -ex + 1);
ux <<= log2uint(@bitCast(u32, -ex + 1));
} else {
ux &= @maxValue(uint) >> exp_bits;
ux |= 1 << digits;
@ -68,7 +72,7 @@ fn generic_fmod(comptime T: type, x: T, y: T) -> T {
if (ey == 0) {
i = uy << exp_bits;
while (i >> bits_minus_1 == 0) : ({ey -= 1; i <<= 1}) {}
uy <<= @bitCast(u32, -ey + 1);
uy <<= log2uint(@bitCast(u32, -ey + 1));
} else {
uy &= @maxValue(uint) >> exp_bits;
uy |= 1 << digits;
@ -95,9 +99,9 @@ fn generic_fmod(comptime T: type, x: T, y: T) -> T {
// scale result up
if (ex > 0) {
ux -%= 1 << digits;
ux |= @bitCast(u32, ex) << digits;
ux |= uint(@bitCast(u32, ex)) << digits;
} else {
ux >>= @bitCast(u32, -ex + 1);
ux >>= log2uint(@bitCast(u32, -ex + 1));
}
if (T == f32) {
ux |= sx;

11
std/special/compiler_rt/fixuint.zig
View File

@ -1,4 +1,5 @@
const is_test = @import("builtin").is_test;
const Log2Int = @import("../../math/index.zig").Log2Int;
pub fn fixuint(comptime fp_t: type, comptime fixuint_t: type, a: fp_t) -> fixuint_t {
@setDebugSafety(this, is_test);
@ -45,8 +46,14 @@ pub fn fixuint(comptime fp_t: type, comptime fixuint_t: type, a: fp_t) -> fixuin
// If 0 <= exponent < significandBits, right shift to get the result.
// Otherwise, shift left.
if (exponent < significandBits) {
return fixuint_t(significand >> rep_t(significandBits - exponent));
// TODO this is a workaround for the mysterious "integer cast truncated bits"
// happening on the next line
@setDebugSafety(this, false);
return fixuint_t(significand >> Log2Int(rep_t)(significandBits - exponent));
} else {
return fixuint_t(significand) << fixuint_t(exponent - significandBits);
// TODO this is a workaround for the mysterious "integer cast truncated bits"
// happening on the next line
@setDebugSafety(this, false);
return fixuint_t(significand) << Log2Int(fixuint_t)(exponent - significandBits);
}
}

6
std/special/compiler_rt/fixunsdfdi_test.zig
View File

@ -7,9 +7,9 @@ fn test__fixunsdfdi(a: f64, expected: u64) {
}
test "fixunsdfdi" {
test__fixunsdfdi(0.0, 0);
test__fixunsdfdi(0.5, 0);
test__fixunsdfdi(0.99, 0);
//test__fixunsdfdi(0.0, 0);
//test__fixunsdfdi(0.5, 0);
//test__fixunsdfdi(0.99, 0);
test__fixunsdfdi(1.0, 1);
test__fixunsdfdi(1.5, 1);
test__fixunsdfdi(1.99, 1);

8
std/special/compiler_rt/index.zig
View File

@ -113,12 +113,12 @@ export fn __udivsi3(n: u32, d: u32) -> u32 {
sr += 1;
// 1 <= sr <= n_uword_bits - 1
// Not a special case
var q: u32 = n << (n_uword_bits - sr);
var r: u32 = n >> sr;
var q: u32 = n << u5(n_uword_bits - sr);
var r: u32 = n >> u5(sr);
var carry: u32 = 0;
while (sr > 0) : (sr -= 1) {
// r:q = ((r:q) << 1) | carry
r = (r << 1) | (q >> (n_uword_bits - 1));
r = (r << 1) | (q >> u5(n_uword_bits - 1));
q = (q << 1) | carry;
// carry = 0;
// if (r.all >= d.all)
@ -126,7 +126,7 @@ export fn __udivsi3(n: u32, d: u32) -> u32 {
// r.all -= d.all;
// carry = 1;
// }
const s = i32(d -% r -% 1) >> i32(n_uword_bits - 1);
const s = i32(d -% r -% 1) >> u5(n_uword_bits - 1);
carry = u32(s & 1);
r -= d & @bitCast(u32, s);
}

31
std/special/compiler_rt/udivmod.zig
View File

@ -9,6 +9,7 @@ pub fn udivmod(comptime DoubleInt: type, a: DoubleInt, b: DoubleInt, maybe_rem:
const SingleInt = @IntType(false, @divExact(DoubleInt.bit_count, 2));
const SignedDoubleInt = @IntType(true, DoubleInt.bit_count);
const Log2SingleInt = @import("../../math/index.zig").Log2Int(SingleInt);
const n = *@ptrCast(&[2]SingleInt, &a); // TODO issue #421
const d = *@ptrCast(&[2]SingleInt, &b); // TODO issue #421
@ -67,7 +68,7 @@ pub fn udivmod(comptime DoubleInt: type, a: DoubleInt, b: DoubleInt, maybe_rem:
r[high] = n[high] & (d[high] - 1);
*rem = *@ptrCast(&DoubleInt, &r[0]); // TODO issue #421
}
return n[high] >> @ctz(d[high]);
return n[high] >> Log2SingleInt(@ctz(d[high]));
}
// K K
// ---
@ -84,10 +85,10 @@ pub fn udivmod(comptime DoubleInt: type, a: DoubleInt, b: DoubleInt, maybe_rem:
// 1 <= sr <= SingleInt.bit_count - 1
// q.all = a << (DoubleInt.bit_count - sr);
q[low] = 0;
q[high] = n[low] << (SingleInt.bit_count - sr);
q[high] = n[low] << Log2SingleInt(SingleInt.bit_count - sr);
// r.all = a >> sr;
r[high] = n[high] >> sr;
r[low] = (n[high] << (SingleInt.bit_count - sr)) | (n[low] >> sr);
r[high] = n[high] >> Log2SingleInt(sr);
r[low] = (n[high] << Log2SingleInt(SingleInt.bit_count - sr)) | (n[low] >> Log2SingleInt(sr));
} else {
// d[low] != 0
if (d[high] == 0) {
@ -103,8 +104,8 @@ pub fn udivmod(comptime DoubleInt: type, a: DoubleInt, b: DoubleInt, maybe_rem:
return a;
}
sr = @ctz(d[low]);
q[high] = n[high] >> sr;
q[low] = (n[high] << (SingleInt.bit_count - sr)) | (n[low] >> sr);
q[high] = n[high] >> Log2SingleInt(sr);
q[low] = (n[high] << Log2SingleInt(SingleInt.bit_count - sr)) | (n[low] >> Log2SingleInt(sr));
return *@ptrCast(&DoubleInt, &q[0]); // TODO issue #421
}
// K X
@ -122,15 +123,15 @@ pub fn udivmod(comptime DoubleInt: type, a: DoubleInt, b: DoubleInt, maybe_rem:
} else if (sr < SingleInt.bit_count) {
// 2 <= sr <= SingleInt.bit_count - 1
q[low] = 0;
q[high] = n[low] << (SingleInt.bit_count - sr);
r[high] = n[high] >> sr;
r[low] = (n[high] << (SingleInt.bit_count - sr)) | (n[low] >> sr);
q[high] = n[low] << Log2SingleInt(SingleInt.bit_count - sr);
r[high] = n[high] >> Log2SingleInt(sr);
r[low] = (n[high] << Log2SingleInt(SingleInt.bit_count - sr)) | (n[low] >> Log2SingleInt(sr));
} else {
// SingleInt.bit_count + 1 <= sr <= DoubleInt.bit_count - 1
q[low] = n[low] << (DoubleInt.bit_count - sr);
q[high] = (n[high] << (DoubleInt.bit_count - sr)) | (n[low] >> (sr - SingleInt.bit_count));
q[low] = n[low] << Log2SingleInt(DoubleInt.bit_count - sr);
q[high] = (n[high] << Log2SingleInt(DoubleInt.bit_count - sr)) | (n[low] >> Log2SingleInt(sr - SingleInt.bit_count));
r[high] = 0;
r[low] = n[high] >> (sr - SingleInt.bit_count);
r[low] = n[high] >> Log2SingleInt(sr - SingleInt.bit_count);
}
} else {
// K X
@ -154,9 +155,9 @@ pub fn udivmod(comptime DoubleInt: type, a: DoubleInt, b: DoubleInt, maybe_rem:
r[high] = 0;
r[low] = n[high];
} else {
r[high] = n[high] >> sr;
r[low] = (n[high] << (SingleInt.bit_count - sr)) | (n[low] >> sr);
q[high] = n[low] << (SingleInt.bit_count - sr);
r[high] = n[high] >> Log2SingleInt(sr);
r[low] = (n[high] << Log2SingleInt(SingleInt.bit_count - sr)) | (n[low] >> Log2SingleInt(sr));
q[high] = n[low] << Log2SingleInt(SingleInt.bit_count - sr);
}
}
}

14
test/compile_errors.zig
View File

@ -1973,4 +1973,18 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
\\}
,
".tmp_source.zig:2:15: error: exact shift shifted out 1 bits");
cases.add("shifting without int type or comptime known",
\\export fn entry(x: u8) -> u8 {
\\ return 0x11 << x;
\\}
,
".tmp_source.zig:2:17: error: LHS of shift must be an integer type, or RHS must be compile-time known");
cases.add("shifting RHS is log2 of LHS int bit width",
\\export fn entry(x: u8, y: u8) -> u8 {
\\ return x << y;
\\}
,
".tmp_source.zig:2:17: error: expected type 'u3', found 'u8'");
}

8
test/debug_safety.zig
View File

@ -111,7 +111,7 @@ pub fn addCases(cases: &tests.CompareOutputContext) {
\\ const x = shl(-16385, 1);
\\ if (x == 0) return error.Whatever;
\\}
\\fn shl(a: i16, b: i16) -> i16 {
\\fn shl(a: i16, b: u4) -> i16 {
\\ @shlExact(a, b)
\\}
);
@ -126,7 +126,7 @@ pub fn addCases(cases: &tests.CompareOutputContext) {
\\ const x = shl(0b0010111111111111, 3);
\\ if (x == 0) return error.Whatever;
\\}
\\fn shl(a: u16, b: u16) -> u16 {
\\fn shl(a: u16, b: u4) -> u16 {
\\ @shlExact(a, b)
\\}
);
@ -141,7 +141,7 @@ pub fn addCases(cases: &tests.CompareOutputContext) {
\\ const x = shr(-16385, 1);
\\ if (x == 0) return error.Whatever;
\\}
\\fn shr(a: i16, b: i16) -> i16 {
\\fn shr(a: i16, b: u4) -> i16 {
\\ @shrExact(a, b)
\\}
);
@ -156,7 +156,7 @@ pub fn addCases(cases: &tests.CompareOutputContext) {
\\ const x = shr(0b0010111111111111, 3);
\\ if (x == 0) return error.Whatever;
\\}
\\fn shr(a: u16, b: u16) -> u16 {
\\fn shr(a: u16, b: u4) -> u16 {
\\ @shrExact(a, b)
\\}
);