Commit d3565ed6b48c9c66128f181e7b90b5348504cb3f | zig

doc/langref.html.in+2-2

...	@@ -4240,9 +4240,9 @@ fn _start() callconv(.Naked) noreturn {	...	@@ -4240,9 +4240,9 @@ fn _start() callconv(.Naked) noreturn {
4240	abort();	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	// If the function cannot be inlined, it is a compile-time error.	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	return a << 1;	4246	return a << 1;
4247	}	4247	}
4248		4248

lib/std/builtin.zig+2-9

 @@ -155,6 +155,7 @@ pub const CallingConvention = enum {
     C,
     Naked,
     Async,
+    Inline,
     Interrupt,
     Signal,
     Stdcall,
 @@ -404,21 +405,13 @@ pub const TypeInfo = union(enum) {
             /// therefore must be kept in sync with the compiler implementation.
             pub const FnDecl = struct {
                 fn_type: type,
-                inline_type: Inline,
+                is_noinline: bool,
                 is_var_args: bool,
                 is_extern: bool,
                 is_export: bool,
                 lib_name: ?[]const u8,
                 return_type: type,
                 arg_names: []const []const u8,
-                /// This data structure is used by the Zig language code generation and
-                /// therefore must be kept in sync with the compiler implementation.
-                pub const Inline = enum {
-                    Auto,
-                    Always,
-                    Never,
-                };
             };
         };
     };

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

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

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

...	@@ -15,12 +15,12 @@ pub const Curve25519 = struct {	...	@@ -15,12 +15,12 @@ pub const Curve25519 = struct {
15	x: Fe,	15	x: Fe,
16		16
17	/// Decode a Curve25519 point from its compressed (X) coordinates.	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	return .{ .x = Fe.fromBytes(s) };	19	return .{ .x = Fe.fromBytes(s) };
20	}	20	}
21		21
22	/// Encode a Curve25519 point.	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	return p.x.toBytes();	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,7 +92,7 @@ pub const Edwards25519 = struct {
92	}	92	}
93		93
94	/// Flip the sign of the X coordinate.	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	return .{ .x = p.x.neg(), .y = p.y, .z = p.z, .t = p.t.neg() };	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,14 +137,14 @@ pub const Edwards25519 = struct {
137	return p.add(q.neg());	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	p.x.cMov(a.x, c);	141	p.x.cMov(a.x, c);
142	p.y.cMov(a.y, c);	142	p.y.cMov(a.y, c);
143	p.z.cMov(a.z, c);	143	p.z.cMov(a.z, c);
144	p.t.cMov(a.t, c);	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	var t = Edwards25519.identityElement;	148	var t = Edwards25519.identityElement;
149	comptime var i: u8 = 1;	149	comptime var i: u8 = 1;
150	inline while (i < pc.len) : (i += 1) {	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,7 +52,7 @@ pub const Fe = struct {
52	pub const edwards25519sqrtam2 = Fe{ .limbs = .{ 1693982333959686, 608509411481997, 2235573344831311, 947681270984193, 266558006233600 } };	52	pub const edwards25519sqrtam2 = Fe{ .limbs = .{ 1693982333959686, 608509411481997, 2235573344831311, 947681270984193, 266558006233600 } };
53		53
54	/// Return true if the field element is zero	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	var reduced = fe;	56	var reduced = fe;
57	reduced.reduce();	57	reduced.reduce();
58	const limbs = reduced.limbs;	58	const limbs = reduced.limbs;
...	@@ -60,7 +60,7 @@ pub const Fe = struct {	...	@@ -60,7 +60,7 @@ pub const Fe = struct {
60	}	60	}
61		61
62	/// Return true if both field elements are equivalent	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	return a.sub(b).isZero();	64	return a.sub(b).isZero();
65	}	65	}
66		66
...	@@ -164,7 +164,7 @@ pub const Fe = struct {	...	@@ -164,7 +164,7 @@ pub const Fe = struct {
164	}	164	}
165		165
166	/// Add a field element	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	var fe: Fe = undefined;	168	var fe: Fe = undefined;
169	comptime var i = 0;	169	comptime var i = 0;
170	inline while (i < 5) : (i += 1) {	170	inline while (i < 5) : (i += 1) {
...	@@ -174,7 +174,7 @@ pub const Fe = struct {	...	@@ -174,7 +174,7 @@ pub const Fe = struct {
174	}	174	}
175		175
176	/// Substract a field elememnt	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	var fe = b;	178	var fe = b;
179	comptime var i = 0;	179	comptime var i = 0;
180	inline while (i < 4) : (i += 1) {	180	inline while (i < 4) : (i += 1) {
...	@@ -193,17 +193,17 @@ pub const Fe = struct {	...	@@ -193,17 +193,17 @@ pub const Fe = struct {
193	}	193	}
194		194
195	/// Negate a field element	195	/// Negate a field element
196	pub inline fn neg(a: Fe) Fe {	196	pub fn neg(a: Fe) callconv(.Inline) Fe {
197	return zero.sub(a);	197	return zero.sub(a);
198	}	198	}
199		199
200	/// Return true if a field element is negative	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	return (a.toBytes()[0] & 1) != 0;	202	return (a.toBytes()[0] & 1) != 0;
203	}	203	}
204		204
205	/// Conditonally replace a field element with `a` if `c` is positive	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	const mask: u64 = 0 -% c;	207	const mask: u64 = 0 -% c;
208	var x = fe.*;	208	var x = fe.*;
209	comptime var i = 0;	209	comptime var i = 0;
...	@@ -244,7 +244,7 @@ pub const Fe = struct {	...	@@ -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	var rs: [5]u64 = undefined;	248	var rs: [5]u64 = undefined;
249	comptime var i = 0;	249	comptime var i = 0;
250	inline while (i < 4) : (i += 1) {	250	inline while (i < 4) : (i += 1) {
...	@@ -265,7 +265,7 @@ pub const Fe = struct {	...	@@ -265,7 +265,7 @@ pub const Fe = struct {
265	}	265	}
266		266
267	/// Multiply two field elements	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	var ax: [5]u128 = undefined;	269	var ax: [5]u128 = undefined;
270	var bx: [5]u128 = undefined;	270	var bx: [5]u128 = undefined;
271	var a19: [5]u128 = undefined;	271	var a19: [5]u128 = undefined;
...	@@ -288,7 +288,7 @@ pub const Fe = struct {	...	@@ -288,7 +288,7 @@ pub const Fe = struct {
288	return _carry128(&r);	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	var ax: [5]u128 = undefined;	292	var ax: [5]u128 = undefined;
293	var r: [5]u128 = undefined;	293	var r: [5]u128 = undefined;
294	comptime var i = 0;	294	comptime var i = 0;
...	@@ -317,17 +317,17 @@ pub const Fe = struct {	...	@@ -317,17 +317,17 @@ pub const Fe = struct {
317	}	317	}
318		318
319	/// Square a field element	319	/// Square a field element
320	pub inline fn sq(a: Fe) Fe {	320	pub fn sq(a: Fe) callconv(.Inline) Fe {
321	return _sq(a, false);	321	return _sq(a, false);
322	}	322	}
323		323
324	/// Square and double a field element	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	return _sq(a, true);	326	return _sq(a, true);
327	}	327	}
328		328
329	/// Multiply a field element with a small (32-bit) integer	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	const sn = @intCast(u128, n);	331	const sn = @intCast(u128, n);
332	var fe: Fe = undefined;	332	var fe: Fe = undefined;
333	var x: u128 = 0;	333	var x: u128 = 0;
...	@@ -342,7 +342,7 @@ pub const Fe = struct {	...	@@ -342,7 +342,7 @@ pub const Fe = struct {
342	}	342	}
343		343
344	/// Square a field element `n` times	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	var i: usize = 0;	346	var i: usize = 0;
347	var fe = a;	347	var fe = a;
348	while (i < n) : (i += 1) {	348	while (i < n) : (i += 1) {

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

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

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

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

...	@@ -35,7 +35,7 @@ const State128L = struct {	...	@@ -35,7 +35,7 @@ const State128L = struct {
35	return state;	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	const blocks = &state.blocks;	39	const blocks = &state.blocks;
40	const tmp = blocks[7];	40	const tmp = blocks[7];
41	comptime var i: usize = 7;	41	comptime var i: usize = 7;
...	@@ -207,7 +207,7 @@ const State256 = struct {	...	@@ -207,7 +207,7 @@ const State256 = struct {
207	return state;	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	const blocks = &state.blocks;	211	const blocks = &state.blocks;
212	const tmp = blocks[5].encrypt(blocks[0]);	212	const tmp = blocks[5].encrypt(blocks[0]);
213	comptime var i: usize = 5;	213	comptime var i: usize = 5;

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

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

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

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

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

...	@@ -35,7 +35,7 @@ const ChaCha20VecImpl = struct {	...	@@ -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	x.* = input;	39	x.* = input;
40		40
41	var r: usize = 0;	41	var r: usize = 0;
...	@@ -80,7 +80,7 @@ const ChaCha20VecImpl = struct {	...	@@ -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	var i: usize = 0;	84	var i: usize = 0;
85	while (i < 4) : (i += 1) {	85	while (i < 4) : (i += 1) {
86	mem.writeIntLittle(u32, out[16 * i + 0 ..][0..4], x[i][0]);	86	mem.writeIntLittle(u32, out[16 * i + 0 ..][0..4], x[i][0]);
...	@@ -90,7 +90,7 @@ const ChaCha20VecImpl = struct {	...	@@ -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	x[0] +%= ctx[0];	94	x[0] +%= ctx[0];
95	x[1] +%= ctx[1];	95	x[1] +%= ctx[1];
96	x[2] +%= ctx[2];	96	x[2] +%= ctx[2];
...	@@ -190,7 +190,7 @@ const ChaCha20NonVecImpl = struct {	...	@@ -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	x.* = input;	194	x.* = input;
195		195
196	const rounds = comptime [_]QuarterRound{	196	const rounds = comptime [_]QuarterRound{
...	@@ -219,7 +219,7 @@ const ChaCha20NonVecImpl = struct {	...	@@ -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	var i: usize = 0;	223	var i: usize = 0;
224	while (i < 4) : (i += 1) {	224	while (i < 4) : (i += 1) {
225	mem.writeIntLittle(u32, out[16 * i + 0 ..][0..4], x[i * 4 + 0]);	225	mem.writeIntLittle(u32, out[16 * i + 0 ..][0..4], x[i * 4 + 0]);
...	@@ -229,7 +229,7 @@ const ChaCha20NonVecImpl = struct {	...	@@ -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	var i: usize = 0;	233	var i: usize = 0;
234	while (i < 16) : (i += 1) {	234	while (i < 16) : (i += 1) {
235	x[i] +%= ctx[i];	235	x[i] +%= ctx[i];

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

...	@@ -95,7 +95,7 @@ pub const Ghash = struct {	...	@@ -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	const Vector = std.meta.Vector;	99	const Vector = std.meta.Vector;
100	const product = asm (	100	const product = asm (
101	\\ vpclmulqdq $0x00, %[x], %[y], %[out]	101	\\ vpclmulqdq $0x00, %[x], %[y], %[out]
...	@@ -106,7 +106,7 @@ pub const Ghash = struct {	...	@@ -106,7 +106,7 @@ pub const Ghash = struct {
106	return product[0];	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	const Vector = std.meta.Vector;	110	const Vector = std.meta.Vector;
111	const product = asm (	111	const product = asm (
112	\\ pmull %[out].1q, %[x].1d, %[y].1d	112	\\ pmull %[out].1q, %[x].1d, %[y].1d

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

...	@@ -48,7 +48,7 @@ pub const State = struct {	...	@@ -48,7 +48,7 @@ pub const State = struct {
48	return mem.asBytes(&self.data);	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	for (self.data) \|*w\| {	52	for (self.data) \|*w\| {
53	w.* = mem.littleToNative(u32, w.*);	53	w.* = mem.littleToNative(u32, w.*);
54	}	54	}
...	@@ -116,7 +116,7 @@ pub const State = struct {	...	@@ -116,7 +116,7 @@ pub const State = struct {
116		116
117	const Lane = Vector(4, u32);	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	return x << @splat(4, @as(u5, n));	120	return x << @splat(4, @as(u5, n));
121	}	121	}
122		122

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

lib/std/elf.zig+8-8

...	@@ -720,10 +720,10 @@ pub const Elf32_Rel = extern struct {	...	@@ -720,10 +720,10 @@ pub const Elf32_Rel = extern struct {
720	r_offset: Elf32_Addr,	720	r_offset: Elf32_Addr,
721	r_info: Elf32_Word,	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	return @truncate(u24, self.r_info >> 8);	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	return @truncate(u8, self.r_info & 0xff);	727	return @truncate(u8, self.r_info & 0xff);
728	}	728	}
729	};	729	};
...	@@ -731,10 +731,10 @@ pub const Elf64_Rel = extern struct {	...	@@ -731,10 +731,10 @@ pub const Elf64_Rel = extern struct {
731	r_offset: Elf64_Addr,	731	r_offset: Elf64_Addr,
732	r_info: Elf64_Xword,	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	return @truncate(u32, self.r_info >> 32);	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	return @truncate(u32, self.r_info & 0xffffffff);	738	return @truncate(u32, self.r_info & 0xffffffff);
739	}	739	}
740	};	740	};
...	@@ -743,10 +743,10 @@ pub const Elf32_Rela = extern struct {	...	@@ -743,10 +743,10 @@ pub const Elf32_Rela = extern struct {
743	r_info: Elf32_Word,	743	r_info: Elf32_Word,
744	r_addend: Elf32_Sword,	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	return @truncate(u24, self.r_info >> 8);	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	return @truncate(u8, self.r_info & 0xff);	750	return @truncate(u8, self.r_info & 0xff);
751	}	751	}
752	};	752	};
...	@@ -755,10 +755,10 @@ pub const Elf64_Rela = extern struct {	...	@@ -755,10 +755,10 @@ pub const Elf64_Rela = extern struct {
755	r_info: Elf64_Xword,	755	r_info: Elf64_Xword,
756	r_addend: Elf64_Sxword,	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	return @truncate(u32, self.r_info >> 32);	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	return @truncate(u32, self.r_info & 0xffffffff);	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,21 +52,21 @@ const Z96 = struct {
52	d2: u32,	52	d2: u32,
53		53
54	// d = s >> 1	54	// d = s >> 1
55	inline fn shiftRight1(d: *Z96, s: Z96) void {	55	fn shiftRight1(d: *Z96, s: Z96) callconv(.Inline) void {
56	d.d0 = (s.d0 >> 1) \| ((s.d1 & 1) << 31);	56	d.d0 = (s.d0 >> 1) \| ((s.d1 & 1) << 31);
57	d.d1 = (s.d1 >> 1) \| ((s.d2 & 1) << 31);	57	d.d1 = (s.d1 >> 1) \| ((s.d2 & 1) << 31);
58	d.d2 = s.d2 >> 1;	58	d.d2 = s.d2 >> 1;
59	}	59	}
60		60
61	// d = s << 1	61	// d = s << 1
62	inline fn shiftLeft1(d: *Z96, s: Z96) void {	62	fn shiftLeft1(d: *Z96, s: Z96) callconv(.Inline) void {
63	d.d2 = (s.d2 << 1) \| ((s.d1 & (1 << 31)) >> 31);	63	d.d2 = (s.d2 << 1) \| ((s.d1 & (1 << 31)) >> 31);
64	d.d1 = (s.d1 << 1) \| ((s.d0 & (1 << 31)) >> 31);	64	d.d1 = (s.d1 << 1) \| ((s.d0 & (1 << 31)) >> 31);
65	d.d0 = s.d0 << 1;	65	d.d0 = s.d0 << 1;
66	}	66	}
67		67
68	// d += s	68	// d += s
69	inline fn add(d: *Z96, s: Z96) void {	69	fn add(d: *Z96, s: Z96) callconv(.Inline) void {
70	var w = @as(u64, d.d0) + @as(u64, s.d0);	70	var w = @as(u64, d.d0) + @as(u64, s.d0);
71	d.d0 = @truncate(u32, w);	71	d.d0 = @truncate(u32, w);
72		72
...	@@ -80,7 +80,7 @@ const Z96 = struct {	...	@@ -80,7 +80,7 @@ const Z96 = struct {
80	}	80	}
81		81
82	// d -= s	82	// d -= s
83	inline fn sub(d: *Z96, s: Z96) void {	83	fn sub(d: *Z96, s: Z96) callconv(.Inline) void {
84	var w = @as(u64, d.d0) -% @as(u64, s.d0);	84	var w = @as(u64, d.d0) -% @as(u64, s.d0);
85	d.d0 = @truncate(u32, w);	85	d.d0 = @truncate(u32, w);
86		86

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

...	@@ -6,7 +6,7 @@	...	@@ -6,7 +6,7 @@
6	const std = @import("std");	6	const std = @import("std");
7	const builtin = @import("builtin");	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	// ptr + offset doesn't work at comptime so we need this instead.	10	// ptr + offset doesn't work at comptime so we need this instead.
11	return @ptrCast([*]const u8, &ptr[offset]);	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,16 +815,16 @@ pub const sigval = extern union {
815	pub const _SIG_WORDS = 4;	815	pub const _SIG_WORDS = 4;
816	pub const _SIG_MAXSIG = 128;	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	return sig - 1;	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	return_SIG_IDX(sig) >> 5;	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	return 1 << (_SIG_IDX(sig) & 31);	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	return sig <= _SIG_MAXSIG and sig > 0;	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,16 +796,16 @@ pub const _ksiginfo = extern struct {
796	pub const _SIG_WORDS = 4;	796	pub const _SIG_WORDS = 4;
797	pub const _SIG_MAXSIG = 128;	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	return sig - 1;	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	return_SIG_IDX(sig) >> 5;	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	return 1 << (_SIG_IDX(sig) & 31);	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	return sig <= _SIG_MAXSIG and sig > 0;	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,7 +126,7 @@ pub fn fork() usize {
126	/// It is advised to avoid this function and use clone instead, because	126	/// It is advised to avoid this function and use clone instead, because
127	/// the compiler is not aware of how vfork affects control flow and you may	127	/// the compiler is not aware of how vfork affects control flow and you may
128	/// see different results in optimized builds.	128	/// see different results in optimized builds.
129	pub inline fn vfork() usize {	129	pub fn vfork() callconv(.Inline) usize {
130	return @call(.{ .modifier = .always_inline }, syscall0, .{.vfork});	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,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	return @ptrCast(T, @alignCast(@alignOf(T), ptr));	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,7 +1669,7 @@ pub fn wToPrefixedFileW(s: []const u16) !PathSpace {
1669	return path_space;	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	return (s << 10) \| p;	1673	return (s << 10) \| p;
1674	}	1674	}
1675		1675

lib/std/start.zig+2-2

lib/std/zig/ast.zig+9

 @@ -1357,6 +1357,7 @@ pub const Node = struct {
             extern_export_inline_token: TokenIndex,
             is_extern_prototype: void, // TODO: Remove once extern fn rewriting is
             is_async: void, // TODO: remove once async fn rewriting is
+            is_inline: void, // TODO: remove once inline fn rewriting is
         });
         pub const RequiredFields = struct {
 @@ -1523,6 +1524,14 @@ pub const Node = struct {
             self.setTrailer(.is_async, value);
         }
+        pub fn getIsInline(self: *const FnProto) ?void {
+            return self.getTrailer(.is_inline);
+        }
+        pub fn setIsInline(self: *FnProto, value: void) void {
+            self.setTrailer(.is_inline, value);
+        }
         fn getTrailer(self: *const FnProto, comptime field: TrailerFlags.FieldEnum) ?TrailerFlags.Field(field) {
             const trailers_start = @alignCast(
                 @alignOf(ParamDecl),

lib/std/zig/parse.zig+9-2

 @@ -493,9 +493,15 @@ const Parser = struct {
         extern_export_inline_token: ?TokenIndex = null,
         lib_name: ?*Node = null,
     }) !?*Node {
-        // TODO: Remove once extern/async fn rewriting is
+        // TODO: Remove once extern/async/inline fn rewriting is
-        var is_async: ?void = null;
         var is_extern_prototype: ?void = null;
+        var is_async: ?void = null;
+        var is_inline: ?void = null;
+        if (fields.extern_export_inline_token != null and
+            p.token_ids[fields.extern_export_inline_token.?] == .Keyword_inline)
+        {
+            is_inline = {};
+        }
         const cc_token: ?TokenIndex = blk: {
             if (p.eatToken(.Keyword_extern)) |token| {
                 is_extern_prototype = {};
 @@ -573,6 +579,7 @@ const Parser = struct {
             .callconv_expr = callconv_expr,
             .is_extern_prototype = is_extern_prototype,
             .is_async = is_async,
+            .is_inline = is_inline,
         });
         std.mem.copy(Node.FnProto.ParamDecl, fn_proto_node.params(), params);

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

lib/std/zig/render.zig+3-1

...	@@ -1558,7 +1558,7 @@ fn renderExpression(	...	@@ -1558,7 +1558,7 @@ fn renderExpression(
1558	}	1558	}
1559		1559
1560	if (fn_proto.getExternExportInlineToken()) \|extern_export_inline_token\| {	1560	if (fn_proto.getExternExportInlineToken()) \|extern_export_inline_token\| {
1561	if (fn_proto.getIsExternPrototype() == null)	1561	if (fn_proto.getIsExternPrototype() == null and fn_proto.getIsInline() == null)
1562	try renderToken(tree, ais, extern_export_inline_token, Space.Space); // extern/export/inline	1562	try renderToken(tree, ais, extern_export_inline_token, Space.Space); // extern/export/inline
1563	}	1563	}
1564		1564
...	@@ -1664,6 +1664,8 @@ fn renderExpression(	...	@@ -1664,6 +1664,8 @@ fn renderExpression(
1664	try ais.writer().writeAll("callconv(.C) ");	1664	try ais.writer().writeAll("callconv(.C) ");
1665	} else if (fn_proto.getIsAsync() != null) {	1665	} else if (fn_proto.getIsAsync() != null) {
1666	try ais.writer().writeAll("callconv(.Async) ");	1666	try ais.writer().writeAll("callconv(.Async) ");
		1667	} else if (fn_proto.getIsInline() != null) {
		1668	try ais.writer().writeAll("callconv(.Inline) ");
1667	}	1669	}
1668		1670
1669	switch (fn_proto.return_type) {	1671	switch (fn_proto.return_type) {

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,11 +19,11 @@ fn setFeature(cpu: *Target.Cpu, feature: Target.x86.Feature, enabled: bool) void
19	if (enabled) cpu.features.addFeature(idx) else cpu.features.removeFeature(idx);	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	return (input >> offset) & 1 != 0;	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	return (input & mask) == mask;	27	return (input & mask) == mask;
28	}	28	}
29		29

src/Module.zig+19-16

...	@@ -1087,14 +1087,23 @@ fn astGenAndAnalyzeDecl(self: Module, decl: Decl) !bool {	...	@@ -1087,14 +1087,23 @@ fn astGenAndAnalyzeDecl(self: Module, decl: Decl) !bool {
1087	if (fn_proto.getSectionExpr()) \|sect_expr\| {	1087	if (fn_proto.getSectionExpr()) \|sect_expr\| {
1088	return self.failNode(&fn_type_scope.base, sect_expr, "TODO implement function section expression", .{});	1088	return self.failNode(&fn_type_scope.base, sect_expr, "TODO implement function section expression", .{});
1089	}	1089	}
1090	if (fn_proto.getCallconvExpr()) \|callconv_expr\| {	1090
1091	return self.failNode(	1091	const enum_literal_type = try astgen.addZIRInstConst(self, &fn_type_scope.base, fn_src, .{
1092	&fn_type_scope.base,	1092	.ty = Type.initTag(.type),
1093	callconv_expr,	1093	.val = Value.initTag(.enum_literal_type),
1094	"TODO implement function calling convention expression",	1094	});
1095	.{},	1095	const enum_literal_type_rl: astgen.ResultLoc = .{ .ty = enum_literal_type };
1096	);	1096	const cc = if (fn_proto.getCallconvExpr()) \|callconv_expr\|
1097	}	1097	try astgen.expr(self, &fn_type_scope.base, enum_literal_type_rl, callconv_expr)
		1098	else
		1099	try astgen.addZIRInstConst(self, &fn_type_scope.base, fn_src, .{
		1100	.ty = Type.initTag(.enum_literal),
		1101	.val = try Value.Tag.enum_literal.create(
		1102	&fn_type_scope_arena.allocator,
		1103	try fn_type_scope_arena.allocator.dupe(u8, "Unspecified"),
		1104	),
		1105	});
		1106
1098	const return_type_expr = switch (fn_proto.return_type) {	1107	const return_type_expr = switch (fn_proto.return_type) {
1099	.Explicit => \|node\| node,	1108	.Explicit => \|node\| node,
1100	.InferErrorSet => \|node\| return self.failNode(&fn_type_scope.base, node, "TODO implement inferred error sets", .{}),	1109	.InferErrorSet => \|node\| return self.failNode(&fn_type_scope.base, node, "TODO implement inferred error sets", .{}),
...	@@ -1105,6 +1114,7 @@ fn astGenAndAnalyzeDecl(self: Module, decl: Decl) !bool {	...	@@ -1105,6 +1114,7 @@ fn astGenAndAnalyzeDecl(self: Module, decl: Decl) !bool {
1105	const fn_type_inst = try astgen.addZIRInst(self, &fn_type_scope.base, fn_src, zir.Inst.FnType, .{	1114	const fn_type_inst = try astgen.addZIRInst(self, &fn_type_scope.base, fn_src, zir.Inst.FnType, .{
1106	.return_type = return_type_inst,	1115	.return_type = return_type_inst,
1107	.param_types = param_types,	1116	.param_types = param_types,
		1117	.cc = cc,
1108	}, .{});	1118	}, .{});
1109		1119
1110	if (std.builtin.mode == .Debug and self.comp.verbose_ir) {	1120	if (std.builtin.mode == .Debug and self.comp.verbose_ir) {
...	@@ -1230,14 +1240,7 @@ fn astGenAndAnalyzeDecl(self: Module, decl: Decl) !bool {	...	@@ -1230,14 +1240,7 @@ fn astGenAndAnalyzeDecl(self: Module, decl: Decl) !bool {
1230	};	1240	};
1231	};	1241	};
1232		1242
1233	const is_inline = blk: {	1243	const is_inline = fn_type.fnCallingConvention() == .Inline;
1234	if (fn_proto.getExternExportInlineToken()) \|maybe_inline_token\| {
1235	if (tree.token_ids[maybe_inline_token] == .Keyword_inline) {
1236	break :blk true;
1237	}
1238	}
1239	break :blk false;
1240	};
1241	const anal_state = ([2]Fn.Analysis{ .queued, .inline_only })[@boolToInt(is_inline)];	1244	const anal_state = ([2]Fn.Analysis{ .queued, .inline_only })[@boolToInt(is_inline)];
1242		1245
1243	new_func.* = .{	1246	new_func.* = .{

src/link/MachO.zig+1-1

...	@@ -2366,7 +2366,7 @@ fn allocatedSizeLinkedit(self: *MachO, start: u64) u64 {	...	@@ -2366,7 +2366,7 @@ fn allocatedSizeLinkedit(self: *MachO, start: u64) u64 {
2366	return min_pos - start;	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	const increased_size = padToIdeal(size);	2370	const increased_size = padToIdeal(size);
2371	const test_end = off + increased_size;	2371	const test_end = off + increased_size;
2372	if (end > off and start < test_end) {	2372	if (end > off and start < test_end) {

src/stage1/all_types.hpp+3-9

 @@ -74,6 +74,7 @@ enum CallingConvention {
     CallingConventionC,
     CallingConventionNaked,
     CallingConventionAsync,
+    CallingConventionInline,
     CallingConventionInterrupt,
     CallingConventionSignal,
     CallingConventionStdcall,
 @@ -703,12 +704,6 @@ enum NodeType {
     NodeTypeAnyTypeField,
 };
-enum FnInline {
-    FnInlineAuto,
-    FnInlineAlways,
-    FnInlineNever,
-};
 struct AstNodeFnProto {
     Buf *name;
     ZigList<AstNode *> params;
 @@ -725,13 +720,12 @@ struct AstNodeFnProto {
     AstNode *callconv_expr;
     Buf doc_comments;
-    FnInline fn_inline;
     VisibMod visib_mod;
     bool auto_err_set;
     bool is_var_args;
     bool is_extern;
     bool is_export;
+    bool is_noinline;
 };
 struct AstNodeFnDef {
 @@ -1719,7 +1713,6 @@ struct ZigFn {
     LLVMValueRef valgrind_client_request_array;
-    FnInline fn_inline;
     FnAnalState anal_state;
     uint32_t align_bytes;
 @@ -1728,6 +1721,7 @@ struct ZigFn {
     bool calls_or_awaits_errorable_fn;
     bool is_cold;
     bool is_test;
+    bool is_noinline;
 };
 uint32_t fn_table_entry_hash(ZigFn*);

src/stage1/analyze.cpp+15-5

...	@@ -973,6 +973,7 @@ const char *calling_convention_name(CallingConvention cc) {	...	@@ -973,6 +973,7 @@ const char *calling_convention_name(CallingConvention cc) {
973	case CallingConventionAPCS: return "APCS";	973	case CallingConventionAPCS: return "APCS";
974	case CallingConventionAAPCS: return "AAPCS";	974	case CallingConventionAAPCS: return "AAPCS";
975	case CallingConventionAAPCSVFP: return "AAPCSVFP";	975	case CallingConventionAAPCSVFP: return "AAPCSVFP";
		976	case CallingConventionInline: return "Inline";
976	}	977	}
977	zig_unreachable();	978	zig_unreachable();
978	}	979	}
...	@@ -981,6 +982,7 @@ bool calling_convention_allows_zig_types(CallingConvention cc) {	...	@@ -981,6 +982,7 @@ bool calling_convention_allows_zig_types(CallingConvention cc) {
981	switch (cc) {	982	switch (cc) {
982	case CallingConventionUnspecified:	983	case CallingConventionUnspecified:
983	case CallingConventionAsync:	984	case CallingConventionAsync:
		985	case CallingConventionInline:
984	return true;	986	return true;
985	case CallingConventionC:	987	case CallingConventionC:
986	case CallingConventionNaked:	988	case CallingConventionNaked:
...	@@ -1007,7 +1009,8 @@ ZigType get_stack_trace_type(CodeGen g) {	...	@@ -1007,7 +1009,8 @@ ZigType get_stack_trace_type(CodeGen g) {
1007	}	1009	}
1008		1010
1009	bool want_first_arg_sret(CodeGen g, FnTypeId fn_type_id) {	1011	bool want_first_arg_sret(CodeGen g, FnTypeId fn_type_id) {
1010	if (fn_type_id->cc == CallingConventionUnspecified) {	1012	if (fn_type_id->cc == CallingConventionUnspecified
		1013	\|\| fn_type_id->cc == CallingConventionInline) {
1011	return handle_is_ptr(g, fn_type_id->return_type);	1014	return handle_is_ptr(g, fn_type_id->return_type);
1012	}	1015	}
1013	if (fn_type_id->cc != CallingConventionC) {	1016	if (fn_type_id->cc != CallingConventionC) {
...	@@ -1888,6 +1891,7 @@ Error emit_error_unless_callconv_allowed_for_target(CodeGen g, AstNode source_	...	@@ -1888,6 +1891,7 @@ Error emit_error_unless_callconv_allowed_for_target(CodeGen g, AstNode source_
1888	case CallingConventionC:	1891	case CallingConventionC:
1889	case CallingConventionNaked:	1892	case CallingConventionNaked:
1890	case CallingConventionAsync:	1893	case CallingConventionAsync:
		1894	case CallingConventionInline:
1891	break;	1895	break;
1892	case CallingConventionInterrupt:	1896	case CallingConventionInterrupt:
1893	if (g->zig_target->arch != ZigLLVM_x86	1897	if (g->zig_target->arch != ZigLLVM_x86
...	@@ -3587,7 +3591,7 @@ static void get_fully_qualified_decl_name(CodeGen g, Buf buf, Tld *tld, bool i	...	@@ -3587,7 +3591,7 @@ static void get_fully_qualified_decl_name(CodeGen g, Buf buf, Tld *tld, bool i
3587	}	3591	}
3588	}	3592	}
3589		3593
3590	static ZigFn create_fn_raw(CodeGen g, FnInline inline_value) {	3594	static ZigFn create_fn_raw(CodeGen g, bool is_noinline) {
3591	ZigFn *fn_entry = heap::c_allocator.create<ZigFn>();	3595	ZigFn *fn_entry = heap::c_allocator.create<ZigFn>();
3592	fn_entry->ir_executable = heap::c_allocator.create<IrExecutableSrc>();	3596	fn_entry->ir_executable = heap::c_allocator.create<IrExecutableSrc>();
3593		3597
...	@@ -3597,7 +3601,7 @@ static ZigFn create_fn_raw(CodeGen g, FnInline inline_value) {	...	@@ -3597,7 +3601,7 @@ static ZigFn create_fn_raw(CodeGen g, FnInline inline_value) {
3597	fn_entry->analyzed_executable.backward_branch_quota = &fn_entry->prealloc_backward_branch_quota;	3601	fn_entry->analyzed_executable.backward_branch_quota = &fn_entry->prealloc_backward_branch_quota;
3598	fn_entry->analyzed_executable.fn_entry = fn_entry;	3602	fn_entry->analyzed_executable.fn_entry = fn_entry;
3599	fn_entry->ir_executable->fn_entry = fn_entry;	3603	fn_entry->ir_executable->fn_entry = fn_entry;
3600	fn_entry->fn_inline = inline_value;	3604	fn_entry->is_noinline = is_noinline;
3601		3605
3602	return fn_entry;	3606	return fn_entry;
3603	}	3607	}
...	@@ -3606,7 +3610,7 @@ ZigFn create_fn(CodeGen g, AstNode *proto_node) {	...	@@ -3606,7 +3610,7 @@ ZigFn create_fn(CodeGen g, AstNode *proto_node) {
3606	assert(proto_node->type == NodeTypeFnProto);	3610	assert(proto_node->type == NodeTypeFnProto);
3607	AstNodeFnProto *fn_proto = &proto_node->data.fn_proto;	3611	AstNodeFnProto *fn_proto = &proto_node->data.fn_proto;
3608		3612
3609	ZigFn *fn_entry = create_fn_raw(g, fn_proto->fn_inline);	3613	ZigFn *fn_entry = create_fn_raw(g, fn_proto->is_noinline);
3610		3614
3611	fn_entry->proto_node = proto_node;	3615	fn_entry->proto_node = proto_node;
3612	fn_entry->body_node = (proto_node->data.fn_proto.fn_def_node == nullptr) ? nullptr :	3616	fn_entry->body_node = (proto_node->data.fn_proto.fn_def_node == nullptr) ? nullptr :
...	@@ -3739,6 +3743,12 @@ static void resolve_decl_fn(CodeGen g, TldFn tld_fn) {	...	@@ -3739,6 +3743,12 @@ static void resolve_decl_fn(CodeGen g, TldFn tld_fn) {
3739	fn_table_entry->type_entry = g->builtin_types.entry_invalid;	3743	fn_table_entry->type_entry = g->builtin_types.entry_invalid;
3740	tld_fn->base.resolution = TldResolutionInvalid;	3744	tld_fn->base.resolution = TldResolutionInvalid;
3741	return;	3745	return;
		3746	case CallingConventionInline:
		3747	add_node_error(g, fn_def_node,
		3748	buf_sprintf("exported function cannot be inline"));
		3749	fn_table_entry->type_entry = g->builtin_types.entry_invalid;
		3750	tld_fn->base.resolution = TldResolutionInvalid;
		3751	return;
3742	case CallingConventionC:	3752	case CallingConventionC:
3743	case CallingConventionNaked:	3753	case CallingConventionNaked:
3744	case CallingConventionInterrupt:	3754	case CallingConventionInterrupt:
...	@@ -3774,7 +3784,7 @@ static void resolve_decl_fn(CodeGen g, TldFn tld_fn) {	...	@@ -3774,7 +3784,7 @@ static void resolve_decl_fn(CodeGen g, TldFn tld_fn) {
3774	fn_table_entry->inferred_async_node = fn_table_entry->proto_node;	3784	fn_table_entry->inferred_async_node = fn_table_entry->proto_node;
3775	}	3785	}
3776	} else if (source_node->type == NodeTypeTestDecl) {	3786	} else if (source_node->type == NodeTypeTestDecl) {
3777	ZigFn *fn_table_entry = create_fn_raw(g, FnInlineAuto);	3787	ZigFn *fn_table_entry = create_fn_raw(g, false);
3778		3788
3779	get_fully_qualified_decl_name(g, &fn_table_entry->symbol_name, &tld_fn->base, true);	3789	get_fully_qualified_decl_name(g, &fn_table_entry->symbol_name, &tld_fn->base, true);
3780		3790

src/stage1/ast_render.cpp+3-8

 @@ -123,13 +123,8 @@ static const char *export_string(bool is_export) {
 //    zig_unreachable();
 //}
-static const char *inline_string(FnInline fn_inline) {
+static const char *inline_string(bool is_inline) {
-    switch (fn_inline) {
+    return is_inline ? "inline" : "";
-        case FnInlineAlways: return "inline ";
-        case FnInlineNever:  return "noinline ";
-        case FnInlineAuto:   return "";
-    }
-    zig_unreachable();
 }
 static const char *const_or_var_string(bool is_const) {
 @@ -446,7 +441,7 @@ static void render_node_extra(AstRender *ar, AstNode *node, bool grouped) {
                 const char *pub_str = visib_mod_string(node->data.fn_proto.visib_mod);
                 const char *extern_str = extern_string(node->data.fn_proto.is_extern);
                 const char *export_str = export_string(node->data.fn_proto.is_export);
-                const char *inline_str = inline_string(node->data.fn_proto.fn_inline);
+                const char *inline_str = inline_string(node->data.fn_proto.is_noinline);
                 fprintf(ar->f, "%s%s%s%sfn ", pub_str, inline_str, export_str, extern_str);
                 if (node->data.fn_proto.name != nullptr) {
                     print_symbol(ar, node->data.fn_proto.name);

src/stage1/codegen.cpp+18-28

...	@@ -159,6 +159,7 @@ static const char get_mangled_name(CodeGen g, const char *original_name) {	...	@@ -159,6 +159,7 @@ static const char get_mangled_name(CodeGen g, const char *original_name) {
159	static ZigLLVM_CallingConv get_llvm_cc(CodeGen *g, CallingConvention cc) {	159	static ZigLLVM_CallingConv get_llvm_cc(CodeGen *g, CallingConvention cc) {
160	switch (cc) {	160	switch (cc) {
161	case CallingConventionUnspecified:	161	case CallingConventionUnspecified:
		162	case CallingConventionInline:
162	return ZigLLVM_Fast;	163	return ZigLLVM_Fast;
163	case CallingConventionC:	164	case CallingConventionC:
164	return ZigLLVM_C;	165	return ZigLLVM_C;
...	@@ -350,6 +351,7 @@ static bool cc_want_sret_attr(CallingConvention cc) {	...	@@ -350,6 +351,7 @@ static bool cc_want_sret_attr(CallingConvention cc) {
350	return true;	351	return true;
351	case CallingConventionAsync:	352	case CallingConventionAsync:
352	case CallingConventionUnspecified:	353	case CallingConventionUnspecified:
		354	case CallingConventionInline:
353	return false;	355	return false;
354	}	356	}
355	zig_unreachable();	357	zig_unreachable();
...	@@ -452,20 +454,11 @@ static LLVMValueRef make_fn_llvm_value(CodeGen g, ZigFn fn) {	...	@@ -452,20 +454,11 @@ static LLVMValueRef make_fn_llvm_value(CodeGen g, ZigFn fn) {
452	}	454	}
453	}	455	}
454		456
455	switch (fn->fn_inline) {	457	if (cc == CallingConventionInline)
456	case FnInlineAlways:	458	addLLVMFnAttr(llvm_fn, "alwaysinline");
457	addLLVMFnAttr(llvm_fn, "alwaysinline");	459
458	g->inline_fns.append(fn);	460	if (fn->is_noinline \|\| (cc != CallingConventionInline && fn->alignstack_value != 0))
459	break;	461	addLLVMFnAttr(llvm_fn, "noinline");
460	case FnInlineNever:
461	addLLVMFnAttr(llvm_fn, "noinline");
462	break;
463	case FnInlineAuto:
464	if (fn->alignstack_value != 0) {
465	addLLVMFnAttr(llvm_fn, "noinline");
466	}
467	break;
468	}
469		462
470	if (cc == CallingConventionNaked) {	463	if (cc == CallingConventionNaked) {
471	addLLVMFnAttr(llvm_fn, "naked");	464	addLLVMFnAttr(llvm_fn, "naked");
...	@@ -532,7 +525,7 @@ static LLVMValueRef make_fn_llvm_value(CodeGen g, ZigFn fn) {	...	@@ -532,7 +525,7 @@ static LLVMValueRef make_fn_llvm_value(CodeGen g, ZigFn fn) {
532	addLLVMFnAttr(llvm_fn, "nounwind");	525	addLLVMFnAttr(llvm_fn, "nounwind");
533	add_uwtable_attr(g, llvm_fn);	526	add_uwtable_attr(g, llvm_fn);
534	addLLVMFnAttr(llvm_fn, "nobuiltin");	527	addLLVMFnAttr(llvm_fn, "nobuiltin");
535	if (codegen_have_frame_pointer(g) && fn->fn_inline != FnInlineAlways) {	528	if (codegen_have_frame_pointer(g) && cc != CallingConventionInline) {
536	ZigLLVMAddFunctionAttr(llvm_fn, "frame-pointer", "all");	529	ZigLLVMAddFunctionAttr(llvm_fn, "frame-pointer", "all");
537	}	530	}
538	if (fn->section_name) {	531	if (fn->section_name) {
...	@@ -9043,19 +9036,16 @@ Buf codegen_generate_builtin_source(CodeGen g) {	...	@@ -9043,19 +9036,16 @@ Buf codegen_generate_builtin_source(CodeGen g) {
9043	static_assert(CallingConventionC == 1, "");	9036	static_assert(CallingConventionC == 1, "");
9044	static_assert(CallingConventionNaked == 2, "");	9037	static_assert(CallingConventionNaked == 2, "");
9045	static_assert(CallingConventionAsync == 3, "");	9038	static_assert(CallingConventionAsync == 3, "");
9046	static_assert(CallingConventionInterrupt == 4, "");	9039	static_assert(CallingConventionInline == 4, "");
9047	static_assert(CallingConventionSignal == 5, "");	9040	static_assert(CallingConventionInterrupt == 5, "");
9048	static_assert(CallingConventionStdcall == 6, "");	9041	static_assert(CallingConventionSignal == 6, "");
9049	static_assert(CallingConventionFastcall == 7, "");	9042	static_assert(CallingConventionStdcall == 7, "");
9050	static_assert(CallingConventionVectorcall == 8, "");	9043	static_assert(CallingConventionFastcall == 8, "");
9051	static_assert(CallingConventionThiscall == 9, "");	9044	static_assert(CallingConventionVectorcall == 9, "");
9052	static_assert(CallingConventionAPCS == 10, "");	9045	static_assert(CallingConventionThiscall == 10, "");
9053	static_assert(CallingConventionAAPCS == 11, "");	9046	static_assert(CallingConventionAPCS == 11, "");
9054	static_assert(CallingConventionAAPCSVFP == 12, "");	9047	static_assert(CallingConventionAAPCS == 12, "");
9055		9048	static_assert(CallingConventionAAPCSVFP == 13, "");
9056	static_assert(FnInlineAuto == 0, "");
9057	static_assert(FnInlineAlways == 1, "");
9058	static_assert(FnInlineNever == 2, "");
9059		9049
9060	static_assert(BuiltinPtrSizeOne == 0, "");	9050	static_assert(BuiltinPtrSizeOne == 0, "");
9061	static_assert(BuiltinPtrSizeMany == 1, "");	9051	static_assert(BuiltinPtrSizeMany == 1, "");

src/stage1/ir.cpp+12-11

...	@@ -19000,7 +19000,7 @@ static IrInstGen ir_analyze_instruction_decl_var(IrAnalyze ira, IrInstSrcDeclV	...	@@ -19000,7 +19000,7 @@ static IrInstGen ir_analyze_instruction_decl_var(IrAnalyze ira, IrInstSrcDeclV
19000	} else if (init_val->type->id == ZigTypeIdFn &&	19000	} else if (init_val->type->id == ZigTypeIdFn &&
19001	init_val->special != ConstValSpecialUndef &&	19001	init_val->special != ConstValSpecialUndef &&
19002	init_val->data.x_ptr.special == ConstPtrSpecialFunction &&	19002	init_val->data.x_ptr.special == ConstPtrSpecialFunction &&
19003	init_val->data.x_ptr.data.fn.fn_entry->fn_inline == FnInlineAlways)	19003	init_val->data.x_ptr.data.fn.fn_entry->type_entry->data.fn.fn_type_id.cc == CallingConventionInline)
19004	{	19004	{
19005	var_class_requires_const = true;	19005	var_class_requires_const = true;
19006	if (!var->src_is_const && !is_comptime_var) {	19006	if (!var->src_is_const && !is_comptime_var) {
...	@@ -19182,6 +19182,11 @@ static IrInstGen ir_analyze_instruction_export(IrAnalyze ira, IrInstSrcExport	...	@@ -19182,6 +19182,11 @@ static IrInstGen ir_analyze_instruction_export(IrAnalyze ira, IrInstSrcExport
19182	buf_sprintf("exported function cannot be async"));	19182	buf_sprintf("exported function cannot be async"));
19183	add_error_note(ira->codegen, msg, fn_entry->proto_node, buf_sprintf("declared here"));	19183	add_error_note(ira->codegen, msg, fn_entry->proto_node, buf_sprintf("declared here"));
19184	} break;	19184	} break;
		19185	case CallingConventionInline: {
		19186	ErrorMsg *msg = ir_add_error(ira, &target->base,
		19187	buf_sprintf("exported function cannot be inline"));
		19188	add_error_note(ira->codegen, msg, fn_entry->proto_node, buf_sprintf("declared here"));
		19189	} break;
19185	case CallingConventionC:	19190	case CallingConventionC:
19186	case CallingConventionNaked:	19191	case CallingConventionNaked:
19187	case CallingConventionInterrupt:	19192	case CallingConventionInterrupt:
...	@@ -21120,7 +21125,7 @@ static IrInstGen ir_analyze_fn_call(IrAnalyze ira, IrInst* source_instr,	...	@@ -21120,7 +21125,7 @@ static IrInstGen ir_analyze_fn_call(IrAnalyze ira, IrInst* source_instr,
21120	if (type_is_invalid(return_type))	21125	if (type_is_invalid(return_type))
21121	return ira->codegen->invalid_inst_gen;	21126	return ira->codegen->invalid_inst_gen;
21122		21127
21123	if (fn_entry != nullptr && fn_entry->fn_inline == FnInlineAlways && modifier == CallModifierNeverInline) {	21128	if (fn_entry != nullptr && fn_type_id->cc == CallingConventionInline && modifier == CallModifierNeverInline) {
21124	ir_add_error(ira, source_instr,	21129	ir_add_error(ira, source_instr,
21125	buf_sprintf("no-inline call of inline function"));	21130	buf_sprintf("no-inline call of inline function"));
21126	return ira->codegen->invalid_inst_gen;	21131	return ira->codegen->invalid_inst_gen;
...	@@ -25219,10 +25224,6 @@ static Error ir_make_type_info_decls(IrAnalyze ira, IrInst source_instr, ZigVa	...	@@ -25219,10 +25224,6 @@ static Error ir_make_type_info_decls(IrAnalyze ira, IrInst source_instr, ZigVa
25219	if ((err = type_resolve(ira->codegen, type_info_fn_decl_type, ResolveStatusSizeKnown)))	25224	if ((err = type_resolve(ira->codegen, type_info_fn_decl_type, ResolveStatusSizeKnown)))
25220	return err;	25225	return err;
25221		25226
25222	ZigType *type_info_fn_decl_inline_type = ir_type_info_get_type(ira, "Inline", type_info_fn_decl_type);
25223	if ((err = type_resolve(ira->codegen, type_info_fn_decl_inline_type, ResolveStatusSizeKnown)))
25224	return err;
25225
25226	resolve_container_usingnamespace_decls(ira->codegen, decls_scope);	25227	resolve_container_usingnamespace_decls(ira->codegen, decls_scope);
25227		25228
25228	// The unresolved declarations are collected in a separate queue to avoid	25229	// The unresolved declarations are collected in a separate queue to avoid
...	@@ -25365,11 +25366,11 @@ static Error ir_make_type_info_decls(IrAnalyze ira, IrInst source_instr, ZigVa	...	@@ -25365,11 +25366,11 @@ static Error ir_make_type_info_decls(IrAnalyze ira, IrInst source_instr, ZigVa
25365	fn_decl_fields[0]->special = ConstValSpecialStatic;	25366	fn_decl_fields[0]->special = ConstValSpecialStatic;
25366	fn_decl_fields[0]->type = ira->codegen->builtin_types.entry_type;	25367	fn_decl_fields[0]->type = ira->codegen->builtin_types.entry_type;
25367	fn_decl_fields[0]->data.x_type = fn_entry->type_entry;	25368	fn_decl_fields[0]->data.x_type = fn_entry->type_entry;
25368	// inline_type: Data.FnDecl.Inline	25369	// is_noinline: bool
25369	ensure_field_index(fn_decl_val->type, "inline_type", 1);	25370	ensure_field_index(fn_decl_val->type, "is_noinline", 1);
25370	fn_decl_fields[1]->special = ConstValSpecialStatic;	25371	fn_decl_fields[1]->special = ConstValSpecialStatic;
25371	fn_decl_fields[1]->type = type_info_fn_decl_inline_type;	25372	fn_decl_fields[1]->type = ira->codegen->builtin_types.entry_bool;
25372	bigint_init_unsigned(&fn_decl_fields[1]->data.x_enum_tag, fn_entry->fn_inline);	25373	fn_decl_fields[1]->data.x_bool = fn_entry->is_noinline;
25373	// is_var_args: bool	25374	// is_var_args: bool
25374	ensure_field_index(fn_decl_val->type, "is_var_args", 2);	25375	ensure_field_index(fn_decl_val->type, "is_var_args", 2);
25375	bool is_varargs = fn_node->is_var_args;	25376	bool is_varargs = fn_node->is_var_args;
...	@@ -30957,7 +30958,7 @@ static IrInstGen ir_analyze_instruction_set_align_stack(IrAnalyze ira, IrInstS	...	@@ -30957,7 +30958,7 @@ static IrInstGen ir_analyze_instruction_set_align_stack(IrAnalyze ira, IrInstS
30957	return ira->codegen->invalid_inst_gen;	30958	return ira->codegen->invalid_inst_gen;
30958	}	30959	}
30959		30960
30960	if (fn_entry->fn_inline == FnInlineAlways) {	30961	if (fn_entry->type_entry->data.fn.fn_type_id.cc == CallingConventionInline) {
30961	ir_add_error(ira, &instruction->base.base, buf_sprintf("@setAlignStack in inline function"));	30962	ir_add_error(ira, &instruction->base.base, buf_sprintf("@setAlignStack in inline function"));
30962	return ira->codegen->invalid_inst_gen;	30963	return ira->codegen->invalid_inst_gen;
30963	}	30964	}

src/stage1/parser.cpp+3-14

 @@ -693,8 +693,6 @@ static AstNode *ast_parse_top_level_decl(ParseContext *pc, VisibMod visib_mod, B
     Token *first = eat_token_if(pc, TokenIdKeywordExport);
     if (first == nullptr)
         first = eat_token_if(pc, TokenIdKeywordExtern);
-    if (first == nullptr)
-        first = eat_token_if(pc, TokenIdKeywordInline);
     if (first == nullptr)
         first = eat_token_if(pc, TokenIdKeywordNoInline);
     if (first != nullptr) {
 @@ -702,7 +700,7 @@ static AstNode *ast_parse_top_level_decl(ParseContext *pc, VisibMod visib_mod, B
         if (first->id == TokenIdKeywordExtern)
             lib_name = eat_token_if(pc, TokenIdStringLiteral);
-        if (first->id != TokenIdKeywordInline && first->id != TokenIdKeywordNoInline) {
+        if (first->id != TokenIdKeywordNoInline) {
             Token *thread_local_kw = eat_token_if(pc, TokenIdKeywordThreadLocal);
             AstNode *var_decl = ast_parse_var_decl(pc);
             if (var_decl != nullptr) {
 @@ -739,17 +737,8 @@ static AstNode *ast_parse_top_level_decl(ParseContext *pc, VisibMod visib_mod, B
             if (!fn_proto->data.fn_proto.is_extern)
                 fn_proto->data.fn_proto.is_extern = first->id == TokenIdKeywordExtern;
             fn_proto->data.fn_proto.is_export = first->id == TokenIdKeywordExport;
-            switch (first->id) {
+            if (first->id == TokenIdKeywordNoInline)
-                case TokenIdKeywordInline:
+                fn_proto->data.fn_proto.is_noinline = true;
-                    fn_proto->data.fn_proto.fn_inline = FnInlineAlways;
-                    break;
-                case TokenIdKeywordNoInline:
-                    fn_proto->data.fn_proto.fn_inline = FnInlineNever;
-                    break;
-                default:
-                    fn_proto->data.fn_proto.fn_inline = FnInlineAuto;
-                    break;
-            }
             fn_proto->data.fn_proto.lib_name = token_buf(lib_name);
             AstNode *res = fn_proto;

src/tracy.zig+1-1

...	@@ -31,7 +31,7 @@ pub const Ctx = if (enable) ___tracy_c_zone_context else struct {	...	@@ -31,7 +31,7 @@ pub const Ctx = if (enable) ___tracy_c_zone_context else struct {
31	pub fn end(self: Ctx) void {}	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	if (!enable) return .{};	35	if (!enable) return .{};
36		36
37	const loc: ___tracy_source_location_data = .{	37	const loc: ___tracy_source_location_data = .{

src/translate_c.zig+12-4

 @@ -4716,7 +4716,6 @@ fn transCreateNodeMacroFn(c: *Context, name: []const u8, ref: *ast.Node, proto_a
     const scope = &c.global_scope.base;
     const pub_tok = try appendToken(c, .Keyword_pub, "pub");
-    const inline_tok = try appendToken(c, .Keyword_inline, "inline");
     const fn_tok = try appendToken(c, .Keyword_fn, "fn");
     const name_tok = try appendIdentifier(c, name);
     _ = try appendToken(c, .LParen, "(");
 @@ -4744,6 +4743,11 @@ fn transCreateNodeMacroFn(c: *Context, name: []const u8, ref: *ast.Node, proto_a
     _ = try appendToken(c, .RParen, ")");
+    _ = try appendToken(c, .Keyword_callconv, "callconv");
+    _ = try appendToken(c, .LParen, "(");
+    const callconv_expr = try transCreateNodeEnumLiteral(c, "Inline");
+    _ = try appendToken(c, .RParen, ")");
     const block_lbrace = try appendToken(c, .LBrace, "{");
     const return_kw = try appendToken(c, .Keyword_return, "return");
 @@ -4783,8 +4787,8 @@ fn transCreateNodeMacroFn(c: *Context, name: []const u8, ref: *ast.Node, proto_a
     }, .{
         .visib_token = pub_tok,
         .name_token = name_tok,
-        .extern_export_inline_token = inline_tok,
         .body_node = &block.base,
+        .callconv_expr = callconv_expr,
     });
     mem.copy(ast.Node.FnProto.ParamDecl, fn_proto.params(), fn_params.items);
     return &fn_proto.base;
 @@ -5734,7 +5738,6 @@ fn transMacroFnDefine(c: *Context, m: *MacroCtx) ParseError!void {
     const scope = &block_scope.base;
     const pub_tok = try appendToken(c, .Keyword_pub, "pub");
-    const inline_tok = try appendToken(c, .Keyword_inline, "inline");
     const fn_tok = try appendToken(c, .Keyword_fn, "fn");
     const name_tok = try appendIdentifier(c, m.name);
     _ = try appendToken(c, .LParen, "(");
 @@ -5779,6 +5782,11 @@ fn transMacroFnDefine(c: *Context, m: *MacroCtx) ParseError!void {
     _ = try appendToken(c, .RParen, ")");
+    _ = try appendToken(c, .Keyword_callconv, "callconv");
+    _ = try appendToken(c, .LParen, "(");
+    const callconv_expr = try transCreateNodeEnumLiteral(c, "Inline");
+    _ = try appendToken(c, .RParen, ")");
     const type_of = try c.createBuiltinCall("@TypeOf", 1);
     const return_kw = try appendToken(c, .Keyword_return, "return");
 @@ -5810,9 +5818,9 @@ fn transMacroFnDefine(c: *Context, m: *MacroCtx) ParseError!void {
         .return_type = .{ .Explicit = &type_of.base },
     }, .{
         .visib_token = pub_tok,
-        .extern_export_inline_token = inline_tok,
         .name_token = name_tok,
         .body_node = block_node,
+        .callconv_expr = callconv_expr,
     });
     mem.copy(ast.Node.FnProto.ParamDecl, fn_proto.params(), fn_params.items);

src/type.zig+3-1

 @@ -552,7 +552,9 @@ pub const Type = extern union {
                         if (i != 0) try out_stream.writeAll(", ");
                         try param_type.format("", .{}, out_stream);
                     }
-                    try out_stream.writeAll(") ");
+                    try out_stream.writeAll(") callconv(.");
+                    try out_stream.writeAll(@tagName(payload.cc));
+                    try out_stream.writeAll(")");
                     ty = payload.return_type;
                     continue;
                 },

src/zir.zig+3-6

 @@ -863,9 +863,7 @@ pub const Inst = struct {
             fn_type: *Inst,
             body: Body,
         },
-        kw_args: struct {
+        kw_args: struct {},
-            is_inline: bool = false,
-        },
     };
     pub const FnType = struct {
 @@ -875,10 +873,9 @@ pub const Inst = struct {
         positionals: struct {
             param_types: []*Inst,
             return_type: *Inst,
+            cc: *Inst,
         },
-        kw_args: struct {
+        kw_args: struct {},
-            cc: std.builtin.CallingConvention = .Unspecified,
-        },
     };
     pub const IntType = struct {

src/zir_sema.zig+13-19

 @@ -980,18 +980,8 @@ fn zirCall(mod: *Module, scope: *Scope, inst: *zir.Inst.Call) InnerError!*Inst {
     const b = try mod.requireFunctionBlock(scope, inst.base.src);
     const is_comptime_call = b.is_comptime or inst.kw_args.modifier == .compile_time;
-    const is_inline_call = is_comptime_call or inst.kw_args.modifier == .always_inline or blk: {
+    const is_inline_call = is_comptime_call or inst.kw_args.modifier == .always_inline or
-        // This logic will get simplified by
+        func.ty.fnCallingConvention() == .Inline;
-        // https://github.com/ziglang/zig/issues/6429
-        if (try mod.resolveDefinedValue(scope, func)) |func_val| {
-            const module_fn = switch (func_val.tag()) {
-                .function => func_val.castTag(.function).?.data,
-                else => break :blk false,
-            };
-            break :blk module_fn.state == .inline_only;
-        }
-        break :blk false;
-    };
     if (is_inline_call) {
         const func_val = try mod.resolveConstValue(scope, func);
         const module_fn = switch (func_val.tag()) {
 @@ -1075,7 +1065,7 @@ fn zirFn(mod: *Module, scope: *Scope, fn_inst: *zir.Inst.Fn) InnerError!*Inst {
     const fn_type = try resolveType(mod, scope, fn_inst.positionals.fn_type);
     const new_func = try scope.arena().create(Module.Fn);
     new_func.* = .{
-        .state = if (fn_inst.kw_args.is_inline) .inline_only else .queued,
+        .state = if (fn_type.fnCallingConvention() == .Inline) .inline_only else .queued,
         .zir = fn_inst.positionals.body,
         .body = undefined,
         .owner_decl = scope.ownerDecl().?,
 @@ -1305,22 +1295,26 @@ fn zirFnType(mod: *Module, scope: *Scope, fntype: *zir.Inst.FnType) InnerError!*
     const tracy = trace(@src());
     defer tracy.end();
     const return_type = try resolveType(mod, scope, fntype.positionals.return_type);
+    const cc_tv = try resolveInstConst(mod, scope, fntype.positionals.cc);
+    const cc_str = cc_tv.val.castTag(.enum_literal).?.data;
+    const cc = std.meta.stringToEnum(std.builtin.CallingConvention, cc_str) orelse
+        return mod.fail(scope, fntype.positionals.cc.src, "Unknown calling convention {s}", .{cc_str});
     // Hot path for some common function types.
     if (fntype.positionals.param_types.len == 0) {
-        if (return_type.zigTypeTag() == .NoReturn and fntype.kw_args.cc == .Unspecified) {
+        if (return_type.zigTypeTag() == .NoReturn and cc == .Unspecified) {
             return mod.constType(scope, fntype.base.src, Type.initTag(.fn_noreturn_no_args));
         }
-        if (return_type.zigTypeTag() == .Void and fntype.kw_args.cc == .Unspecified) {
+        if (return_type.zigTypeTag() == .Void and cc == .Unspecified) {
             return mod.constType(scope, fntype.base.src, Type.initTag(.fn_void_no_args));
         }
-        if (return_type.zigTypeTag() == .NoReturn and fntype.kw_args.cc == .Naked) {
+        if (return_type.zigTypeTag() == .NoReturn and cc == .Naked) {
             return mod.constType(scope, fntype.base.src, Type.initTag(.fn_naked_noreturn_no_args));
         }
-        if (return_type.zigTypeTag() == .Void and fntype.kw_args.cc == .C) {
+        if (return_type.zigTypeTag() == .Void and cc == .C) {
             return mod.constType(scope, fntype.base.src, Type.initTag(.fn_ccc_void_no_args));
         }
     }
 @@ -1337,9 +1331,9 @@ fn zirFnType(mod: *Module, scope: *Scope, fntype: *zir.Inst.FnType) InnerError!*
     }
     const fn_ty = try Type.Tag.function.create(arena, .{
-        .cc = fntype.kw_args.cc,
-        .return_type = return_type,
         .param_types = param_types,
+        .return_type = return_type,
+        .cc = cc,
     });
     return mod.constType(scope, fntype.base.src, fn_ty);
 }

test/cli.zig+1-1

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

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

...	@@ -113,7 +113,7 @@ test "assign inline fn to const variable" {	...	@@ -113,7 +113,7 @@ test "assign inline fn to const variable" {
113	a();	113	a();
114	}	114	}
115		115
116	inline fn inlineFn() void {}	116	fn inlineFn() callconv(.Inline) void {}
117		117
118	test "pass by non-copying value" {	118	test "pass by non-copying value" {
119	expect(addPointCoords(Point{ .x = 1, .y = 2 }) == 3);	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,7 +179,7 @@ pub fn addCases(ctx: *TestContext) !void {
179	\\ return y - 1;	179	\\ return y - 1;
180	\\}	180	\\}
181	\\	181	\\
182	\\inline fn rec(n: usize) usize {	182	\\fn rec(n: usize) callconv(.Inline) usize {
183	\\ if (n <= 1) return n;	183	\\ if (n <= 1) return n;
184	\\ return rec(n - 1);	184	\\ return rec(n - 1);
185	\\}	185	\\}

test/stage2/test.zig+5-5

...	@@ -255,7 +255,7 @@ pub fn addCases(ctx: *TestContext) !void {	...	@@ -255,7 +255,7 @@ pub fn addCases(ctx: *TestContext) !void {
255	\\ exit(y - 6);	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	\\ return a + b + c;	259	\\ return a + b + c;
260	\\}	260	\\}
261	\\	261	\\
...	@@ -1228,7 +1228,7 @@ pub fn addCases(ctx: *TestContext) !void {	...	@@ -1228,7 +1228,7 @@ pub fn addCases(ctx: *TestContext) !void {
1228	\\ exit(y - 6);	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	\\ if (a == 10) @compileError("bad");	1232	\\ if (a == 10) @compileError("bad");
1233	\\ return a + b + c;	1233	\\ return a + b + c;
1234	\\}	1234	\\}
...	@@ -1251,7 +1251,7 @@ pub fn addCases(ctx: *TestContext) !void {	...	@@ -1251,7 +1251,7 @@ pub fn addCases(ctx: *TestContext) !void {
1251	\\ exit(y - 6);	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	\\ if (a == 10) @compileError("bad");	1255	\\ if (a == 10) @compileError("bad");
1256	\\ return a + b + c;	1256	\\ return a + b + c;
1257	\\}	1257	\\}
...	@@ -1277,7 +1277,7 @@ pub fn addCases(ctx: *TestContext) !void {	...	@@ -1277,7 +1277,7 @@ pub fn addCases(ctx: *TestContext) !void {
1277	\\ exit(y - 21);	1277	\\ exit(y - 21);
1278	\\}	1278	\\}
1279	\\	1279	\\
1280	\\inline fn fibonacci(n: usize) usize {	1280	\\fn fibonacci(n: usize) callconv(.Inline) usize {
1281	\\ if (n <= 2) return n;	1281	\\ if (n <= 2) return n;
1282	\\ return fibonacci(n - 2) + fibonacci(n - 1);	1282	\\ return fibonacci(n - 2) + fibonacci(n - 1);
1283	\\}	1283	\\}
...	@@ -1300,7 +1300,7 @@ pub fn addCases(ctx: *TestContext) !void {	...	@@ -1300,7 +1300,7 @@ pub fn addCases(ctx: *TestContext) !void {
1300	\\ exit(y - 21);	1300	\\ exit(y - 21);
1301	\\}	1301	\\}
1302	\\	1302	\\
1303	\\inline fn fibonacci(n: usize) usize {	1303	\\fn fibonacci(n: usize) callconv(.Inline) usize {
1304	\\ if (n <= 2) return n;	1304	\\ if (n <= 2) return n;
1305	\\ return fibonacci(n - 2) + fibonacci(n - 1);	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,7 +43,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
43	,	43	,
44	\\pub const VALUE = ((((1 + (2 * 3)) + (4 * 5)) + 6) << 7) \| @boolToInt(8 == 9);	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	\\ 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);	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,7 +116,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
116	\\};	116	\\};
117	\\pub const Color = struct_Color;	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	\\ return type_1;	120	\\ return type_1;
121	\\}	121	\\}
122	,	122	,
...	@@ -148,7 +148,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -148,7 +148,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
148	cases.add("correct semicolon after infixop",	148	cases.add("correct semicolon after infixop",
149	\\#define __ferror_unlocked_body(_fp) (((_fp)->_flags & _IO_ERR_SEEN) != 0)	149	\\#define __ferror_unlocked_body(_fp) (((_fp)->_flags & _IO_ERR_SEEN) != 0)
150	, &[_][]const u8{	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	\\ return ((_fp.*._flags) & _IO_ERR_SEEN) != 0;	152	\\ return ((_fp.*._flags) & _IO_ERR_SEEN) != 0;
153	\\}	153	\\}
154	});	154	});
...	@@ -157,7 +157,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -157,7 +157,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
157	\\#define FOO(x) ((x >= 0) + (x >= 0))	157	\\#define FOO(x) ((x >= 0) + (x >= 0))
158	\\#define BAR 1 && 2 > 4	158	\\#define BAR 1 && 2 > 4
159	, &[_][]const u8{	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	\\ return @boolToInt(x >= 0) + @boolToInt(x >= 0);	161	\\ return @boolToInt(x >= 0) + @boolToInt(x >= 0);
162	\\}	162	\\}
163	,	163	,
...	@@ -208,7 +208,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -208,7 +208,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
208	\\ break :blk bar;	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	\\ return blk: {	212	\\ return blk: {
213	\\ _ = &x;	213	\\ _ = &x;
214	\\ _ = 3;	214	\\ _ = 3;
...	@@ -1590,13 +1590,13 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -1590,13 +1590,13 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
1590	, &[_][]const u8{	1590	, &[_][]const u8{
1591	\\pub extern var fn_ptr: ?fn () callconv(.C) void;	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	\\ return fn_ptr.?();	1594	\\ return fn_ptr.?();
1595	\\}	1595	\\}
1596	,	1596	,
1597	\\pub extern var fn_ptr2: ?fn (c_int, f32) callconv(.C) u8;	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	\\ return fn_ptr2.?(arg_1, arg_2);	1600	\\ return fn_ptr2.?(arg_1, arg_2);
1601	\\}	1601	\\}
1602	});	1602	});
...	@@ -1629,7 +1629,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -1629,7 +1629,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
1629	,	1629	,
1630	\\pub const glClearPFN = PFNGLCLEARPROC;	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	\\ return glProcs.gl.Clear.?(arg_2);	1633	\\ return glProcs.gl.Clear.?(arg_2);
1634	\\}	1634	\\}
1635	,	1635	,
...	@@ -1650,15 +1650,15 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -1650,15 +1650,15 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
1650	, &[_][]const u8{	1650	, &[_][]const u8{
1651	\\pub extern var c: c_int;	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	\\ return c_1 * 2;	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	\\ return L + b;	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	\\ return c * c;	1662	\\ return c * c;
1663	\\}	1663	\\}
1664	});	1664	});
...	@@ -2310,7 +2310,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -2310,7 +2310,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
2310	cases.add("macro call",	2310	cases.add("macro call",
2311	\\#define CALL(arg) bar(arg)	2311	\\#define CALL(arg) bar(arg)
2312	, &[_][]const u8{	2312	, &[_][]const u8{
2313	\\pub inline fn CALL(arg: anytype) @TypeOf(bar(arg)) {	2313	\\pub fn CALL(arg: anytype) callconv(.Inline) @TypeOf(bar(arg)) {
2314	\\ return bar(arg);	2314	\\ return bar(arg);
2315	\\}	2315	\\}
2316	});	2316	});
...	@@ -2872,7 +2872,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -2872,7 +2872,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
2872	\\#define BAR (void*) a	2872	\\#define BAR (void*) a
2873	\\#define BAZ (uint32_t)(2)	2873	\\#define BAZ (uint32_t)(2)
2874	, &[_][]const u8{	2874	, &[_][]const u8{
2875	\\pub inline fn FOO(bar: anytype) @TypeOf(baz((@import("std").meta.cast(?*c_void, baz)))) {	2875	\\pub fn FOO(bar: anytype) callconv(.Inline) @TypeOf(baz((@import("std").meta.cast(?*c_void, baz)))) {
2876	\\ return baz((@import("std").meta.cast(?*c_void, baz)));	2876	\\ return baz((@import("std").meta.cast(?*c_void, baz)));
2877	\\}	2877	\\}
2878	,	2878	,
...	@@ -2914,11 +2914,11 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -2914,11 +2914,11 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
2914	\\#define MIN(a, b) ((b) < (a) ? (b) : (a))	2914	\\#define MIN(a, b) ((b) < (a) ? (b) : (a))
2915	\\#define MAX(a, b) ((b) > (a) ? (b) : (a))	2915	\\#define MAX(a, b) ((b) > (a) ? (b) : (a))
2916	, &[_][]const u8{	2916	, &[_][]const u8{
2917	\\pub inline fn MIN(a: anytype, b: anytype) @TypeOf(if (b < a) b else a) {	2917	\\pub fn MIN(a: anytype, b: anytype) callconv(.Inline) @TypeOf(if (b < a) b else a) {
2918	\\ return if (b < a) b else a;	2918	\\ return if (b < a) b else a;
2919	\\}	2919	\\}
2920	,	2920	,
2921	\\pub inline fn MAX(a: anytype, b: anytype) @TypeOf(if (b > a) b else a) {	2921	\\pub fn MAX(a: anytype, b: anytype) callconv(.Inline) @TypeOf(if (b > a) b else a) {
2922	\\ return if (b > a) b else a;	2922	\\ return if (b > a) b else a;
2923	\\}	2923	\\}
2924	});	2924	});
...	@@ -3106,7 +3106,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -3106,7 +3106,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
3106	\\#define DefaultScreen(dpy) (((_XPrivDisplay)(dpy))->default_screen)	3106	\\#define DefaultScreen(dpy) (((_XPrivDisplay)(dpy))->default_screen)
3107	\\	3107	\\
3108	, &[_][]const u8{	3108	, &[_][]const u8{
3109	\\pub inline fn DefaultScreen(dpy: anytype) @TypeOf((@import("std").meta.cast(_XPrivDisplay, dpy)).*.default_screen) {	3109	\\pub fn DefaultScreen(dpy: anytype) callconv(.Inline) @TypeOf((@import("std").meta.cast(_XPrivDisplay, dpy)).*.default_screen) {
3110	\\ return (@import("std").meta.cast(_XPrivDisplay, dpy)).*.default_screen;	3110	\\ return (@import("std").meta.cast(_XPrivDisplay, dpy)).*.default_screen;
3111	\\}	3111	\\}
3112	});	3112	});

author	Andrew Kelley <andrew@ziglang.org> 2021-02-11 16:01:58-08:00
committer	GitHub <noreply@github.com> 2021-02-11 16:01:58-08:00
log	d3565ed6b48c9c66128f181e7b90b5348504cb3f
tree	99a03080830c1f9433046427feb18f90cade6c09
parent	d98f09e4f67fb2848be6052466db035450326605
parent	bb4f4c043e7dde4e8b9fcbf0af9329d3fd08ff7b
signature	Signed by PGP key 4AEE18F83AFDEB23

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

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

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

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

...	@@ -66,7 +66,7 @@ const CompressVectorized = struct {	...	@@ -66,7 +66,7 @@ const CompressVectorized = struct {
66	const Lane = Vector(4, u32);	66	const Lane = Vector(4, u32);
67	const Rows = [4]Lane;	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	rows[0] +%= rows[1] +% m;	70	rows[0] +%= rows[1] +% m;
71	rows[3] ^= rows[0];	71	rows[3] ^= rows[0];
72	rows[3] = math.rotr(Lane, rows[3], if (even) 8 else 16);	72	rows[3] = math.rotr(Lane, rows[3], if (even) 8 else 16);
...	@@ -75,13 +75,13 @@ const CompressVectorized = struct {	...	@@ -75,13 +75,13 @@ const CompressVectorized = struct {
75	rows[1] = math.rotr(Lane, rows[1], if (even) 7 else 12);	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	rows[0] = @shuffle(u32, rows[0], undefined, [_]i32{ 3, 0, 1, 2 });	79	rows[0] = @shuffle(u32, rows[0], undefined, [_]i32{ 3, 0, 1, 2 });
80	rows[3] = @shuffle(u32, rows[3], undefined, [_]i32{ 2, 3, 0, 1 });	80	rows[3] = @shuffle(u32, rows[3], undefined, [_]i32{ 2, 3, 0, 1 });
81	rows[2] = @shuffle(u32, rows[2], undefined, [_]i32{ 1, 2, 3, 0 });	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	rows[0] = @shuffle(u32, rows[0], undefined, [_]i32{ 1, 2, 3, 0 });	85	rows[0] = @shuffle(u32, rows[0], undefined, [_]i32{ 1, 2, 3, 0 });
86	rows[3] = @shuffle(u32, rows[3], undefined, [_]i32{ 2, 3, 0, 1 });	86	rows[3] = @shuffle(u32, rows[3], undefined, [_]i32{ 2, 3, 0, 1 });
87	rows[2] = @shuffle(u32, rows[2], undefined, [_]i32{ 3, 0, 1, 2 });	87	rows[2] = @shuffle(u32, rows[2], undefined, [_]i32{ 3, 0, 1, 2 });

...	@@ -37,7 +37,7 @@ const Salsa20VecImpl = struct {	...	@@ -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	const n1n2n3n0 = Lane{ input[3][1], input[3][2], input[3][3], input[3][0] };	41	const n1n2n3n0 = Lane{ input[3][1], input[3][2], input[3][3], input[3][0] };
42	const n1n2 = Half{ n1n2n3n0[0], n1n2n3n0[1] };	42	const n1n2 = Half{ n1n2n3n0[0], n1n2n3n0[1] };
43	const n3n0 = Half{ n1n2n3n0[2], n1n2n3n0[3] };	43	const n3n0 = Half{ n1n2n3n0[2], n1n2n3n0[3] };
...	@@ -211,7 +211,7 @@ const Salsa20NonVecImpl = struct {	...	@@ -211,7 +211,7 @@ const Salsa20NonVecImpl = struct {
211	d: u6,	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	return QuarterRound{	215	return QuarterRound{
216	.a = a,	216	.a = a,
217	.b = b,	217	.b = b,
...	@@ -220,7 +220,7 @@ const Salsa20NonVecImpl = struct {	...	@@ -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	const arx_steps = comptime [_]QuarterRound{	224	const arx_steps = comptime [_]QuarterRound{
225	Rp(4, 0, 12, 7), Rp(8, 4, 0, 9), Rp(12, 8, 4, 13), Rp(0, 12, 8, 18),	225	Rp(4, 0, 12, 7), Rp(8, 4, 0, 9), Rp(12, 8, 4, 13), Rp(0, 12, 8, 18),
226	Rp(9, 5, 1, 7), Rp(13, 9, 5, 9), Rp(1, 13, 9, 13), Rp(5, 1, 13, 18),	226	Rp(9, 5, 1, 7), Rp(13, 9, 5, 9), Rp(1, 13, 9, 13), Rp(5, 1, 13, 18),

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

...	@@ -2355,17 +2355,17 @@ test "zig fmt: functions" {	...	@@ -2355,17 +2355,17 @@ test "zig fmt: functions" {
2355	\\extern fn puts(s: *const u8) c_int;	2355	\\extern fn puts(s: *const u8) c_int;
2356	\\extern "c" fn puts(s: *const u8) c_int;	2356	\\extern "c" fn puts(s: *const u8) c_int;
2357	\\export fn puts(s: *const u8) c_int;	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	\\noinline fn puts(s: *const u8) c_int;	2359	\\noinline fn puts(s: *const u8) c_int;
2360	\\pub extern fn puts(s: *const u8) c_int;	2360	\\pub extern fn puts(s: *const u8) c_int;
2361	\\pub extern "c" fn puts(s: *const u8) c_int;	2361	\\pub extern "c" fn puts(s: *const u8) c_int;
2362	\\pub export fn puts(s: *const u8) c_int;	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	\\pub noinline fn puts(s: *const u8) c_int;	2364	\\pub noinline fn puts(s: *const u8) c_int;
2365	\\pub extern fn puts(s: *const u8) align(2 + 2) c_int;	2365	\\pub extern fn puts(s: *const u8) align(2 + 2) c_int;
2366	\\pub extern "c" fn puts(s: *const u8) align(2 + 2) c_int;	2366	\\pub extern "c" fn puts(s: *const u8) align(2 + 2) c_int;
2367	\\pub export fn puts(s: *const u8) align(2 + 2) c_int;	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	\\pub noinline fn puts(s: *const u8) align(2 + 2) c_int;	2369	\\pub noinline fn puts(s: *const u8) align(2 + 2) c_int;
2370	\\	2370	\\
2371	);	2371	);

Merge pull request #7749 from tadeokondrak/6429-callconv-inline