Commit c1793d61061a112dc3d58c33ac0d3a1ebc8fb35e | zig

std/ascii.zig+11-11

...	...	@@ -29,7 +29,7 @@ const combinedTable = init: {
29	29	const mem = std.mem;
30	30
31	31	const alpha = []u1{
32		// 0, 1, 2, 3, 4, 5, 6, 7 ,8, 9,10,11,12,13,14,15
	32	// 0, 1, 2, 3, 4, 5, 6, 7 ,8, 9,10,11,12,13,14,15
33	33	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
34	34	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
35	35	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
...	...	@@ -41,7 +41,7 @@ const combinedTable = init: {
41	41	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
42	42	};
43	43	const lower = []u1{
44		// 0, 1, 2, 3, 4, 5, 6, 7 ,8, 9,10,11,12,13,14,15
	44	// 0, 1, 2, 3, 4, 5, 6, 7 ,8, 9,10,11,12,13,14,15
45	45	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
46	46	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
47	47	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
...	...	@@ -53,7 +53,7 @@ const combinedTable = init: {
53	53	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
54	54	};
55	55	const upper = []u1{
56		// 0, 1, 2, 3, 4, 5, 6, 7 ,8, 9,10,11,12,13,14,15
	56	// 0, 1, 2, 3, 4, 5, 6, 7 ,8, 9,10,11,12,13,14,15
57	57	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
58	58	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
59	59	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
...	...	@@ -65,7 +65,7 @@ const combinedTable = init: {
65	65	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
66	66	};
67	67	const digit = []u1{
68		// 0, 1, 2, 3, 4, 5, 6, 7 ,8, 9,10,11,12,13,14,15
	68	// 0, 1, 2, 3, 4, 5, 6, 7 ,8, 9,10,11,12,13,14,15
69	69	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
70	70	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
71	71	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
...	...	@@ -77,7 +77,7 @@ const combinedTable = init: {
77	77	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
78	78	};
79	79	const hex = []u1{
80		// 0, 1, 2, 3, 4, 5, 6, 7 ,8, 9,10,11,12,13,14,15
	80	// 0, 1, 2, 3, 4, 5, 6, 7 ,8, 9,10,11,12,13,14,15
81	81	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
82	82	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
83	83	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
...	...	@@ -89,7 +89,7 @@ const combinedTable = init: {
89	89	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
90	90	};
91	91	const space = []u1{
92		// 0, 1, 2, 3, 4, 5, 6, 7 ,8, 9,10,11,12,13,14,15
	92	// 0, 1, 2, 3, 4, 5, 6, 7 ,8, 9,10,11,12,13,14,15
93	93	0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0,
94	94	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
95	95	1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
...	...	@@ -101,7 +101,7 @@ const combinedTable = init: {
101	101	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
102	102	};
103	103	const punct = []u1{
104		// 0, 1, 2, 3, 4, 5, 6, 7 ,8, 9,10,11,12,13,14,15
	104	// 0, 1, 2, 3, 4, 5, 6, 7 ,8, 9,10,11,12,13,14,15
105	105	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
106	106	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
107	107	0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
...	...	@@ -113,7 +113,7 @@ const combinedTable = init: {
113	113	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0,
114	114	};
115	115	const graph = []u1{
116		// 0, 1, 2, 3, 4, 5, 6, 7 ,8, 9,10,11,12,13,14,15
	116	// 0, 1, 2, 3, 4, 5, 6, 7 ,8, 9,10,11,12,13,14,15
117	117	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
118	118	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
119	119	0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
...	...	@@ -129,7 +129,7 @@ const combinedTable = init: {
129	129	inline while (i < 128) : (i += 1) {
130	130	table[i] =
131	131	u8(alpha[i]) << @enumToInt(tIndex.Alpha) \|
132		u8(hex[i]) << @enumToInt(tIndex.Hex) \|
	132	u8(hex[i]) << @enumToInt(tIndex.Hex) \|
133	133	u8(space[i]) << @enumToInt(tIndex.Space) \|
134	134	u8(digit[i]) << @enumToInt(tIndex.Digit) \|
135	135	u8(lower[i]) << @enumToInt(tIndex.Lower) \|
...	...	@@ -146,8 +146,8 @@ fn inTable(c: u8, t: tIndex) bool {
146	146	}
147	147
148	148	pub fn isAlNum(c: u8) bool {
149		return (combinedTable[c] & ((u8(1) << @enumToInt(tIndex.Alpha)) \|
150		u8(1) << @enumToInt(tIndex.Digit))) != 0;
	149	return (combinedTable[c] & ((u8(1) << @enumToInt(tIndex.Alpha)) \|
	150	u8(1) << @enumToInt(tIndex.Digit))) != 0;
151	151	}
152	152
153	153	pub fn isAlpha(c: u8) bool {

std/c/freebsd.zig+12

...	...	@@ -44,16 +44,22 @@ pub const pthread_attr_t = extern struct {
44	44	pub const msghdr = extern struct {
45	45	/// optional address
46	46	msg_name: ?*sockaddr,
	47
47	48	/// size of address
48	49	msg_namelen: socklen_t,
	50
49	51	/// scatter/gather array
50	52	msg_iov: [*]iovec,
	53
51	54	/// # elements in msg_iov
52	55	msg_iovlen: i32,
	56
53	57	/// ancillary data
54	58	msg_control: ?*c_void,
	59
55	60	/// ancillary data buffer len
56	61	msg_controllen: socklen_t,
	62
57	63	/// flags on received message
58	64	msg_flags: i32,
59	65	};
...	...	@@ -61,16 +67,22 @@ pub const msghdr = extern struct {
61	67	pub const msghdr_const = extern struct {
62	68	/// optional address
63	69	msg_name: ?*const sockaddr,
	70
64	71	/// size of address
65	72	msg_namelen: socklen_t,
	73
66	74	/// scatter/gather array
67	75	msg_iov: [*]iovec_const,
	76
68	77	/// # elements in msg_iov
69	78	msg_iovlen: i32,
	79
70	80	/// ancillary data
71	81	msg_control: ?*c_void,
	82
72	83	/// ancillary data buffer len
73	84	msg_controllen: socklen_t,
	85
74	86	/// flags on received message
75	87	msg_flags: i32,
76	88	};

std/c/netbsd.zig+12

...	...	@@ -44,16 +44,22 @@ pub const pthread_attr_t = extern struct {
44	44	pub const msghdr = extern struct {
45	45	/// optional address
46	46	msg_name: ?*sockaddr,
	47
47	48	/// size of address
48	49	msg_namelen: socklen_t,
	50
49	51	/// scatter/gather array
50	52	msg_iov: [*]iovec,
	53
51	54	/// # elements in msg_iov
52	55	msg_iovlen: i32,
	56
53	57	/// ancillary data
54	58	msg_control: ?*c_void,
	59
55	60	/// ancillary data buffer len
56	61	msg_controllen: socklen_t,
	62
57	63	/// flags on received message
58	64	msg_flags: i32,
59	65	};
...	...	@@ -61,16 +67,22 @@ pub const msghdr = extern struct {
61	67	pub const msghdr_const = extern struct {
62	68	/// optional address
63	69	msg_name: ?*const sockaddr,
	70
64	71	/// size of address
65	72	msg_namelen: socklen_t,
	73
66	74	/// scatter/gather array
67	75	msg_iov: [*]iovec_const,
	76
68	77	/// # elements in msg_iov
69	78	msg_iovlen: i32,
	79
70	80	/// ancillary data
71	81	msg_control: ?*c_void,
	82
72	83	/// ancillary data buffer len
73	84	msg_controllen: socklen_t,
	85
74	86	/// flags on received message
75	87	msg_flags: i32,
76	88	};

std/crypto/chacha20.zig+2-2

...	...	@@ -206,8 +206,8 @@ test "crypto.chacha20 test vector sunscreen" {
206	206	const input = "Ladies and Gentlemen of the class of '99: If I could offer you only one tip for the future, sunscreen would be it.";
207	207	var result: [114]u8 = undefined;
208	208	const key = []u8{
209		0, 1, 2, 3, 4, 5, 6, 7,
210		8, 9, 10, 11, 12, 13, 14, 15,
	209	0, 1, 2, 3, 4, 5, 6, 7,
	210	8, 9, 10, 11, 12, 13, 14, 15,
211	211	16, 17, 18, 19, 20, 21, 22, 23,
212	212	24, 25, 26, 27, 28, 29, 30, 31,
213	213	};

std/dynamic_library.zig+4-4

...	...	@@ -71,12 +71,12 @@ pub fn linkmap_iterator(phdrs: []elf.Phdr) !LinkMap.Iterator {
71	71	for (phdrs) \|*phdr\| {
72	72	if (phdr.p_type == elf.PT_DYNAMIC) {
73	73	const ptr = @intToPtr([*]elf.Dyn, va_offset + phdr.p_vaddr);
74		break :init ptr[0..phdr.p_memsz / @sizeOf(elf.Dyn)];
	74	break :init ptr[0 .. phdr.p_memsz / @sizeOf(elf.Dyn)];
75	75	}
76	76	}
77	77	// No PT_DYNAMIC means this is either a statically-linked program or a
78	78	// badly corrupted one
79		return LinkMap.Iterator{.current = null};
	79	return LinkMap.Iterator{ .current = null };
80	80	};
81	81
82	82	const link_map_ptr = init: {
...	...	@@ -93,13 +93,13 @@ pub fn linkmap_iterator(phdrs: []elf.Phdr) !LinkMap.Iterator {
93	93	// second slot
94	94	break :init @intToPtr(?*LinkMap, got_table[1]);
95	95	},
96		else => { }
	96	else => {},
97	97	}
98	98	}
99	99	return error.InvalidExe;
100	100	};
101	101
102		return LinkMap.Iterator{.current = link_map_ptr};
	102	return LinkMap.Iterator{ .current = link_map_ptr };
103	103	}
104	104
105	105	pub const LinuxDynLib = struct {

std/event/locked.zig+1-1

...	...	@@ -34,7 +34,7 @@ pub fn Locked(comptime T: type) type {
34	34
35	35	pub async fn acquire(self: *Self) HeldLock {
36	36	return HeldLock{
37		// TODO guaranteed allocation elision
	37	// TODO guaranteed allocation elision
38	38	.held = await (async self.lock.acquire() catch unreachable),
39	39	.value = &self.private_data,
40	40	};

std/fmt.zig+2-2

...	...	@@ -183,7 +183,7 @@ pub fn formatType(
183	183	}
184	184	try output(context, @memberName(T, field_i));
185	185	try output(context, " = ");
186		try formatType(@field(value, @memberName(T, field_i)), "", context, Errors, output, max_depth-1);
	186	try formatType(@field(value, @memberName(T, field_i)), "", context, Errors, output, max_depth - 1);
187	187	}
188	188	try output(context, " }");
189	189	},
...	...	@@ -198,7 +198,7 @@ pub fn formatType(
198	198	try output(context, " = ");
199	199	inline for (info.fields) \|u_field\| {
200	200	if (@enumToInt(UnionTagType(value)) == u_field.enum_field.?.value) {
201		try formatType(@field(value, u_field.name), "", context, Errors, output, max_depth-1);
	201	try formatType(@field(value, u_field.name), "", context, Errors, output, max_depth - 1);
202	202	}
203	203	}
204	204	try output(context, " }");

std/hash_map.zig+3-3

...	...	@@ -155,7 +155,7 @@ pub fn HashMap(comptime K: type, comptime V: type, comptime hash: fn (key: K) u3
155	155	/// capacity is greater than the current capacity.
156	156	/// New capacity must be a power of two.
157	157	fn ensureCapacityExact(self: *Self, new_capacity: usize) !void {
158		const is_power_of_two = new_capacity & (new_capacity-1) == 0;
	158	const is_power_of_two = new_capacity & (new_capacity - 1) == 0;
159	159	assert(is_power_of_two);
160	160
161	161	if (new_capacity <= self.entries.len) {
...	...	@@ -474,9 +474,9 @@ test "ensure capacity" {
474	474	try map.ensureCapacity(20);
475	475	const initialCapacity = map.entries.len;
476	476	testing.expect(initialCapacity >= 20);
477		var i : i32 = 0;
	477	var i: i32 = 0;
478	478	while (i < 20) : (i += 1) {
479		testing.expect(map.putAssumeCapacity(i, i+10) == null);
	479	testing.expect(map.putAssumeCapacity(i, i + 10) == null);
480	480	}
481	481	// shouldn't resize from putAssumeCapacity
482	482	testing.expect(initialCapacity == map.entries.len);

std/os/linux/tls.zig+8-10

...	...	@@ -86,8 +86,7 @@ const tls_dtv_offset = switch (builtin.arch) {
86	86	};
87	87
88	88	// Per-thread storage for Zig's use
89		const CustomData = packed struct {
90		};
	89	const CustomData = packed struct {};
91	90
92	91	// Dynamic Thread Vector
93	92	const DTV = packed struct {
...	...	@@ -109,14 +108,14 @@ pub var tls_image: ?TLSImage = null;
109	108	pub fn setThreadPointer(addr: usize) void {
110	109	switch (builtin.arch) {
111	110	.x86_64 => {
112		const rc = std.os.linux.syscall2(std.os.linux.SYS_arch_prctl,
113		std.os.linux.ARCH_SET_FS, addr);
	111	const rc = std.os.linux.syscall2(std.os.linux.SYS_arch_prctl, std.os.linux.ARCH_SET_FS, addr);
114	112	assert(rc == 0);
115	113	},
116	114	.aarch64 => {
117	115	asm volatile (
118	116	\\ msr tpidr_el0, %[addr]
119		: : [addr] "r" (addr)
	117	:
	118	: [addr] "r" (addr)
120	119	);
121	120	},
122	121	else => @compileError("Unsupported architecture"),
...	...	@@ -137,7 +136,7 @@ pub fn initTLS() void {
137	136	switch (auxv[i].a_type) {
138	137	elf.AT_PHENT => at_phent = auxv[i].a_un.a_val,
139	138	elf.AT_PHNUM => at_phnum = auxv[i].a_un.a_val,
140		elf.AT_PHDR => at_phdr = auxv[i].a_un.a_val,
	139	elf.AT_PHDR => at_phdr = auxv[i].a_un.a_val,
141	140	else => continue,
142	141	}
143	142	}
...	...	@@ -151,7 +150,7 @@ pub fn initTLS() void {
151	150	for (phdrs) \|*phdr\| {
152	151	switch (phdr.p_type) {
153	152	elf.PT_PHDR => img_base = at_phdr - phdr.p_vaddr,
154		elf.PT_TLS => tls_phdr = phdr,
	153	elf.PT_TLS => tls_phdr = phdr,
155	154	else => continue,
156	155	}
157	156	}
...	...	@@ -194,7 +193,7 @@ pub fn initTLS() void {
194	193	dtv_offset = l;
195	194	l += @sizeOf(DTV);
196	195	break :blk l;
197		}
	196	},
198	197	};
199	198
200	199	tls_image = TLSImage{
...	...	@@ -238,8 +237,7 @@ pub fn allocateTLS(size: usize) usize {
238	237	return @ptrToInt(&main_thread_tls_buffer);
239	238	}
240	239
241		const addr = posix.mmap(null, size, posix.PROT_READ \| posix.PROT_WRITE,
242		posix.MAP_PRIVATE \| posix.MAP_ANONYMOUS, -1, 0);
	240	const addr = posix.mmap(null, size, posix.PROT_READ \| posix.PROT_WRITE, posix.MAP_PRIVATE \| posix.MAP_ANONYMOUS, -1, 0);
243	241
244	242	if (posix.getErrno(addr) != 0) @panic("out of memory");
245	243

std/os/windows/shell32.zig-1

...	...	@@ -1,4 +1,3 @@
1	1	use @import("../windows.zig");
2	2
3	3	pub extern "shell32" stdcallcc fn SHGetKnownFolderPath(rfid: const KNOWNFOLDERID, dwFlags: DWORD, hToken: ?HANDLE, ppszPath: [*]WCHAR) HRESULT;
4

std/special/compiler_rt.zig+16-4

...	...	@@ -338,7 +338,10 @@ extern fn __umoddi3(a: u64, b: u64) u64 {
338	338	return r;
339	339	}
340	340
341		extern fn __aeabi_uidivmod(n: u32, d: u32) extern struct{q: u32, r: u32} {
	341	extern fn __aeabi_uidivmod(n: u32, d: u32) extern struct {
	342	q: u32,
	343	r: u32,
	344	} {
342	345	@setRuntimeSafety(is_test);
343	346
344	347	var result: @typeOf(__aeabi_uidivmod).ReturnType = undefined;
...	...	@@ -346,7 +349,10 @@ extern fn __aeabi_uidivmod(n: u32, d: u32) extern struct{q: u32, r: u32} {
346	349	return result;
347	350	}
348	351
349		extern fn __aeabi_uldivmod(n: u64, d: u64) extern struct{q: u64, r: u64} {
	352	extern fn __aeabi_uldivmod(n: u64, d: u64) extern struct {
	353	q: u64,
	354	r: u64,
	355	} {
350	356	@setRuntimeSafety(is_test);
351	357
352	358	var result: @typeOf(__aeabi_uldivmod).ReturnType = undefined;
...	...	@@ -354,7 +360,10 @@ extern fn __aeabi_uldivmod(n: u64, d: u64) extern struct{q: u64, r: u64} {
354	360	return result;
355	361	}
356	362
357		extern fn __aeabi_idivmod(n: i32, d: i32) extern struct{q: i32, r: i32} {
	363	extern fn __aeabi_idivmod(n: i32, d: i32) extern struct {
	364	q: i32,
	365	r: i32,
	366	} {
358	367	@setRuntimeSafety(is_test);
359	368
360	369	var result: @typeOf(__aeabi_idivmod).ReturnType = undefined;
...	...	@@ -362,7 +371,10 @@ extern fn __aeabi_idivmod(n: i32, d: i32) extern struct{q: i32, r: i32} {
362	371	return result;
363	372	}
364	373
365		extern fn __aeabi_ldivmod(n: i64, d: i64) extern struct{q: i64, r:i64} {
	374	extern fn __aeabi_ldivmod(n: i64, d: i64) extern struct {
	375	q: i64,
	376	r: i64,
	377	} {
366	378	@setRuntimeSafety(is_test);
367	379
368	380	var result: @typeOf(__aeabi_ldivmod).ReturnType = undefined;

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

...	...	@@ -4,7 +4,7 @@ const testing = @import("std").testing;
4	4	fn test__ashrti3(a: i128, b: i32, expected: i128) void {
5	5	const x = __ashrti3(a, b);
6	6	// @import("std").debug.warn("got 0x{x}\nexp 0x{x}\n", @truncate(u64,
7		// @bitCast(u128, x) >> 64), @truncate(u64, @bitCast(u128, expected)) >> 64);
	7	// @bitCast(u128, x) >> 64), @truncate(u64, @bitCast(u128, expected)) >> 64);
8	8	testing.expect(x == expected);
9	9	}
10	10

std/special/compiler_rt/fixdfdi_test.zig-1

...	...	@@ -12,7 +12,6 @@ fn test__fixdfdi(a: f64, expected: i64) void {
12	12
13	13	test "fixdfdi" {
14	14	//warn("\n");
15
16	15	test__fixdfdi(-math.f64_max, math.minInt(i64));
17	16
18	17	test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));

std/special/compiler_rt/fixdfsi_test.zig+4-5

...	...	@@ -12,7 +12,6 @@ fn test__fixdfsi(a: f64, expected: i32) void {
12	12
13	13	test "fixdfsi" {
14	14	//warn("\n");
15
16	15	test__fixdfsi(-math.f64_max, math.minInt(i32));
17	16
18	17	test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
...	...	@@ -22,10 +21,10 @@ test "fixdfsi" {
22	21	test__fixdfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);
23	22	test__fixdfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);
24	23
25		test__fixdfsi(-0x1.0000000000001p+63, -0x80000000);
26		test__fixdfsi(-0x1.0000000000000p+63, -0x80000000);
27		test__fixdfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
28		test__fixdfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
	24	test__fixdfsi(-0x1.0000000000001p+63, -0x80000000);
	25	test__fixdfsi(-0x1.0000000000000p+63, -0x80000000);
	26	test__fixdfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
	27	test__fixdfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
29	28
30	29	test__fixdfsi(-0x1.FFFFFEp+62, -0x80000000);
31	30	test__fixdfsi(-0x1.FFFFFCp+62, -0x80000000);

std/special/compiler_rt/fixdfti_test.zig-1

...	...	@@ -12,7 +12,6 @@ fn test__fixdfti(a: f64, expected: i128) void {
12	12
13	13	test "fixdfti" {
14	14	//warn("\n");
15
16	15	test__fixdfti(-math.f64_max, math.minInt(i128));
17	16
18	17	test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));

std/special/compiler_rt/fixint_test.zig+7-7

...	...	@@ -82,7 +82,7 @@ test "fixint.i32" {
82	82	test__fixint(f64, i32, -math.inf_f64, math.minInt(i32));
83	83	test__fixint(f64, i32, -math.f64_max, math.minInt(i32));
84	84	test__fixint(f64, i32, f64(math.minInt(i32)), math.minInt(i32));
85		test__fixint(f64, i32, f64(math.minInt(i32))+1, math.minInt(i32)+1);
	85	test__fixint(f64, i32, f64(math.minInt(i32)) + 1, math.minInt(i32) + 1);
86	86	test__fixint(f64, i32, -2.0, -2);
87	87	test__fixint(f64, i32, -1.9, -1);
88	88	test__fixint(f64, i32, -1.1, -1);
...	...	@@ -96,7 +96,7 @@ test "fixint.i32" {
96	96	test__fixint(f64, i32, 0.1, 0);
97	97	test__fixint(f64, i32, 0.9, 0);
98	98	test__fixint(f64, i32, 1.0, 1);
99		test__fixint(f64, i32, f64(math.maxInt(i32))-1, math.maxInt(i32)-1);
	99	test__fixint(f64, i32, f64(math.maxInt(i32)) - 1, math.maxInt(i32) - 1);
100	100	test__fixint(f64, i32, f64(math.maxInt(i32)), math.maxInt(i32));
101	101	test__fixint(f64, i32, math.f64_max, math.maxInt(i32));
102	102	test__fixint(f64, i32, math.inf_f64, math.maxInt(i32));
...	...	@@ -106,8 +106,8 @@ test "fixint.i64" {
106	106	test__fixint(f64, i64, -math.inf_f64, math.minInt(i64));
107	107	test__fixint(f64, i64, -math.f64_max, math.minInt(i64));
108	108	test__fixint(f64, i64, f64(math.minInt(i64)), math.minInt(i64));
109		test__fixint(f64, i64, f64(math.minInt(i64))+1, math.minInt(i64));
110		test__fixint(f64, i64, f64(math.minInt(i64)/2), math.minInt(i64)/2);
	109	test__fixint(f64, i64, f64(math.minInt(i64)) + 1, math.minInt(i64));
	110	test__fixint(f64, i64, f64(math.minInt(i64) / 2), math.minInt(i64) / 2);
111	111	test__fixint(f64, i64, -2.0, -2);
112	112	test__fixint(f64, i64, -1.9, -1);
113	113	test__fixint(f64, i64, -1.1, -1);
...	...	@@ -121,7 +121,7 @@ test "fixint.i64" {
121	121	test__fixint(f64, i64, 0.1, 0);
122	122	test__fixint(f64, i64, 0.9, 0);
123	123	test__fixint(f64, i64, 1.0, 1);
124		test__fixint(f64, i64, f64(math.maxInt(i64))-1, math.maxInt(i64));
	124	test__fixint(f64, i64, f64(math.maxInt(i64)) - 1, math.maxInt(i64));
125	125	test__fixint(f64, i64, f64(math.maxInt(i64)), math.maxInt(i64));
126	126	test__fixint(f64, i64, math.f64_max, math.maxInt(i64));
127	127	test__fixint(f64, i64, math.inf_f64, math.maxInt(i64));
...	...	@@ -131,7 +131,7 @@ test "fixint.i128" {
131	131	test__fixint(f64, i128, -math.inf_f64, math.minInt(i128));
132	132	test__fixint(f64, i128, -math.f64_max, math.minInt(i128));
133	133	test__fixint(f64, i128, f64(math.minInt(i128)), math.minInt(i128));
134		test__fixint(f64, i128, f64(math.minInt(i128))+1, math.minInt(i128));
	134	test__fixint(f64, i128, f64(math.minInt(i128)) + 1, math.minInt(i128));
135	135	test__fixint(f64, i128, -2.0, -2);
136	136	test__fixint(f64, i128, -1.9, -1);
137	137	test__fixint(f64, i128, -1.1, -1);
...	...	@@ -145,7 +145,7 @@ test "fixint.i128" {
145	145	test__fixint(f64, i128, 0.1, 0);
146	146	test__fixint(f64, i128, 0.9, 0);
147	147	test__fixint(f64, i128, 1.0, 1);
148		test__fixint(f64, i128, f64(math.maxInt(i128))-1, math.maxInt(i128));
	148	test__fixint(f64, i128, f64(math.maxInt(i128)) - 1, math.maxInt(i128));
149	149	test__fixint(f64, i128, f64(math.maxInt(i128)), math.maxInt(i128));
150	150	test__fixint(f64, i128, math.f64_max, math.maxInt(i128));
151	151	test__fixint(f64, i128, math.inf_f64, math.maxInt(i128));

std/special/compiler_rt/fixsfdi_test.zig-1

...	...	@@ -12,7 +12,6 @@ fn test__fixsfdi(a: f32, expected: i64) void {
12	12
13	13	test "fixsfdi" {
14	14	//warn("\n");
15
16	15	test__fixsfdi(-math.f32_max, math.minInt(i64));
17	16
18	17	test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));

std/special/compiler_rt/fixsfsi_test.zig+4-5

...	...	@@ -12,7 +12,6 @@ fn test__fixsfsi(a: f32, expected: i32) void {
12	12
13	13	test "fixsfsi" {
14	14	//warn("\n");
15
16	15	test__fixsfsi(-math.f32_max, math.minInt(i32));
17	16
18	17	test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
...	...	@@ -22,10 +21,10 @@ test "fixsfsi" {
22	21	test__fixsfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);
23	22	test__fixsfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);
24	23
25		test__fixsfsi(-0x1.0000000000001p+63, -0x80000000);
26		test__fixsfsi(-0x1.0000000000000p+63, -0x80000000);
27		test__fixsfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
28		test__fixsfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
	24	test__fixsfsi(-0x1.0000000000001p+63, -0x80000000);
	25	test__fixsfsi(-0x1.0000000000000p+63, -0x80000000);
	26	test__fixsfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
	27	test__fixsfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
29	28
30	29	test__fixsfsi(-0x1.FFFFFEp+62, -0x80000000);
31	30	test__fixsfsi(-0x1.FFFFFCp+62, -0x80000000);

std/special/compiler_rt/fixsfti_test.zig+1-2

...	...	@@ -12,7 +12,6 @@ fn test__fixsfti(a: f32, expected: i128) void {
12	12
13	13	test "fixsfti" {
14	14	//warn("\n");
15
16	15	test__fixsfti(-math.f32_max, math.minInt(i128));
17	16
18	17	test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
...	...	@@ -30,7 +29,7 @@ test "fixsfti" {
30	29	test__fixsfti(-0x1.FFFFFFFFFFFFFp+62, -0x8000000000000000);
31	30	test__fixsfti(-0x1.FFFFFFFFFFFFEp+62, -0x8000000000000000);
32	31
33		test__fixsfti(-0x1.FFFFFFp+62, -0x8000000000000000);
	32	test__fixsfti(-0x1.FFFFFFp+62, -0x8000000000000000);
34	33	test__fixsfti(-0x1.FFFFFEp+62, -0x7fffff8000000000);
35	34	test__fixsfti(-0x1.FFFFFCp+62, -0x7fffff0000000000);
36	35

std/special/compiler_rt/fixtfdi_test.zig+4-5

...	...	@@ -12,7 +12,6 @@ fn test__fixtfdi(a: f128, expected: i64) void {
12	12
13	13	test "fixtfdi" {
14	14	//warn("\n");
15
16	15	test__fixtfdi(-math.f128_max, math.minInt(i64));
17	16
18	17	test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
...	...	@@ -22,10 +21,10 @@ test "fixtfdi" {
22	21	test__fixtfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000);
23	22	test__fixtfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000);
24	23
25		test__fixtfdi(-0x1.0000000000001p+63, -0x8000000000000000);
26		test__fixtfdi(-0x1.0000000000000p+63, -0x8000000000000000);
27		test__fixtfdi(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
28		test__fixtfdi(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
	24	test__fixtfdi(-0x1.0000000000001p+63, -0x8000000000000000);
	25	test__fixtfdi(-0x1.0000000000000p+63, -0x8000000000000000);
	26	test__fixtfdi(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
	27	test__fixtfdi(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
29	28
30	29	test__fixtfdi(-0x1.FFFFFEp+62, -0x7FFFFF8000000000);
31	30	test__fixtfdi(-0x1.FFFFFCp+62, -0x7FFFFF0000000000);

std/special/compiler_rt/fixtfsi_test.zig+4-5

...	...	@@ -12,7 +12,6 @@ fn test__fixtfsi(a: f128, expected: i32) void {
12	12
13	13	test "fixtfsi" {
14	14	//warn("\n");
15
16	15	test__fixtfsi(-math.f128_max, math.minInt(i32));
17	16
18	17	test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
...	...	@@ -22,10 +21,10 @@ test "fixtfsi" {
22	21	test__fixtfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);
23	22	test__fixtfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);
24	23
25		test__fixtfsi(-0x1.0000000000001p+63, -0x80000000);
26		test__fixtfsi(-0x1.0000000000000p+63, -0x80000000);
27		test__fixtfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
28		test__fixtfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
	24	test__fixtfsi(-0x1.0000000000001p+63, -0x80000000);
	25	test__fixtfsi(-0x1.0000000000000p+63, -0x80000000);
	26	test__fixtfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
	27	test__fixtfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
29	28
30	29	test__fixtfsi(-0x1.FFFFFEp+62, -0x80000000);
31	30	test__fixtfsi(-0x1.FFFFFCp+62, -0x80000000);

std/special/compiler_rt/fixtfti_test.zig-1

...	...	@@ -12,7 +12,6 @@ fn test__fixtfti(a: f128, expected: i128) void {
12	12
13	13	test "fixtfti" {
14	14	//warn("\n");
15
16	15	test__fixtfti(-math.f128_max, math.minInt(i128));
17	16
18	17	test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));

std/special/compiler_rt/stack_probe.zig+5-5

...	...	@@ -51,7 +51,7 @@ pub nakedcc fn zig_probe_stack() void {
51	51	\\ ret
52	52	);
53	53	},
54		else => { }
	54	else => {},
55	55	}
56	56
57	57	unreachable;
...	...	@@ -103,7 +103,7 @@ fn win_probe_stack_only() void {
103	103	\\ ret
104	104	);
105	105	},
106		else => { }
	106	else => {},
107	107	}
108	108
109	109	unreachable;
...	...	@@ -159,9 +159,9 @@ fn win_probe_stack_adjust_sp() void {
159	159	\\ push (%%eax)
160	160	\\ sub %%esp,%%eax
161	161	\\ ret
162		);
	162	);
163	163	},
164		else => { },
	164	else => {},
165	165	}
166	166
167	167	unreachable;
...	...	@@ -189,7 +189,7 @@ pub nakedcc fn __chkstk() void {
189	189	switch (builtin.arch) {
190	190	.i386 => @inlineCall(win_probe_stack_adjust_sp),
191	191	.x86_64 => @inlineCall(win_probe_stack_only),
192		else => unreachable
	192	else => unreachable,
193	193	}
194	194	}
195	195	pub nakedcc fn ___chkstk() void {

std/valgrind.zig+40-136

...	...	@@ -1,11 +1,7 @@
1	1	const builtin = @import("builtin");
2	2	const math = @import("index.zig").math;
3	3
4
5		pub fn doClientRequest(default: usize, request: usize,
6		a1: usize, a2: usize, a3: usize, a4: usize, a5: usize
7		) usize
8		{
	4	pub fn doClientRequest(default: usize, request: usize, a1: usize, a2: usize, a3: usize, a4: usize, a5: usize) usize {
9	5	if (!builtin.valgrind_support) {
10	6	return default;
11	7	}
...	...	@@ -16,8 +12,8 @@ pub fn doClientRequest(default: usize, request: usize,
16	12	\\ roll $3, %%edi ; roll $13, %%edi
17	13	\\ roll $29, %%edi ; roll $19, %%edi
18	14	\\ xchgl %%ebx,%%ebx
19		: [_] "={edx}" (-> usize)
20		: [_] "{eax}" (&[]usize{request, a1, a2, a3, a4, a5}),
	15	: [_] "={edx}" (-> usize)
	16	: [_] "{eax}" (&[]usize{ request, a1, a2, a3, a4, a5 }),
21	17	[_] "0" (default)
22	18	: "cc", "memory"
23	19	);
...	...	@@ -27,8 +23,8 @@ pub fn doClientRequest(default: usize, request: usize,
27	23	\\ rolq $3, %%rdi ; rolq $13, %%rdi
28	24	\\ rolq $61, %%rdi ; rolq $51, %%rdi
29	25	\\ xchgq %%rbx,%%rbx
30		: [_] "={rdx}" (-> usize)
31		: [_] "{rax}" (&[]usize{request, a1, a2, a3, a4, a5}),
	26	: [_] "={rdx}" (-> usize)
	27	: [_] "{rax}" (&[]usize{ request, a1, a2, a3, a4, a5 }),
32	28	[_] "0" (default)
33	29	: "cc", "memory"
34	30	);
...	...	@@ -42,11 +38,10 @@ pub fn doClientRequest(default: usize, request: usize,
42	38	// mips64
43	39	else => {
44	40	return default;
45		}
	41	},
46	42	}
47	43	}
48	44
49
50	45	pub const ClientRequest = extern enum {
51	46	RunningOnValgrind = 4097,
52	47	DiscardTranslations = 4098,
...	...	@@ -81,59 +76,39 @@ pub const ClientRequest = extern enum {
81	76	InnerThreads = 6402,
82	77	};
83	78	pub fn ToolBase(base: [2]u8) u32 {
84		return (u32(base[0]&0xff) << 24) \| (u32(base[1]&0xff) << 16);
	79	return (u32(base[0] & 0xff) << 24) \| (u32(base[1] & 0xff) << 16);
85	80	}
86	81	pub fn IsTool(base: [2]u8, code: usize) bool {
87	82	return ToolBase(base) == (code & 0xffff0000);
88	83	}
89	84
90		fn doClientRequestExpr(default: usize, request: ClientRequest,
91		a1: usize, a2: usize, a3: usize, a4: usize, a5: usize
92		) usize
93		{
94		return doClientRequest(
95		default,
96		@intCast(usize, @enumToInt(request)),
97		a1, a2, a3, a4, a5);
	85	fn doClientRequestExpr(default: usize, request: ClientRequest, a1: usize, a2: usize, a3: usize, a4: usize, a5: usize) usize {
	86	return doClientRequest(default, @intCast(usize, @enumToInt(request)), a1, a2, a3, a4, a5);
98	87	}
99	88
100		fn doClientRequestStmt(request: ClientRequest,
101		a1: usize, a2: usize, a3: usize, a4: usize, a5: usize
102		) void
103		{
	89	fn doClientRequestStmt(request: ClientRequest, a1: usize, a2: usize, a3: usize, a4: usize, a5: usize) void {
104	90	_ = doClientRequestExpr(0, request, a1, a2, a3, a4, a5);
105	91	}
106	92
107
108
109	93	/// Returns the number of Valgrinds this code is running under. That
110	94	/// is, 0 if running natively, 1 if running under Valgrind, 2 if
111	95	/// running under Valgrind which is running under another Valgrind,
112	96	/// etc.
113	97	pub fn runningOnValgrind() usize {
114		return doClientRequestExpr(0,
115		ClientRequest.RunningOnValgrind,
116		0, 0, 0, 0, 0);
	98	return doClientRequestExpr(0, ClientRequest.RunningOnValgrind, 0, 0, 0, 0, 0);
117	99	}
118	100
119
120	101	/// Discard translation of code in the slice qzz. Useful if you are debugging
121	102	/// a JITter or some such, since it provides a way to make sure valgrind will
122	103	/// retranslate the invalidated area. Returns no value.
123	104	pub fn discardTranslations(qzz: []const u8) void {
124		doClientRequestStmt(ClientRequest.DiscardTranslations,
125		@ptrToInt(qzz.ptr), qzz.len,
126		0, 0, 0);
	105	doClientRequestStmt(ClientRequest.DiscardTranslations, @ptrToInt(qzz.ptr), qzz.len, 0, 0, 0);
127	106	}
128	107
129
130	108	pub fn innerThreads(qzz: [*]u8) void {
131		doClientRequestStmt(ClientRequest.InnerThreads,
132		qzz,
133		0, 0, 0, 0);
	109	doClientRequestStmt(ClientRequest.InnerThreads, qzz, 0, 0, 0, 0);
134	110	}
135	111
136
137	112	//pub fn printf(format: [*]const u8, args: ...) usize {
138	113	// return doClientRequestExpr(0,
139	114	// ClientRequest.PrintfValistByRef,
...	...	@@ -141,7 +116,6 @@ pub fn innerThreads(qzz: [*]u8) void {
141	116	// 0, 0, 0);
142	117	//}
143	118
144
145	119	//pub fn printfBacktrace(format: [*]const u8, args: ...) usize {
146	120	// return doClientRequestExpr(0,
147	121	// ClientRequest.PrintfBacktraceValistByRef,
...	...	@@ -149,161 +123,105 @@ pub fn innerThreads(qzz: [*]u8) void {
149	123	// 0, 0, 0);
150	124	//}
151	125
152
153		pub fn nonSIMDCall0(func: fn(usize) usize) usize {
154		return doClientRequestExpr(0,
155		ClientRequest.ClientCall0,
156		@ptrToInt(func),
157		0, 0, 0, 0);
	126	pub fn nonSIMDCall0(func: fn (usize) usize) usize {
	127	return doClientRequestExpr(0, ClientRequest.ClientCall0, @ptrToInt(func), 0, 0, 0, 0);
158	128	}
159	129
160		pub fn nonSIMDCall1(func: fn(usize, usize) usize, a1: usize) usize {
161		return doClientRequestExpr(0,
162		ClientRequest.ClientCall1,
163		@ptrToInt(func), a1,
164		0, 0, 0);
	130	pub fn nonSIMDCall1(func: fn (usize, usize) usize, a1: usize) usize {
	131	return doClientRequestExpr(0, ClientRequest.ClientCall1, @ptrToInt(func), a1, 0, 0, 0);
165	132	}
166	133
167		pub fn nonSIMDCall2(func: fn(usize, usize, usize) usize,
168		a1: usize, a2: usize) usize
169		{
170		return doClientRequestExpr(0,
171		ClientRequest.ClientCall2,
172		@ptrToInt(func), a1, a2,
173		0, 0);
	134	pub fn nonSIMDCall2(func: fn (usize, usize, usize) usize, a1: usize, a2: usize) usize {
	135	return doClientRequestExpr(0, ClientRequest.ClientCall2, @ptrToInt(func), a1, a2, 0, 0);
174	136	}
175	137
176		pub fn nonSIMDCall3(func: fn(usize, usize, usize, usize) usize,
177		a1: usize, a2: usize, a3: usize) usize
178		{
179		return doClientRequestExpr(0,
180		ClientRequest.ClientCall3,
181		@ptrToInt(func), a1, a2, a3,
182		0);
	138	pub fn nonSIMDCall3(func: fn (usize, usize, usize, usize) usize, a1: usize, a2: usize, a3: usize) usize {
	139	return doClientRequestExpr(0, ClientRequest.ClientCall3, @ptrToInt(func), a1, a2, a3, 0);
183	140	}
184	141
185
186	142	/// Counts the number of errors that have been recorded by a tool. Nb:
187	143	/// the tool must record the errors with VG_(maybe_record_error)() or
188	144	/// VG_(unique_error)() for them to be counted.
189	145	pub fn countErrors() usize {
190	146	return doClientRequestExpr(0, // default return
191		ClientRequest.CountErrors,
192		0, 0, 0, 0, 0);
	147	ClientRequest.CountErrors, 0, 0, 0, 0, 0);
193	148	}
194	149
195
196	150	pub fn mallocLikeBlock(mem: []u8, rzB: usize, is_zeroed: bool) void {
197		doClientRequestStmt(ClientRequest.MalloclikeBlock,
198		@ptrToInt(mem.ptr), mem.len, rzB, @boolToInt(is_zeroed),
199		0);
	151	doClientRequestStmt(ClientRequest.MalloclikeBlock, @ptrToInt(mem.ptr), mem.len, rzB, @boolToInt(is_zeroed), 0);
200	152	}
201	153
202
203	154	pub fn resizeInPlaceBlock(oldmem: []u8, newsize: usize, rzB: usize) void {
204		doClientRequestStmt(ClientRequest.ResizeinplaceBlock,
205		@ptrToInt(oldmem.ptr), oldmem.len, newsize, rzB,
206		0);
	155	doClientRequestStmt(ClientRequest.ResizeinplaceBlock, @ptrToInt(oldmem.ptr), oldmem.len, newsize, rzB, 0);
207	156	}
208	157
209
210	158	pub fn freeLikeBlock(addr: [*]u8, rzB: usize) void {
211		doClientRequestStmt(ClientRequest.FreelikeBlock,
212		@ptrToInt(addr), rzB,
213		0, 0, 0);
	159	doClientRequestStmt(ClientRequest.FreelikeBlock, @ptrToInt(addr), rzB, 0, 0, 0);
214	160	}
215	161
216
217	162	/// Create a memory pool.
218	163	pub const MempoolFlags = extern enum {
219	164	AutoFree = 1,
220	165	MetaPool = 2,
221	166	};
222	167	pub fn createMempool(pool: [*]u8, rzB: usize, is_zeroed: bool, flags: usize) void {
223		doClientRequestStmt(ClientRequest.CreateMempool,
224		@ptrToInt(pool), rzB, @boolToInt(is_zeroed), flags,
225		0);
	168	doClientRequestStmt(ClientRequest.CreateMempool, @ptrToInt(pool), rzB, @boolToInt(is_zeroed), flags, 0);
226	169	}
227	170
228	171	/// Destroy a memory pool.
229	172	pub fn destroyMempool(pool: [*]u8) void {
230		doClientRequestStmt(ClientRequest.DestroyMempool,
231		pool,
232		0, 0, 0, 0);
	173	doClientRequestStmt(ClientRequest.DestroyMempool, pool, 0, 0, 0, 0);
233	174	}
234	175
235
236	176	/// Associate a piece of memory with a memory pool.
237	177	pub fn mempoolAlloc(pool: [*]u8, mem: []u8) void {
238		doClientRequestStmt(ClientRequest.MempoolAlloc,
239		@ptrToInt(pool), @ptrToInt(mem.ptr), mem.len,
240		0, 0);
	178	doClientRequestStmt(ClientRequest.MempoolAlloc, @ptrToInt(pool), @ptrToInt(mem.ptr), mem.len, 0, 0);
241	179	}
242	180
243	181	/// Disassociate a piece of memory from a memory pool.
244	182	pub fn mempoolFree(pool: []u8, addr: []u8) void {
245		doClientRequestStmt(ClientRequest.MempoolFree,
246		@ptrToInt(pool), @ptrToInt(addr),
247		0, 0, 0);
	183	doClientRequestStmt(ClientRequest.MempoolFree, @ptrToInt(pool), @ptrToInt(addr), 0, 0, 0);
248	184	}
249	185
250	186	/// Disassociate any pieces outside a particular range.
251	187	pub fn mempoolTrim(pool: [*]u8, mem: []u8) void {
252		doClientRequestStmt(ClientRequest.MempoolTrim,
253		@ptrToInt(pool), @ptrToInt(mem.ptr), mem.len,
254		0, 0);
	188	doClientRequestStmt(ClientRequest.MempoolTrim, @ptrToInt(pool), @ptrToInt(mem.ptr), mem.len, 0, 0);
255	189	}
256	190
257	191	/// Resize and/or move a piece associated with a memory pool.
258	192	pub fn moveMempool(poolA: []u8, poolB: []u8) void {
259		doClientRequestStmt(ClientRequest.MoveMempool,
260		@ptrToInt(poolA), @ptrToInt(poolB),
261		0, 0, 0);
	193	doClientRequestStmt(ClientRequest.MoveMempool, @ptrToInt(poolA), @ptrToInt(poolB), 0, 0, 0);
262	194	}
263	195
264	196	/// Resize and/or move a piece associated with a memory pool.
265	197	pub fn mempoolChange(pool: []u8, addrA: []u8, mem: []u8) void {
266		doClientRequestStmt(ClientRequest.MempoolChange,
267		@ptrToInt(pool), @ptrToInt(addrA), @ptrToInt(mem.ptr), mem.len,
268		0);
	198	doClientRequestStmt(ClientRequest.MempoolChange, @ptrToInt(pool), @ptrToInt(addrA), @ptrToInt(mem.ptr), mem.len, 0);
269	199	}
270	200
271	201	/// Return if a mempool exists.
272	202	pub fn mempoolExists(pool: [*]u8) bool {
273		return doClientRequestExpr(0,
274		ClientRequest.MempoolExists,
275		@ptrToInt(pool),
276		0, 0, 0, 0) != 0;
	203	return doClientRequestExpr(0, ClientRequest.MempoolExists, @ptrToInt(pool), 0, 0, 0, 0) != 0;
277	204	}
278	205
279
280	206	/// Mark a piece of memory as being a stack. Returns a stack id.
281	207	/// start is the lowest addressable stack byte, end is the highest
282	208	/// addressable stack byte.
283	209	pub fn stackRegister(stack: []u8) usize {
284		return doClientRequestExpr(0,
285		ClientRequest.StackRegister,
286		@ptrToInt(stack.ptr), @ptrToInt(stack.ptr) + stack.len,
287		0, 0, 0);
	210	return doClientRequestExpr(0, ClientRequest.StackRegister, @ptrToInt(stack.ptr), @ptrToInt(stack.ptr) + stack.len, 0, 0, 0);
288	211	}
289	212
290	213	/// Unmark the piece of memory associated with a stack id as being a stack.
291	214	pub fn stackDeregister(id: usize) void {
292		doClientRequestStmt(ClientRequest.StackDeregister,
293		id,
294		0, 0, 0, 0);
	215	doClientRequestStmt(ClientRequest.StackDeregister, id, 0, 0, 0, 0);
295	216	}
296	217
297	218	/// Change the start and end address of the stack id.
298	219	/// start is the new lowest addressable stack byte, end is the new highest
299	220	/// addressable stack byte.
300	221	pub fn stackChange(id: usize, newstack: []u8) void {
301		doClientRequestStmt(ClientRequest.StackChange,
302		id, @ptrToInt(newstack.ptr), @ptrToInt(newstack.ptr) + newstack.len,
303		0, 0);
	222	doClientRequestStmt(ClientRequest.StackChange, id, @ptrToInt(newstack.ptr), @ptrToInt(newstack.ptr) + newstack.len, 0, 0);
304	223	}
305	224
306
307	225	// Load PDB debug info for Wine PE image_map.
308	226	// pub fn loadPdbDebuginfo(fd, ptr, total_size, delta) void {
309	227	// doClientRequestStmt(ClientRequest.LoadPdbDebuginfo,
...	...	@@ -311,19 +229,14 @@ pub fn stackChange(id: usize, newstack: []u8) void {
311	229	// 0);
312	230	// }
313	231
314
315	232	/// Map a code address to a source file name and line number. buf64
316	233	/// must point to a 64-byte buffer in the caller's address space. The
317	234	/// result will be dumped in there and is guaranteed to be zero
318	235	/// terminated. If no info is found, the first byte is set to zero.
319	236	pub fn mapIpToSrcloc(addr: *const u8, buf64: [64]u8) usize {
320		return doClientRequestExpr(0,
321		ClientRequest.MapIpToSrcloc,
322		@ptrToInt(addr), @ptrToInt(&buf64[0]),
323		0, 0, 0);
	237	return doClientRequestExpr(0, ClientRequest.MapIpToSrcloc, @ptrToInt(addr), @ptrToInt(&buf64[0]), 0, 0, 0);
324	238	}
325	239
326
327	240	/// Disable error reporting for this thread. Behaves in a stack like
328	241	/// way, so you can safely call this multiple times provided that
329	242	/// enableErrorReporting() is called the same number of times
...	...	@@ -333,31 +246,22 @@ pub fn mapIpToSrcloc(addr: *const u8, buf64: [64]u8) usize {
333	246	/// reporting. Child threads do not inherit this setting from their
334	247	/// parents -- they are always created with reporting enabled.
335	248	pub fn disableErrorReporting() void {
336		doClientRequestStmt(ClientRequest.ChangeErrDisablement,
337		1,
338		0, 0, 0, 0);
	249	doClientRequestStmt(ClientRequest.ChangeErrDisablement, 1, 0, 0, 0, 0);
339	250	}
340	251
341	252	/// Re-enable error reporting, (see disableErrorReporting())
342	253	pub fn enableErrorReporting() void {
343		doClientRequestStmt(ClientRequest.ChangeErrDisablement,
344		math.maxInt(usize),
345		0, 0, 0, 0);
	254	doClientRequestStmt(ClientRequest.ChangeErrDisablement, math.maxInt(usize), 0, 0, 0, 0);
346	255	}
347	256
348
349	257	/// Execute a monitor command from the client program.
350	258	/// If a connection is opened with GDB, the output will be sent
351	259	/// according to the output mode set for vgdb.
352	260	/// If no connection is opened, output will go to the log output.
353	261	/// Returns 1 if command not recognised, 0 otherwise.
354	262	pub fn monitorCommand(command: [*]u8) bool {
355		return doClientRequestExpr(0,
356		ClientRequest.GdbMonitorCommand,
357		@ptrToInt(command.ptr),
358		0, 0, 0, 0) != 0;
	263	return doClientRequestExpr(0, ClientRequest.GdbMonitorCommand, @ptrToInt(command.ptr), 0, 0, 0, 0) != 0;
359	264	}
360	265
361
362	266	pub const memcheck = @import("memcheck.zig");
363	267	pub const callgrind = @import("callgrind.zig");

std/zig.zig-1

...	...	@@ -13,4 +13,3 @@ test "std.zig tests" {
13	13	_ = @import("zig/tokenizer.zig");
14	14	_ = @import("zig/parse_string_literal.zig");
15	15	}
16

author	Andrew Kelley <andrew@ziglang.org> 2019-05-12 12:56:01-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2019-05-12 12:56:01-04:00
log	c1793d61061a112dc3d58c33ac0d3a1ebc8fb35e
tree	da9b4839ee1c8bcc4d5c6dcd3423f955cfce2e5d
parent	ed5a6d74ad980474ed46732828c7f8363dd5b80d
signature	Commit is signed but in an unrecognized format.

zig fmt on the standard library