Commit 1c73c08298fc3a19886038d935e45cf74ba152fb | zig

author	emekoi <emekankurumeh@outlook.com> 2019-05-19 15:26:43-05:00
committer	Andrew Kelley <andrew@ziglang.org> 2019-05-19 16:33:31-04:00
log	1c73c08298fc3a19886038d935e45cf74ba152fb
tree	0583f8c9b0118e3e9f3c0268d6e6ea14063cd363
parent	6672ee9eb39a1cd9a3d6874ac1fb6de347ee2d33

ran zig fmt on stdlib

8 files changed, 71 insertions(+), 149 deletions(-)

std
- debug.zig
- io.zig
- os
  - linux
    tls.zig
- special
  - bootstrap.zig
  - c.zig
  - compiler_rt
    extendXfYf2.zig
- valgrind
  - callgrind.zig
  - memcheck.zig

std/debug.zig+10-8

...	...	@@ -1490,14 +1490,16 @@ fn parseFormValueTargetAddrSize(in_stream: var) !u64 {
1490	1490	}
1491	1491
1492	1492	fn parseFormValueRef(allocator: *mem.Allocator, in_stream: var, size: i32) !FormValue {
1493		return FormValue{ .Ref = switch (size) {
1494		1 => try in_stream.readIntLittle(u8),
1495		2 => try in_stream.readIntLittle(u16),
1496		4 => try in_stream.readIntLittle(u32),
1497		8 => try in_stream.readIntLittle(u64),
1498		-1 => try leb.readULEB128(u64, in_stream),
1499		else => unreachable,
1500		} };
	1493	return FormValue{
	1494	.Ref = switch (size) {
	1495	1 => try in_stream.readIntLittle(u8),
	1496	2 => try in_stream.readIntLittle(u16),
	1497	4 => try in_stream.readIntLittle(u32),
	1498	8 => try in_stream.readIntLittle(u64),
	1499	-1 => try leb.readULEB128(u64, in_stream),
	1500	else => unreachable,
	1501	},
	1502	};
1501	1503	}
1502	1504
1503	1505	fn parseFormValue(allocator: *mem.Allocator, in_stream: var, form_id: u64, is_64: bool) anyerror!FormValue {

std/io.zig+12-8

...	...	@@ -1116,10 +1116,12 @@ pub fn Deserializer(comptime endian: builtin.Endian, comptime packing: Packing,
1116	1116	pub const Stream = InStream(Error);
1117	1117
1118	1118	pub fn init(in_stream: *Stream) Self {
1119		return Self{ .in_stream = switch (packing) {
1120		.Bit => BitInStream(endian, Stream.Error).init(in_stream),
1121		.Byte => in_stream,
1122		} };
	1119	return Self{
	1120	.in_stream = switch (packing) {
	1121	.Bit => BitInStream(endian, Stream.Error).init(in_stream),
	1122	.Byte => in_stream,
	1123	},
	1124	};
1123	1125	}
1124	1126
1125	1127	pub fn alignToByte(self: *Self) void {
...	...	@@ -1325,10 +1327,12 @@ pub fn Serializer(comptime endian: builtin.Endian, comptime packing: Packing, co
1325	1327	pub const Stream = OutStream(Error);
1326	1328
1327	1329	pub fn init(out_stream: *Stream) Self {
1328		return Self{ .out_stream = switch (packing) {
1329		.Bit => BitOutStream(endian, Stream.Error).init(out_stream),
1330		.Byte => out_stream,
1331		} };
	1330	return Self{
	1331	.out_stream = switch (packing) {
	1332	.Bit => BitOutStream(endian, Stream.Error).init(out_stream),
	1333	.Byte => out_stream,
	1334	},
	1335	};
1332	1336	}
1333	1337
1334	1338	/// Flushes any unwritten bits to the stream

std/os/linux/tls.zig+1-1

...	...	@@ -114,7 +114,7 @@ pub fn setThreadPointer(addr: usize) void {
114	114	.aarch64 => {
115	115	asm volatile (
116	116	\\ msr tpidr_el0, %[addr]
117		:
	117	:
118	118	: [addr] "r" (addr)
119	119	);
120	120	},

std/special/bootstrap.zig+4-1

...	...	@@ -8,7 +8,10 @@ const assert = std.debug.assert;
8	8
9	9	var argc_ptr: [*]usize = undefined;
10	10
11		const is_wasm = switch (builtin.arch) { .wasm32, .wasm64 => true, else => false};
	11	const is_wasm = switch (builtin.arch) {
	12	.wasm32, .wasm64 => true,
	13	else => false,
	14	};
12	15
13	16	comptime {
14	17	if (builtin.link_libc) {

std/special/c.zig+8-2

...	...	@@ -8,8 +8,14 @@ const std = @import("std");
8	8	const builtin = @import("builtin");
9	9	const maxInt = std.math.maxInt;
10	10
11		const is_wasm = switch (builtin.arch) { .wasm32, .wasm64 => true, else => false};
12		const is_freestanding = switch (builtin.os) { .freestanding => true, else => false };
	11	const is_wasm = switch (builtin.arch) {
	12	.wasm32, .wasm64 => true,
	13	else => false,
	14	};
	15	const is_freestanding = switch (builtin.os) {
	16	.freestanding => true,
	17	else => false,
	18	};
13	19	comptime {
14	20	if (is_freestanding and is_wasm and builtin.link_libc) {
15	21	@export("_start", wasm_start, .Strong);

std/special/compiler_rt/extendXfYf2.zig+1-1

...	...	@@ -76,7 +76,7 @@ fn extendXfYf2(comptime dst_t: type, comptime src_t: type, a: @IntType(false, @t
76	76	// renormalize the significand and clear the leading bit, then insert
77	77	// the correct adjusted exponent in the destination type.
78	78	const scale: u32 = @clz(src_rep_t, aAbs) -
79		@clz(src_rep_t, src_rep_t(srcMinNormal));
	79	@clz(src_rep_t, src_rep_t(srcMinNormal));
80	80	absResult = dst_rep_t(aAbs) << @intCast(DstShift, dstSigBits - srcSigBits + scale);
81	81	absResult ^= dstMinNormal;
82	82	const resultExponent: u32 = dstExpBias - srcExpBias - scale + 1;

std/valgrind/callgrind.zig+9-32

...	...	@@ -10,70 +10,48 @@ pub const CallgrindClientRequest = extern enum {
10	10	StopInstrumentation,
11	11	};
12	12
13		fn doCallgrindClientRequestExpr(default: usize, request: CallgrindClientRequest,
14		a1: usize, a2: usize, a3: usize, a4: usize, a5: usize
15		) usize
16		{
17		return valgrind.doClientRequest(
18		default,
19		@intCast(usize, @enumToInt(request)),
20		a1, a2, a3, a4, a5);
	13	fn doCallgrindClientRequestExpr(default: usize, request: CallgrindClientRequest, a1: usize, a2: usize, a3: usize, a4: usize, a5: usize) usize {
	14	return valgrind.doClientRequest(default, @intCast(usize, @enumToInt(request)), a1, a2, a3, a4, a5);
21	15	}
22	16
23		fn doCallgrindClientRequestStmt(request: CallgrindClientRequest,
24		a1: usize, a2: usize, a3: usize, a4: usize, a5: usize
25		) void
26		{
	17	fn doCallgrindClientRequestStmt(request: CallgrindClientRequest, a1: usize, a2: usize, a3: usize, a4: usize, a5: usize) void {
27	18	_ = doCallgrindClientRequestExpr(0, request, a1, a2, a3, a4, a5);
28	19	}
29	20
30
31
32	21	/// Dump current state of cost centers, and zero them afterwards
33	22	pub fn dumpStats() void {
34		doCallgrindClientRequestStmt(CallgrindClientRequest.DumpStats,
35		0, 0, 0, 0, 0);
	23	doCallgrindClientRequestStmt(CallgrindClientRequest.DumpStats, 0, 0, 0, 0, 0);
36	24	}
37	25
38
39	26	/// Dump current state of cost centers, and zero them afterwards.
40	27	/// The argument is appended to a string stating the reason which triggered
41	28	/// the dump. This string is written as a description field into the
42	29	/// profile data dump.
43	30	pub fn dumpStatsAt(pos_str: [*]u8) void {
44		doCallgrindClientRequestStmt(CallgrindClientRequest.DumpStatsAt,
45		@ptrToInt(pos_str),
46		0, 0, 0, 0);
	31	doCallgrindClientRequestStmt(CallgrindClientRequest.DumpStatsAt, @ptrToInt(pos_str), 0, 0, 0, 0);
47	32	}
48	33
49
50	34	/// Zero cost centers
51	35	pub fn zeroStats() void {
52		doCallgrindClientRequestStmt(CallgrindClientRequest.ZeroStats,
53		0, 0, 0, 0, 0);
	36	doCallgrindClientRequestStmt(CallgrindClientRequest.ZeroStats, 0, 0, 0, 0, 0);
54	37	}
55	38
56
57	39	/// Toggles collection state.
58	40	/// The collection state specifies whether the happening of events
59	41	/// should be noted or if they are to be ignored. Events are noted
60	42	/// by increment of counters in a cost center
61	43	pub fn toggleCollect() void {
62		doCallgrindClientRequestStmt(CallgrindClientRequest.ToggleCollect,
63		0, 0, 0, 0, 0);
	44	doCallgrindClientRequestStmt(CallgrindClientRequest.ToggleCollect, 0, 0, 0, 0, 0);
64	45	}
65	46
66
67	47	/// Start full callgrind instrumentation if not already switched on.
68	48	/// When cache simulation is done, it will flush the simulated cache;
69	49	/// this will lead to an artificial cache warmup phase afterwards with
70	50	/// cache misses which would not have happened in reality.
71	51	pub fn startInstrumentation() void {
72		doCallgrindClientRequestStmt(CallgrindClientRequest.StartInstrumentation,
73		0, 0, 0, 0, 0);
	52	doCallgrindClientRequestStmt(CallgrindClientRequest.StartInstrumentation, 0, 0, 0, 0, 0);
74	53	}
75	54
76
77	55	/// Stop full callgrind instrumentation if not already switched off.
78	56	/// This flushes Valgrinds translation cache, and does no additional
79	57	/// instrumentation afterwards, which effectivly will run at the same
...	...	@@ -82,6 +60,5 @@ pub fn startInstrumentation() void {
82	60	/// To start Callgrind in this mode to ignore the setup phase, use
83	61	/// the option "--instr-atstart=no".
84	62	pub fn stopInstrumentation() void {
85		doCallgrindClientRequestStmt(CallgrindClientRequest.StopInstrumentation,
86		0, 0, 0, 0, 0);
	63	doCallgrindClientRequestStmt(CallgrindClientRequest.StopInstrumentation, 0, 0, 0, 0, 0);
87	64	}

std/valgrind/memcheck.zig+26-96

...	...	@@ -19,149 +19,102 @@ pub const MemCheckClientRequest = extern enum {
19	19	DisableAddrErrorReportingInRange,
20	20	};
21	21
22		fn doMemCheckClientRequestExpr(default: usize, request: MemCheckClientRequest,
23		a1: usize, a2: usize, a3: usize, a4: usize, a5: usize
24		) usize
25		{
26		return valgrind.doClientRequest(
27		default,
28		@intCast(usize, @enumToInt(request)),
29		a1, a2, a3, a4, a5);
30		}
31
32		fn doMemCheckClientRequestStmt(request: MemCheckClientRequest,
33		a1: usize, a2: usize, a3: usize, a4: usize, a5: usize
34		) void
35		{
36		_ = doMemCheckClientRequestExpr(0, request, a1, a2, a3, a4, a5);
	22	fn doMemCheckClientRequestExpr(default: usize, request: MemCheckClientRequest, a1: usize, a2: usize, a3: usize, a4: usize, a5: usize) usize {
	23	return valgrind.doClientRequest(default, @intCast(usize, @enumToInt(request)), a1, a2, a3, a4, a5);
37	24	}
38	25
39
	26	fn doMemCheckClientRequestStmt(request: MemCheckClientRequest, a1: usize, a2: usize, a3: usize, a4: usize, a5: usize) void {
	27	_ = doMemCheckClientRequestExpr(0, request, a1, a2, a3, a4, a5);
	28	}
40	29
41	30	/// Mark memory at qzz.ptr as unaddressable for qzz.len bytes.
42	31	/// This returns -1 when run on Valgrind and 0 otherwise.
43	32	pub fn makeMemNoAccess(qzz: []u8) i1 {
44	33	return @intCast(i1, doMemCheckClientRequestExpr(0, // default return
45		MemCheckClientRequest.MakeMemNoAccess,
46		@ptrToInt(qzz.ptr), qzz.len,
47		0, 0, 0));
	34	MemCheckClientRequest.MakeMemNoAccess, @ptrToInt(qzz.ptr), qzz.len, 0, 0, 0));
48	35	}
49	36
50
51	37	/// Similarly, mark memory at qzz.ptr as addressable but undefined
52	38	/// for qzz.len bytes.
53	39	/// This returns -1 when run on Valgrind and 0 otherwise.
54	40	pub fn makeMemUndefined(qzz: []u8) i1 {
55	41	return @intCast(i1, doMemCheckClientRequestExpr(0, // default return
56		MemCheckClientRequest.MakeMemUndefined,
57		@ptrToInt(qzz.ptr), qzz.len,
58		0, 0, 0));
	42	MemCheckClientRequest.MakeMemUndefined, @ptrToInt(qzz.ptr), qzz.len, 0, 0, 0));
59	43	}
60	44
61
62	45	/// Similarly, mark memory at qzz.ptr as addressable and defined
63	46	/// for qzz.len bytes.
64	47	pub fn makeMemDefined(qzz: []u8) i1 {
65		// This returns -1 when run on Valgrind and 0 otherwise.
	48	// This returns -1 when run on Valgrind and 0 otherwise.
66	49	return @intCast(i1, doMemCheckClientRequestExpr(0, // default return
67		MemCheckClientRequest.MakeMemDefined,
68		@ptrToInt(qzz.ptr), qzz.len,
69		0, 0, 0));
	50	MemCheckClientRequest.MakeMemDefined, @ptrToInt(qzz.ptr), qzz.len, 0, 0, 0));
70	51	}
71	52
72
73	53	/// Similar to makeMemDefined except that addressability is
74	54	/// not altered: bytes which are addressable are marked as defined,
75	55	/// but those which are not addressable are left unchanged.
76	56	/// This returns -1 when run on Valgrind and 0 otherwise.
77	57	pub fn makeMemDefinedIfAddressable(qzz: []u8) i1 {
78	58	return @intCast(i1, doMemCheckClientRequestExpr(0, // default return
79		MemCheckClientRequest.MakeMemDefinedIfAddressable,
80		@ptrToInt(qzz.ptr), qzz.len,
81		0, 0, 0));
	59	MemCheckClientRequest.MakeMemDefinedIfAddressable, @ptrToInt(qzz.ptr), qzz.len, 0, 0, 0));
82	60	}
83	61
84
85	62	/// Create a block-description handle. The description is an ascii
86	63	/// string which is included in any messages pertaining to addresses
87	64	/// within the specified memory range. Has no other effect on the
88	65	/// properties of the memory range.
89	66	pub fn createBlock(qzz: []u8, desc: [*]u8) usize {
90	67	return doMemCheckClientRequestExpr(0, // default return
91		MemCheckClientRequest.CreateBlock,
92		@ptrToInt(qzz.ptr), qzz.len, @ptrToInt(desc),
93		0, 0);
	68	MemCheckClientRequest.CreateBlock, @ptrToInt(qzz.ptr), qzz.len, @ptrToInt(desc), 0, 0);
94	69	}
95	70
96
97	71	/// Discard a block-description-handle. Returns 1 for an
98	72	/// invalid handle, 0 for a valid handle.
99	73	pub fn discard(blkindex) bool {
100	74	return doMemCheckClientRequestExpr(0, // default return
101		MemCheckClientRequest.Discard,
102		0, blkindex,
103		0, 0, 0) != 0;
	75	MemCheckClientRequest.Discard, 0, blkindex, 0, 0, 0) != 0;
104	76	}
105	77
106
107	78	/// Check that memory at qzz.ptr is addressable for qzz.len bytes.
108	79	/// If suitable addressibility is not established, Valgrind prints an
109	80	/// error message and returns the address of the first offending byte.
110	81	/// Otherwise it returns zero.
111	82	pub fn checkMemIsAddressable(qzz: []u8) usize {
112		return doMemCheckClientRequestExpr(0,
113		MemCheckClientRequest.CheckMemIsAddressable,
114		@ptrToInt(qzz.ptr), qzz.len,
115		0, 0, 0);
	83	return doMemCheckClientRequestExpr(0, MemCheckClientRequest.CheckMemIsAddressable, @ptrToInt(qzz.ptr), qzz.len, 0, 0, 0);
116	84	}
117	85
118
119	86	/// Check that memory at qzz.ptr is addressable and defined for
120	87	/// qzz.len bytes. If suitable addressibility and definedness are not
121	88	/// established, Valgrind prints an error message and returns the
122	89	/// address of the first offending byte. Otherwise it returns zero.
123	90	pub fn checkMemIsDefined(qzz: []u8) usize {
124		return doMemCheckClientRequestExpr(0,
125		MemCheckClientRequest.CheckMemIsDefined,
126		@ptrToInt(qzz.ptr), qzz.len,
127		0, 0, 0);
	91	return doMemCheckClientRequestExpr(0, MemCheckClientRequest.CheckMemIsDefined, @ptrToInt(qzz.ptr), qzz.len, 0, 0, 0);
128	92	}
129	93
130	94	/// Do a full memory leak check (like --leak-check=full) mid-execution.
131	95	pub fn doLeakCheck() void {
132		doMemCheckClientRequestStmt(MemCheckClientRequest.DO_LEAK_CHECK,
133		0, 0,
134		0, 0, 0);
	96	doMemCheckClientRequestStmt(MemCheckClientRequest.DO_LEAK_CHECK, 0, 0, 0, 0, 0);
135	97	}
136	98
137	99	/// Same as doLeakCheck() but only showing the entries for
138	100	/// which there was an increase in leaked bytes or leaked nr of blocks
139	101	/// since the previous leak search.
140	102	pub fn doAddedLeakCheck() void {
141		doMemCheckClientRequestStmt(MemCheckClientRequest.DO_LEAK_CHECK,
142		0, 1,
143		0, 0, 0);
	103	doMemCheckClientRequestStmt(MemCheckClientRequest.DO_LEAK_CHECK, 0, 1, 0, 0, 0);
144	104	}
145	105
146
147	106	/// Same as doAddedLeakCheck() but showing entries with
148	107	/// increased or decreased leaked bytes/blocks since previous leak
149	108	/// search.
150	109	pub fn doChangedLeakCheck() void {
151		doMemCheckClientRequestStmt(MemCheckClientRequest.DO_LEAK_CHECK,
152		0, 2,
153		0, 0, 0);
	110	doMemCheckClientRequestStmt(MemCheckClientRequest.DO_LEAK_CHECK, 0, 2, 0, 0, 0);
154	111	}
155	112
156
157	113	/// Do a summary memory leak check (like --leak-check=summary) mid-execution.
158	114	pub fn doQuickLeakCheck() void {
159		doMemCheckClientRequestStmt(MemCheckClientRequest.DO_LEAK_CHECK,
160		1, 0,
161		0, 0, 0);
	115	doMemCheckClientRequestStmt(MemCheckClientRequest.DO_LEAK_CHECK, 1, 0, 0, 0, 0);
162	116	}
163	117
164
165	118	/// Return number of leaked, dubious, reachable and suppressed bytes found by
166	119	/// all previous leak checks.
167	120	const CountResult = struct {
...	...	@@ -172,34 +125,27 @@ const CountResult = struct {
172	125	};
173	126
174	127	pub fn countLeaks() CountResult {
175		var res = CountResult {
	128	var res = CountResult{
176	129	.leaked = 0,
177	130	.dubious = 0,
178	131	.reachable = 0,
179	132	.suppressed = 0,
180	133	};
181		doMemCheckClientRequestStmt(MemCheckClientRequest.CountLeaks,
182		&res.leaked, &res.dubious,
183		&res.reachable, &res.suppressed,
184		0);
	134	doMemCheckClientRequestStmt(MemCheckClientRequest.CountLeaks, &res.leaked, &res.dubious, &res.reachable, &res.suppressed, 0);
185	135	return res;
186	136	}
187	137
188	138	pub fn countLeakBlocks() CountResult {
189		var res = CountResult {
	139	var res = CountResult{
190	140	.leaked = 0,
191	141	.dubious = 0,
192	142	.reachable = 0,
193	143	.suppressed = 0,
194	144	};
195		doMemCheckClientRequestStmt(MemCheckClientRequest.CountLeakBlocks,
196		&res.leaked, &res.dubious,
197		&res.reachable, &res.suppressed,
198		0);
	145	doMemCheckClientRequestStmt(MemCheckClientRequest.CountLeakBlocks, &res.leaked, &res.dubious, &res.reachable, &res.suppressed, 0);
199	146	return res;
200	147	}
201	148
202
203	149	/// Get the validity data for addresses zza and copy it
204	150	/// into the provided zzvbits array. Return values:
205	151	/// 0 if not running on valgrind
...	...	@@ -210,15 +156,9 @@ pub fn countLeakBlocks() CountResult {
210	156	/// impossible to segfault your system by using this call.
211	157	pub fn getVbits(zza: []u8, zzvbits: []u8) u2 {
212	158	std.debug.assert(zzvbits.len >= zza.len / 8);
213		return @intCast(u2, doMemCheckClientRequestExpr(0,
214		MemCheckClientRequest.GetVbits,
215		@ptrToInt(zza.ptr),
216		@ptrToInt(zzvbits),
217		zza.len,
218		0, 0));
	159	return @intCast(u2, doMemCheckClientRequestExpr(0, MemCheckClientRequest.GetVbits, @ptrToInt(zza.ptr), @ptrToInt(zzvbits), zza.len, 0, 0));
219	160	}
220	161
221
222	162	/// Set the validity data for addresses zza, copying it
223	163	/// from the provided zzvbits array. Return values:
224	164	/// 0 if not running on valgrind
...	...	@@ -229,27 +169,17 @@ pub fn getVbits(zza: []u8, zzvbits: []u8) u2 {
229	169	/// impossible to segfault your system by using this call.
230	170	pub fn setVbits(zzvbits: []u8, zza: []u8) u2 {
231	171	std.debug.assert(zzvbits.len >= zza.len / 8);
232		return @intCast(u2, doMemCheckClientRequestExpr(0,
233		MemCheckClientRequest.SetVbits,
234		@ptrToInt(zza.ptr),
235		@ptrToInt(zzvbits),
236		zza.len,
237		0, 0));
	172	return @intCast(u2, doMemCheckClientRequestExpr(0, MemCheckClientRequest.SetVbits, @ptrToInt(zza.ptr), @ptrToInt(zzvbits), zza.len, 0, 0));
238	173	}
239	174
240
241	175	/// Disable and re-enable reporting of addressing errors in the
242	176	/// specified address range.
243	177	pub fn disableAddrErrorReportingInRange(qzz: []u8) usize {
244	178	return doMemCheckClientRequestExpr(0, // default return
245		MemCheckClientRequest.DisableAddrErrorReportingInRange,
246		@ptrToInt(qzz.ptr), qzz.len,
247		0, 0, 0);
	179	MemCheckClientRequest.DisableAddrErrorReportingInRange, @ptrToInt(qzz.ptr), qzz.len, 0, 0, 0);
248	180	}
249	181
250	182	pub fn enableAddrErrorReportingInRange(qzz: []u8) usize {
251	183	return doMemCheckClientRequestExpr(0, // default return
252		MemCheckClientRequest.EnableAddrErrorReportingInRange,
253		@ptrToInt(qzz.ptr), qzz.len,
254		0, 0, 0);
	184	MemCheckClientRequest.EnableAddrErrorReportingInRange, @ptrToInt(qzz.ptr), qzz.len, 0, 0, 0);
255	185	}