misc: add restrict qualifier to get more optimization opportunities

hexian000 · hexian000 · commit a742dbed45aa · 2025-02-20T15:04:21.000+08:00
Signed-off-by: He Xian &lt;hexian000@outlook.com&gt;
diff --git a/contrib/csnippets/utils/debug.c b/contrib/csnippets/utils/debug.c
@@ -29,11 +29,11 @@
 
 #define INDENT "  "
 
-void slog_extra_txt(FILE *restrict f, void *data)
+void slog_extra_txt(FILE *restrict f, void *restrict data)
 {
-	const struct slog_extra_txt *restrict extra = data;
+	const struct slog_extra_txt *extra = data;
 	size_t n = extra->len;
-	const char *s = extra->data;
+	const char *restrict s = extra->data;
 	struct {
 		BUFFER_HDR;
 		unsigned char data[256];
@@ -118,9 +118,9 @@ void slog_extra_txt(FILE *restrict f, void *data)
 	}
 }
 
-void slog_extra_bin(FILE *restrict f, void *data)
+void slog_extra_bin(FILE *restrict f, void *restrict data)
 {
-	const struct slog_extra_bin *restrict extra = data;
+	const struct slog_extra_bin *extra = data;
 	size_t n = extra->len;
 	struct {
 		BUFFER_HDR;
diff --git a/contrib/csnippets/utils/serialize.h b/contrib/csnippets/utils/serialize.h
@@ -11,97 +11,97 @@
 
 #include <stdint.h>
 
-static inline uint_least8_t read_uint8(const void *p)
+static inline uint_least8_t read_uint8(const void *restrict p)
 {
-	const unsigned char *restrict b = p;
+	const unsigned char *b = p;
 	return b[0];
 }
 
-static inline void write_uint8(void *p, uint_least8_t v)
+static inline void write_uint8(void *restrict p, uint_least8_t v)
 {
-	unsigned char *restrict b = p;
+	unsigned char *b = p;
 	b[0] = v;
 }
 
-static inline uint_least16_t read_uint16(const void *p)
+static inline uint_least16_t read_uint16(const void *restrict p)
 {
-	const unsigned char *restrict b = p;
+	const unsigned char *b = p;
 	return (((uint_fast16_t)b[0]) << 8U) | ((uint_fast16_t)b[1]);
 }
 
-static inline uint_least16_t read_uint16_le(const void *p)
+static inline uint_least16_t read_uint16_le(const void *restrict p)
 {
-	const unsigned char *restrict b = p;
+	const unsigned char *b = p;
 	return (((uint_fast16_t)b[0])) | ((uint_fast16_t)b[1] << 8U);
 }
 
-static inline void write_uint16(void *p, uint_least16_t v)
+static inline void write_uint16(void *restrict p, uint_least16_t v)
 {
-	unsigned char *restrict b = p;
+	unsigned char *b = p;
 	b[0] = (unsigned char)(v >> 8U);
 	b[1] = (unsigned char)v;
 }
 
-static inline void write_uint16_le(void *p, uint_least16_t v)
+static inline void write_uint16_le(void *restrict p, uint_least16_t v)
 {
-	unsigned char *restrict b = p;
+	unsigned char *b = p;
 	b[0] = (unsigned char)v;
 	b[1] = (unsigned char)(v >> 8U);
 }
 
-static inline uint_least32_t read_uint32(const void *p)
+static inline uint_least32_t read_uint32(const void *restrict p)
 {
-	const unsigned char *restrict b = p;
+	const unsigned char *b = p;
 	return (uint_fast32_t)(b[0]) << 24U | (uint_fast32_t)(b[1]) << 16U |
 	       (uint_fast32_t)(b[2]) << 8U | (uint_fast32_t)(b[3]);
 }
 
-static inline uint_least32_t read_uint32_le(const void *p)
+static inline uint_least32_t read_uint32_le(const void *restrict p)
 {
-	const unsigned char *restrict b = p;
+	const unsigned char *b = p;
 	return (uint_fast32_t)(b[0]) | (uint_fast32_t)(b[1]) << 8U |
 	       (uint_fast32_t)(b[2]) << 16U | (uint_fast32_t)(b[3]) << 24U;
 }
 
-static inline void write_uint32(void *p, uint_least32_t v)
+static inline void write_uint32(void *restrict p, uint_least32_t v)
 {
-	unsigned char *restrict b = p;
+	unsigned char *b = p;
 	b[0] = (unsigned char)(v >> 24U);
 	b[1] = (unsigned char)(v >> 16U);
 	b[2] = (unsigned char)(v >> 8U);
 	b[3] = (unsigned char)v;
 }
 
-static inline void write_uint32_le(void *p, uint_least32_t v)
+static inline void write_uint32_le(void *restrict p, uint_least32_t v)
 {
-	unsigned char *restrict b = p;
+	unsigned char *b = p;
 	b[0] = (unsigned char)v;
 	b[1] = (unsigned char)(v >> 8U);
 	b[2] = (unsigned char)(v >> 16U);
 	b[3] = (unsigned char)(v >> 24U);
 }
 
-static inline uint_least64_t read_uint64(const void *p)
+static inline uint_least64_t read_uint64(const void *restrict p)
 {
-	const unsigned char *restrict b = p;
+	const unsigned char *b = p;
 	return (uint_fast64_t)(b[0]) << 56U | (uint_fast64_t)(b[1]) << 48U |
 	       (uint_fast64_t)(b[2]) << 40U | (uint_fast64_t)(b[3]) << 32U |
 	       (uint_fast64_t)(b[4]) << 24U | (uint_fast64_t)(b[5]) << 16U |
 	       (uint_fast64_t)(b[6]) << 8U | (uint_fast64_t)(b[7]);
 }
 
-static inline uint_least64_t read_uint64_le(const void *p)
+static inline uint_least64_t read_uint64_le(const void *restrict p)
 {
-	const unsigned char *restrict b = p;
+	const unsigned char *b = p;
 	return (uint_fast64_t)(b[0]) | (uint_fast64_t)(b[1]) << 8U |
 	       (uint_fast64_t)(b[2]) << 16U | (uint_fast64_t)(b[3]) << 24U |
 	       (uint_fast64_t)(b[4]) << 32U | (uint_fast64_t)(b[5]) << 40U |
 	       (uint_fast64_t)(b[6]) << 48U | (uint_fast64_t)(b[7]) << 56U;
 }
 
-static inline void write_uint64(void *p, uint_least64_t v)
+static inline void write_uint64(void *restrict p, uint_least64_t v)
 {
-	unsigned char *restrict b = p;
+	unsigned char *b = p;
 	b[0] = (unsigned char)(v >> 56U);
 	b[1] = (unsigned char)(v >> 48U);
 	b[2] = (unsigned char)(v >> 40U);
@@ -112,9 +112,9 @@ static inline void write_uint64(void *p, uint_least64_t v)
 	b[7] = (unsigned char)v;
 }
 
-static inline void write_uint64_le(void *p, uint_least64_t v)
+static inline void write_uint64_le(void *restrict p, uint_least64_t v)
 {
-	unsigned char *restrict b = p;
+	unsigned char *b = p;
 	b[0] = (unsigned char)v;
 	b[1] = (unsigned char)(v >> 8U);
 	b[2] = (unsigned char)(v >> 16U);
diff --git a/src/obfs.c b/src/obfs.c
@@ -1569,7 +1569,7 @@ void obfs_ctx_auth(struct obfs_ctx *restrict ctx, const bool ok)
 
 static void obfs_accept_one(
 	struct obfs *restrict obfs, struct ev_loop *loop, const int fd,
-	struct sockaddr *sa, socklen_t len)
+	struct sockaddr *restrict sa, socklen_t len)
 {
 	struct obfs_ctx *restrict ctx = obfs_ctx_new(obfs);
 	if (ctx == NULL) {
@@ -1614,7 +1614,8 @@ static bool is_startup_limited(struct obfs *restrict obfs)
 	return false;
 }
 
-void obfs_accept_cb(struct ev_loop *loop, struct ev_io *watcher, int revents)
+void obfs_accept_cb(
+	struct ev_loop *loop, struct ev_io *restrict watcher, int revents)
 {
 	CHECK_REVENTS(revents, EV_READ);
 
diff --git a/src/session.h b/src/session.h
@@ -104,7 +104,7 @@ struct session {
 
 #define SESSION_MAKEKEY(key, sa, conv)                                         \
 	do {                                                                   \
-		unsigned char *p = (key);                                      \
+		unsigned char *restrict p = (key);                             \
 		size_t size = SESSION_KEY_SIZE;                                \
 		const size_t n = getsocklen(sa);                               \
 		write_uint32(p, conv);                                         \
diff --git a/src/sockutil.c b/src/sockutil.c
@@ -177,7 +177,9 @@ static bool sa_matches_inet6(
 	return true;
 }
 
-bool sa_matches(const struct sockaddr *bind, const struct sockaddr *dest)
+bool sa_matches(
+	const struct sockaddr *restrict bind,
+	const struct sockaddr *restrict dest)
 {
 	const int domain = bind->sa_family;
 	if (domain != dest->sa_family) {
@@ -198,8 +200,9 @@ bool sa_matches(const struct sockaddr *bind, const struct sockaddr *dest)
 	FAIL();
 }
 
-static int
-format_sa_inet(char *s, const size_t maxlen, const struct sockaddr_in *sa)
+static int format_sa_inet(
+	char *restrict s, const size_t maxlen,
+	const struct sockaddr_in *restrict sa)
 {
 	char buf[INET_ADDRSTRLEN];
 	if (inet_ntop(AF_INET, &(sa->sin_addr), buf, sizeof(buf)) == NULL) {
@@ -209,8 +212,9 @@ format_sa_inet(char *s, const size_t maxlen, const struct sockaddr_in *sa)
 	return snprintf(s, maxlen, "%s:%" PRIu16, buf, port);
 }
 
-static int
-format_sa_inet6(char *s, const size_t maxlen, const struct sockaddr_in6 *sa)
+static int format_sa_inet6(
+	char *restrict s, const size_t maxlen,
+	const struct sockaddr_in6 *restrict sa)
 {
 	char buf[INET6_ADDRSTRLEN];
 	if (inet_ntop(AF_INET6, &(sa->sin6_addr), buf, sizeof(buf)) == NULL) {
@@ -225,7 +229,9 @@ format_sa_inet6(char *s, const size_t maxlen, const struct sockaddr_in6 *sa)
 		s, maxlen, "[%s%%%" PRIu32 "]:%" PRIu16, buf, scope, port);
 }
 
-int format_sa(char *s, const size_t maxlen, const struct sockaddr *sa)
+int format_sa(
+	char *restrict s, const size_t maxlen,
+	const struct sockaddr *restrict sa)
 {
 	switch (sa->sa_family) {
 	case AF_INET:
@@ -238,7 +244,8 @@ int format_sa(char *s, const size_t maxlen, const struct sockaddr *sa)
 	return snprintf(s, maxlen, "<af:%jd>", (intmax_t)sa->sa_family);
 }
 
-static bool find_addrinfo(union sockaddr_max *sa, const struct addrinfo *it)
+static bool find_addrinfo(
+	union sockaddr_max *restrict sa, const struct addrinfo *restrict it)
 {
 	for (; it != NULL; it = it->ai_next) {
 		switch (it->ai_family) {
@@ -261,7 +268,9 @@ static bool find_addrinfo(union sockaddr_max *sa, const struct addrinfo *it)
 /* RFC 1035: Section 2.3.4 */
 #define FQDN_MAX_LENGTH ((size_t)(255))
 
-bool resolve_addr(union sockaddr_max *sa, const char *s, const int flags)
+bool resolve_addr(
+	union sockaddr_max *restrict sa, const char *restrict s,
+	const int flags)
 {
 	const size_t addrlen = strlen(s);
 	ASSERT(addrlen <= FQDN_MAX_LENGTH + 1 + 5);
diff --git a/src/util.c b/src/util.c
@@ -182,7 +182,7 @@ void genpsk(const char *method)
 }
 #endif
 
-bool parse_user(struct user_ident *ident, const char *s)
+bool parse_user(struct user_ident *restrict ident, const char *restrict s)
 {
 	const size_t len = strlen(s);
 	if (len >= 1024) {
@@ -294,7 +294,8 @@ void drop_privileges(const struct user_ident *restrict ident)
 }
 
 void daemonize(
-	const struct user_ident *ident, const bool nochdir, const bool noclose)
+	const struct user_ident *restrict ident, const bool nochdir,
+	const bool noclose)
 {
 	/* Create an anonymous pipe for communicating with daemon process. */
 	int fd[2];

Original file line number	Diff line number	Diff line change
`@@ -29,11 +29,11 @@`
`29`	`29`
`30`	`30`	`#define INDENT " "`
`31`	`31`
`32`		`-void slog_extra_txt(FILE restrict f, void data)`
	`32`	`+void slog_extra_txt(FILE restrict f, void restrict data)`
`33`	`33`	`{`
`34`		`- const struct slog_extra_txt *restrict extra = data;`
	`34`	`+ const struct slog_extra_txt *extra = data;`
`35`	`35`	`size_t n = extra->len;`
`36`		`- const char *s = extra->data;`
	`36`	`+ const char *restrict s = extra->data;`
`37`	`37`	`struct {`
`38`	`38`	`BUFFER_HDR;`
`39`	`39`	`unsigned char data[256];`
`@@ -118,9 +118,9 @@ void slog_extra_txt(FILE restrict f, void data)`
`118`	`118`	`}`
`119`	`119`	`}`
`120`	`120`
`121`		`-void slog_extra_bin(FILE restrict f, void data)`
	`121`	`+void slog_extra_bin(FILE restrict f, void restrict data)`
`122`	`122`	`{`
`123`		`- const struct slog_extra_bin *restrict extra = data;`
	`123`	`+ const struct slog_extra_bin *extra = data;`
`124`	`124`	`size_t n = extra->len;`
`125`	`125`	`struct {`
`126`	`126`	`BUFFER_HDR;`
Original file line number	Diff line number	Diff line change
`@@ -11,97 +11,97 @@`
`11`	`11`
`12`	`12`	`#include <stdint.h>`
`13`	`13`
`14`		`-static inline uint_least8_t read_uint8(const void *p)`
	`14`	`+static inline uint_least8_t read_uint8(const void *restrict p)`
`15`	`15`	`{`
`16`		`- const unsigned char *restrict b = p;`
	`16`	`+ const unsigned char *b = p;`
`17`	`17`	`return b[0];`
`18`	`18`	`}`
`19`	`19`
`20`		`-static inline void write_uint8(void *p, uint_least8_t v)`
	`20`	`+static inline void write_uint8(void *restrict p, uint_least8_t v)`
`21`	`21`	`{`
`22`		`- unsigned char *restrict b = p;`
	`22`	`+ unsigned char *b = p;`
`23`	`23`	`b[0] = v;`
`24`	`24`	`}`
`25`	`25`
`26`		`-static inline uint_least16_t read_uint16(const void *p)`
	`26`	`+static inline uint_least16_t read_uint16(const void *restrict p)`
`27`	`27`	`{`
`28`		`- const unsigned char *restrict b = p;`
	`28`	`+ const unsigned char *b = p;`
`29`	`29`	`return (((uint_fast16_t)b[0]) << 8U) \| ((uint_fast16_t)b[1]);`
`30`	`30`	`}`
`31`	`31`
`32`		`-static inline uint_least16_t read_uint16_le(const void *p)`
	`32`	`+static inline uint_least16_t read_uint16_le(const void *restrict p)`
`33`	`33`	`{`
`34`		`- const unsigned char *restrict b = p;`
	`34`	`+ const unsigned char *b = p;`
`35`	`35`	`return (((uint_fast16_t)b[0])) \| ((uint_fast16_t)b[1] << 8U);`
`36`	`36`	`}`
`37`	`37`
`38`		`-static inline void write_uint16(void *p, uint_least16_t v)`
	`38`	`+static inline void write_uint16(void *restrict p, uint_least16_t v)`
`39`	`39`	`{`
`40`		`- unsigned char *restrict b = p;`
	`40`	`+ unsigned char *b = p;`
`41`	`41`	`b[0] = (unsigned char)(v >> 8U);`
`42`	`42`	`b[1] = (unsigned char)v;`
`43`	`43`	`}`
`44`	`44`
`45`		`-static inline void write_uint16_le(void *p, uint_least16_t v)`
	`45`	`+static inline void write_uint16_le(void *restrict p, uint_least16_t v)`
`46`	`46`	`{`
`47`		`- unsigned char *restrict b = p;`
	`47`	`+ unsigned char *b = p;`
`48`	`48`	`b[0] = (unsigned char)v;`
`49`	`49`	`b[1] = (unsigned char)(v >> 8U);`
`50`	`50`	`}`
`51`	`51`
`52`		`-static inline uint_least32_t read_uint32(const void *p)`
	`52`	`+static inline uint_least32_t read_uint32(const void *restrict p)`
`53`	`53`	`{`
`54`		`- const unsigned char *restrict b = p;`
	`54`	`+ const unsigned char *b = p;`
`55`	`55`	`return (uint_fast32_t)(b[0]) << 24U \| (uint_fast32_t)(b[1]) << 16U \|`
`56`	`56`	`(uint_fast32_t)(b[2]) << 8U \| (uint_fast32_t)(b[3]);`
`57`	`57`	`}`
`58`	`58`
`59`		`-static inline uint_least32_t read_uint32_le(const void *p)`
	`59`	`+static inline uint_least32_t read_uint32_le(const void *restrict p)`
`60`	`60`	`{`
`61`		`- const unsigned char *restrict b = p;`
	`61`	`+ const unsigned char *b = p;`
`62`	`62`	`return (uint_fast32_t)(b[0]) \| (uint_fast32_t)(b[1]) << 8U \|`
`63`	`63`	`(uint_fast32_t)(b[2]) << 16U \| (uint_fast32_t)(b[3]) << 24U;`
`64`	`64`	`}`
`65`	`65`
`66`		`-static inline void write_uint32(void *p, uint_least32_t v)`
	`66`	`+static inline void write_uint32(void *restrict p, uint_least32_t v)`
`67`	`67`	`{`
`68`		`- unsigned char *restrict b = p;`
	`68`	`+ unsigned char *b = p;`
`69`	`69`	`b[0] = (unsigned char)(v >> 24U);`
`70`	`70`	`b[1] = (unsigned char)(v >> 16U);`
`71`	`71`	`b[2] = (unsigned char)(v >> 8U);`
`72`	`72`	`b[3] = (unsigned char)v;`
`73`	`73`	`}`
`74`	`74`
`75`		`-static inline void write_uint32_le(void *p, uint_least32_t v)`
	`75`	`+static inline void write_uint32_le(void *restrict p, uint_least32_t v)`
`76`	`76`	`{`
`77`		`- unsigned char *restrict b = p;`
	`77`	`+ unsigned char *b = p;`
`78`	`78`	`b[0] = (unsigned char)v;`
`79`	`79`	`b[1] = (unsigned char)(v >> 8U);`
`80`	`80`	`b[2] = (unsigned char)(v >> 16U);`
`81`	`81`	`b[3] = (unsigned char)(v >> 24U);`
`82`	`82`	`}`
`83`	`83`
`84`		`-static inline uint_least64_t read_uint64(const void *p)`
	`84`	`+static inline uint_least64_t read_uint64(const void *restrict p)`
`85`	`85`	`{`
`86`		`- const unsigned char *restrict b = p;`
	`86`	`+ const unsigned char *b = p;`
`87`	`87`	`return (uint_fast64_t)(b[0]) << 56U \| (uint_fast64_t)(b[1]) << 48U \|`
`88`	`88`	`(uint_fast64_t)(b[2]) << 40U \| (uint_fast64_t)(b[3]) << 32U \|`
`89`	`89`	`(uint_fast64_t)(b[4]) << 24U \| (uint_fast64_t)(b[5]) << 16U \|`
`90`	`90`	`(uint_fast64_t)(b[6]) << 8U \| (uint_fast64_t)(b[7]);`
`91`	`91`	`}`
`92`	`92`
`93`		`-static inline uint_least64_t read_uint64_le(const void *p)`
	`93`	`+static inline uint_least64_t read_uint64_le(const void *restrict p)`
`94`	`94`	`{`
`95`		`- const unsigned char *restrict b = p;`
	`95`	`+ const unsigned char *b = p;`
`96`	`96`	`return (uint_fast64_t)(b[0]) \| (uint_fast64_t)(b[1]) << 8U \|`
`97`	`97`	`(uint_fast64_t)(b[2]) << 16U \| (uint_fast64_t)(b[3]) << 24U \|`
`98`	`98`	`(uint_fast64_t)(b[4]) << 32U \| (uint_fast64_t)(b[5]) << 40U \|`
`99`	`99`	`(uint_fast64_t)(b[6]) << 48U \| (uint_fast64_t)(b[7]) << 56U;`
`100`	`100`	`}`
`101`	`101`
`102`		`-static inline void write_uint64(void *p, uint_least64_t v)`
	`102`	`+static inline void write_uint64(void *restrict p, uint_least64_t v)`
`103`	`103`	`{`
`104`		`- unsigned char *restrict b = p;`
	`104`	`+ unsigned char *b = p;`
`105`	`105`	`b[0] = (unsigned char)(v >> 56U);`
`106`	`106`	`b[1] = (unsigned char)(v >> 48U);`
`107`	`107`	`b[2] = (unsigned char)(v >> 40U);`
`@@ -112,9 +112,9 @@ static inline void write_uint64(void *p, uint_least64_t v)`
`112`	`112`	`b[7] = (unsigned char)v;`
`113`	`113`	`}`
`114`	`114`
`115`		`-static inline void write_uint64_le(void *p, uint_least64_t v)`
	`115`	`+static inline void write_uint64_le(void *restrict p, uint_least64_t v)`
`116`	`116`	`{`
`117`		`- unsigned char *restrict b = p;`
	`117`	`+ unsigned char *b = p;`
`118`	`118`	`b[0] = (unsigned char)v;`
`119`	`119`	`b[1] = (unsigned char)(v >> 8U);`
`120`	`120`	`b[2] = (unsigned char)(v >> 16U);`
Original file line number	Diff line number	Diff line change
`@@ -1569,7 +1569,7 @@ void obfs_ctx_auth(struct obfs_ctx *restrict ctx, const bool ok)`
`1569`	`1569`
`1570`	`1570`	`static void obfs_accept_one(`
`1571`	`1571`	`struct obfs restrict obfs, struct ev_loop loop, const int fd,`
`1572`		`- struct sockaddr *sa, socklen_t len)`
	`1572`	`+ struct sockaddr *restrict sa, socklen_t len)`
`1573`	`1573`	`{`
`1574`	`1574`	`struct obfs_ctx *restrict ctx = obfs_ctx_new(obfs);`
`1575`	`1575`	`if (ctx == NULL) {`
`@@ -1614,7 +1614,8 @@ static bool is_startup_limited(struct obfs *restrict obfs)`
`1614`	`1614`	`return false;`
`1615`	`1615`	`}`
`1616`	`1616`
`1617`		`-void obfs_accept_cb(struct ev_loop loop, struct ev_io watcher, int revents)`
	`1617`	`+void obfs_accept_cb(`
	`1618`	`+ struct ev_loop loop, struct ev_io restrict watcher, int revents)`
`1618`	`1619`	`{`
`1619`	`1620`	`CHECK_REVENTS(revents, EV_READ);`
`1620`	`1621`
Original file line number	Diff line number	Diff line change
`@@ -177,7 +177,9 @@ static bool sa_matches_inet6(`
`177`	`177`	`return true;`
`178`	`178`	`}`
`179`	`179`
`180`		`-bool sa_matches(const struct sockaddr bind, const struct sockaddr dest)`
	`180`	`+bool sa_matches(`
	`181`	`+ const struct sockaddr *restrict bind,`
	`182`	`+ const struct sockaddr *restrict dest)`
`181`	`183`	`{`
`182`	`184`	`const int domain = bind->sa_family;`
`183`	`185`	`if (domain != dest->sa_family) {`
`@@ -198,8 +200,9 @@ bool sa_matches(const struct sockaddr bind, const struct sockaddr dest)`
`198`	`200`	`FAIL();`
`199`	`201`	`}`
`200`	`202`
`201`		`-static int`
`202`		`-format_sa_inet(char s, const size_t maxlen, const struct sockaddr_in sa)`
	`203`	`+static int format_sa_inet(`
	`204`	`+ char *restrict s, const size_t maxlen,`
	`205`	`+ const struct sockaddr_in *restrict sa)`
`203`	`206`	`{`
`204`	`207`	`char buf[INET_ADDRSTRLEN];`
`205`	`208`	`if (inet_ntop(AF_INET, &(sa->sin_addr), buf, sizeof(buf)) == NULL) {`
`@@ -209,8 +212,9 @@ format_sa_inet(char s, const size_t maxlen, const struct sockaddr_in sa)`
`209`	`212`	`return snprintf(s, maxlen, "%s:%" PRIu16, buf, port);`
`210`	`213`	`}`
`211`	`214`
`212`		`-static int`
`213`		`-format_sa_inet6(char s, const size_t maxlen, const struct sockaddr_in6 sa)`
	`215`	`+static int format_sa_inet6(`
	`216`	`+ char *restrict s, const size_t maxlen,`
	`217`	`+ const struct sockaddr_in6 *restrict sa)`
`214`	`218`	`{`
`215`	`219`	`char buf[INET6_ADDRSTRLEN];`
`216`	`220`	`if (inet_ntop(AF_INET6, &(sa->sin6_addr), buf, sizeof(buf)) == NULL) {`
`@@ -225,7 +229,9 @@ format_sa_inet6(char s, const size_t maxlen, const struct sockaddr_in6 sa)`
`225`	`229`	`s, maxlen, "[%s%%%" PRIu32 "]:%" PRIu16, buf, scope, port);`
`226`	`230`	`}`
`227`	`231`
`228`		`-int format_sa(char s, const size_t maxlen, const struct sockaddr sa)`
	`232`	`+int format_sa(`
	`233`	`+ char *restrict s, const size_t maxlen,`
	`234`	`+ const struct sockaddr *restrict sa)`
`229`	`235`	`{`
`230`	`236`	`switch (sa->sa_family) {`
`231`	`237`	`case AF_INET:`
`@@ -238,7 +244,8 @@ int format_sa(char s, const size_t maxlen, const struct sockaddr sa)`
`238`	`244`	`return snprintf(s, maxlen, "<af:%jd>", (intmax_t)sa->sa_family);`
`239`	`245`	`}`
`240`	`246`
`241`		`-static bool find_addrinfo(union sockaddr_max sa, const struct addrinfo it)`
	`247`	`+static bool find_addrinfo(`
	`248`	`+ union sockaddr_max restrict sa, const struct addrinfo restrict it)`
`242`	`249`	`{`
`243`	`250`	`for (; it != NULL; it = it->ai_next) {`
`244`	`251`	`switch (it->ai_family) {`
`@@ -261,7 +268,9 @@ static bool find_addrinfo(union sockaddr_max sa, const struct addrinfo it)`
`261`	`268`	`/* RFC 1035: Section 2.3.4 */`
`262`	`269`	`#define FQDN_MAX_LENGTH ((size_t)(255))`
`263`	`270`
`264`		`-bool resolve_addr(union sockaddr_max sa, const char s, const int flags)`
	`271`	`+bool resolve_addr(`
	`272`	`+ union sockaddr_max restrict sa, const char restrict s,`
	`273`	`+ const int flags)`
`265`	`274`	`{`
`266`	`275`	`const size_t addrlen = strlen(s);`
`267`	`276`	`ASSERT(addrlen <= FQDN_MAX_LENGTH + 1 + 5);`
Original file line number	Diff line number	Diff line change
`@@ -182,7 +182,7 @@ void genpsk(const char *method)`
`182`	`182`	`}`
`183`	`183`	`#endif`
`184`	`184`
`185`		`-bool parse_user(struct user_ident ident, const char s)`
	`185`	`+bool parse_user(struct user_ident restrict ident, const char restrict s)`
`186`	`186`	`{`
`187`	`187`	`const size_t len = strlen(s);`
`188`	`188`	`if (len >= 1024) {`
`@@ -294,7 +294,8 @@ void drop_privileges(const struct user_ident *restrict ident)`
`294`	`294`	`}`
`295`	`295`
`296`	`296`	`void daemonize(`
`297`		`- const struct user_ident *ident, const bool nochdir, const bool noclose)`
	`297`	`+ const struct user_ident *restrict ident, const bool nochdir,`
	`298`	`+ const bool noclose)`
`298`	`299`	`{`
`299`	`300`	`/* Create an anonymous pipe for communicating with daemon process. */`
`300`	`301`	`int fd[2];`