From 985b8342244b5f76ed1df75eb8757d6feff30316 Mon Sep 17 00:00:00 2001

From: Blue Swirl <blauwirbel@gmail.com>

Date: Sun, 2 Sep 2012 07:33:30 +0000

Subject: [PATCH] target-s390x: fix style

Before splitting op_helper.c and helper.c in the next patches,

fix style issues. No functional changes.

Replace also GCC specific __FUNCTION__ with

standard __func__.

Don't init static variable (cpu_s390x_init:inited) with 0.

Signed-off-by: Blue Swirl <blauwirbel@gmail.com>

Signed-off-by: Alexander Graf <agraf@suse.de>

Signed-off-by: Michael Roth <mdroth@linux.vnet.ibm.com>

---

 target-s390x/helper.c    |  96 ++++++-----

 target-s390x/op_helper.c | 438 +++++++++++++++++++++++++++--------------------

 2 files changed, 297 insertions(+), 237 deletions(-)

diff --git a/target-s390x/helper.c b/target-s390x/helper.c

index d0a1180..d98e6d9 100644

--- a/target-s390x/helper.c

+++ b/target-s390x/helper.c

@@ -74,7 +74,7 @@ S390CPU *cpu_s390x_init(const char *cpu_model)

 {

     S390CPU *cpu;

     CPUS390XState *env;

-    static int inited = 0;

+    static int inited;

     cpu = S390_CPU(object_new(TYPE_S390_CPU));

     env = &cpu->env;

@@ -91,25 +91,27 @@ S390CPU *cpu_s390x_init(const char *cpu_model)

 #if defined(CONFIG_USER_ONLY)

-void do_interrupt (CPUS390XState *env)

+void do_interrupt(CPUS390XState *env)

 {

     env->exception_index = -1;

 }

-int cpu_s390x_handle_mmu_fault (CPUS390XState *env, target_ulong address, int rw,

-                                int mmu_idx)

+int cpu_s390x_handle_mmu_fault(CPUS390XState *env, target_ulong address,

+                               int rw, int mmu_idx)

 {

-    /* fprintf(stderr,"%s: address 0x%lx rw %d mmu_idx %d\n",

-            __FUNCTION__, address, rw, mmu_idx); */

+    /* fprintf(stderr, "%s: address 0x%lx rw %d mmu_idx %d\n",

+       __func__, address, rw, mmu_idx); */

     env->exception_index = EXCP_ADDR;

-    env->__excp_addr = address; /* FIXME: find out how this works on a real machine */

+    /* FIXME: find out how this works on a real machine */

+    env->__excp_addr = address;

     return 1;

 }

 #else /* !CONFIG_USER_ONLY */

 /* Ensure to exit the TB after this call! */

-static void trigger_pgm_exception(CPUS390XState *env, uint32_t code, uint32_t ilc)

+static void trigger_pgm_exception(CPUS390XState *env, uint32_t code,

+                                  uint32_t ilc)

 {

     env->exception_index = EXCP_PGM;

     env->int_pgm_code = code;

@@ -138,19 +140,20 @@ static int trans_bits(CPUS390XState *env, uint64_t mode)

     return bits;

 }

-static void trigger_prot_fault(CPUS390XState *env, target_ulong vaddr, uint64_t mode)

+static void trigger_prot_fault(CPUS390XState *env, target_ulong vaddr,

+                               uint64_t mode)

 {

     int ilc = ILC_LATER_INC_2;

     int bits = trans_bits(env, mode) | 4;

-    DPRINTF("%s: vaddr=%016" PRIx64 " bits=%d\n", __FUNCTION__, vaddr, bits);

+    DPRINTF("%s: vaddr=%016" PRIx64 " bits=%d\n", __func__, vaddr, bits);

     stq_phys(env->psa + offsetof(LowCore, trans_exc_code), vaddr | bits);

     trigger_pgm_exception(env, PGM_PROTECTION, ilc);

 }

-static void trigger_page_fault(CPUS390XState *env, target_ulong vaddr, uint32_t type,

-                               uint64_t asc, int rw)

+static void trigger_page_fault(CPUS390XState *env, target_ulong vaddr,

+                               uint32_t type, uint64_t asc, int rw)

 {

     int ilc = ILC_LATER;

     int bits = trans_bits(env, asc);

@@ -160,26 +163,26 @@ static void trigger_page_fault(CPUS390XState *env, target_ulong vaddr, uint32_t

         ilc = 2;

     }

-    DPRINTF("%s: vaddr=%016" PRIx64 " bits=%d\n", __FUNCTION__, vaddr, bits);

+    DPRINTF("%s: vaddr=%016" PRIx64 " bits=%d\n", __func__, vaddr, bits);

     stq_phys(env->psa + offsetof(LowCore, trans_exc_code), vaddr | bits);

     trigger_pgm_exception(env, type, ilc);

 }

-static int mmu_translate_asce(CPUS390XState *env, target_ulong vaddr, uint64_t asc,

-                              uint64_t asce, int level, target_ulong *raddr,

-                              int *flags, int rw)

+static int mmu_translate_asce(CPUS390XState *env, target_ulong vaddr,

+                              uint64_t asc, uint64_t asce, int level,

+                              target_ulong *raddr, int *flags, int rw)

 {

     uint64_t offs = 0;

     uint64_t origin;

     uint64_t new_asce;

-    PTE_DPRINTF("%s: 0x%" PRIx64 "\n", __FUNCTION__, asce);

+    PTE_DPRINTF("%s: 0x%" PRIx64 "\n", __func__, asce);

     if (((level != _ASCE_TYPE_SEGMENT) && (asce & _REGION_ENTRY_INV)) ||

         ((level == _ASCE_TYPE_SEGMENT) && (asce & _SEGMENT_ENTRY_INV))) {

         /* XXX different regions have different faults */

-        DPRINTF("%s: invalid region\n", __FUNCTION__);

+        DPRINTF("%s: invalid region\n", __func__);

         trigger_page_fault(env, vaddr, PGM_SEGMENT_TRANS, asc, rw);

         return -1;

     }

@@ -222,7 +225,7 @@ static int mmu_translate_asce(CPUS390XState *env, target_ulong vaddr, uint64_t a

     new_asce = ldq_phys(origin + offs);

     PTE_DPRINTF("%s: 0x%" PRIx64 " + 0x%" PRIx64 " => 0x%016" PRIx64 "\n",

-                __FUNCTION__, origin, offs, new_asce);

+                __func__, origin, offs, new_asce);

     if (level != _ASCE_TYPE_SEGMENT) {

         /* yet another region */

@@ -232,7 +235,7 @@ static int mmu_translate_asce(CPUS390XState *env, target_ulong vaddr, uint64_t a

     /* PTE */

     if (new_asce & _PAGE_INVALID) {

-        DPRINTF("%s: PTE=0x%" PRIx64 " invalid\n", __FUNCTION__, new_asce);

+        DPRINTF("%s: PTE=0x%" PRIx64 " invalid\n", __func__, new_asce);

         trigger_page_fault(env, vaddr, PGM_PAGE_TRANS, asc, rw);

         return -1;

     }

@@ -243,13 +246,14 @@ static int mmu_translate_asce(CPUS390XState *env, target_ulong vaddr, uint64_t a

     *raddr = new_asce & _ASCE_ORIGIN;

-    PTE_DPRINTF("%s: PTE=0x%" PRIx64 "\n", __FUNCTION__, new_asce);

+    PTE_DPRINTF("%s: PTE=0x%" PRIx64 "\n", __func__, new_asce);

     return 0;

 }

-static int mmu_translate_asc(CPUS390XState *env, target_ulong vaddr, uint64_t asc,

-                             target_ulong *raddr, int *flags, int rw)

+static int mmu_translate_asc(CPUS390XState *env, target_ulong vaddr,

+                             uint64_t asc, target_ulong *raddr, int *flags,

+                             int rw)

 {

     uint64_t asce = 0;

     int level, new_level;

@@ -257,15 +261,15 @@ static int mmu_translate_asc(CPUS390XState *env, target_ulong vaddr, uint64_t as

     switch (asc) {

     case PSW_ASC_PRIMARY:

-        PTE_DPRINTF("%s: asc=primary\n", __FUNCTION__);

+        PTE_DPRINTF("%s: asc=primary\n", __func__);

         asce = env->cregs[1];

         break;

     case PSW_ASC_SECONDARY:

-        PTE_DPRINTF("%s: asc=secondary\n", __FUNCTION__);

+        PTE_DPRINTF("%s: asc=secondary\n", __func__);

         asce = env->cregs[7];

         break;

     case PSW_ASC_HOME:

-        PTE_DPRINTF("%s: asc=home\n", __FUNCTION__);

+        PTE_DPRINTF("%s: asc=home\n", __func__);

         asce = env->cregs[13];

         break;

     }

@@ -276,8 +280,7 @@ static int mmu_translate_asc(CPUS390XState *env, target_ulong vaddr, uint64_t as

     case _ASCE_TYPE_REGION2:

         if (vaddr & 0xffe0000000000000ULL) {

             DPRINTF("%s: vaddr doesn't fit 0x%16" PRIx64

-                        " 0xffe0000000000000ULL\n", __FUNCTION__,

-                        vaddr);

+                    " 0xffe0000000000000ULL\n", __func__, vaddr);

             trigger_page_fault(env, vaddr, PGM_TRANS_SPEC, asc, rw);

             return -1;

         }

@@ -285,8 +288,7 @@ static int mmu_translate_asc(CPUS390XState *env, target_ulong vaddr, uint64_t as

     case _ASCE_TYPE_REGION3:

         if (vaddr & 0xfffffc0000000000ULL) {

             DPRINTF("%s: vaddr doesn't fit 0x%16" PRIx64

-                        " 0xfffffc0000000000ULL\n", __FUNCTION__,

-                        vaddr);

+                    " 0xfffffc0000000000ULL\n", __func__, vaddr);

             trigger_page_fault(env, vaddr, PGM_TRANS_SPEC, asc, rw);

             return -1;

         }

@@ -294,8 +296,7 @@ static int mmu_translate_asc(CPUS390XState *env, target_ulong vaddr, uint64_t as

     case _ASCE_TYPE_SEGMENT:

         if (vaddr & 0xffffffff80000000ULL) {

             DPRINTF("%s: vaddr doesn't fit 0x%16" PRIx64

-                        " 0xffffffff80000000ULL\n", __FUNCTION__,

-                        vaddr);

+                    " 0xffffffff80000000ULL\n", __func__, vaddr);

             trigger_page_fault(env, vaddr, PGM_TRANS_SPEC, asc, rw);

             return -1;

         }

@@ -358,7 +359,7 @@ int mmu_translate(CPUS390XState *env, target_ulong vaddr, int rw, uint64_t asc,

         break;

     }

-out:

+ out:

     /* Convert real address -> absolute address */

     if (*raddr < 0x2000) {

         *raddr = *raddr + env->psa;

@@ -378,18 +379,18 @@ out:

     return r;

 }

-int cpu_s390x_handle_mmu_fault (CPUS390XState *env, target_ulong _vaddr, int rw,

-                                int mmu_idx)

+int cpu_s390x_handle_mmu_fault(CPUS390XState *env, target_ulong orig_vaddr,

+                               int rw, int mmu_idx)

 {

     uint64_t asc = env->psw.mask & PSW_MASK_ASC;

     target_ulong vaddr, raddr;

     int prot;

     DPRINTF("%s: address 0x%" PRIx64 " rw %d mmu_idx %d\n",

-            __FUNCTION__, _vaddr, rw, mmu_idx);

+            __func__, _vaddr, rw, mmu_idx);

-    _vaddr &= TARGET_PAGE_MASK;

-    vaddr = _vaddr;

+    orig_vaddr &= TARGET_PAGE_MASK;

+    vaddr = orig_vaddr;

     /* 31-Bit mode */

     if (!(env->psw.mask & PSW_MASK_64)) {

@@ -403,22 +404,23 @@ int cpu_s390x_handle_mmu_fault (CPUS390XState *env, target_ulong _vaddr, int rw,

     /* check out of RAM access */

     if (raddr > (ram_size + virtio_size)) {

-        DPRINTF("%s: aaddr %" PRIx64 " > ram_size %" PRIx64 "\n", __FUNCTION__,

+        DPRINTF("%s: aaddr %" PRIx64 " > ram_size %" PRIx64 "\n", __func__,

                 (uint64_t)aaddr, (uint64_t)ram_size);

         trigger_pgm_exception(env, PGM_ADDRESSING, ILC_LATER);

         return 1;

     }

-    DPRINTF("%s: set tlb %" PRIx64 " -> %" PRIx64 " (%x)\n", __FUNCTION__,

+    DPRINTF("%s: set tlb %" PRIx64 " -> %" PRIx64 " (%x)\n", __func__,

             (uint64_t)vaddr, (uint64_t)raddr, prot);

-    tlb_set_page(env, _vaddr, raddr, prot,

+    tlb_set_page(env, orig_vaddr, raddr, prot,

                  mmu_idx, TARGET_PAGE_SIZE);

     return 0;

 }

-target_phys_addr_t cpu_get_phys_page_debug(CPUS390XState *env, target_ulong vaddr)

+target_phys_addr_t cpu_get_phys_page_debug(CPUS390XState *env,

+                                           target_ulong vaddr)

 {

     target_ulong raddr;

     int prot = PAGE_READ | PAGE_WRITE | PAGE_EXEC;

@@ -509,7 +511,7 @@ static void do_program_interrupt(CPUS390XState *env)

         break;

     }

-    qemu_log("%s: code=0x%x ilc=%d\n", __FUNCTION__, env->int_pgm_code, ilc);

+    qemu_log("%s: code=0x%x ilc=%d\n", __func__, env->int_pgm_code, ilc);

     lowcore = cpu_physical_memory_map(env->psa, &len, 1);

@@ -522,7 +524,7 @@ static void do_program_interrupt(CPUS390XState *env)

     cpu_physical_memory_unmap(lowcore, len, 1, len);

-    DPRINTF("%s: %x %x %" PRIx64 " %" PRIx64 "\n", __FUNCTION__,

+    DPRINTF("%s: %x %x %" PRIx64 " %" PRIx64 "\n", __func__,

             env->int_pgm_code, ilc, env->psw.mask,

             env->psw.addr);

@@ -565,15 +567,15 @@ static void do_ext_interrupt(CPUS390XState *env)

         env->pending_int &= ~INTERRUPT_EXT;

     }

-    DPRINTF("%s: %" PRIx64 " %" PRIx64 "\n", __FUNCTION__,

+    DPRINTF("%s: %" PRIx64 " %" PRIx64 "\n", __func__,

             env->psw.mask, env->psw.addr);

     load_psw(env, mask, addr);

 }

-void do_interrupt (CPUS390XState *env)

+void do_interrupt(CPUS390XState *env)

 {

-    qemu_log("%s: %d at pc=%" PRIx64 "\n", __FUNCTION__, env->exception_index,

+    qemu_log("%s: %d at pc=%" PRIx64 "\n", __func__, env->exception_index,

              env->psw.addr);

     s390_add_running_cpu(env);

diff --git a/target-s390x/op_helper.c b/target-s390x/op_helper.c

index abc35dd..195e93e 100644

--- a/target-s390x/op_helper.c

+++ b/target-s390x/op_helper.c

@@ -31,13 +31,13 @@

 #include <linux/kvm.h>

 #endif

-#if !defined (CONFIG_USER_ONLY)

+#if !defined(CONFIG_USER_ONLY)

 #include "sysemu.h"

 #endif

 /*****************************************************************************/

 /* Softmmu support */

-#if !defined (CONFIG_USER_ONLY)

+#if !defined(CONFIG_USER_ONLY)

 #include "softmmu_exec.h"

 #define MMUSUFFIX _mmu

@@ -95,7 +95,7 @@ void tlb_fill(CPUS390XState *env1, target_ulong addr, int is_write, int mmu_idx,

 /* raise an exception */

 void HELPER(exception)(uint32_t excp)

 {

-    HELPER_LOG("%s: exception %d\n", __FUNCTION__, excp);

+    HELPER_LOG("%s: exception %d\n", __func__, excp);

     env->exception_index = excp;

     cpu_loop_exit(env);

 }

@@ -164,7 +164,7 @@ uint32_t HELPER(nc)(uint32_t l, uint64_t dest, uint64_t src)

     uint32_t cc = 0;

     HELPER_LOG("%s l %d dest %" PRIx64 " src %" PRIx64 "\n",

-               __FUNCTION__, l, dest, src);

+               __func__, l, dest, src);

     for (i = 0; i <= l; i++) {

         x = ldub(dest + i) & ldub(src + i);

         if (x) {

@@ -183,7 +183,7 @@ uint32_t HELPER(xc)(uint32_t l, uint64_t dest, uint64_t src)

     uint32_t cc = 0;

     HELPER_LOG("%s l %d dest %" PRIx64 " src %" PRIx64 "\n",

-               __FUNCTION__, l, dest, src);

+               __func__, l, dest, src);

 #ifndef CONFIG_USER_ONLY

     /* xor with itself is the same as memset(0) */

@@ -217,7 +217,7 @@ uint32_t HELPER(oc)(uint32_t l, uint64_t dest, uint64_t src)

     uint32_t cc = 0;

     HELPER_LOG("%s l %d dest %" PRIx64 " src %" PRIx64 "\n",

-               __FUNCTION__, l, dest, src);

+               __func__, l, dest, src);

     for (i = 0; i <= l; i++) {

         x = ldub(dest + i) | ldub(src + i);

         if (x) {

@@ -236,7 +236,7 @@ void HELPER(mvc)(uint32_t l, uint64_t dest, uint64_t src)

     uint32_t l_64 = (l + 1) / 8;

     HELPER_LOG("%s l %d dest %" PRIx64 " src %" PRIx64 "\n",

-               __FUNCTION__, l, dest, src);

+               __func__, l, dest, src);

 #ifndef CONFIG_USER_ONLY

     if ((l > 32) &&

@@ -278,10 +278,11 @@ void HELPER(mvc)(uint32_t l, uint64_t dest, uint64_t src)

 uint32_t HELPER(clc)(uint32_t l, uint64_t s1, uint64_t s2)

 {

     int i;

-    unsigned char x,y;

+    unsigned char x, y;

     uint32_t cc;

+

     HELPER_LOG("%s l %d s1 %" PRIx64 " s2 %" PRIx64 "\n",

-               __FUNCTION__, l, s1, s2);

+               __func__, l, s1, s2);

     for (i = 0; i <= l; i++) {

         x = ldub(s1 + i);

         y = ldub(s2 + i);

@@ -295,7 +296,7 @@ uint32_t HELPER(clc)(uint32_t l, uint64_t s1, uint64_t s2)

         }

     }

     cc = 0;

-done:

+ done:

     HELPER_LOG("\n");

     return cc;

 }

@@ -303,9 +304,10 @@ done:

 /* compare logical under mask */

 uint32_t HELPER(clm)(uint32_t r1, uint32_t mask, uint64_t addr)

 {

-    uint8_t r,d;

+    uint8_t r, d;

     uint32_t cc;

-    HELPER_LOG("%s: r1 0x%x mask 0x%x addr 0x%" PRIx64 "\n", __FUNCTION__, r1,

+

+    HELPER_LOG("%s: r1 0x%x mask 0x%x addr 0x%" PRIx64 "\n", __func__, r1,

                mask, addr);

     cc = 0;

     while (mask) {

@@ -313,7 +315,7 @@ uint32_t HELPER(clm)(uint32_t r1, uint32_t mask, uint64_t addr)

             d = ldub(addr);

             r = (r1 & 0xff000000UL) >> 24;

             HELPER_LOG("mask 0x%x %02x/%02x (0x%" PRIx64 ") ", mask, r, d,

-                        addr);

+                       addr);

             if (r < d) {

                 cc = 1;

                 break;

@@ -334,7 +336,8 @@ uint32_t HELPER(clm)(uint32_t r1, uint32_t mask, uint64_t addr)

 void HELPER(stcm)(uint32_t r1, uint32_t mask, uint64_t addr)

 {

     uint8_t r;

-    HELPER_LOG("%s: r1 0x%x mask 0x%x addr 0x%lx\n", __FUNCTION__, r1, mask,

+

+    HELPER_LOG("%s: r1 0x%x mask 0x%x addr 0x%lx\n", __func__, r1, mask,

                addr);

     while (mask) {

         if (mask & 8) {

@@ -355,6 +358,7 @@ void HELPER(mlg)(uint32_t r1, uint64_t v2)

 #if HOST_LONG_BITS == 64 && defined(__GNUC__)

     /* assuming 64-bit hosts have __uint128_t */

     __uint128_t res = (__uint128_t)env->regs[r1 + 1];

+

     res *= (__uint128_t)v2;

     env->regs[r1] = (uint64_t)(res >> 64);

     env->regs[r1 + 1] = (uint64_t)res;

@@ -370,18 +374,18 @@ void HELPER(dlg)(uint32_t r1, uint64_t v2)

     if (!env->regs[r1]) {

         /* 64 -> 64/64 case */

-        env->regs[r1] = env->regs[r1+1] % divisor;

-        env->regs[r1+1] = env->regs[r1+1] / divisor;

+        env->regs[r1] = env->regs[r1 + 1] % divisor;

+        env->regs[r1 + 1] = env->regs[r1 + 1] / divisor;

         return;

     } else {

-

 #if HOST_LONG_BITS == 64 && defined(__GNUC__)

         /* assuming 64-bit hosts have __uint128_t */

         __uint128_t dividend = (((__uint128_t)env->regs[r1]) << 64) |

-                               (env->regs[r1+1]);

+            (env->regs[r1 + 1]);

         __uint128_t quotient = dividend / divisor;

-        env->regs[r1+1] = quotient;

         __uint128_t remainder = dividend % divisor;

+

+        env->regs[r1 + 1] = quotient;

         env->regs[r1] = remainder;

 #else

         /* 32-bit hosts would need special wrapper functionality - just abort if

@@ -431,7 +435,7 @@ uint32_t HELPER(srst)(uint32_t c, uint32_t r1, uint32_t r2)

     uint64_t str = get_address_31fix(r2);

     uint64_t end = get_address_31fix(r1);

-    HELPER_LOG("%s: c %d *r1 0x%" PRIx64 " *r2 0x%" PRIx64 "\n", __FUNCTION__,

+    HELPER_LOG("%s: c %d *r1 0x%" PRIx64 " *r2 0x%" PRIx64 "\n", __func__,

                c, env->regs[r1], env->regs[r2]);

     for (i = str; i != end; i++) {

@@ -452,11 +456,12 @@ uint32_t HELPER(clst)(uint32_t c, uint32_t r1, uint32_t r2)

     uint64_t s2 = get_address_31fix(r2);

     uint8_t v1, v2;

     uint32_t cc;

+

     c = c & 0xff;

 #ifdef CONFIG_USER_ONLY

     if (!c) {

         HELPER_LOG("%s: comparing '%s' and '%s'\n",

-                   __FUNCTION__, (char*)g2h(s1), (char*)g2h(s2));

+                   __func__, (char *)g2h(s1), (char *)g2h(s2));

     }

 #endif

     for (;;) {

@@ -501,10 +506,11 @@ void HELPER(mvst)(uint32_t c, uint32_t r1, uint32_t r2)

     uint64_t dest = get_address_31fix(r1);

     uint64_t src = get_address_31fix(r2);

     uint8_t v;

+

     c = c & 0xff;

 #ifdef CONFIG_USER_ONLY

     if (!c) {

-        HELPER_LOG("%s: copy '%s' to 0x%lx\n", __FUNCTION__, (char*)g2h(src),

+        HELPER_LOG("%s: copy '%s' to 0x%lx\n", __func__, (char *)g2h(src),

                    dest);

     }

 #endif

@@ -526,6 +532,7 @@ uint32_t HELPER(csg)(uint32_t r1, uint64_t a2, uint32_t r3)

     /* FIXME: locking? */

     uint32_t cc;

     uint64_t v2 = ldq(a2);

+

     if (env->regs[r1] == v2) {

         cc = 0;

         stq(a2, env->regs[r3]);

@@ -564,8 +571,9 @@ uint32_t HELPER(cs)(uint32_t r1, uint64_t a2, uint32_t r3)

 {

     /* FIXME: locking? */

     uint32_t cc;

-    HELPER_LOG("%s: r1 %d a2 0x%lx r3 %d\n", __FUNCTION__, r1, a2, r3);

     uint32_t v2 = ldl(a2);

+

+    HELPER_LOG("%s: r1 %d a2 0x%lx r3 %d\n", __func__, r1, a2, r3);

     if (((uint32_t)env->regs[r1]) == v2) {

         cc = 0;

         stl(a2, (uint32_t)env->regs[r3]);

@@ -612,14 +620,16 @@ static uint32_t helper_icm(uint32_t r1, uint64_t address, uint32_t mask)

    it does not change the program counter

    in other words: tricky...

    currently implemented by interpreting the cases it is most commonly used in

- */

+*/

 uint32_t HELPER(ex)(uint32_t cc, uint64_t v1, uint64_t addr, uint64_t ret)

 {

     uint16_t insn = lduw_code(addr);

-    HELPER_LOG("%s: v1 0x%lx addr 0x%lx insn 0x%x\n", __FUNCTION__, v1, addr,

-             insn);

+

+    HELPER_LOG("%s: v1 0x%lx addr 0x%lx insn 0x%x\n", __func__, v1, addr,

+               insn);

     if ((insn & 0xf0ff) == 0xd000) {

         uint32_t l, insn2, b1, b2, d1, d2;

+

         l = v1 & 0xff;

         insn2 = ldl_code(addr + 2);

         b1 = (insn2 >> 28) & 0xf;

@@ -645,13 +655,14 @@ uint32_t HELPER(ex)(uint32_t cc, uint64_t v1, uint64_t addr, uint64_t ret)

         }

     } else if ((insn & 0xff00) == 0x0a00) {

         /* supervisor call */

-        HELPER_LOG("%s: svc %ld via execute\n", __FUNCTION__, (insn|v1) & 0xff);

+        HELPER_LOG("%s: svc %ld via execute\n", __func__, (insn | v1) & 0xff);

         env->psw.addr = ret - 4;

-        env->int_svc_code = (insn|v1) & 0xff;

+        env->int_svc_code = (insn | v1) & 0xff;

         env->int_svc_ilc = 4;

         helper_exception(EXCP_SVC);

     } else if ((insn & 0xff00) == 0xbf00) {

         uint32_t insn2, r1, r3, b2, d2;

+

         insn2 = ldl_code(addr + 2);

         r1 = (insn2 >> 20) & 0xf;

         r3 = (insn2 >> 16) & 0xf;

@@ -659,7 +670,7 @@ uint32_t HELPER(ex)(uint32_t cc, uint64_t v1, uint64_t addr, uint64_t ret)

         d2 = insn2 & 0xfff;

         cc = helper_icm(r1, get_address(0, b2, d2), r3);

     } else {

-abort:

+    abort:

         cpu_abort(env, "EXECUTE on instruction prefix 0x%x not implemented\n",

                   insn);

     }

@@ -689,7 +700,7 @@ int32_t HELPER(nabs_i32)(int32_t val)

 /* absolute value 64-bit */

 uint64_t HELPER(abs_i64)(int64_t val)

 {

-    HELPER_LOG("%s: val 0x%" PRIx64 "\n", __FUNCTION__, val);

+    HELPER_LOG("%s: val 0x%" PRIx64 "\n", __func__, val);

     if (val < 0) {

         return -val;

@@ -774,9 +785,9 @@ void HELPER(ipm)(uint32_t cc, uint32_t r1)

     uint64_t r = env->regs[r1];

     r &= 0xffffffff00ffffffULL;

-    r |= (cc << 28) | ( (env->psw.mask >> 40) & 0xf );

+    r |= (cc << 28) | ((env->psw.mask >> 40) & 0xf);

     env->regs[r1] = r;

-    HELPER_LOG("%s: cc %d psw.mask 0x%lx r1 0x%lx\n", __FUNCTION__,

+    HELPER_LOG("%s: cc %d psw.mask 0x%lx r1 0x%lx\n", __func__,

                cc, env->psw.mask, r);

 }

@@ -908,7 +919,7 @@ uint32_t HELPER(clcle)(uint32_t r1, uint64_t a2, uint32_t r3)

     uint64_t srclen = env->regs[r3 + 1];

     uint64_t src = get_address_31fix(r3);

     uint8_t pad = a2 & 0xff;

-    uint8_t v1 = 0,v2 = 0;

+    uint8_t v1 = 0, v2 = 0;

     uint32_t cc = 0;

     if (!(destlen || srclen)) {

@@ -1036,7 +1047,7 @@ static uint32_t set_cc_nz_f128(float128 v)

 /* convert 32-bit int to 64-bit float */

 void HELPER(cdfbr)(uint32_t f1, int32_t v2)

 {

-    HELPER_LOG("%s: converting %d to f%d\n", __FUNCTION__, v2, f1);

+    HELPER_LOG("%s: converting %d to f%d\n", __func__, v2, f1);

     env->fregs[f1].d = int32_to_float64(v2, &env->fpu_status);

 }

@@ -1044,6 +1055,7 @@ void HELPER(cdfbr)(uint32_t f1, int32_t v2)

 void HELPER(cxfbr)(uint32_t f1, int32_t v2)

 {

     CPU_QuadU v1;

+

     v1.q = int32_to_float128(v2, &env->fpu_status);

     env->fregs[f1].ll = v1.ll.upper;

     env->fregs[f1 + 2].ll = v1.ll.lower;

@@ -1052,14 +1064,14 @@ void HELPER(cxfbr)(uint32_t f1, int32_t v2)

 /* convert 64-bit int to 32-bit float */

 void HELPER(cegbr)(uint32_t f1, int64_t v2)

 {

-    HELPER_LOG("%s: converting %ld to f%d\n", __FUNCTION__, v2, f1);

+    HELPER_LOG("%s: converting %ld to f%d\n", __func__, v2, f1);

     env->fregs[f1].l.upper = int64_to_float32(v2, &env->fpu_status);

 }

 /* convert 64-bit int to 64-bit float */

 void HELPER(cdgbr)(uint32_t f1, int64_t v2)

 {

-    HELPER_LOG("%s: converting %ld to f%d\n", __FUNCTION__, v2, f1);

+    HELPER_LOG("%s: converting %ld to f%d\n", __func__, v2, f1);

     env->fregs[f1].d = int64_to_float64(v2, &env->fpu_status);

 }

@@ -1067,8 +1079,9 @@ void HELPER(cdgbr)(uint32_t f1, int64_t v2)

 void HELPER(cxgbr)(uint32_t f1, int64_t v2)

 {

     CPU_QuadU x1;

+

     x1.q = int64_to_float128(v2, &env->fpu_status);

-    HELPER_LOG("%s: converted %ld to 0x%lx and 0x%lx\n", __FUNCTION__, v2,

+    HELPER_LOG("%s: converted %ld to 0x%lx and 0x%lx\n", __func__, v2,

                x1.ll.upper, x1.ll.lower);

     env->fregs[f1].ll = x1.ll.upper;

     env->fregs[f1 + 2].ll = x1.ll.lower;

@@ -1078,7 +1091,7 @@ void HELPER(cxgbr)(uint32_t f1, int64_t v2)

 void HELPER(cefbr)(uint32_t f1, int32_t v2)

 {

     env->fregs[f1].l.upper = int32_to_float32(v2, &env->fpu_status);

-    HELPER_LOG("%s: converting %d to 0x%d in f%d\n", __FUNCTION__, v2,

+    HELPER_LOG("%s: converting %d to 0x%d in f%d\n", __func__, v2,

                env->fregs[f1].l.upper, f1);

 }

@@ -1088,7 +1101,7 @@ uint32_t HELPER(aebr)(uint32_t f1, uint32_t f2)

     env->fregs[f1].l.upper = float32_add(env->fregs[f1].l.upper,

                                          env->fregs[f2].l.upper,

                                          &env->fpu_status);

-    HELPER_LOG("%s: adding 0x%d resulting in 0x%d in f%d\n", __FUNCTION__,

+    HELPER_LOG("%s: adding 0x%d resulting in 0x%d in f%d\n", __func__,

                env->fregs[f2].l.upper, env->fregs[f1].l.upper, f1);

     return set_cc_nz_f32(env->fregs[f1].l.upper);

@@ -1099,7 +1112,7 @@ uint32_t HELPER(adbr)(uint32_t f1, uint32_t f2)

 {

     env->fregs[f1].d = float64_add(env->fregs[f1].d, env->fregs[f2].d,

                                    &env->fpu_status);

-    HELPER_LOG("%s: adding 0x%ld resulting in 0x%ld in f%d\n", __FUNCTION__,

+    HELPER_LOG("%s: adding 0x%ld resulting in 0x%ld in f%d\n", __func__,

                env->fregs[f2].d, env->fregs[f1].d, f1);

     return set_cc_nz_f64(env->fregs[f1].d);

@@ -1111,7 +1124,7 @@ uint32_t HELPER(sebr)(uint32_t f1, uint32_t f2)

     env->fregs[f1].l.upper = float32_sub(env->fregs[f1].l.upper,

                                          env->fregs[f2].l.upper,

                                          &env->fpu_status);

-    HELPER_LOG("%s: adding 0x%d resulting in 0x%d in f%d\n", __FUNCTION__,

+    HELPER_LOG("%s: adding 0x%d resulting in 0x%d in f%d\n", __func__,

                env->fregs[f2].l.upper, env->fregs[f1].l.upper, f1);

     return set_cc_nz_f32(env->fregs[f1].l.upper);

@@ -1123,7 +1136,7 @@ uint32_t HELPER(sdbr)(uint32_t f1, uint32_t f2)

     env->fregs[f1].d = float64_sub(env->fregs[f1].d, env->fregs[f2].d,

                                    &env->fpu_status);

     HELPER_LOG("%s: subtracting 0x%ld resulting in 0x%ld in f%d\n",

-               __FUNCTION__, env->fregs[f2].d, env->fregs[f1].d, f1);

+               __func__, env->fregs[f2].d, env->fregs[f1].d, f1);

     return set_cc_nz_f64(env->fregs[f1].d);

 }

@@ -1140,12 +1153,13 @@ void HELPER(debr)(uint32_t f1, uint32_t f2)

 void HELPER(dxbr)(uint32_t f1, uint32_t f2)

 {

     CPU_QuadU v1;

+    CPU_QuadU v2;

+    CPU_QuadU res;

+

     v1.ll.upper = env->fregs[f1].ll;

     v1.ll.lower = env->fregs[f1 + 2].ll;

-    CPU_QuadU v2;

     v2.ll.upper = env->fregs[f2].ll;

     v2.ll.lower = env->fregs[f2 + 2].ll;

-    CPU_QuadU res;

     res.q = float128_div(v1.q, v2.q, &env->fpu_status);

     env->fregs[f1].ll = res.ll.upper;

     env->fregs[f1 + 2].ll = res.ll.lower;

@@ -1162,12 +1176,13 @@ void HELPER(mdbr)(uint32_t f1, uint32_t f2)

 void HELPER(mxbr)(uint32_t f1, uint32_t f2)

 {

     CPU_QuadU v1;

+    CPU_QuadU v2;

+    CPU_QuadU res;

+

     v1.ll.upper = env->fregs[f1].ll;

     v1.ll.lower = env->fregs[f1 + 2].ll;

-    CPU_QuadU v2;

     v2.ll.upper = env->fregs[f2].ll;

     v2.ll.lower = env->fregs[f2 + 2].ll;

-    CPU_QuadU res;

     res.q = float128_mul(v1.q, v2.q, &env->fpu_status);

     env->fregs[f1].ll = res.ll.upper;

     env->fregs[f1 + 2].ll = res.ll.lower;

@@ -1184,16 +1199,18 @@ void HELPER(ldebr)(uint32_t r1, uint32_t r2)

 void HELPER(ldxbr)(uint32_t f1, uint32_t f2)

 {

     CPU_QuadU x2;

+