mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2026-01-03 20:13:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/master' into macos-stack-traces

Browse Source
This commit is contained in:
Andrew Kelley 2018-08-25 04:48:58 -04:00
commit 815950996d
21 changed files with 62 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
doc/langref.html.in
View File

@ -744,19 +744,19 @@ const yet_another_hex_float = 0x103.70P-5;
{#code_end#}
{#header_close#}
{#header_open|Floating Point Operations#}
<p>By default floating point operations use <code>Optimized</code> mode,
but you can switch to <code>Strict</code> mode on a per-block basis:</p>
<p>By default floating point operations use <code>Strict</code> mode,
but you can switch to <code>Optimized</code> mode on a per-block basis:</p>
{#code_begin|obj|foo#}
{#code_release_fast#}
const builtin = @import("builtin");
const big = f64(1 << 40);
export fn foo_strict(x: f64) f64 {
@setFloatMode(this, builtin.FloatMode.Strict);
return x + big - big;
}
export fn foo_optimized(x: f64) f64 {
@setFloatMode(this, builtin.FloatMode.Optimized);
return x + big - big;
}
{#code_end#}
@ -5948,7 +5948,7 @@ pub const FloatMode = enum {
{#code_end#}
<ul>
<li>
<code>Optimized</code> (default) - Floating point operations may do all of the following:
<code>Optimized</code> - Floating point operations may do all of the following:
<ul>
<li>Assume the arguments and result are not NaN. Optimizations are required to retain defined behavior over NaNs, but the value of the result is undefined.</li>
<li>Assume the arguments and result are not +/-Inf. Optimizations are required to retain defined behavior over +/-Inf, but the value of the result is undefined.</li>
@ -5960,7 +5960,7 @@ pub const FloatMode = enum {
This is equivalent to <code>-ffast-math</code> in GCC.
</li>
<li>
<code>Strict</code> - Floating point operations follow strict IEEE compliance.
<code>Strict</code> (default) - Floating point operations follow strict IEEE compliance.
</li>
</ul>
{#see_also|Floating Point Operations#}
@ -6166,7 +6166,7 @@ pub const TypeInfo = union(TypeId) {
size: Size,
is_const: bool,
is_volatile: bool,
alignment: u32,
alignment: u29,
child: type,
pub const Size = enum {

4
src/all_types.hpp
View File

@ -1852,7 +1852,7 @@ struct ScopeDecls {
HashMap<Buf *, Tld *, buf_hash, buf_eql_buf> decl_table;
bool safety_off;
AstNode *safety_set_node;
bool fast_math_off;
bool fast_math_on;
AstNode *fast_math_set_node;
ImportTableEntry *import;
// If this is a scope from a container, this is the type entry, otherwise null
@ -1872,7 +1872,7 @@ struct ScopeBlock {
bool safety_off;
AstNode *safety_set_node;
bool fast_math_off;
bool fast_math_on;
AstNode *fast_math_set_node;
};

2
src/analyze.cpp
View File

@ -3073,7 +3073,7 @@ static bool scope_is_root_decls(Scope *scope) {
static void wrong_panic_prototype(CodeGen *g, AstNode *proto_node, TypeTableEntry *fn_type) {
add_node_error(g, proto_node,
buf_sprintf("expected 'fn([]const u8, ?&builtin.StackTrace) unreachable', found '%s'",
buf_sprintf("expected 'fn([]const u8, ?*builtin.StackTrace) noreturn', found '%s'",
buf_ptr(&fn_type->name)));
}

6
src/codegen.cpp
View File

@ -829,15 +829,15 @@ static bool ir_want_fast_math(CodeGen *g, IrInstruction *instruction) {
if (scope->id == ScopeIdBlock) {
ScopeBlock *block_scope = (ScopeBlock *)scope;
if (block_scope->fast_math_set_node)
return !block_scope->fast_math_off;
return block_scope->fast_math_on;
} else if (scope->id == ScopeIdDecls) {
ScopeDecls *decls_scope = (ScopeDecls *)scope;
if (decls_scope->fast_math_set_node)
return !decls_scope->fast_math_off;
return decls_scope->fast_math_on;
}
scope = scope->parent;
}
return true;
return false;
}
static bool ir_want_runtime_safety(CodeGen *g, IrInstruction *instruction) {

12
src/ir.cpp
View File

@ -15203,17 +15203,17 @@ static TypeTableEntry *ir_analyze_instruction_set_float_mode(IrAnalyze *ira,
return ira->codegen->builtin_types.entry_void;
}
bool *fast_math_off_ptr;
bool *fast_math_on_ptr;
AstNode **fast_math_set_node_ptr;
if (target_type->id == TypeTableEntryIdBlock) {
ScopeBlock *block_scope = (ScopeBlock *)target_val->data.x_block;
fast_math_off_ptr = &block_scope->fast_math_off;
fast_math_on_ptr = &block_scope->fast_math_on;
fast_math_set_node_ptr = &block_scope->fast_math_set_node;
} else if (target_type->id == TypeTableEntryIdFn) {
assert(target_val->data.x_ptr.special == ConstPtrSpecialFunction);
FnTableEntry *target_fn = target_val->data.x_ptr.data.fn.fn_entry;
assert(target_fn->def_scope);
fast_math_off_ptr = &target_fn->def_scope->fast_math_off;
fast_math_on_ptr = &target_fn->def_scope->fast_math_on;
fast_math_set_node_ptr = &target_fn->def_scope->fast_math_set_node;
} else if (target_type->id == TypeTableEntryIdMetaType) {
ScopeDecls *decls_scope;
@ -15229,7 +15229,7 @@ static TypeTableEntry *ir_analyze_instruction_set_float_mode(IrAnalyze *ira,
buf_sprintf("expected scope reference, found type '%s'", buf_ptr(&type_arg->name)));
return ira->codegen->builtin_types.entry_invalid;
}
fast_math_off_ptr = &decls_scope->fast_math_off;
fast_math_on_ptr = &decls_scope->fast_math_on;
fast_math_set_node_ptr = &decls_scope->fast_math_set_node;
} else {
ir_add_error_node(ira, target_instruction->source_node,
@ -15251,7 +15251,7 @@ static TypeTableEntry *ir_analyze_instruction_set_float_mode(IrAnalyze *ira,
return ira->codegen->builtin_types.entry_invalid;
}
*fast_math_set_node_ptr = source_node;
*fast_math_off_ptr = (float_mode_scalar == FloatModeStrict);
*fast_math_on_ptr = (float_mode_scalar == FloatModeOptimized);
ir_build_const_from(ira, &instruction->base);
return ira->codegen->builtin_types.entry_void;
@ -17093,7 +17093,7 @@ static ConstExprValue *create_ptr_like_type_info(IrAnalyze *ira, TypeTableEntry
// alignment: u32
ensure_field_index(result->type, "alignment", 3);
fields[3].special = ConstValSpecialStatic;
fields[3].type = ira->codegen->builtin_types.entry_u32;
fields[3].type = get_int_type(ira->codegen, false, 29);
bigint_init_unsigned(&fields[3].data.x_bigint, attrs_type->data.pointer.alignment);
// child: type
ensure_field_index(result->type, "child", 4);

5
std/event/fs.zig
View File

@ -638,10 +638,7 @@ pub async fn readFile(loop: *Loop, file_path: []const u8, max_size: usize) ![]u8
var close_op = try CloseOperation.start(loop);
defer close_op.finish();
const path_with_null = try std.cstr.addNullByte(loop.allocator, file_path);
defer loop.allocator.free(path_with_null);
const fd = try await (async openRead(loop, path_with_null[0..file_path.len]) catch unreachable);
const fd = try await (async openRead(loop, file_path) catch unreachable);
close_op.setHandle(fd);
var list = std.ArrayList(u8).init(loop.allocator);

4
std/fmt/errol/index.zig
View File

@ -253,11 +253,7 @@ fn gethi(in: f64) f64 {
/// Normalize the number by factoring in the error.
/// @hp: The float pair.
fn hpNormalize(hp: *HP) void {
// Required to avoid segfaults causing buffer overrun during errol3 digit output termination.
@setFloatMode(this, @import("builtin").FloatMode.Strict);
const val = hp.val;
hp.val += hp.off;
hp.off += val - hp.val;
}

2
std/math/ceil.zig
View File

@ -61,10 +61,8 @@ fn ceil64(x: f64) f64 {
}
if (u >> 63 != 0) {
@setFloatMode(this, builtin.FloatMode.Strict);
y = x - math.f64_toint + math.f64_toint - x;
} else {
@setFloatMode(this, builtin.FloatMode.Strict);
y = x + math.f64_toint - math.f64_toint - x;
}

2
std/math/complex/exp.zig
View File

@ -17,8 +17,6 @@ pub fn exp(z: var) @typeOf(z) {
}
fn exp32(z: Complex(f32)) Complex(f32) {
@setFloatMode(this, @import("builtin").FloatMode.Strict);
const exp_overflow = 0x42b17218; // max_exp * ln2 ~= 88.72283955
const cexp_overflow = 0x43400074; // (max_exp - min_denom_exp) * ln2

2
std/math/cos.zig
View File

@ -37,8 +37,6 @@ const C5 = 4.16666666666665929218E-2;
//
// This may have slight differences on some edge cases and may need to replaced if so.
fn cos32(x_: f32) f32 {
@setFloatMode(this, @import("builtin").FloatMode.Strict);
const pi4a = 7.85398125648498535156e-1;
const pi4b = 3.77489470793079817668E-8;
const pi4c = 2.69515142907905952645E-15;

4
std/math/exp.zig
View File

@ -18,8 +18,6 @@ pub fn exp(x: var) @typeOf(x) {
}
fn exp32(x_: f32) f32 {
@setFloatMode(this, builtin.FloatMode.Strict);
const half = []f32{ 0.5, -0.5 };
const ln2hi = 6.9314575195e-1;
const ln2lo = 1.4286067653e-6;
@ -95,8 +93,6 @@ fn exp32(x_: f32) f32 {
}
fn exp64(x_: f64) f64 {
@setFloatMode(this, builtin.FloatMode.Strict);
const half = []const f64{ 0.5, -0.5 };
const ln2hi: f64 = 6.93147180369123816490e-01;
const ln2lo: f64 = 1.90821492927058770002e-10;

4
std/math/exp2.zig
View File

@ -36,8 +36,6 @@ const exp2ft = []const f64{
};
fn exp2_32(x: f32) f32 {
@setFloatMode(this, @import("builtin").FloatMode.Strict);
const tblsiz = @intCast(u32, exp2ft.len);
const redux: f32 = 0x1.8p23 / @intToFloat(f32, tblsiz);
const P1: f32 = 0x1.62e430p-1;
@ -353,8 +351,6 @@ const exp2dt = []f64{
};
fn exp2_64(x: f64) f64 {
@setFloatMode(this, @import("builtin").FloatMode.Strict);
const tblsiz = @intCast(u32, exp2dt.len / 2);
const redux: f64 = 0x1.8p52 / @intToFloat(f64, tblsiz);
const P1: f64 = 0x1.62e42fefa39efp-1;

4
std/math/expm1.zig
View File

@ -19,8 +19,6 @@ pub fn expm1(x: var) @typeOf(x) {
}
fn expm1_32(x_: f32) f32 {
@setFloatMode(this, builtin.FloatMode.Strict);
if (math.isNan(x_))
return math.nan(f32);
@ -149,8 +147,6 @@ fn expm1_32(x_: f32) f32 {
}
fn expm1_64(x_: f64) f64 {
@setFloatMode(this, builtin.FloatMode.Strict);
if (math.isNan(x_))
return math.nan(f64);

2
std/math/floor.zig
View File

@ -97,10 +97,8 @@ fn floor64(x: f64) f64 {
}
if (u >> 63 != 0) {
@setFloatMode(this, builtin.FloatMode.Strict);
y = x - math.f64_toint + math.f64_toint - x;
} else {
@setFloatMode(this, builtin.FloatMode.Strict);
y = x + math.f64_toint - math.f64_toint - x;
}

4
std/math/ln.zig
View File

@ -35,8 +35,6 @@ pub fn ln(x: var) @typeOf(x) {
}
pub fn ln_32(x_: f32) f32 {
@setFloatMode(this, @import("builtin").FloatMode.Strict);
const ln2_hi: f32 = 6.9313812256e-01;
const ln2_lo: f32 = 9.0580006145e-06;
const Lg1: f32 = 0xaaaaaa.0p-24;
@ -89,8 +87,6 @@ pub fn ln_32(x_: f32) f32 {
}
pub fn ln_64(x_: f64) f64 {
@setFloatMode(this, @import("builtin").FloatMode.Strict);
const ln2_hi: f64 = 6.93147180369123816490e-01;
const ln2_lo: f64 = 1.90821492927058770002e-10;
const Lg1: f64 = 6.666666666666735130e-01;

2
std/math/pow.zig
View File

@ -28,8 +28,6 @@ const assert = std.debug.assert;
// This implementation is taken from the go stlib, musl is a bit more complex.
pub fn pow(comptime T: type, x: T, y: T) T {
@setFloatMode(this, @import("builtin").FloatMode.Strict);
if (T != f32 and T != f64) {
@compileError("pow not implemented for " ++ @typeName(T));
}

12
std/math/round.zig
View File

@ -35,11 +35,7 @@ fn round32(x_: f32) f32 {
return 0 * @bitCast(f32, u);
}
{
@setFloatMode(this, builtin.FloatMode.Strict);
y = x + math.f32_toint - math.f32_toint - x;
}
y = x + math.f32_toint - math.f32_toint - x;
if (y > 0.5) {
y = y + x - 1;
} else if (y <= -0.5) {
@ -72,11 +68,7 @@ fn round64(x_: f64) f64 {
return 0 * @bitCast(f64, u);
}
{
@setFloatMode(this, builtin.FloatMode.Strict);
y = x + math.f64_toint - math.f64_toint - x;
}
y = x + math.f64_toint - math.f64_toint - x;
if (y > 0.5) {
y = y + x - 1;
} else if (y <= -0.5) {

2
std/math/sin.zig
View File

@ -38,8 +38,6 @@ const C5 = 4.16666666666665929218E-2;
//
// This may have slight differences on some edge cases and may need to replaced if so.
fn sin32(x_: f32) f32 {
@setFloatMode(this, @import("builtin").FloatMode.Strict);
const pi4a = 7.85398125648498535156e-1;
const pi4b = 3.77489470793079817668E-8;
const pi4c = 2.69515142907905952645E-15;

2
std/math/sinh.zig
View File

@ -54,8 +54,6 @@ fn sinh32(x: f32) f32 {
}
fn sinh64(x: f64) f64 {
@setFloatMode(this, @import("builtin").FloatMode.Strict);
const u = @bitCast(u64, x);
const w = @intCast(u32, u >> 32);
const ax = @bitCast(f64, u & (@maxValue(u64) >> 1));

2
std/math/tan.zig
View File

@ -31,8 +31,6 @@ const Tq4 = -5.38695755929454629881E7;
//
// This may have slight differences on some edge cases and may need to replaced if so.
fn tan32(x_: f32) f32 {
@setFloatMode(this, @import("builtin").FloatMode.Strict);
const pi4a = 7.85398125648498535156e-1;
const pi4b = 3.77489470793079817668E-8;
const pi4c = 2.69515142907905952645E-15;

42
std/mem.zig
View File

@ -679,10 +679,38 @@ test "testWriteInt" {
comptime testWriteIntImpl();
}
fn testWriteIntImpl() void {
var bytes: [4]u8 = undefined;
var bytes: [8]u8 = undefined;
writeInt(bytes[0..], u64(0x12345678CAFEBABE), builtin.Endian.Big);
assert(eql(u8, bytes, []u8{
0x12,
0x34,
0x56,
0x78,
0xCA,
0xFE,
0xBA,
0xBE,
}));
writeInt(bytes[0..], u64(0xBEBAFECA78563412), builtin.Endian.Little);
assert(eql(u8, bytes, []u8{
0x12,
0x34,
0x56,
0x78,
0xCA,
0xFE,
0xBA,
0xBE,
}));
writeInt(bytes[0..], u32(0x12345678), builtin.Endian.Big);
assert(eql(u8, bytes, []u8{
0x00,
0x00,
0x00,
0x00,
0x12,
0x34,
0x56,
@ -695,10 +723,18 @@ fn testWriteIntImpl() void {
0x34,
0x56,
0x78,
0x00,
0x00,
0x00,
0x00,
}));
writeInt(bytes[0..], u16(0x1234), builtin.Endian.Big);
assert(eql(u8, bytes, []u8{
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x12,
@ -711,6 +747,10 @@ fn testWriteIntImpl() void {
0x12,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
}));
}