lists.openwall.net   lists  /  announce  owl-users  owl-dev  john-users  john-dev  passwdqc-users  yescrypt  popa3d-users  /  oss-security  kernel-hardening  musl  sabotage  tlsify  passwords  /  crypt-dev  xvendor  /  Bugtraq  Full-Disclosure  linux-kernel  linux-netdev  linux-ext4  linux-hardening  linux-cve-announce  PHC 
Open Source and information security mailing list archives
 
Hash Suite: Windows password security audit tool. GUI, reports in PDF.
[<prev] [next>] [<thread-prev] [thread-next>] [day] [month] [year] [list]
Message-Id: <20220324073039.140946-6-ammarfaizi2@gnuweeb.org>
Date:   Thu, 24 Mar 2022 14:30:33 +0700
From:   Ammar Faizi <ammarfaizi2@...weeb.org>
To:     Willy Tarreau <w@....eu>
Cc:     "Paul E. McKenney" <paulmck@...nel.org>,
        Alviro Iskandar Setiawan <alviro.iskandar@...weeb.org>,
        Nugraha <richiisei@...il.com>,
        Linux Kernel Mailing List <linux-kernel@...r.kernel.org>,
        GNU/Weeb Mailing List <gwml@...r.gnuweeb.org>,
        Ammar Faizi <ammarfaizi2@...weeb.org>,
        David Laight <David.Laight@...LAB.COM>
Subject: [PATCH v1 05/11] tools/nolibc: i386: Use appropriate register constraints if exist

Use appropriate register constraints if exist. Don't use register
variables for all inputs.

Register variables with "r" constraint should be used when we need to
pass data through a specific register to extended inline assembly that
doesn't have a specific register constraint associated with it (anything
outside %eax, %ebx, %ecx, %edx, %esi, %edi).

It also simplifies the macro definition.

Link: https://lore.kernel.org/lkml/3d2cfdeecddc45dc8e4beada305b5948@AcuMS.aculab.com
Suggested-by: David Laight <David.Laight@...LAB.COM>
Signed-off-by: Ammar Faizi <ammarfaizi2@...weeb.org>
---
 tools/include/nolibc/arch-i386.h | 162 +++++++++++++------------------
 1 file changed, 70 insertions(+), 92 deletions(-)

diff --git a/tools/include/nolibc/arch-i386.h b/tools/include/nolibc/arch-i386.h
index ff2e6bb453cf..6eb96ee8c4f7 100644
--- a/tools/include/nolibc/arch-i386.h
+++ b/tools/include/nolibc/arch-i386.h
@@ -63,108 +63,86 @@ struct sys_stat_struct {
  */
 #define __ARCH_WANT_SYS_OLD_SELECT
 
-#define my_syscall0(num)                                                      \
-({                                                                            \
-	long _ret;                                                            \
-	register long _num __asm__("eax") = (num);                            \
-	                                                                      \
-	__asm__ volatile (                                                    \
-		"int $0x80\n"                                                 \
-		: "=a" (_ret)                                                 \
-		: "0"(_num)                                                   \
-		: "memory", "cc"                                              \
-	);                                                                    \
-	_ret;                                                                 \
+#define my_syscall0(num)				\
+({							\
+	long _ret = (num);				\
+	__asm__ volatile (				\
+		"int $0x80\n"				\
+		: "+a"(_ret)	/* %eax */		\
+		:					\
+		: "memory", "cc"			\
+	);						\
+	_ret;						\
 })
 
-#define my_syscall1(num, arg1)                                                \
-({                                                                            \
-	long _ret;                                                            \
-	register long _num __asm__("eax") = (num);                            \
-	register long _arg1 __asm__("ebx") = (long)(arg1);                    \
-	                                                                      \
-	__asm__ volatile (                                                    \
-		"int $0x80\n"                                                 \
-		: "=a" (_ret)                                                 \
-		: "r"(_arg1),                                                 \
-		  "0"(_num)                                                   \
-		: "memory", "cc"                                              \
-	);                                                                    \
-	_ret;                                                                 \
+#define my_syscall1(num, arg1)				\
+({							\
+	long _ret = (num);				\
+	__asm__ volatile (				\
+		"int $0x80\n"				\
+		: "+a"(_ret)	/* %eax */		\
+		: "b"(arg1)	/* %ebx */		\
+		: "memory", "cc"			\
+	);						\
+	_ret;						\
 })
 
-#define my_syscall2(num, arg1, arg2)                                          \
-({                                                                            \
-	long _ret;                                                            \
-	register long _num __asm__("eax") = (num);                            \
-	register long _arg1 __asm__("ebx") = (long)(arg1);                    \
-	register long _arg2 __asm__("ecx") = (long)(arg2);                    \
-	                                                                      \
-	__asm__ volatile (                                                    \
-		"int $0x80\n"                                                 \
-		: "=a" (_ret)                                                 \
-		: "r"(_arg1), "r"(_arg2),                                     \
-		  "0"(_num)                                                   \
-		: "memory", "cc"                                              \
-	);                                                                    \
-	_ret;                                                                 \
+#define my_syscall2(num, arg1, arg2)			\
+({							\
+	long _ret = (num);				\
+	__asm__ volatile (				\
+		"int $0x80\n"				\
+		: "+a"(_ret)	/* %eax */		\
+		: "b"(arg1),	/* %ebx */		\
+		  "c"(arg2)	/* %ecx */		\
+		: "memory", "cc"			\
+	);						\
+	_ret;						\
 })
 
-#define my_syscall3(num, arg1, arg2, arg3)                                    \
-({                                                                            \
-	long _ret;                                                            \
-	register long _num __asm__("eax") = (num);                            \
-	register long _arg1 __asm__("ebx") = (long)(arg1);                    \
-	register long _arg2 __asm__("ecx") = (long)(arg2);                    \
-	register long _arg3 __asm__("edx") = (long)(arg3);                    \
-	                                                                      \
-	__asm__ volatile (                                                    \
-		"int $0x80\n"                                                 \
-		: "=a" (_ret)                                                 \
-		: "r"(_arg1), "r"(_arg2), "r"(_arg3),                         \
-		  "0"(_num)                                                   \
-		: "memory", "cc"                                              \
-	);                                                                    \
-	_ret;                                                                 \
+#define my_syscall3(num, arg1, arg2, arg3)		\
+({							\
+	long _ret = (num);				\
+	__asm__ volatile (				\
+		"int $0x80\n"				\
+		: "+a"(_ret)	/* %eax */		\
+		: "b"(arg1),	/* %ebx */		\
+		  "c"(arg2),	/* %ecx */		\
+		  "d"(arg3)	/* %edx */		\
+		: "memory", "cc"			\
+	);						\
+	_ret;						\
 })
 
-#define my_syscall4(num, arg1, arg2, arg3, arg4)                              \
-({                                                                            \
-	long _ret;                                                            \
-	register long _num __asm__("eax") = (num);                            \
-	register long _arg1 __asm__("ebx") = (long)(arg1);                    \
-	register long _arg2 __asm__("ecx") = (long)(arg2);                    \
-	register long _arg3 __asm__("edx") = (long)(arg3);                    \
-	register long _arg4 __asm__("esi") = (long)(arg4);                    \
-	                                                                      \
-	__asm__ volatile (                                                    \
-		"int $0x80\n"                                                 \
-		: "=a" (_ret)                                                 \
-		: "r"(_arg1), "r"(_arg2), "r"(_arg3), "r"(_arg4),             \
-		  "0"(_num)                                                   \
-		: "memory", "cc"                                              \
-	);                                                                    \
-	_ret;                                                                 \
+#define my_syscall4(num, arg1, arg2, arg3, arg4)	\
+({							\
+	long _ret = (num);				\
+	__asm__ volatile (				\
+		"int $0x80\n"				\
+		: "+a"(_ret)	/* %eax */		\
+		: "b"(arg1),	/* %ebx */		\
+		  "c"(arg2),	/* %ecx */		\
+		  "d"(arg3),	/* %edx */		\
+		  "S"(arg4)	/* %esi */		\
+		: "memory", "cc"			\
+	);						\
+	_ret;						\
 })
 
-#define my_syscall5(num, arg1, arg2, arg3, arg4, arg5)                        \
-({                                                                            \
-	long _ret;                                                            \
-	register long _num __asm__("eax") = (num);                            \
-	register long _arg1 __asm__("ebx") = (long)(arg1);                    \
-	register long _arg2 __asm__("ecx") = (long)(arg2);                    \
-	register long _arg3 __asm__("edx") = (long)(arg3);                    \
-	register long _arg4 __asm__("esi") = (long)(arg4);                    \
-	register long _arg5 __asm__("edi") = (long)(arg5);                    \
-	                                                                      \
-	__asm__ volatile (                                                    \
-		"int $0x80\n"                                                 \
-		: "=a" (_ret)                                                 \
-		: "r"(_arg1), "r"(_arg2), "r"(_arg3), "r"(_arg4), "r"(_arg5), \
-		  "0"(_num)                                                   \
-		: "memory", "cc"                                              \
-	);                                                                    \
-	_ret;                                                                 \
+#define my_syscall5(num, arg1, arg2, arg3, arg4, arg5)	\
+({							\
+	long _ret = (num);				\
+	__asm__ volatile (				\
+		"int $0x80\n"				\
+		: "+a"(_ret)	/* %eax */		\
+		: "b"(arg1),	/* %ebx */		\
+		  "c"(arg2),	/* %ecx */		\
+		  "d"(arg3),	/* %edx */		\
+		  "S"(arg4),	/* %esi */		\
+		  "D"(arg5)	/* %edi */		\
+		: "memory", "cc"			\
+	);						\
+	_ret;						\
 })
 
 /* startup code */
-- 
Ammar Faizi

Powered by blists - more mailing lists

Powered by Openwall GNU/*/Linux Powered by OpenVZ