Commit 5dfe0e7e8fabd3cfc3fdf5c7099791da98899903 | zig

author	Tadeo Kondrak <me@tadeo.ca> 2021-01-11 08:03:09-07:00
committer	Tadeo Kondrak <me@tadeo.ca> 2021-02-10 20:06:12-07:00
log	5dfe0e7e8fabd3cfc3fdf5c7099791da98899903
tree	9232489bf17f8ac7dec688277dcfcc1792849d3e
parent	9c797fe3ac3a377caa01bdbd74b984d11b53398e
signature	Commit is signed but in an unrecognized format.

Convert inline fn to callconv(.Inline) everywhere

36 files changed, 199 insertions(+), 199 deletions(-)

doc
- langref.html.in
lib
- std
  - c
    builtins.zig
  - compress
    deflate.zig
  - crypto
    25519
    curve25519.zig
    edwards25519.zig
    field.zig
    ristretto255.zig
    scalar.zig
    aegis.zig
    aes
    aesni.zig
    armcrypto.zig
    soft.zig
    blake3.zig
    chacha20.zig
    ghash.zig
    gimli.zig
    salsa20.zig
  - elf.zig
  - fmt
    parse_float.zig
  - hash
    cityhash.zig
  - os
    bits
    freebsd.zig
    netbsd.zig
    linux.zig
    linux
    tls.zig
    windows.zig
  - start.zig
  - zig
    parser_test.zig
    system
    x86.zig
src
- link
  - MachO.zig
- tracy.zig
test
- cli.zig
- compile_errors.zig
- stage1
  - behavior
    fn.zig
- stage2
  - cbe.zig
  - test.zig
- translate_c.zig

doc/langref.html.in+2-2

...	...	@@ -4240,9 +4240,9 @@ fn _start() callconv(.Naked) noreturn {
4240	4240	abort();
4241	4241	}
4242	4242
4243		// The inline specifier forces a function to be inlined at all call sites.
	4243	// The inline calling convention forces a function to be inlined at all call sites.
4244	4244	// If the function cannot be inlined, it is a compile-time error.
4245		inline fn shiftLeftOne(a: u32) u32 {
	4245	fn shiftLeftOne(a: u32) callconv(.Inline) u32 {
4246	4246	return a << 1;
4247	4247	}
4248	4248

lib/std/c/builtins.zig+49-49

...	...	@@ -6,70 +6,70 @@
6	6
7	7	const std = @import("std");
8	8
9		pub inline fn __builtin_bswap16(val: u16) callconv(.C) u16 { return @byteSwap(u16, val); }
10		pub inline fn __builtin_bswap32(val: u32) callconv(.C) u32 { return @byteSwap(u32, val); }
11		pub inline fn __builtin_bswap64(val: u64) callconv(.C) u64 { return @byteSwap(u64, val); }
	9	pub fn __builtin_bswap16(val: u16) callconv(.Inline) u16 { return @byteSwap(u16, val); }
	10	pub fn __builtin_bswap32(val: u32) callconv(.Inline) u32 { return @byteSwap(u32, val); }
	11	pub fn __builtin_bswap64(val: u64) callconv(.Inline) u64 { return @byteSwap(u64, val); }
12	12
13		pub inline fn __builtin_signbit(val: f64) callconv(.C) c_int { return @boolToInt(std.math.signbit(val)); }
14		pub inline fn __builtin_signbitf(val: f32) callconv(.C) c_int { return @boolToInt(std.math.signbit(val)); }
	13	pub fn __builtin_signbit(val: f64) callconv(.Inline) c_int { return @boolToInt(std.math.signbit(val)); }
	14	pub fn __builtin_signbitf(val: f32) callconv(.Inline) c_int { return @boolToInt(std.math.signbit(val)); }
15	15
16		pub inline fn __builtin_popcount(val: c_uint) callconv(.C) c_int {
	16	pub fn __builtin_popcount(val: c_uint) callconv(.Inline) c_int {
17	17	// popcount of a c_uint will never exceed the capacity of a c_int
18	18	@setRuntimeSafety(false);
19	19	return @bitCast(c_int, @as(c_uint, @popCount(c_uint, val)));
20	20	}
21		pub inline fn __builtin_ctz(val: c_uint) callconv(.C) c_int {
	21	pub fn __builtin_ctz(val: c_uint) callconv(.Inline) c_int {
22	22	// Returns the number of trailing 0-bits in val, starting at the least significant bit position.
23	23	// In C if `val` is 0, the result is undefined; in zig it's the number of bits in a c_uint
24	24	@setRuntimeSafety(false);
25	25	return @bitCast(c_int, @as(c_uint, @ctz(c_uint, val)));
26	26	}
27		pub inline fn __builtin_clz(val: c_uint) callconv(.C) c_int {
	27	pub fn __builtin_clz(val: c_uint) callconv(.Inline) c_int {
28	28	// Returns the number of leading 0-bits in x, starting at the most significant bit position.
29	29	// In C if `val` is 0, the result is undefined; in zig it's the number of bits in a c_uint
30	30	@setRuntimeSafety(false);
31	31	return @bitCast(c_int, @as(c_uint, @clz(c_uint, val)));
32	32	}
33	33
34		pub inline fn __builtin_sqrt(val: f64) callconv(.C) f64 { return @sqrt(val); }
35		pub inline fn __builtin_sqrtf(val: f32) callconv(.C) f32 { return @sqrt(val); }
36
37		pub inline fn __builtin_sin(val: f64) callconv(.C) f64 { return @sin(val); }
38		pub inline fn __builtin_sinf(val: f32) callconv(.C) f32 { return @sin(val); }
39		pub inline fn __builtin_cos(val: f64) callconv(.C) f64 { return @cos(val); }
40		pub inline fn __builtin_cosf(val: f32) callconv(.C) f32 { return @cos(val); }
41
42		pub inline fn __builtin_exp(val: f64) callconv(.C) f64 { return @exp(val); }
43		pub inline fn __builtin_expf(val: f32) callconv(.C) f32 { return @exp(val); }
44		pub inline fn __builtin_exp2(val: f64) callconv(.C) f64 { return @exp2(val); }
45		pub inline fn __builtin_exp2f(val: f32) callconv(.C) f32 { return @exp2(val); }
46		pub inline fn __builtin_log(val: f64) callconv(.C) f64 { return @log(val); }
47		pub inline fn __builtin_logf(val: f32) callconv(.C) f32 { return @log(val); }
48		pub inline fn __builtin_log2(val: f64) callconv(.C) f64 { return @log2(val); }
49		pub inline fn __builtin_log2f(val: f32) callconv(.C) f32 { return @log2(val); }
50		pub inline fn __builtin_log10(val: f64) callconv(.C) f64 { return @log10(val); }
51		pub inline fn __builtin_log10f(val: f32) callconv(.C) f32 { return @log10(val); }
	34	pub fn __builtin_sqrt(val: f64) callconv(.Inline) f64 { return @sqrt(val); }
	35	pub fn __builtin_sqrtf(val: f32) callconv(.Inline) f32 { return @sqrt(val); }
	36
	37	pub fn __builtin_sin(val: f64) callconv(.Inline) f64 { return @sin(val); }
	38	pub fn __builtin_sinf(val: f32) callconv(.Inline) f32 { return @sin(val); }
	39	pub fn __builtin_cos(val: f64) callconv(.Inline) f64 { return @cos(val); }
	40	pub fn __builtin_cosf(val: f32) callconv(.Inline) f32 { return @cos(val); }
	41
	42	pub fn __builtin_exp(val: f64) callconv(.Inline) f64 { return @exp(val); }
	43	pub fn __builtin_expf(val: f32) callconv(.Inline) f32 { return @exp(val); }
	44	pub fn __builtin_exp2(val: f64) callconv(.Inline) f64 { return @exp2(val); }
	45	pub fn __builtin_exp2f(val: f32) callconv(.Inline) f32 { return @exp2(val); }
	46	pub fn __builtin_log(val: f64) callconv(.Inline) f64 { return @log(val); }
	47	pub fn __builtin_logf(val: f32) callconv(.Inline) f32 { return @log(val); }
	48	pub fn __builtin_log2(val: f64) callconv(.Inline) f64 { return @log2(val); }
	49	pub fn __builtin_log2f(val: f32) callconv(.Inline) f32 { return @log2(val); }
	50	pub fn __builtin_log10(val: f64) callconv(.Inline) f64 { return @log10(val); }
	51	pub fn __builtin_log10f(val: f32) callconv(.Inline) f32 { return @log10(val); }
52	52
53	53	// Standard C Library bug: The absolute value of the most negative integer remains negative.
54		pub inline fn __builtin_abs(val: c_int) callconv(.C) c_int { return std.math.absInt(val) catch std.math.minInt(c_int); }
55		pub inline fn __builtin_fabs(val: f64) callconv(.C) f64 { return @fabs(val); }
56		pub inline fn __builtin_fabsf(val: f32) callconv(.C) f32 { return @fabs(val); }
57
58		pub inline fn __builtin_floor(val: f64) callconv(.C) f64 { return @floor(val); }
59		pub inline fn __builtin_floorf(val: f32) callconv(.C) f32 { return @floor(val); }
60		pub inline fn __builtin_ceil(val: f64) callconv(.C) f64 { return @ceil(val); }
61		pub inline fn __builtin_ceilf(val: f32) callconv(.C) f32 { return @ceil(val); }
62		pub inline fn __builtin_trunc(val: f64) callconv(.C) f64 { return @trunc(val); }
63		pub inline fn __builtin_truncf(val: f32) callconv(.C) f32 { return @trunc(val); }
64		pub inline fn __builtin_round(val: f64) callconv(.C) f64 { return @round(val); }
65		pub inline fn __builtin_roundf(val: f32) callconv(.C) f32 { return @round(val); }
66
67		pub inline fn __builtin_strlen(s: [*c]const u8) callconv(.C) usize { return std.mem.lenZ(s); }
68		pub inline fn __builtin_strcmp(s1: [c]const u8, s2: [c]const u8) callconv(.C) c_int {
	54	pub fn __builtin_abs(val: c_int) callconv(.Inline) c_int { return std.math.absInt(val) catch std.math.minInt(c_int); }
	55	pub fn __builtin_fabs(val: f64) callconv(.Inline) f64 { return @fabs(val); }
	56	pub fn __builtin_fabsf(val: f32) callconv(.Inline) f32 { return @fabs(val); }
	57
	58	pub fn __builtin_floor(val: f64) callconv(.Inline) f64 { return @floor(val); }
	59	pub fn __builtin_floorf(val: f32) callconv(.Inline) f32 { return @floor(val); }
	60	pub fn __builtin_ceil(val: f64) callconv(.Inline) f64 { return @ceil(val); }
	61	pub fn __builtin_ceilf(val: f32) callconv(.Inline) f32 { return @ceil(val); }
	62	pub fn __builtin_trunc(val: f64) callconv(.Inline) f64 { return @trunc(val); }
	63	pub fn __builtin_truncf(val: f32) callconv(.Inline) f32 { return @trunc(val); }
	64	pub fn __builtin_round(val: f64) callconv(.Inline) f64 { return @round(val); }
	65	pub fn __builtin_roundf(val: f32) callconv(.Inline) f32 { return @round(val); }
	66
	67	pub fn __builtin_strlen(s: [*c]const u8) callconv(.Inline) usize { return std.mem.lenZ(s); }
	68	pub fn __builtin_strcmp(s1: [c]const u8, s2: [c]const u8) callconv(.Inline) c_int {
69	69	return @as(c_int, std.cstr.cmp(s1, s2));
70	70	}
71	71
72		pub inline fn __builtin_object_size(ptr: ?*const c_void, ty: c_int) callconv(.C) usize {
	72	pub fn __builtin_object_size(ptr: ?*const c_void, ty: c_int) callconv(.Inline) usize {
73	73	// clang semantics match gcc's: https://gcc.gnu.org/onlinedocs/gcc/Object-Size-Checking.html
74	74	// If it is not possible to determine which objects ptr points to at compile time,
75	75	// __builtin_object_size should return (size_t) -1 for type 0 or 1 and (size_t) 0
...	...	@@ -79,37 +79,37 @@ pub inline fn __builtin_object_size(ptr: ?*const c_void, ty: c_int) callconv(.C)
79	79	unreachable;
80	80	}
81	81
82		pub inline fn __builtin___memset_chk(
	82	pub fn __builtin___memset_chk(
83	83	dst: ?*c_void,
84	84	val: c_int,
85	85	len: usize,
86	86	remaining: usize,
87		) callconv(.C) ?*c_void {
	87	) callconv(.Inline) ?*c_void {
88	88	if (len > remaining) @panic("std.c.builtins.memset_chk called with len > remaining");
89	89	return __builtin_memset(dst, val, len);
90	90	}
91	91
92		pub inline fn __builtin_memset(dst: ?c_void, val: c_int, len: usize) callconv(.C) ?c_void {
	92	pub fn __builtin_memset(dst: ?c_void, val: c_int, len: usize) callconv(.Inline) ?c_void {
93	93	const dst_cast = @ptrCast([*c]u8, dst);
94	94	@memset(dst_cast, @bitCast(u8, @truncate(i8, val)), len);
95	95	return dst;
96	96	}
97	97
98		pub inline fn __builtin___memcpy_chk(
	98	pub fn __builtin___memcpy_chk(
99	99	noalias dst: ?*c_void,
100	100	noalias src: ?*const c_void,
101	101	len: usize,
102	102	remaining: usize,
103		) callconv(.C) ?*c_void {
	103	) callconv(.Inline) ?*c_void {
104	104	if (len > remaining) @panic("std.c.builtins.memcpy_chk called with len > remaining");
105	105	return __builtin_memcpy(dst, src, len);
106	106	}
107	107
108		pub inline fn __builtin_memcpy(
	108	pub fn __builtin_memcpy(
109	109	noalias dst: ?*c_void,
110	110	noalias src: ?*const c_void,
111	111	len: usize,
112		) callconv(.C) ?*c_void {
	112	) callconv(.Inline) ?*c_void {
113	113	const dst_cast = @ptrCast([*c]u8, dst);
114	114	const src_cast = @ptrCast([*c]const u8, src);
115	115

lib/std/compress/deflate.zig+1-1

...	...	@@ -209,7 +209,7 @@ pub fn InflateStream(comptime ReaderType: type) type {
209	209
210	210	// Insert a single byte into the window.
211	211	// Assumes there's enough space.
212		inline fn appendUnsafe(self: *WSelf, value: u8) void {
	212	fn appendUnsafe(self: *WSelf, value: u8) callconv(.Inline) void {
213	213	self.buf[self.wi] = value;
214	214	self.wi = (self.wi + 1) & (self.buf.len - 1);
215	215	self.el += 1;

lib/std/crypto/25519/curve25519.zig+2-2

...	...	@@ -15,12 +15,12 @@ pub const Curve25519 = struct {
15	15	x: Fe,
16	16
17	17	/// Decode a Curve25519 point from its compressed (X) coordinates.
18		pub inline fn fromBytes(s: [32]u8) Curve25519 {
	18	pub fn fromBytes(s: [32]u8) callconv(.Inline) Curve25519 {
19	19	return .{ .x = Fe.fromBytes(s) };
20	20	}
21	21
22	22	/// Encode a Curve25519 point.
23		pub inline fn toBytes(p: Curve25519) [32]u8 {
	23	pub fn toBytes(p: Curve25519) callconv(.Inline) [32]u8 {
24	24	return p.x.toBytes();
25	25	}
26	26

lib/std/crypto/25519/edwards25519.zig+3-3

...	...	@@ -92,7 +92,7 @@ pub const Edwards25519 = struct {
92	92	}
93	93
94	94	/// Flip the sign of the X coordinate.
95		pub inline fn neg(p: Edwards25519) Edwards25519 {
	95	pub fn neg(p: Edwards25519) callconv(.Inline) Edwards25519 {
96	96	return .{ .x = p.x.neg(), .y = p.y, .z = p.z, .t = p.t.neg() };
97	97	}
98	98
...	...	@@ -137,14 +137,14 @@ pub const Edwards25519 = struct {
137	137	return p.add(q.neg());
138	138	}
139	139
140		inline fn cMov(p: *Edwards25519, a: Edwards25519, c: u64) void {
	140	fn cMov(p: *Edwards25519, a: Edwards25519, c: u64) callconv(.Inline) void {
141	141	p.x.cMov(a.x, c);
142	142	p.y.cMov(a.y, c);
143	143	p.z.cMov(a.z, c);
144	144	p.t.cMov(a.t, c);
145	145	}
146	146
147		inline fn pcSelect(comptime n: usize, pc: [n]Edwards25519, b: u8) Edwards25519 {
	147	fn pcSelect(comptime n: usize, pc: [n]Edwards25519, b: u8) callconv(.Inline) Edwards25519 {
148	148	var t = Edwards25519.identityElement;
149	149	comptime var i: u8 = 1;
150	150	inline while (i < pc.len) : (i += 1) {

lib/std/crypto/25519/field.zig+14-14

...	...	@@ -52,7 +52,7 @@ pub const Fe = struct {
52	52	pub const edwards25519sqrtam2 = Fe{ .limbs = .{ 1693982333959686, 608509411481997, 2235573344831311, 947681270984193, 266558006233600 } };
53	53
54	54	/// Return true if the field element is zero
55		pub inline fn isZero(fe: Fe) bool {
	55	pub fn isZero(fe: Fe) callconv(.Inline) bool {
56	56	var reduced = fe;
57	57	reduced.reduce();
58	58	const limbs = reduced.limbs;
...	...	@@ -60,7 +60,7 @@ pub const Fe = struct {
60	60	}
61	61
62	62	/// Return true if both field elements are equivalent
63		pub inline fn equivalent(a: Fe, b: Fe) bool {
	63	pub fn equivalent(a: Fe, b: Fe) callconv(.Inline) bool {
64	64	return a.sub(b).isZero();
65	65	}
66	66
...	...	@@ -164,7 +164,7 @@ pub const Fe = struct {
164	164	}
165	165
166	166	/// Add a field element
167		pub inline fn add(a: Fe, b: Fe) Fe {
	167	pub fn add(a: Fe, b: Fe) callconv(.Inline) Fe {
168	168	var fe: Fe = undefined;
169	169	comptime var i = 0;
170	170	inline while (i < 5) : (i += 1) {
...	...	@@ -174,7 +174,7 @@ pub const Fe = struct {
174	174	}
175	175
176	176	/// Substract a field elememnt
177		pub inline fn sub(a: Fe, b: Fe) Fe {
	177	pub fn sub(a: Fe, b: Fe) callconv(.Inline) Fe {
178	178	var fe = b;
179	179	comptime var i = 0;
180	180	inline while (i < 4) : (i += 1) {
...	...	@@ -193,17 +193,17 @@ pub const Fe = struct {
193	193	}
194	194
195	195	/// Negate a field element
196		pub inline fn neg(a: Fe) Fe {
	196	pub fn neg(a: Fe) callconv(.Inline) Fe {
197	197	return zero.sub(a);
198	198	}
199	199
200	200	/// Return true if a field element is negative
201		pub inline fn isNegative(a: Fe) bool {
	201	pub fn isNegative(a: Fe) callconv(.Inline) bool {
202	202	return (a.toBytes()[0] & 1) != 0;
203	203	}
204	204
205	205	/// Conditonally replace a field element with `a` if `c` is positive
206		pub inline fn cMov(fe: *Fe, a: Fe, c: u64) void {
	206	pub fn cMov(fe: *Fe, a: Fe, c: u64) callconv(.Inline) void {
207	207	const mask: u64 = 0 -% c;
208	208	var x = fe.*;
209	209	comptime var i = 0;
...	...	@@ -244,7 +244,7 @@ pub const Fe = struct {
244	244	}
245	245	}
246	246
247		inline fn _carry128(r: *[5]u128) Fe {
	247	fn _carry128(r: *[5]u128) callconv(.Inline) Fe {
248	248	var rs: [5]u64 = undefined;
249	249	comptime var i = 0;
250	250	inline while (i < 4) : (i += 1) {
...	...	@@ -265,7 +265,7 @@ pub const Fe = struct {
265	265	}
266	266
267	267	/// Multiply two field elements
268		pub inline fn mul(a: Fe, b: Fe) Fe {
	268	pub fn mul(a: Fe, b: Fe) callconv(.Inline) Fe {
269	269	var ax: [5]u128 = undefined;
270	270	var bx: [5]u128 = undefined;
271	271	var a19: [5]u128 = undefined;
...	...	@@ -288,7 +288,7 @@ pub const Fe = struct {
288	288	return _carry128(&r);
289	289	}
290	290
291		inline fn _sq(a: Fe, double: comptime bool) Fe {
	291	fn _sq(a: Fe, double: comptime bool) callconv(.Inline) Fe {
292	292	var ax: [5]u128 = undefined;
293	293	var r: [5]u128 = undefined;
294	294	comptime var i = 0;
...	...	@@ -317,17 +317,17 @@ pub const Fe = struct {
317	317	}
318	318
319	319	/// Square a field element
320		pub inline fn sq(a: Fe) Fe {
	320	pub fn sq(a: Fe) callconv(.Inline) Fe {
321	321	return _sq(a, false);
322	322	}
323	323
324	324	/// Square and double a field element
325		pub inline fn sq2(a: Fe) Fe {
	325	pub fn sq2(a: Fe) callconv(.Inline) Fe {
326	326	return _sq(a, true);
327	327	}
328	328
329	329	/// Multiply a field element with a small (32-bit) integer
330		pub inline fn mul32(a: Fe, comptime n: u32) Fe {
	330	pub fn mul32(a: Fe, comptime n: u32) callconv(.Inline) Fe {
331	331	const sn = @intCast(u128, n);
332	332	var fe: Fe = undefined;
333	333	var x: u128 = 0;
...	...	@@ -342,7 +342,7 @@ pub const Fe = struct {
342	342	}
343	343
344	344	/// Square a field element `n` times
345		inline fn sqn(a: Fe, comptime n: comptime_int) Fe {
	345	fn sqn(a: Fe, comptime n: comptime_int) callconv(.Inline) Fe {
346	346	var i: usize = 0;
347	347	var fe = a;
348	348	while (i < n) : (i += 1) {

lib/std/crypto/25519/ristretto255.zig+4-4

...	...	@@ -42,7 +42,7 @@ pub const Ristretto255 = struct {
42	42	}
43	43
44	44	/// Reject the neutral element.
45		pub inline fn rejectIdentity(p: Ristretto255) !void {
	45	pub fn rejectIdentity(p: Ristretto255) callconv(.Inline) !void {
46	46	return p.p.rejectIdentity();
47	47	}
48	48
...	...	@@ -141,19 +141,19 @@ pub const Ristretto255 = struct {
141	141	}
142	142
143	143	/// Double a Ristretto255 element.
144		pub inline fn dbl(p: Ristretto255) Ristretto255 {
	144	pub fn dbl(p: Ristretto255) callconv(.Inline) Ristretto255 {
145	145	return .{ .p = p.p.dbl() };
146	146	}
147	147
148	148	/// Add two Ristretto255 elements.
149		pub inline fn add(p: Ristretto255, q: Ristretto255) Ristretto255 {
	149	pub fn add(p: Ristretto255, q: Ristretto255) callconv(.Inline) Ristretto255 {
150	150	return .{ .p = p.p.add(q.p) };
151	151	}
152	152
153	153	/// Multiply a Ristretto255 element with a scalar.
154	154	/// Return error.WeakPublicKey if the resulting element is
155	155	/// the identity element.
156		pub inline fn mul(p: Ristretto255, s: [encoded_length]u8) !Ristretto255 {
	156	pub fn mul(p: Ristretto255, s: [encoded_length]u8) callconv(.Inline) !Ristretto255 {
157	157	return Ristretto255{ .p = try p.p.mul(s) };
158	158	}
159	159

lib/std/crypto/25519/scalar.zig+1-1

...	...	@@ -46,7 +46,7 @@ pub fn reduce64(s: [64]u8) [32]u8 {
46	46
47	47	/// Perform the X25519 "clamping" operation.
48	48	/// The scalar is then guaranteed to be a multiple of the cofactor.
49		pub inline fn clamp(s: *[32]u8) void {
	49	pub fn clamp(s: *[32]u8) callconv(.Inline) void {
50	50	s[0] &= 248;
51	51	s[31] = (s[31] & 127) \| 64;
52	52	}

lib/std/crypto/aegis.zig+2-2

...	...	@@ -35,7 +35,7 @@ const State128L = struct {
35	35	return state;
36	36	}
37	37
38		inline fn update(state: *State128L, d1: AesBlock, d2: AesBlock) void {
	38	fn update(state: *State128L, d1: AesBlock, d2: AesBlock) callconv(.Inline) void {
39	39	const blocks = &state.blocks;
40	40	const tmp = blocks[7];
41	41	comptime var i: usize = 7;
...	...	@@ -207,7 +207,7 @@ const State256 = struct {
207	207	return state;
208	208	}
209	209
210		inline fn update(state: *State256, d: AesBlock) void {
	210	fn update(state: *State256, d: AesBlock) callconv(.Inline) void {
211	211	const blocks = &state.blocks;
212	212	const tmp = blocks[5].encrypt(blocks[0]);
213	213	comptime var i: usize = 5;

lib/std/crypto/aes/aesni.zig+16-16

...	...	@@ -19,24 +19,24 @@ pub const Block = struct {
19	19	repr: BlockVec,
20	20
21	21	/// Convert a byte sequence into an internal representation.
22		pub inline fn fromBytes(bytes: *const [16]u8) Block {
	22	pub fn fromBytes(bytes: *const [16]u8) callconv(.Inline) Block {
23	23	const repr = mem.bytesToValue(BlockVec, bytes);
24	24	return Block{ .repr = repr };
25	25	}
26	26
27	27	/// Convert the internal representation of a block into a byte sequence.
28		pub inline fn toBytes(block: Block) [16]u8 {
	28	pub fn toBytes(block: Block) callconv(.Inline) [16]u8 {
29	29	return mem.toBytes(block.repr);
30	30	}
31	31
32	32	/// XOR the block with a byte sequence.
33		pub inline fn xorBytes(block: Block, bytes: *const [16]u8) [16]u8 {
	33	pub fn xorBytes(block: Block, bytes: *const [16]u8) callconv(.Inline) [16]u8 {
34	34	const x = block.repr ^ fromBytes(bytes).repr;
35	35	return mem.toBytes(x);
36	36	}
37	37
38	38	/// Encrypt a block with a round key.
39		pub inline fn encrypt(block: Block, round_key: Block) Block {
	39	pub fn encrypt(block: Block, round_key: Block) callconv(.Inline) Block {
40	40	return Block{
41	41	.repr = asm (
42	42	\\ vaesenc %[rk], %[in], %[out]
...	...	@@ -48,7 +48,7 @@ pub const Block = struct {
48	48	}
49	49
50	50	/// Encrypt a block with the last round key.
51		pub inline fn encryptLast(block: Block, round_key: Block) Block {
	51	pub fn encryptLast(block: Block, round_key: Block) callconv(.Inline) Block {
52	52	return Block{
53	53	.repr = asm (
54	54	\\ vaesenclast %[rk], %[in], %[out]
...	...	@@ -60,7 +60,7 @@ pub const Block = struct {
60	60	}
61	61
62	62	/// Decrypt a block with a round key.
63		pub inline fn decrypt(block: Block, inv_round_key: Block) Block {
	63	pub fn decrypt(block: Block, inv_round_key: Block) callconv(.Inline) Block {
64	64	return Block{
65	65	.repr = asm (
66	66	\\ vaesdec %[rk], %[in], %[out]
...	...	@@ -72,7 +72,7 @@ pub const Block = struct {
72	72	}
73	73
74	74	/// Decrypt a block with the last round key.
75		pub inline fn decryptLast(block: Block, inv_round_key: Block) Block {
	75	pub fn decryptLast(block: Block, inv_round_key: Block) callconv(.Inline) Block {
76	76	return Block{
77	77	.repr = asm (
78	78	\\ vaesdeclast %[rk], %[in], %[out]
...	...	@@ -84,17 +84,17 @@ pub const Block = struct {
84	84	}
85	85
86	86	/// Apply the bitwise XOR operation to the content of two blocks.
87		pub inline fn xorBlocks(block1: Block, block2: Block) Block {
	87	pub fn xorBlocks(block1: Block, block2: Block) callconv(.Inline) Block {
88	88	return Block{ .repr = block1.repr ^ block2.repr };
89	89	}
90	90
91	91	/// Apply the bitwise AND operation to the content of two blocks.
92		pub inline fn andBlocks(block1: Block, block2: Block) Block {
	92	pub fn andBlocks(block1: Block, block2: Block) callconv(.Inline) Block {
93	93	return Block{ .repr = block1.repr & block2.repr };
94	94	}
95	95
96	96	/// Apply the bitwise OR operation to the content of two blocks.
97		pub inline fn orBlocks(block1: Block, block2: Block) Block {
	97	pub fn orBlocks(block1: Block, block2: Block) callconv(.Inline) Block {
98	98	return Block{ .repr = block1.repr \| block2.repr };
99	99	}
100	100
...	...	@@ -114,7 +114,7 @@ pub const Block = struct {
114	114	};
115	115
116	116	/// Encrypt multiple blocks in parallel, each their own round key.
117		pub inline fn encryptParallel(comptime count: usize, blocks: [count]Block, round_keys: [count]Block) [count]Block {
	117	pub fn encryptParallel(comptime count: usize, blocks: [count]Block, round_keys: [count]Block) callconv(.Inline) [count]Block {
118	118	comptime var i = 0;
119	119	var out: [count]Block = undefined;
120	120	inline while (i < count) : (i += 1) {
...	...	@@ -124,7 +124,7 @@ pub const Block = struct {
124	124	}
125	125
126	126	/// Decrypt multiple blocks in parallel, each their own round key.
127		pub inline fn decryptParallel(comptime count: usize, blocks: [count]Block, round_keys: [count]Block) [count]Block {
	127	pub fn decryptParallel(comptime count: usize, blocks: [count]Block, round_keys: [count]Block) callconv(.Inline) [count]Block {
128	128	comptime var i = 0;
129	129	var out: [count]Block = undefined;
130	130	inline while (i < count) : (i += 1) {
...	...	@@ -134,7 +134,7 @@ pub const Block = struct {
134	134	}
135	135
136	136	/// Encrypt multiple blocks in parallel with the same round key.
137		pub inline fn encryptWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block {
	137	pub fn encryptWide(comptime count: usize, blocks: [count]Block, round_key: Block) callconv(.Inline) [count]Block {
138	138	comptime var i = 0;
139	139	var out: [count]Block = undefined;
140	140	inline while (i < count) : (i += 1) {
...	...	@@ -144,7 +144,7 @@ pub const Block = struct {
144	144	}
145	145
146	146	/// Decrypt multiple blocks in parallel with the same round key.
147		pub inline fn decryptWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block {
	147	pub fn decryptWide(comptime count: usize, blocks: [count]Block, round_key: Block) callconv(.Inline) [count]Block {
148	148	comptime var i = 0;
149	149	var out: [count]Block = undefined;
150	150	inline while (i < count) : (i += 1) {
...	...	@@ -154,7 +154,7 @@ pub const Block = struct {
154	154	}
155	155
156	156	/// Encrypt multiple blocks in parallel with the same last round key.
157		pub inline fn encryptLastWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block {
	157	pub fn encryptLastWide(comptime count: usize, blocks: [count]Block, round_key: Block) callconv(.Inline) [count]Block {
158	158	comptime var i = 0;
159	159	var out: [count]Block = undefined;
160	160	inline while (i < count) : (i += 1) {
...	...	@@ -164,7 +164,7 @@ pub const Block = struct {
164	164	}
165	165
166	166	/// Decrypt multiple blocks in parallel with the same last round key.
167		pub inline fn decryptLastWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block {
	167	pub fn decryptLastWide(comptime count: usize, blocks: [count]Block, round_key: Block) callconv(.Inline) [count]Block {
168	168	comptime var i = 0;
169	169	var out: [count]Block = undefined;
170	170	inline while (i < count) : (i += 1) {

lib/std/crypto/aes/armcrypto.zig+16-16

...	...	@@ -19,18 +19,18 @@ pub const Block = struct {
19	19	repr: BlockVec,
20	20
21	21	/// Convert a byte sequence into an internal representation.
22		pub inline fn fromBytes(bytes: *const [16]u8) Block {
	22	pub fn fromBytes(bytes: *const [16]u8) callconv(.Inline) Block {
23	23	const repr = mem.bytesToValue(BlockVec, bytes);
24	24	return Block{ .repr = repr };
25	25	}
26	26
27	27	/// Convert the internal representation of a block into a byte sequence.
28		pub inline fn toBytes(block: Block) [16]u8 {
	28	pub fn toBytes(block: Block) callconv(.Inline) [16]u8 {
29	29	return mem.toBytes(block.repr);
30	30	}
31	31
32	32	/// XOR the block with a byte sequence.
33		pub inline fn xorBytes(block: Block, bytes: *const [16]u8) [16]u8 {
	33	pub fn xorBytes(block: Block, bytes: *const [16]u8) callconv(.Inline) [16]u8 {
34	34	const x = block.repr ^ fromBytes(bytes).repr;
35	35	return mem.toBytes(x);
36	36	}
...	...	@@ -38,7 +38,7 @@ pub const Block = struct {
38	38	const zero = Vector(2, u64){ 0, 0 };
39	39
40	40	/// Encrypt a block with a round key.
41		pub inline fn encrypt(block: Block, round_key: Block) Block {
	41	pub fn encrypt(block: Block, round_key: Block) callconv(.Inline) Block {
42	42	return Block{
43	43	.repr = asm (
44	44	\\ mov %[out].16b, %[in].16b
...	...	@@ -54,7 +54,7 @@ pub const Block = struct {
54	54	}
55	55
56	56	/// Encrypt a block with the last round key.
57		pub inline fn encryptLast(block: Block, round_key: Block) Block {
	57	pub fn encryptLast(block: Block, round_key: Block) callconv(.Inline) Block {
58	58	return Block{
59	59	.repr = asm (
60	60	\\ mov %[out].16b, %[in].16b
...	...	@@ -69,7 +69,7 @@ pub const Block = struct {
69	69	}
70	70
71	71	/// Decrypt a block with a round key.
72		pub inline fn decrypt(block: Block, inv_round_key: Block) Block {
	72	pub fn decrypt(block: Block, inv_round_key: Block) callconv(.Inline) Block {
73	73	return Block{
74	74	.repr = asm (
75	75	\\ mov %[out].16b, %[in].16b
...	...	@@ -85,7 +85,7 @@ pub const Block = struct {
85	85	}
86	86
87	87	/// Decrypt a block with the last round key.
88		pub inline fn decryptLast(block: Block, inv_round_key: Block) Block {
	88	pub fn decryptLast(block: Block, inv_round_key: Block) callconv(.Inline) Block {
89	89	return Block{
90	90	.repr = asm (
91	91	\\ mov %[out].16b, %[in].16b
...	...	@@ -100,17 +100,17 @@ pub const Block = struct {
100	100	}
101	101
102	102	/// Apply the bitwise XOR operation to the content of two blocks.
103		pub inline fn xorBlocks(block1: Block, block2: Block) Block {
	103	pub fn xorBlocks(block1: Block, block2: Block) callconv(.Inline) Block {
104	104	return Block{ .repr = block1.repr ^ block2.repr };
105	105	}
106	106
107	107	/// Apply the bitwise AND operation to the content of two blocks.
108		pub inline fn andBlocks(block1: Block, block2: Block) Block {
	108	pub fn andBlocks(block1: Block, block2: Block) callconv(.Inline) Block {
109	109	return Block{ .repr = block1.repr & block2.repr };
110	110	}
111	111
112	112	/// Apply the bitwise OR operation to the content of two blocks.
113		pub inline fn orBlocks(block1: Block, block2: Block) Block {
	113	pub fn orBlocks(block1: Block, block2: Block) callconv(.Inline) Block {
114	114	return Block{ .repr = block1.repr \| block2.repr };
115	115	}
116	116
...	...	@@ -120,7 +120,7 @@ pub const Block = struct {
120	120	pub const optimal_parallel_blocks = 8;
121	121
122	122	/// Encrypt multiple blocks in parallel, each their own round key.
123		pub inline fn encryptParallel(comptime count: usize, blocks: [count]Block, round_keys: [count]Block) [count]Block {
	123	pub fn encryptParallel(comptime count: usize, blocks: [count]Block, round_keys: [count]Block) callconv(.Inline) [count]Block {
124	124	comptime var i = 0;
125	125	var out: [count]Block = undefined;
126	126	inline while (i < count) : (i += 1) {
...	...	@@ -130,7 +130,7 @@ pub const Block = struct {
130	130	}
131	131
132	132	/// Decrypt multiple blocks in parallel, each their own round key.
133		pub inline fn decryptParallel(comptime count: usize, blocks: [count]Block, round_keys: [count]Block) [count]Block {
	133	pub fn decryptParallel(comptime count: usize, blocks: [count]Block, round_keys: [count]Block) callconv(.Inline) [count]Block {
134	134	comptime var i = 0;
135	135	var out: [count]Block = undefined;
136	136	inline while (i < count) : (i += 1) {
...	...	@@ -140,7 +140,7 @@ pub const Block = struct {
140	140	}
141	141
142	142	/// Encrypt multiple blocks in parallel with the same round key.
143		pub inline fn encryptWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block {
	143	pub fn encryptWide(comptime count: usize, blocks: [count]Block, round_key: Block) callconv(.Inline) [count]Block {
144	144	comptime var i = 0;
145	145	var out: [count]Block = undefined;
146	146	inline while (i < count) : (i += 1) {
...	...	@@ -150,7 +150,7 @@ pub const Block = struct {
150	150	}
151	151
152	152	/// Decrypt multiple blocks in parallel with the same round key.
153		pub inline fn decryptWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block {
	153	pub fn decryptWide(comptime count: usize, blocks: [count]Block, round_key: Block) callconv(.Inline) [count]Block {
154	154	comptime var i = 0;
155	155	var out: [count]Block = undefined;
156	156	inline while (i < count) : (i += 1) {
...	...	@@ -160,7 +160,7 @@ pub const Block = struct {
160	160	}
161	161
162	162	/// Encrypt multiple blocks in parallel with the same last round key.
163		pub inline fn encryptLastWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block {
	163	pub fn encryptLastWide(comptime count: usize, blocks: [count]Block, round_key: Block) callconv(.Inline) [count]Block {
164	164	comptime var i = 0;
165	165	var out: [count]Block = undefined;
166	166	inline while (i < count) : (i += 1) {
...	...	@@ -170,7 +170,7 @@ pub const Block = struct {
170	170	}
171	171
172	172	/// Decrypt multiple blocks in parallel with the same last round key.
173		pub inline fn decryptLastWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block {
	173	pub fn decryptLastWide(comptime count: usize, blocks: [count]Block, round_key: Block) callconv(.Inline) [count]Block {
174	174	comptime var i = 0;
175	175	var out: [count]Block = undefined;
176	176	inline while (i < count) : (i += 1) {

lib/std/crypto/aes/soft.zig+10-10

...	...	@@ -18,7 +18,7 @@ pub const Block = struct {
18	18	repr: BlockVec align(16),
19	19
20	20	/// Convert a byte sequence into an internal representation.
21		pub inline fn fromBytes(bytes: *const [16]u8) Block {
	21	pub fn fromBytes(bytes: *const [16]u8) callconv(.Inline) Block {
22	22	const s0 = mem.readIntBig(u32, bytes[0..4]);
23	23	const s1 = mem.readIntBig(u32, bytes[4..8]);
24	24	const s2 = mem.readIntBig(u32, bytes[8..12]);
...	...	@@ -27,7 +27,7 @@ pub const Block = struct {
27	27	}
28	28
29	29	/// Convert the internal representation of a block into a byte sequence.
30		pub inline fn toBytes(block: Block) [16]u8 {
	30	pub fn toBytes(block: Block) callconv(.Inline) [16]u8 {
31	31	var bytes: [16]u8 = undefined;
32	32	mem.writeIntBig(u32, bytes[0..4], block.repr[0]);
33	33	mem.writeIntBig(u32, bytes[4..8], block.repr[1]);
...	...	@@ -37,7 +37,7 @@ pub const Block = struct {
37	37	}
38	38
39	39	/// XOR the block with a byte sequence.
40		pub inline fn xorBytes(block: Block, bytes: *const [16]u8) [16]u8 {
	40	pub fn xorBytes(block: Block, bytes: *const [16]u8) callconv(.Inline) [16]u8 {
41	41	const block_bytes = block.toBytes();
42	42	var x: [16]u8 = undefined;
43	43	comptime var i: usize = 0;
...	...	@@ -48,7 +48,7 @@ pub const Block = struct {
48	48	}
49	49
50	50	/// Encrypt a block with a round key.
51		pub inline fn encrypt(block: Block, round_key: Block) Block {
	51	pub fn encrypt(block: Block, round_key: Block) callconv(.Inline) Block {
52	52	const src = &block.repr;
53	53
54	54	const s0 = block.repr[0];
...	...	@@ -65,7 +65,7 @@ pub const Block = struct {
65	65	}
66	66
67	67	/// Encrypt a block with the last round key.
68		pub inline fn encryptLast(block: Block, round_key: Block) Block {
	68	pub fn encryptLast(block: Block, round_key: Block) callconv(.Inline) Block {
69	69	const src = &block.repr;
70	70
71	71	const t0 = block.repr[0];
...	...	@@ -87,7 +87,7 @@ pub const Block = struct {
87	87	}
88	88
89	89	/// Decrypt a block with a round key.
90		pub inline fn decrypt(block: Block, round_key: Block) Block {
	90	pub fn decrypt(block: Block, round_key: Block) callconv(.Inline) Block {
91	91	const src = &block.repr;
92	92
93	93	const s0 = block.repr[0];
...	...	@@ -104,7 +104,7 @@ pub const Block = struct {
104	104	}
105	105
106	106	/// Decrypt a block with the last round key.
107		pub inline fn decryptLast(block: Block, round_key: Block) Block {
	107	pub fn decryptLast(block: Block, round_key: Block) callconv(.Inline) Block {
108	108	const src = &block.repr;
109	109
110	110	const t0 = block.repr[0];
...	...	@@ -126,7 +126,7 @@ pub const Block = struct {
126	126	}
127	127
128	128	/// Apply the bitwise XOR operation to the content of two blocks.
129		pub inline fn xorBlocks(block1: Block, block2: Block) Block {
	129	pub fn xorBlocks(block1: Block, block2: Block) callconv(.Inline) Block {
130	130	var x: BlockVec = undefined;
131	131	comptime var i = 0;
132	132	inline while (i < 4) : (i += 1) {
...	...	@@ -136,7 +136,7 @@ pub const Block = struct {
136	136	}
137	137
138	138	/// Apply the bitwise AND operation to the content of two blocks.
139		pub inline fn andBlocks(block1: Block, block2: Block) Block {
	139	pub fn andBlocks(block1: Block, block2: Block) callconv(.Inline) Block {
140	140	var x: BlockVec = undefined;
141	141	comptime var i = 0;
142	142	inline while (i < 4) : (i += 1) {
...	...	@@ -146,7 +146,7 @@ pub const Block = struct {
146	146	}
147	147
148	148	/// Apply the bitwise OR operation to the content of two blocks.
149		pub inline fn orBlocks(block1: Block, block2: Block) Block {
	149	pub fn orBlocks(block1: Block, block2: Block) callconv(.Inline) Block {
150	150	var x: BlockVec = undefined;
151	151	comptime var i = 0;
152	152	inline while (i < 4) : (i += 1) {

lib/std/crypto/blake3.zig+3-3

...	...	@@ -66,7 +66,7 @@ const CompressVectorized = struct {
66	66	const Lane = Vector(4, u32);
67	67	const Rows = [4]Lane;
68	68
69		inline fn g(comptime even: bool, rows: *Rows, m: Lane) void {
	69	fn g(comptime even: bool, rows: *Rows, m: Lane) callconv(.Inline) void {
70	70	rows[0] +%= rows[1] +% m;
71	71	rows[3] ^= rows[0];
72	72	rows[3] = math.rotr(Lane, rows[3], if (even) 8 else 16);
...	...	@@ -75,13 +75,13 @@ const CompressVectorized = struct {
75	75	rows[1] = math.rotr(Lane, rows[1], if (even) 7 else 12);
76	76	}
77	77
78		inline fn diagonalize(rows: *Rows) void {
	78	fn diagonalize(rows: *Rows) callconv(.Inline) void {
79	79	rows[0] = @shuffle(u32, rows[0], undefined, [_]i32{ 3, 0, 1, 2 });
80	80	rows[3] = @shuffle(u32, rows[3], undefined, [_]i32{ 2, 3, 0, 1 });
81	81	rows[2] = @shuffle(u32, rows[2], undefined, [_]i32{ 1, 2, 3, 0 });
82	82	}
83	83
84		inline fn undiagonalize(rows: *Rows) void {
	84	fn undiagonalize(rows: *Rows) callconv(.Inline) void {
85	85	rows[0] = @shuffle(u32, rows[0], undefined, [_]i32{ 1, 2, 3, 0 });
86	86	rows[3] = @shuffle(u32, rows[3], undefined, [_]i32{ 2, 3, 0, 1 });
87	87	rows[2] = @shuffle(u32, rows[2], undefined, [_]i32{ 3, 0, 1, 2 });

lib/std/crypto/chacha20.zig+6-6

...	...	@@ -35,7 +35,7 @@ const ChaCha20VecImpl = struct {
35	35	};
36	36	}
37	37
38		inline fn chacha20Core(x: *BlockVec, input: BlockVec) void {
	38	fn chacha20Core(x: *BlockVec, input: BlockVec) callconv(.Inline) void {
39	39	x.* = input;
40	40
41	41	var r: usize = 0;
...	...	@@ -80,7 +80,7 @@ const ChaCha20VecImpl = struct {
80	80	}
81	81	}
82	82
83		inline fn hashToBytes(out: *[64]u8, x: BlockVec) void {
	83	fn hashToBytes(out: *[64]u8, x: BlockVec) callconv(.Inline) void {
84	84	var i: usize = 0;
85	85	while (i < 4) : (i += 1) {
86	86	mem.writeIntLittle(u32, out[16 * i + 0 ..][0..4], x[i][0]);
...	...	@@ -90,7 +90,7 @@ const ChaCha20VecImpl = struct {
90	90	}
91	91	}
92	92
93		inline fn contextFeedback(x: *BlockVec, ctx: BlockVec) void {
	93	fn contextFeedback(x: *BlockVec, ctx: BlockVec) callconv(.Inline) void {
94	94	x[0] +%= ctx[0];
95	95	x[1] +%= ctx[1];
96	96	x[2] +%= ctx[2];
...	...	@@ -190,7 +190,7 @@ const ChaCha20NonVecImpl = struct {
190	190	};
191	191	}
192	192
193		inline fn chacha20Core(x: *BlockVec, input: BlockVec) void {
	193	fn chacha20Core(x: *BlockVec, input: BlockVec) callconv(.Inline) void {
194	194	x.* = input;
195	195
196	196	const rounds = comptime [_]QuarterRound{
...	...	@@ -219,7 +219,7 @@ const ChaCha20NonVecImpl = struct {
219	219	}
220	220	}
221	221
222		inline fn hashToBytes(out: *[64]u8, x: BlockVec) void {
	222	fn hashToBytes(out: *[64]u8, x: BlockVec) callconv(.Inline) void {
223	223	var i: usize = 0;
224	224	while (i < 4) : (i += 1) {
225	225	mem.writeIntLittle(u32, out[16 * i + 0 ..][0..4], x[i * 4 + 0]);
...	...	@@ -229,7 +229,7 @@ const ChaCha20NonVecImpl = struct {
229	229	}
230	230	}
231	231
232		inline fn contextFeedback(x: *BlockVec, ctx: BlockVec) void {
	232	fn contextFeedback(x: *BlockVec, ctx: BlockVec) callconv(.Inline) void {
233	233	var i: usize = 0;
234	234	while (i < 16) : (i += 1) {
235	235	x[i] +%= ctx[i];

lib/std/crypto/ghash.zig+2-2

...	...	@@ -95,7 +95,7 @@ pub const Ghash = struct {
95	95	}
96	96	}
97	97
98		inline fn clmul_pclmul(x: u64, y: u64) u64 {
	98	fn clmul_pclmul(x: u64, y: u64) callconv(.Inline) u64 {
99	99	const Vector = std.meta.Vector;
100	100	const product = asm (
101	101	\\ vpclmulqdq $0x00, %[x], %[y], %[out]
...	...	@@ -106,7 +106,7 @@ pub const Ghash = struct {
106	106	return product[0];
107	107	}
108	108
109		inline fn clmul_pmull(x: u64, y: u64) u64 {
	109	fn clmul_pmull(x: u64, y: u64) callconv(.Inline) u64 {
110	110	const Vector = std.meta.Vector;
111	111	const product = asm (
112	112	\\ pmull %[out].1q, %[x].1d, %[y].1d

lib/std/crypto/gimli.zig+2-2

...	...	@@ -48,7 +48,7 @@ pub const State = struct {
48	48	return mem.asBytes(&self.data);
49	49	}
50	50
51		inline fn endianSwap(self: *Self) void {
	51	fn endianSwap(self: *Self) callconv(.Inline) void {
52	52	for (self.data) \|*w\| {
53	53	w.* = mem.littleToNative(u32, w.*);
54	54	}
...	...	@@ -116,7 +116,7 @@ pub const State = struct {
116	116
117	117	const Lane = Vector(4, u32);
118	118
119		inline fn shift(x: Lane, comptime n: comptime_int) Lane {
	119	fn shift(x: Lane, comptime n: comptime_int) callconv(.Inline) Lane {
120	120	return x << @splat(4, @as(u5, n));
121	121	}
122	122

lib/std/crypto/salsa20.zig+3-3

...	...	@@ -37,7 +37,7 @@ const Salsa20VecImpl = struct {
37	37	};
38	38	}
39	39
40		inline fn salsa20Core(x: *BlockVec, input: BlockVec, comptime feedback: bool) void {
	40	fn salsa20Core(x: *BlockVec, input: BlockVec, comptime feedback: bool) callconv(.Inline) void {
41	41	const n1n2n3n0 = Lane{ input[3][1], input[3][2], input[3][3], input[3][0] };
42	42	const n1n2 = Half{ n1n2n3n0[0], n1n2n3n0[1] };
43	43	const n3n0 = Half{ n1n2n3n0[2], n1n2n3n0[3] };
...	...	@@ -211,7 +211,7 @@ const Salsa20NonVecImpl = struct {
211	211	d: u6,
212	212	};
213	213
214		inline fn Rp(a: usize, b: usize, c: usize, d: u6) QuarterRound {
	214	fn Rp(a: usize, b: usize, c: usize, d: u6) callconv(.Inline) QuarterRound {
215	215	return QuarterRound{
216	216	.a = a,
217	217	.b = b,
...	...	@@ -220,7 +220,7 @@ const Salsa20NonVecImpl = struct {
220	220	};
221	221	}
222	222
223		inline fn salsa20Core(x: *BlockVec, input: BlockVec, comptime feedback: bool) void {
	223	fn salsa20Core(x: *BlockVec, input: BlockVec, comptime feedback: bool) callconv(.Inline) void {
224	224	const arx_steps = comptime [_]QuarterRound{
225	225	Rp(4, 0, 12, 7), Rp(8, 4, 0, 9), Rp(12, 8, 4, 13), Rp(0, 12, 8, 18),
226	226	Rp(9, 5, 1, 7), Rp(13, 9, 5, 9), Rp(1, 13, 9, 13), Rp(5, 1, 13, 18),

lib/std/elf.zig+8-8

...	...	@@ -720,10 +720,10 @@ pub const Elf32_Rel = extern struct {
720	720	r_offset: Elf32_Addr,
721	721	r_info: Elf32_Word,
722	722
723		pub inline fn r_sym(self: @This()) u24 {
	723	pub fn r_sym(self: @This()) callconv(.Inline) u24 {
724	724	return @truncate(u24, self.r_info >> 8);
725	725	}
726		pub inline fn r_type(self: @This()) u8 {
	726	pub fn r_type(self: @This()) callconv(.Inline) u8 {
727	727	return @truncate(u8, self.r_info & 0xff);
728	728	}
729	729	};
...	...	@@ -731,10 +731,10 @@ pub const Elf64_Rel = extern struct {
731	731	r_offset: Elf64_Addr,
732	732	r_info: Elf64_Xword,
733	733
734		pub inline fn r_sym(self: @This()) u32 {
	734	pub fn r_sym(self: @This()) callconv(.Inline) u32 {
735	735	return @truncate(u32, self.r_info >> 32);
736	736	}
737		pub inline fn r_type(self: @This()) u32 {
	737	pub fn r_type(self: @This()) callconv(.Inline) u32 {
738	738	return @truncate(u32, self.r_info & 0xffffffff);
739	739	}
740	740	};
...	...	@@ -743,10 +743,10 @@ pub const Elf32_Rela = extern struct {
743	743	r_info: Elf32_Word,
744	744	r_addend: Elf32_Sword,
745	745
746		pub inline fn r_sym(self: @This()) u24 {
	746	pub fn r_sym(self: @This()) callconv(.Inline) u24 {
747	747	return @truncate(u24, self.r_info >> 8);
748	748	}
749		pub inline fn r_type(self: @This()) u8 {
	749	pub fn r_type(self: @This()) callconv(.Inline) u8 {
750	750	return @truncate(u8, self.r_info & 0xff);
751	751	}
752	752	};
...	...	@@ -755,10 +755,10 @@ pub const Elf64_Rela = extern struct {
755	755	r_info: Elf64_Xword,
756	756	r_addend: Elf64_Sxword,
757	757
758		pub inline fn r_sym(self: @This()) u32 {
	758	pub fn r_sym(self: @This()) callconv(.Inline) u32 {
759	759	return @truncate(u32, self.r_info >> 32);
760	760	}
761		pub inline fn r_type(self: @This()) u32 {
	761	pub fn r_type(self: @This()) callconv(.Inline) u32 {
762	762	return @truncate(u32, self.r_info & 0xffffffff);
763	763	}
764	764	};

lib/std/fmt/parse_float.zig+4-4

...	...	@@ -52,21 +52,21 @@ const Z96 = struct {
52	52	d2: u32,
53	53
54	54	// d = s >> 1
55		inline fn shiftRight1(d: *Z96, s: Z96) void {
	55	fn shiftRight1(d: *Z96, s: Z96) callconv(.Inline) void {
56	56	d.d0 = (s.d0 >> 1) \| ((s.d1 & 1) << 31);
57	57	d.d1 = (s.d1 >> 1) \| ((s.d2 & 1) << 31);
58	58	d.d2 = s.d2 >> 1;
59	59	}
60	60
61	61	// d = s << 1
62		inline fn shiftLeft1(d: *Z96, s: Z96) void {
	62	fn shiftLeft1(d: *Z96, s: Z96) callconv(.Inline) void {
63	63	d.d2 = (s.d2 << 1) \| ((s.d1 & (1 << 31)) >> 31);
64	64	d.d1 = (s.d1 << 1) \| ((s.d0 & (1 << 31)) >> 31);
65	65	d.d0 = s.d0 << 1;
66	66	}
67	67
68	68	// d += s
69		inline fn add(d: *Z96, s: Z96) void {
	69	fn add(d: *Z96, s: Z96) callconv(.Inline) void {
70	70	var w = @as(u64, d.d0) + @as(u64, s.d0);
71	71	d.d0 = @truncate(u32, w);
72	72
...	...	@@ -80,7 +80,7 @@ const Z96 = struct {
80	80	}
81	81
82	82	// d -= s
83		inline fn sub(d: *Z96, s: Z96) void {
	83	fn sub(d: *Z96, s: Z96) callconv(.Inline) void {
84	84	var w = @as(u64, d.d0) -% @as(u64, s.d0);
85	85	d.d0 = @truncate(u32, w);
86	86

lib/std/hash/cityhash.zig+1-1

...	...	@@ -6,7 +6,7 @@
6	6	const std = @import("std");
7	7	const builtin = @import("builtin");
8	8
9		inline fn offsetPtr(ptr: []const u8, offset: usize) []const u8 {
	9	fn offsetPtr(ptr: []const u8, offset: usize) callconv(.Inline) []const u8 {
10	10	// ptr + offset doesn't work at comptime so we need this instead.
11	11	return @ptrCast([*]const u8, &ptr[offset]);
12	12	}

lib/std/os/bits/freebsd.zig+4-4

...	...	@@ -815,16 +815,16 @@ pub const sigval = extern union {
815	815	pub const _SIG_WORDS = 4;
816	816	pub const _SIG_MAXSIG = 128;
817	817
818		pub inline fn _SIG_IDX(sig: usize) usize {
	818	pub fn _SIG_IDX(sig: usize) callconv(.Inline) usize {
819	819	return sig - 1;
820	820	}
821		pub inline fn _SIG_WORD(sig: usize) usize {
	821	pub fn _SIG_WORD(sig: usize) callconv(.Inline) usize {
822	822	return_SIG_IDX(sig) >> 5;
823	823	}
824		pub inline fn _SIG_BIT(sig: usize) usize {
	824	pub fn _SIG_BIT(sig: usize) callconv(.Inline) usize {
825	825	return 1 << (_SIG_IDX(sig) & 31);
826	826	}
827		pub inline fn _SIG_VALID(sig: usize) usize {
	827	pub fn _SIG_VALID(sig: usize) callconv(.Inline) usize {
828	828	return sig <= _SIG_MAXSIG and sig > 0;
829	829	}
830	830

lib/std/os/bits/netbsd.zig+4-4

...	...	@@ -796,16 +796,16 @@ pub const _ksiginfo = extern struct {
796	796	pub const _SIG_WORDS = 4;
797	797	pub const _SIG_MAXSIG = 128;
798	798
799		pub inline fn _SIG_IDX(sig: usize) usize {
	799	pub fn _SIG_IDX(sig: usize) callconv(.Inline) usize {
800	800	return sig - 1;
801	801	}
802		pub inline fn _SIG_WORD(sig: usize) usize {
	802	pub fn _SIG_WORD(sig: usize) callconv(.Inline) usize {
803	803	return_SIG_IDX(sig) >> 5;
804	804	}
805		pub inline fn _SIG_BIT(sig: usize) usize {
	805	pub fn _SIG_BIT(sig: usize) callconv(.Inline) usize {
806	806	return 1 << (_SIG_IDX(sig) & 31);
807	807	}
808		pub inline fn _SIG_VALID(sig: usize) usize {
	808	pub fn _SIG_VALID(sig: usize) callconv(.Inline) usize {
809	809	return sig <= _SIG_MAXSIG and sig > 0;
810	810	}
811	811

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

...	...	@@ -126,7 +126,7 @@ pub fn fork() usize {
126	126	/// It is advised to avoid this function and use clone instead, because
127	127	/// the compiler is not aware of how vfork affects control flow and you may
128	128	/// see different results in optimized builds.
129		pub inline fn vfork() usize {
	129	pub fn vfork() callconv(.Inline) usize {
130	130	return @call(.{ .modifier = .always_inline }, syscall0, .{.vfork});
131	131	}
132	132

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

...	...	@@ -300,7 +300,7 @@ fn initTLS() void {
300	300	};
301	301	}
302	302
303		inline fn alignPtrCast(comptime T: type, ptr: []u8) T {
	303	fn alignPtrCast(comptime T: type, ptr: []u8) callconv(.Inline) T {
304	304	return @ptrCast(T, @alignCast(@alignOf(T), ptr));
305	305	}
306	306

lib/std/os/windows.zig+1-1

...	...	@@ -1669,7 +1669,7 @@ pub fn wToPrefixedFileW(s: []const u16) !PathSpace {
1669	1669	return path_space;
1670	1670	}
1671	1671
1672		inline fn MAKELANGID(p: c_ushort, s: c_ushort) LANGID {
	1672	fn MAKELANGID(p: c_ushort, s: c_ushort) callconv(.Inline) LANGID {
1673	1673	return (s << 10) \| p;
1674	1674	}
1675	1675

lib/std/start.zig+2-2

...	...	@@ -262,7 +262,7 @@ const bad_main_ret = "expected return type of main to be 'void', '!void', 'noret
262	262
263	263	// This is marked inline because for some reason LLVM in release mode fails to inline it,
264	264	// and we want fewer call frames in stack traces.
265		inline fn initEventLoopAndCallMain() u8 {
	265	fn initEventLoopAndCallMain() callconv(.Inline) u8 {
266	266	if (std.event.Loop.instance) \|loop\| {
267	267	if (!@hasDecl(root, "event_loop")) {
268	268	loop.init() catch \|err\| {
...	...	@@ -291,7 +291,7 @@ inline fn initEventLoopAndCallMain() u8 {
291	291	// and we want fewer call frames in stack traces.
292	292	// TODO This function is duplicated from initEventLoopAndCallMain instead of using generics
293	293	// because it is working around stage1 compiler bugs.
294		inline fn initEventLoopAndCallWinMain() std.os.windows.INT {
	294	fn initEventLoopAndCallWinMain() callconv(.Inline) std.os.windows.INT {
295	295	if (std.event.Loop.instance) \|loop\| {
296	296	if (!@hasDecl(root, "event_loop")) {
297	297	loop.init() catch \|err\| {

lib/std/zig/parser_test.zig+3-3

...	...	@@ -2355,17 +2355,17 @@ test "zig fmt: functions" {
2355	2355	\\extern fn puts(s: *const u8) c_int;
2356	2356	\\extern "c" fn puts(s: *const u8) c_int;
2357	2357	\\export fn puts(s: *const u8) c_int;
2358		\\inline fn puts(s: *const u8) c_int;
	2358	\\fn puts(s: *const u8) callconv(.Inline) c_int;
2359	2359	\\noinline fn puts(s: *const u8) c_int;
2360	2360	\\pub extern fn puts(s: *const u8) c_int;
2361	2361	\\pub extern "c" fn puts(s: *const u8) c_int;
2362	2362	\\pub export fn puts(s: *const u8) c_int;
2363		\\pub inline fn puts(s: *const u8) c_int;
	2363	\\pub fn puts(s: *const u8) callconv(.Inline) c_int;
2364	2364	\\pub noinline fn puts(s: *const u8) c_int;
2365	2365	\\pub extern fn puts(s: *const u8) align(2 + 2) c_int;
2366	2366	\\pub extern "c" fn puts(s: *const u8) align(2 + 2) c_int;
2367	2367	\\pub export fn puts(s: *const u8) align(2 + 2) c_int;
2368		\\pub inline fn puts(s: *const u8) align(2 + 2) c_int;
	2368	\\pub fn puts(s: *const u8) align(2 + 2) callconv(.Inline) c_int;
2369	2369	\\pub noinline fn puts(s: *const u8) align(2 + 2) c_int;
2370	2370	\\
2371	2371	);

lib/std/zig/system/x86.zig+2-2

...	...	@@ -19,11 +19,11 @@ fn setFeature(cpu: *Target.Cpu, feature: Target.x86.Feature, enabled: bool) void
19	19	if (enabled) cpu.features.addFeature(idx) else cpu.features.removeFeature(idx);
20	20	}
21	21
22		inline fn bit(input: u32, offset: u5) bool {
	22	fn bit(input: u32, offset: u5) callconv(.Inline) bool {
23	23	return (input >> offset) & 1 != 0;
24	24	}
25	25
26		inline fn hasMask(input: u32, mask: u32) bool {
	26	fn hasMask(input: u32, mask: u32) callconv(.Inline) bool {
27	27	return (input & mask) == mask;
28	28	}
29	29

src/link/MachO.zig+1-1

...	...	@@ -2366,7 +2366,7 @@ fn allocatedSizeLinkedit(self: *MachO, start: u64) u64 {
2366	2366	return min_pos - start;
2367	2367	}
2368	2368
2369		inline fn checkForCollision(start: u64, end: u64, off: u64, size: u64) ?u64 {
	2369	fn checkForCollision(start: u64, end: u64, off: u64, size: u64) callconv(.Inline) ?u64 {
2370	2370	const increased_size = padToIdeal(size);
2371	2371	const test_end = off + increased_size;
2372	2372	if (end > off and start < test_end) {

src/tracy.zig+1-1

...	...	@@ -31,7 +31,7 @@ pub const Ctx = if (enable) ___tracy_c_zone_context else struct {
31	31	pub fn end(self: Ctx) void {}
32	32	};
33	33
34		pub inline fn trace(comptime src: std.builtin.SourceLocation) Ctx {
	34	pub fn trace(comptime src: std.builtin.SourceLocation) callconv(.Inline) Ctx {
35	35	if (!enable) return .{};
36	36
37	37	const loc: ___tracy_source_location_data = .{

test/cli.zig+1-1

...	...	@@ -113,7 +113,7 @@ fn testGodboltApi(zig_exe: []const u8, dir_path: []const u8) anyerror!void {
113	113	\\ return num * num;
114	114	\\}
115	115	\\extern fn zig_panic() noreturn;
116		\\pub inline fn panic(msg: []const u8, error_return_trace: ?*@import("builtin").StackTrace) noreturn {
	116	\\pub fn panic(msg: []const u8, error_return_trace: ?*@import("builtin").StackTrace) callconv(.Inline) noreturn {
117	117	\\ zig_panic();
118	118	\\}
119	119	);

test/compile_errors.zig+6-6

...	...	@@ -1648,7 +1648,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1648	1648	\\ @call(.{ .modifier = .compile_time }, baz, .{});
1649	1649	\\}
1650	1650	\\fn foo() void {}
1651		\\inline fn bar() void {}
	1651	\\fn bar() callconv(.Inline) void {}
1652	1652	\\fn baz1() void {}
1653	1653	\\fn baz2() void {}
1654	1654	, &[_][]const u8{
...	...	@@ -3944,7 +3944,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3944	3944	\\export fn entry() void {
3945	3945	\\ var a = b;
3946	3946	\\}
3947		\\inline fn b() void { }
	3947	\\fn b() callconv(.Inline) void { }
3948	3948	, &[_][]const u8{
3949	3949	"tmp.zig:2:5: error: functions marked inline must be stored in const or comptime var",
3950	3950	"tmp.zig:4:1: note: declared here",
...	...	@@ -6782,11 +6782,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6782	6782	// \\export fn foo() void {
6783	6783	// \\ bar();
6784	6784	// \\}
6785		// \\inline fn bar() void {
	6785	// \\fn bar() callconv(.Inline) void {
6786	6786	// \\ baz();
6787	6787	// \\ quux();
6788	6788	// \\}
6789		// \\inline fn baz() void {
	6789	// \\fn baz() callconv(.Inline) void {
6790	6790	// \\ bar();
6791	6791	// \\ quux();
6792	6792	// \\}
...	...	@@ -6799,7 +6799,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
6799	6799	// \\export fn foo() void {
6800	6800	// \\ quux(@ptrToInt(bar));
6801	6801	// \\}
6802		// \\inline fn bar() void { }
	6802	// \\fn bar() callconv(.Inline) void { }
6803	6803	// \\extern fn quux(usize) void;
6804	6804	//, &[_][]const u8{
6805	6805	// "tmp.zig:4:1: error: unable to inline function",
...	...	@@ -7207,7 +7207,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7207	7207	\\export fn entry() void {
7208	7208	\\ foo();
7209	7209	\\}
7210		\\inline fn foo() void {
	7210	\\fn foo() callconv(.Inline) void {
7211	7211	\\ @setAlignStack(16);
7212	7212	\\}
7213	7213	, &[_][]const u8{

test/stage1/behavior/fn.zig+1-1

...	...	@@ -113,7 +113,7 @@ test "assign inline fn to const variable" {
113	113	a();
114	114	}
115	115
116		inline fn inlineFn() void {}
	116	fn inlineFn() callconv(.Inline) void {}
117	117
118	118	test "pass by non-copying value" {
119	119	expect(addPointCoords(Point{ .x = 1, .y = 2 }) == 3);

test/stage2/cbe.zig+1-1

...	...	@@ -179,7 +179,7 @@ pub fn addCases(ctx: *TestContext) !void {
179	179	\\ return y - 1;
180	180	\\}
181	181	\\
182		\\inline fn rec(n: usize) usize {
	182	\\fn rec(n: usize) callconv(.Inline) usize {
183	183	\\ if (n <= 1) return n;
184	184	\\ return rec(n - 1);
185	185	\\}

test/stage2/test.zig+5-5

...	...	@@ -255,7 +255,7 @@ pub fn addCases(ctx: *TestContext) !void {
255	255	\\ exit(y - 6);
256	256	\\}
257	257	\\
258		\\inline fn add(a: usize, b: usize, c: usize) usize {
	258	\\fn add(a: usize, b: usize, c: usize) callconv(.Inline) usize {
259	259	\\ return a + b + c;
260	260	\\}
261	261	\\
...	...	@@ -1228,7 +1228,7 @@ pub fn addCases(ctx: *TestContext) !void {
1228	1228	\\ exit(y - 6);
1229	1229	\\}
1230	1230	\\
1231		\\inline fn add(a: usize, b: usize, c: usize) usize {
	1231	\\fn add(a: usize, b: usize, c: usize) callconv(.Inline) usize {
1232	1232	\\ if (a == 10) @compileError("bad");
1233	1233	\\ return a + b + c;
1234	1234	\\}
...	...	@@ -1251,7 +1251,7 @@ pub fn addCases(ctx: *TestContext) !void {
1251	1251	\\ exit(y - 6);
1252	1252	\\}
1253	1253	\\
1254		\\inline fn add(a: usize, b: usize, c: usize) usize {
	1254	\\fn add(a: usize, b: usize, c: usize) callconv(.Inline) usize {
1255	1255	\\ if (a == 10) @compileError("bad");
1256	1256	\\ return a + b + c;
1257	1257	\\}
...	...	@@ -1277,7 +1277,7 @@ pub fn addCases(ctx: *TestContext) !void {
1277	1277	\\ exit(y - 21);
1278	1278	\\}
1279	1279	\\
1280		\\inline fn fibonacci(n: usize) usize {
	1280	\\fn fibonacci(n: usize) callconv(.Inline) usize {
1281	1281	\\ if (n <= 2) return n;
1282	1282	\\ return fibonacci(n - 2) + fibonacci(n - 1);
1283	1283	\\}
...	...	@@ -1300,7 +1300,7 @@ pub fn addCases(ctx: *TestContext) !void {
1300	1300	\\ exit(y - 21);
1301	1301	\\}
1302	1302	\\
1303		\\inline fn fibonacci(n: usize) usize {
	1303	\\fn fibonacci(n: usize) callconv(.Inline) usize {
1304	1304	\\ if (n <= 2) return n;
1305	1305	\\ return fibonacci(n - 2) + fibonacci(n - 1);
1306	1306	\\}

test/translate_c.zig+16-16

...	...	@@ -43,7 +43,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
43	43	,
44	44	\\pub const VALUE = ((((1 + (2 * 3)) + (4 * 5)) + 6) << 7) \| @boolToInt(8 == 9);
45	45	,
46		\\pub inline fn _AL_READ3BYTES(p: anytype) @TypeOf(((@import("std").meta.cast([c]u8, p)). \| (((@import("std").meta.cast([c]u8, p)) + 1). << 8)) \| (((@import("std").meta.cast([c]u8, p)) + 2). << 16)) {
	46	\\pub fn _AL_READ3BYTES(p: anytype) callconv(.Inline) @TypeOf(((@import("std").meta.cast([c]u8, p)). \| (((@import("std").meta.cast([c]u8, p)) + 1). << 8)) \| (((@import("std").meta.cast([c]u8, p)) + 2). << 16)) {
47	47	\\ return ((@import("std").meta.cast([c]u8, p)). \| (((@import("std").meta.cast([c]u8, p)) + 1). << 8)) \| (((@import("std").meta.cast([c]u8, p)) + 2). << 16);
48	48	\\}
49	49	});
...	...	@@ -116,7 +116,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
116	116	\\};
117	117	\\pub const Color = struct_Color;
118	118	,
119		\\pub inline fn CLITERAL(type_1: anytype) @TypeOf(type_1) {
	119	\\pub fn CLITERAL(type_1: anytype) callconv(.Inline) @TypeOf(type_1) {
120	120	\\ return type_1;
121	121	\\}
122	122	,
...	...	@@ -148,7 +148,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
148	148	cases.add("correct semicolon after infixop",
149	149	\\#define __ferror_unlocked_body(_fp) (((_fp)->_flags & _IO_ERR_SEEN) != 0)
150	150	, &[_][]const u8{
151		\\pub inline fn __ferror_unlocked_body(_fp: anytype) @TypeOf(((_fp.*._flags) & _IO_ERR_SEEN) != 0) {
	151	\\pub fn __ferror_unlocked_body(_fp: anytype) callconv(.Inline) @TypeOf(((_fp.*._flags) & _IO_ERR_SEEN) != 0) {
152	152	\\ return ((_fp.*._flags) & _IO_ERR_SEEN) != 0;
153	153	\\}
154	154	});
...	...	@@ -157,7 +157,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
157	157	\\#define FOO(x) ((x >= 0) + (x >= 0))
158	158	\\#define BAR 1 && 2 > 4
159	159	, &[_][]const u8{
160		\\pub inline fn FOO(x: anytype) @TypeOf(@boolToInt(x >= 0) + @boolToInt(x >= 0)) {
	160	\\pub fn FOO(x: anytype) callconv(.Inline) @TypeOf(@boolToInt(x >= 0) + @boolToInt(x >= 0)) {
161	161	\\ return @boolToInt(x >= 0) + @boolToInt(x >= 0);
162	162	\\}
163	163	,
...	...	@@ -208,7 +208,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
208	208	\\ break :blk bar;
209	209	\\};
210	210	,
211		\\pub inline fn bar(x: anytype) @TypeOf(baz(1, 2)) {
	211	\\pub fn bar(x: anytype) callconv(.Inline) @TypeOf(baz(1, 2)) {
212	212	\\ return blk: {
213	213	\\ _ = &x;
214	214	\\ _ = 3;
...	...	@@ -1590,13 +1590,13 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
1590	1590	, &[_][]const u8{
1591	1591	\\pub extern var fn_ptr: ?fn () callconv(.C) void;
1592	1592	,
1593		\\pub inline fn foo() void {
	1593	\\pub fn foo() callconv(.Inline) void {
1594	1594	\\ return fn_ptr.?();
1595	1595	\\}
1596	1596	,
1597	1597	\\pub extern var fn_ptr2: ?fn (c_int, f32) callconv(.C) u8;
1598	1598	,
1599		\\pub inline fn bar(arg_1: c_int, arg_2: f32) u8 {
	1599	\\pub fn bar(arg_1: c_int, arg_2: f32) callconv(.Inline) u8 {
1600	1600	\\ return fn_ptr2.?(arg_1, arg_2);
1601	1601	\\}
1602	1602	});
...	...	@@ -1629,7 +1629,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
1629	1629	,
1630	1630	\\pub const glClearPFN = PFNGLCLEARPROC;
1631	1631	,
1632		\\pub inline fn glClearUnion(arg_2: GLbitfield) void {
	1632	\\pub fn glClearUnion(arg_2: GLbitfield) callconv(.Inline) void {
1633	1633	\\ return glProcs.gl.Clear.?(arg_2);
1634	1634	\\}
1635	1635	,
...	...	@@ -1650,15 +1650,15 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
1650	1650	, &[_][]const u8{
1651	1651	\\pub extern var c: c_int;
1652	1652	,
1653		\\pub inline fn BASIC(c_1: anytype) @TypeOf(c_1 * 2) {
	1653	\\pub fn BASIC(c_1: anytype) callconv(.Inline) @TypeOf(c_1 * 2) {
1654	1654	\\ return c_1 * 2;
1655	1655	\\}
1656	1656	,
1657		\\pub inline fn FOO(L: anytype, b: anytype) @TypeOf(L + b) {
	1657	\\pub fn FOO(L: anytype, b: anytype) callconv(.Inline) @TypeOf(L + b) {
1658	1658	\\ return L + b;
1659	1659	\\}
1660	1660	,
1661		\\pub inline fn BAR() @TypeOf(c * c) {
	1661	\\pub fn BAR() callconv(.Inline) @TypeOf(c * c) {
1662	1662	\\ return c * c;
1663	1663	\\}
1664	1664	});
...	...	@@ -2298,7 +2298,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
2298	2298	cases.add("macro call",
2299	2299	\\#define CALL(arg) bar(arg)
2300	2300	, &[_][]const u8{
2301		\\pub inline fn CALL(arg: anytype) @TypeOf(bar(arg)) {
	2301	\\pub fn CALL(arg: anytype) callconv(.Inline) @TypeOf(bar(arg)) {
2302	2302	\\ return bar(arg);
2303	2303	\\}
2304	2304	});
...	...	@@ -2860,7 +2860,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
2860	2860	\\#define BAR (void*) a
2861	2861	\\#define BAZ (uint32_t)(2)
2862	2862	, &[_][]const u8{
2863		\\pub inline fn FOO(bar: anytype) @TypeOf(baz((@import("std").meta.cast(?*c_void, baz)))) {
	2863	\\pub fn FOO(bar: anytype) callconv(.Inline) @TypeOf(baz((@import("std").meta.cast(?*c_void, baz)))) {
2864	2864	\\ return baz((@import("std").meta.cast(?*c_void, baz)));
2865	2865	\\}
2866	2866	,
...	...	@@ -2902,11 +2902,11 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
2902	2902	\\#define MIN(a, b) ((b) < (a) ? (b) : (a))
2903	2903	\\#define MAX(a, b) ((b) > (a) ? (b) : (a))
2904	2904	, &[_][]const u8{
2905		\\pub inline fn MIN(a: anytype, b: anytype) @TypeOf(if (b < a) b else a) {
	2905	\\pub fn MIN(a: anytype, b: anytype) callconv(.Inline) @TypeOf(if (b < a) b else a) {
2906	2906	\\ return if (b < a) b else a;
2907	2907	\\}
2908	2908	,
2909		\\pub inline fn MAX(a: anytype, b: anytype) @TypeOf(if (b > a) b else a) {
	2909	\\pub fn MAX(a: anytype, b: anytype) callconv(.Inline) @TypeOf(if (b > a) b else a) {
2910	2910	\\ return if (b > a) b else a;
2911	2911	\\}
2912	2912	});
...	...	@@ -3094,7 +3094,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
3094	3094	\\#define DefaultScreen(dpy) (((_XPrivDisplay)(dpy))->default_screen)
3095	3095	\\
3096	3096	, &[_][]const u8{
3097		\\pub inline fn DefaultScreen(dpy: anytype) @TypeOf((@import("std").meta.cast(_XPrivDisplay, dpy)).*.default_screen) {
	3097	\\pub fn DefaultScreen(dpy: anytype) callconv(.Inline) @TypeOf((@import("std").meta.cast(_XPrivDisplay, dpy)).*.default_screen) {
3098	3098	\\ return (@import("std").meta.cast(_XPrivDisplay, dpy)).*.default_screen;
3099	3099	\\}
3100	3100	});