cleanup: make get_error.c files more readable

Make get_error.c files more self-sustained.  While they are still being
included by syscall.c, the latter no longer defines get_error function.

* linux/aarch64/get_error.c: Include "arm/get_error.c" with get_error
temporarily defined to arm_get_error.
(get_error): Define.
* linux/alpha/get_error.c (get_error): Define.
* linux/arc/get_error.c: Likewise.
* linux/arm/get_error.c: Likewise.
* linux/avr32/get_error.c: Likewise.
* linux/bfin/get_error.c: Likewise.
* linux/crisv10/get_error.c: Likewise.
* linux/hppa/get_error.c: Likewise.
* linux/i386/get_error.c: Likewise.
* linux/ia64/get_error.c: Likewise.
* linux/m68k/get_error.c: Likewise.
* linux/metag/get_error.c: Likewise.
* linux/microblaze/get_error.c: Likewise.
* linux/mips/get_error.c: Likewise.
* linux/nios2/get_error.c: Likewise.
* linux/or1k/get_error.c: Likewise.
* linux/powerpc/get_error.c: Likewise.
* linux/s390/get_error.c: Likewise.
* linux/sh/get_error.c: Likewise.
* linux/sh64/get_error.c: Likewise.
* linux/sparc/get_error.c: Likewise.
* linux/sparc64/get_error.c: Likewise.
* linux/tile/get_error.c: Likewise.
* linux/x86_64/get_error.c: Likewise.
* linux/xtensa/get_error.c: Likewise.
* syscall.c: Include "get_error.c" in file scope.
(get_error): Remove.  Move arch independent code ...
(get_syscall_result): ... here.  Update get_error invocation.

Requested-by: Denys Vlasenko <dvlasenk@redhat.com>

diff --git a/linux/aarch64/get_error.c b/linux/aarch64/get_error.c
index 7dd67790f179639bb83b04f92009ddb032f73a11..c5c0f69cc2c9cdc0b3d4d6ec039a30bc94c4e8b7 100644 (file)
--- a/linux/aarch64/get_error.c
+++ b/linux/aarch64/get_error.c
@@ -1,10 +1,19 @@
-if (tcp->currpers == 1) {
+#define get_error arm_get_error
+#include "arm/get_error.c"
+#undef get_error
+
+static void
+get_error(struct tcb *tcp, const bool check_errno)
+{
+       if (tcp->currpers == 0) {
+               arm_get_error(tcp, check_errno);
+               return;
+       }
+
        if (check_errno && is_negated_errno(aarch64_regs.regs[0])) {
                tcp->u_rval = -1;
                tcp->u_error = -aarch64_regs.regs[0];
        } else {
                tcp->u_rval = aarch64_regs.regs[0];
        }
-} else {
-#include "arm/get_error.c"
 }

diff --git a/linux/alpha/get_error.c b/linux/alpha/get_error.c
index 5b615a52900ca9ec4a67a5059ad1afe0dade8cde..ddf3dae9c5175f8634ebf4290bc772b0dc94eddb 100644 (file)
--- a/linux/alpha/get_error.c
+++ b/linux/alpha/get_error.c
@@ -1,6 +1,10 @@
-if (check_errno && alpha_a3) {
-       tcp->u_rval = -1;
-       tcp->u_error = alpha_r0;
-} else {
-       tcp->u_rval = alpha_r0;
+static void
+get_error(struct tcb *tcp, const bool check_errno)
+{
+       if (check_errno && alpha_a3) {
+               tcp->u_rval = -1;
+               tcp->u_error = alpha_r0;
+       } else {
+               tcp->u_rval = alpha_r0;
+       }
 }

diff --git a/linux/arc/get_error.c b/linux/arc/get_error.c
index 1741c179090b02696727edb7170fcee24b7ff147..e19debc10e86eada2a749ddcb4dd823195b788a0 100644 (file)
--- a/linux/arc/get_error.c
+++ b/linux/arc/get_error.c
@@ -1,6 +1,10 @@
-if (check_errno && is_negated_errno(arc_regs.scratch.r0)) {
-       tcp->u_rval = -1;
-       tcp->u_error = -arc_regs.scratch.r0;
-} else {
-       tcp->u_rval = arc_regs.scratch.r0;
+static void
+get_error(struct tcb *tcp, const bool check_errno)
+{
+       if (check_errno && is_negated_errno(arc_regs.scratch.r0)) {
+               tcp->u_rval = -1;
+               tcp->u_error = -arc_regs.scratch.r0;
+       } else {
+               tcp->u_rval = arc_regs.scratch.r0;
+       }
 }

diff --git a/linux/arm/get_error.c b/linux/arm/get_error.c
index d2ae09b10817dff3134290c63d933527f5841071..fa81dd76fb0606ccf520d480aa07410dca80b18b 100644 (file)
--- a/linux/arm/get_error.c
+++ b/linux/arm/get_error.c
@@ -1,6 +1,10 @@
-if (check_errno && is_negated_errno(arm_regs.ARM_r0)) {
-       tcp->u_rval = -1;
-       tcp->u_error = -arm_regs.ARM_r0;
-} else {
-       tcp->u_rval = arm_regs.ARM_r0;
+static void
+get_error(struct tcb *tcp, const bool check_errno)
+{
+       if (check_errno && is_negated_errno(arm_regs.ARM_r0)) {
+               tcp->u_rval = -1;
+               tcp->u_error = -arm_regs.ARM_r0;
+       } else {
+               tcp->u_rval = arm_regs.ARM_r0;
+       }
 }

diff --git a/linux/avr32/get_error.c b/linux/avr32/get_error.c
index ef445844b48fe5216a75e6b7aba79ba57ce9acc1..75e7f67f6364f116c37c2c915bdae06bb5c1a0d0 100644 (file)
--- a/linux/avr32/get_error.c
+++ b/linux/avr32/get_error.c
@@ -1,6 +1,10 @@
-if (check_errno && is_negated_errno(avr32_regs.r12)) {
-       tcp->u_rval = -1;
-       tcp->u_error = -avr32_regs.r12;
-} else {
-       tcp->u_rval = avr32_regs.r12;
+static void
+get_error(struct tcb *tcp, const bool check_errno)
+{
+       if (check_errno && is_negated_errno(avr32_regs.r12)) {
+               tcp->u_rval = -1;
+               tcp->u_error = -avr32_regs.r12;
+       } else {
+               tcp->u_rval = avr32_regs.r12;
+       }
 }

diff --git a/linux/bfin/get_error.c b/linux/bfin/get_error.c
index d7ff24767de72153425e29e4a2b1e5511363efee..80aeb377f788b4fc99df9750a8a36a226946a987 100644 (file)
--- a/linux/bfin/get_error.c
+++ b/linux/bfin/get_error.c
@@ -1,6 +1,10 @@
-if (check_errno && is_negated_errno(bfin_r0)) {
-       tcp->u_rval = -1;
-       tcp->u_error = -bfin_r0;
-} else {
-       tcp->u_rval = bfin_r0;
+static void
+get_error(struct tcb *tcp, const bool check_errno)
+{
+       if (check_errno && is_negated_errno(bfin_r0)) {
+               tcp->u_rval = -1;
+               tcp->u_error = -bfin_r0;
+       } else {
+               tcp->u_rval = bfin_r0;
+       }
 }

diff --git a/linux/crisv10/get_error.c b/linux/crisv10/get_error.c
index 3f947ae6c69e71f8169ebf312ef91f9cd3ed89fa..b9da923f8b7a80dc4e605283db0486bc37b68edd 100644 (file)
--- a/linux/crisv10/get_error.c
+++ b/linux/crisv10/get_error.c
@@ -1,6 +1,10 @@
-if (check_errno && is_negated_errno(cris_r10)) {
-       tcp->u_rval = -1;
-       tcp->u_error = -cris_r10;
-} else {
-       tcp->u_rval = cris_r10;
+static void
+get_error(struct tcb *tcp, const bool check_errno)
+{
+       if (check_errno && is_negated_errno(cris_r10)) {
+               tcp->u_rval = -1;
+               tcp->u_error = -cris_r10;
+       } else {
+               tcp->u_rval = cris_r10;
+       }
 }

diff --git a/linux/hppa/get_error.c b/linux/hppa/get_error.c
index 901aa54509f92da75e9aa2d3f54707082918898a..a2a7c0ea662b2df49bd622432d08bce871251fc2 100644 (file)
--- a/linux/hppa/get_error.c
+++ b/linux/hppa/get_error.c
@@ -1,6 +1,10 @@
-if (check_errno && is_negated_errno(hppa_r28)) {
-       tcp->u_rval = -1;
-       tcp->u_error = -hppa_r28;
-} else {
-       tcp->u_rval = hppa_r28;
+static void
+get_error(struct tcb *tcp, const bool check_errno)
+{
+       if (check_errno && is_negated_errno(hppa_r28)) {
+               tcp->u_rval = -1;
+               tcp->u_error = -hppa_r28;
+       } else {
+               tcp->u_rval = hppa_r28;
+       }
 }

diff --git a/linux/i386/get_error.c b/linux/i386/get_error.c
index 465118b265dd67761acef9aadb0dadc0d8f35f5e..1f63605e107f9b66c32a1c31dc35b9dce15aeaab 100644 (file)
--- a/linux/i386/get_error.c
+++ b/linux/i386/get_error.c
@@ -1,6 +1,10 @@
-if (check_errno && is_negated_errno(i386_regs.eax)) {
-       tcp->u_rval = -1;
-       tcp->u_error = -i386_regs.eax;
-} else {
-       tcp->u_rval = i386_regs.eax;
+static void
+get_error(struct tcb *tcp, const bool check_errno)
+{
+       if (check_errno && is_negated_errno(i386_regs.eax)) {
+               tcp->u_rval = -1;
+               tcp->u_error = -i386_regs.eax;
+       } else {
+               tcp->u_rval = i386_regs.eax;
+       }
 }

diff --git a/linux/ia64/get_error.c b/linux/ia64/get_error.c
index fb6b9f4a834a1fd1cf9d2965789641fc581d8fba..09dfdef6866e68381074045e23ea0697f5a6675a 100644 (file)
--- a/linux/ia64/get_error.c
+++ b/linux/ia64/get_error.c
@@ -1,16 +1,20 @@
-if (ia64_ia32mode) {
-       int err = ia64_regs.gr[8];
-       if (check_errno && is_negated_errno(err)) {
-               tcp->u_rval = -1;
-               tcp->u_error = -err;
+static void
+get_error(struct tcb *tcp, const bool check_errno)
+{
+       if (ia64_ia32mode) {
+               int err = ia64_regs.gr[8];
+               if (check_errno && is_negated_errno(err)) {
+                       tcp->u_rval = -1;
+                       tcp->u_error = -err;
+               } else {
+                       tcp->u_rval = err;
+               }
        } else {
-               tcp->u_rval = err;
-       }
-} else {
-       if (check_errno && ia64_regs.gr[10]) {
-               tcp->u_rval = -1;
-               tcp->u_error = ia64_regs.gr[8];
-       } else {
-               tcp->u_rval = ia64_regs.gr[8];
+               if (check_errno && ia64_regs.gr[10]) {
+                       tcp->u_rval = -1;
+                       tcp->u_error = ia64_regs.gr[8];
+               } else {
+                       tcp->u_rval = ia64_regs.gr[8];
+               }
        }
 }

diff --git a/linux/m68k/get_error.c b/linux/m68k/get_error.c
index 8bf5359b0efc8aa41d8ddca8033ccb37414ddd10..a792835d4a19772ec0271d1281aa587d80346fdc 100644 (file)
--- a/linux/m68k/get_error.c
+++ b/linux/m68k/get_error.c
@@ -1,6 +1,10 @@
-if (check_errno && is_negated_errno(m68k_d0)) {
-       tcp->u_rval = -1;
-       tcp->u_error = -m68k_d0;
-} else {
-       tcp->u_rval = m68k_d0;
+static void
+get_error(struct tcb *tcp, const bool check_errno)
+{
+       if (check_errno && is_negated_errno(m68k_d0)) {
+               tcp->u_rval = -1;
+               tcp->u_error = -m68k_d0;
+       } else {
+               tcp->u_rval = m68k_d0;
+       }
 }

diff --git a/linux/metag/get_error.c b/linux/metag/get_error.c
index 809eec54c4b2a0a8f69e1186e0a807fc4417c3fe..b7d287f9a09f6c781ac8790867469b0c3b38f384 100644 (file)
--- a/linux/metag/get_error.c
+++ b/linux/metag/get_error.c
@@ -1,7 +1,11 @@
-/* result pointer in D0Re0 (D0.0) */
-if (check_errno && is_negated_errno(metag_regs.dx[0][0])) {
-       tcp->u_rval = -1;
-       tcp->u_error = -metag_regs.dx[0][0];
-} else {
-       tcp->u_rval = metag_regs.dx[0][0];
+static void
+get_error(struct tcb *tcp, const bool check_errno)
+{
+       /* result pointer in D0Re0 (D0.0) */
+       if (check_errno && is_negated_errno(metag_regs.dx[0][0])) {
+               tcp->u_rval = -1;
+               tcp->u_error = -metag_regs.dx[0][0];
+       } else {
+               tcp->u_rval = metag_regs.dx[0][0];
+       }
 }

diff --git a/linux/microblaze/get_error.c b/linux/microblaze/get_error.c
index d36e281c55ec9ef840e40d1a6b02f91ed15f4a5e..878e24f67e2a23b47ffc45a1e4ff923f67b13573 100644 (file)
--- a/linux/microblaze/get_error.c
+++ b/linux/microblaze/get_error.c
@@ -1,6 +1,10 @@
-if (check_errno && is_negated_errno(microblaze_r3)) {
-       tcp->u_rval = -1;
-       tcp->u_error = -microblaze_r3;
-} else {
-       tcp->u_rval = microblaze_r3;
+static void
+get_error(struct tcb *tcp, const bool check_errno)
+{
+       if (check_errno && is_negated_errno(microblaze_r3)) {
+               tcp->u_rval = -1;
+               tcp->u_error = -microblaze_r3;
+       } else {
+               tcp->u_rval = microblaze_r3;
+       }
 }

diff --git a/linux/mips/get_error.c b/linux/mips/get_error.c
index e934af08f11d072e549b0cb5118d3f873585d7b4..e58055e132d02e127c9b25509d23eabd39626e74 100644 (file)
--- a/linux/mips/get_error.c
+++ b/linux/mips/get_error.c
@@ -1,9 +1,14 @@
-if (check_errno && mips_REG_A3) {
-       tcp->u_rval = -1;
-       tcp->u_error = mips_REG_V0;
-} else {
-# if defined LINUX_MIPSN32
-       tcp->u_lrval = mips_REG_V0;
-# endif
-       tcp->u_rval = mips_REG_V0;
+static void
+get_error(struct tcb *tcp, const bool check_errno)
+{
+       if (check_errno && mips_REG_A3) {
+               tcp->u_rval = -1;
+               tcp->u_error = mips_REG_V0;
+       } else {
+               tcp->u_rval = mips_REG_V0;
+#ifdef LINUX_MIPSN32
+               /* tcp->u_rval contains a truncated value */
+               tcp->u_lrval = mips_REG_V0;
+#endif
+       }
 }

diff --git a/linux/nios2/get_error.c b/linux/nios2/get_error.c
index 5d7e6db69e30df66703a35b8493ab747aef77c9f..52c05ad916a26902bf05a4c5459ca241aff4a1eb 100644 (file)
--- a/linux/nios2/get_error.c
+++ b/linux/nios2/get_error.c
@@ -1,13 +1,17 @@
-/*
- * The system call convention specifies that r2 contains the return
- * value on success or a positive error number on failure.  A flag
- * indicating successful completion is written to r7; r7=0 indicates
- * the system call success, r7=1 indicates an error.  The positive
- * errno value written in r2.
- */
-if (check_errno && nios2_regs.regs[7]) {
-       tcp->u_rval = -1;
-       tcp->u_error = nios2_regs.regs[2];
-} else {
-       tcp->u_rval = nios2_regs.regs[2];
+static void
+get_error(struct tcb *tcp, const bool check_errno)
+{
+       /*
+        * The system call convention specifies that r2 contains the return
+        * value on success or a positive error number on failure.  A flag
+        * indicating successful completion is written to r7; r7=0 indicates
+        * the system call success, r7=1 indicates an error.  The positive
+        * errno value written in r2.
+        */
+       if (check_errno && nios2_regs.regs[7]) {
+               tcp->u_rval = -1;
+               tcp->u_error = nios2_regs.regs[2];
+       } else {
+               tcp->u_rval = nios2_regs.regs[2];
+       }
 }

diff --git a/linux/or1k/get_error.c b/linux/or1k/get_error.c
index cbf9a6eb1afd35633f9285774e179543b199838a..40e00bf4652e9ee0542c4e1306a989011d1bea8c 100644 (file)
--- a/linux/or1k/get_error.c
+++ b/linux/or1k/get_error.c
@@ -1,6 +1,10 @@
-if (check_errno && is_negated_errno(or1k_regs.gpr[11])) {
-       tcp->u_rval = -1;
-       tcp->u_error = -or1k_regs.gpr[11];
-} else {
-       tcp->u_rval = or1k_regs.gpr[11];
+static void
+get_error(struct tcb *tcp, const bool check_errno)
+{
+       if (check_errno && is_negated_errno(or1k_regs.gpr[11])) {
+               tcp->u_rval = -1;
+               tcp->u_error = -or1k_regs.gpr[11];
+       } else {
+               tcp->u_rval = or1k_regs.gpr[11];
+       }
 }

diff --git a/linux/powerpc/get_error.c b/linux/powerpc/get_error.c
index f0f0a4e71f9dae583aaecccf2bd1b18858761456..41506fb72419047c42d267a83b02cedc6b49bfb4 100644 (file)
--- a/linux/powerpc/get_error.c
+++ b/linux/powerpc/get_error.c
@@ -1,6 +1,10 @@
-if (check_errno && (ppc_regs.ccr & 0x10000000)) {
-       tcp->u_rval = -1;
-       tcp->u_error = ppc_regs.gpr[3];
-} else {
-       tcp->u_rval = ppc_regs.gpr[3];
+static void
+get_error(struct tcb *tcp, const bool check_errno)
+{
+       if (check_errno && (ppc_regs.ccr & 0x10000000)) {
+               tcp->u_rval = -1;
+               tcp->u_error = ppc_regs.gpr[3];
+       } else {
+               tcp->u_rval = ppc_regs.gpr[3];
+       }
 }

diff --git a/linux/s390/get_error.c b/linux/s390/get_error.c
index 29fffbd196c8767fdd1b705a6d3426de62959a7d..f491962de8cc92907b8b3f261f430cebe0c64518 100644 (file)
--- a/linux/s390/get_error.c
+++ b/linux/s390/get_error.c
@@ -1,6 +1,10 @@
-if (check_errno && is_negated_errno(s390_regset.gprs[2])) {
-       tcp->u_rval = -1;
-       tcp->u_error = -s390_regset.gprs[2];
-} else {
-       tcp->u_rval = s390_regset.gprs[2];
+static void
+get_error(struct tcb *tcp, const bool check_errno)
+{
+       if (check_errno && is_negated_errno(s390_regset.gprs[2])) {
+               tcp->u_rval = -1;
+               tcp->u_error = -s390_regset.gprs[2];
+       } else {
+               tcp->u_rval = s390_regset.gprs[2];
+       }
 }

diff --git a/linux/sh/get_error.c b/linux/sh/get_error.c
index 2375e3c836aa0d9dfb150fc518bab010a6bb81e2..158ff9e6ce48f9b15d83d92cf63704a6dd64aeed 100644 (file)
--- a/linux/sh/get_error.c
+++ b/linux/sh/get_error.c
@@ -1,6 +1,10 @@
-if (check_errno && is_negated_errno(sh_r0)) {
-       tcp->u_rval = -1;
-       tcp->u_error = -sh_r0;
-} else {
-       tcp->u_rval = sh_r0;
+static void
+get_error(struct tcb *tcp, const bool check_errno)
+{
+       if (check_errno && is_negated_errno(sh_r0)) {
+               tcp->u_rval = -1;
+               tcp->u_error = -sh_r0;
+       } else {
+               tcp->u_rval = sh_r0;
+       }
 }

diff --git a/linux/sh64/get_error.c b/linux/sh64/get_error.c
index 9e8aeafb0957f3636cad00b23b913d7ad88310e1..7858df7c2697fd197d1ed741509c22908cb8737b 100644 (file)
--- a/linux/sh64/get_error.c
+++ b/linux/sh64/get_error.c
@@ -1,6 +1,10 @@
-if (check_errno && is_negated_errno(sh64_r9)) {
-       tcp->u_rval = -1;
-       tcp->u_error = -sh64_r9;
-} else {
-       tcp->u_rval = sh64_r9;
+static void
+get_error(struct tcb *tcp, const bool check_errno)
+{
+       if (check_errno && is_negated_errno(sh64_r9)) {
+               tcp->u_rval = -1;
+               tcp->u_error = -sh64_r9;
+       } else {
+               tcp->u_rval = sh64_r9;
+       }
 }

diff --git a/linux/sparc/get_error.c b/linux/sparc/get_error.c
index 3531f01cccccc1bea2567098da35d13fd0c27528..fa57ed091a93661a3efb87698eb0dfcb714aa2e2 100644 (file)
--- a/linux/sparc/get_error.c
+++ b/linux/sparc/get_error.c
@@ -1,6 +1,10 @@
-if (check_errno && sparc_regs.psr & PSR_C) {
-       tcp->u_rval = -1;
-       tcp->u_error = sparc_regs.u_regs[U_REG_O0];
-} else {
-       tcp->u_rval = sparc_regs.u_regs[U_REG_O0];
+static void
+get_error(struct tcb *tcp, const bool check_errno)
+{
+       if (check_errno && sparc_regs.psr & PSR_C) {
+               tcp->u_rval = -1;
+               tcp->u_error = sparc_regs.u_regs[U_REG_O0];
+       } else {
+               tcp->u_rval = sparc_regs.u_regs[U_REG_O0];
+       }
 }

diff --git a/linux/sparc64/get_error.c b/linux/sparc64/get_error.c
index ee3a7e50f706cb3ef4ec68cb4f3d255f9c256451..bacd04fbdc8fe90e6711c7176d79ea9594e80734 100644 (file)
--- a/linux/sparc64/get_error.c
+++ b/linux/sparc64/get_error.c
@@ -1,6 +1,10 @@
-if (check_errno && sparc_regs.tstate & 0x1100000000UL) {
-       tcp->u_rval = -1;
-       tcp->u_error = sparc_regs.u_regs[U_REG_O0];
-} else {
-       tcp->u_rval = sparc_regs.u_regs[U_REG_O0];
+static void
+get_error(struct tcb *tcp, const bool check_errno)
+{
+       if (check_errno && sparc_regs.tstate & 0x1100000000UL) {
+               tcp->u_rval = -1;
+               tcp->u_error = sparc_regs.u_regs[U_REG_O0];
+       } else {
+               tcp->u_rval = sparc_regs.u_regs[U_REG_O0];
+       }
 }

diff --git a/linux/tile/get_error.c b/linux/tile/get_error.c
index 8b73dfa20911f7a82e8060387b5a6efbd9aae70f..9949af4f24a5fd7f27b5f8b667055ecf838e5aeb 100644 (file)
--- a/linux/tile/get_error.c
+++ b/linux/tile/get_error.c
@@ -1,12 +1,16 @@
-/*
- * The standard tile calling convention returns the value (or negative
- * errno) in r0, and zero (or positive errno) in r1.
- * Until at least kernel 3.8, however, the r1 value is not reflected
- * in ptregs at this point, so we use r0 here.
- */
-if (check_errno && is_negated_errno(tile_regs.regs[0])) {
-       tcp->u_rval = -1;
-       tcp->u_error = -tile_regs.regs[0];
-} else {
-       tcp->u_rval = tile_regs.regs[0];
+static void
+get_error(struct tcb *tcp, const bool check_errno)
+{
+       /*
+        * The standard tile calling convention returns the value
+        * (or negative errno) in r0, and zero (or positive errno) in r1.
+        * Until at least kernel 3.8, however, the r1 value is not
+        * reflected in ptregs at this point, so we use r0 here.
+        */
+       if (check_errno && is_negated_errno(tile_regs.regs[0])) {
+               tcp->u_rval = -1;
+               tcp->u_error = -tile_regs.regs[0];
+       } else {
+               tcp->u_rval = tile_regs.regs[0];
+       }
 }

diff --git a/linux/x86_64/get_error.c b/linux/x86_64/get_error.c
index 29b78163e690c4462919107f19c1fe816ca2999a..ddf78b7cae509e2c72492373b6d5942f6bd93a4c 100644 (file)
--- a/linux/x86_64/get_error.c
+++ b/linux/x86_64/get_error.c
@@ -1,23 +1,27 @@
-/*
- * In X32, return value is 64-bit (llseek uses one).
- * Using merely "long rax" would not work.
- */
-long long rax;
+static void
+get_error(struct tcb *tcp, const bool check_errno)
+{
+       /*
+        * In X32, return value is 64-bit (llseek uses one).
+        * Using merely "long rax" would not work.
+        */
+       long long rax;
 
-if (x86_io.iov_len == sizeof(i386_regs)) {
-       /* Sign extend from 32 bits */
-       rax = (int32_t) i386_regs.eax;
-} else {
-       rax = x86_64_regs.rax;
-}
+       if (x86_io.iov_len == sizeof(i386_regs)) {
+               /* Sign extend from 32 bits */
+               rax = (int32_t) i386_regs.eax;
+       } else {
+               rax = x86_64_regs.rax;
+       }
 
-if (check_errno && is_negated_errno(rax)) {
-       tcp->u_rval = -1;
-       tcp->u_error = -rax;
-} else {
-       tcp->u_rval = rax;
-# ifdef X32
-       /* tcp->u_rval contains a truncated value */
-       tcp->u_lrval = rax;
-# endif
+       if (check_errno && is_negated_errno(rax)) {
+               tcp->u_rval = -1;
+               tcp->u_error = -rax;
+       } else {
+               tcp->u_rval = rax;
+#ifdef X32
+               /* tcp->u_rval contains a truncated value */
+               tcp->u_lrval = rax;
+#endif
+       }
 }

diff --git a/linux/xtensa/get_error.c b/linux/xtensa/get_error.c
index 6efbb6e17e44dd5685269df0510fd391dd16ef92..51ccd3b84cdaa837a198d6ce86aa602cfdc48b4c 100644 (file)
--- a/linux/xtensa/get_error.c
+++ b/linux/xtensa/get_error.c
@@ -1,6 +1,10 @@
-if (check_errno && is_negated_errno(xtensa_a2)) {
-       tcp->u_rval = -1;
-       tcp->u_error = -xtensa_a2;
-} else {
-       tcp->u_rval = xtensa_a2;
+static void
+get_error(struct tcb *tcp, const bool check_errno)
+{
+       if (check_errno && is_negated_errno(xtensa_a2)) {
+               tcp->u_rval = -1;
+               tcp->u_error = -xtensa_a2;
+       } else {
+               tcp->u_rval = xtensa_a2;
+       }
 }

diff --git a/syscall.c b/syscall.c
index d603c5cc1b101f1c25a0eda679494266e104d0b8..34627f255793e1664a2460b9779e21a29874962b 100644 (file)
--- a/syscall.c
+++ b/syscall.c
@@ -1343,14 +1343,7 @@ get_syscall_args(struct tcb *tcp)
        return 1;
 }
 
-static void
-get_error(struct tcb *tcp)
-{
-       const bool check_errno = !(tcp->s_ent->sys_flags & SYSCALL_NEVER_FAILS);
-       tcp->u_error = 0;
-
 #include "get_error.c"
-}
 
 /* Returns:
  * 1: ok, continue in trace_syscall_exiting().
@@ -1365,6 +1358,8 @@ get_syscall_result(struct tcb *tcp)
 #else
 # include "get_syscall_result.c"
 #endif
-       get_error(tcp);
+       tcp->u_error = 0;
+       get_error(tcp, !(tcp->s_ent->sys_flags & SYSCALL_NEVER_FAILS));
+
        return 1;
 }