white space fixes

diff --git a/ext/opcache/jit/zend_elf.c b/ext/opcache/jit/zend_elf.c
index f5180e0a96ab6cf4b83f94d03b2769a0e6c279e7..7db7957befdeee3000bede12fd604c57814aca57 100644 (file)
--- a/ext/opcache/jit/zend_elf.c
+++ b/ext/opcache/jit/zend_elf.c
@@ -58,7 +58,7 @@ void zend_elf_load_symbols(void)
        size_t pathlen = sizeof(path);
        int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1};
        if (sysctl(mib, 4, path, &pathlen, NULL, 0) == -1) {
-             return;
+               return;
        }
        int fd = open(path, O_RDONLY);
 #else

diff --git a/ext/opcache/jit/zend_jit.c b/ext/opcache/jit/zend_jit.c
index 267b2edb33c52f59709e6fd614e730c5c4a0a8d0..d357f72a2e769a7ed5fec489f4681eb089fb762f 100644 (file)
--- a/ext/opcache/jit/zend_jit.c
+++ b/ext/opcache/jit/zend_jit.c
@@ -70,7 +70,7 @@ zend_jit_globals jit_globals;
     } \
   } while(0)
 
-#define DASM_M_FREE(ctx, p, sz)        efree(p)
+#define DASM_M_FREE(ctx, p, sz) efree(p)
 
 #include "dynasm/dasm_proto.h"
 
@@ -254,7 +254,7 @@ static void *dasm_link_and_encode(dasm_State             **dasm_state,
        zend_string *str = NULL;
 #endif
 
-    if (rt_opline && ssa && ssa->cfg.map) {
+       if (rt_opline && ssa && ssa->cfg.map) {
                /* Create additional entry point, to switch from interpreter to JIT-ed
                 * code at run-time.
                 */
@@ -291,7 +291,7 @@ static void *dasm_link_and_encode(dasm_State             **dasm_state,
                        }
                        zend_jit_jmp(dasm_state, b);
                }
-    }
+       }
 
        if (dasm_link(dasm_state, &size) != DASM_S_OK) {
                // TODO: dasm_link() failed ???
@@ -347,7 +347,7 @@ static void *dasm_link_and_encode(dasm_State             **dasm_state,
        }
 
 #if defined(HAVE_DISASM) || defined(HAVE_GDB) || defined(HAVE_OPROFILE) || defined(HAVE_PERFTOOLS) || defined(HAVE_VTUNE)
-    if (!name) {
+       if (!name) {
                if (ZCG(accel_directives).jit_debug & (ZEND_JIT_DEBUG_ASM|ZEND_JIT_DEBUG_GDB|ZEND_JIT_DEBUG_OPROFILE|ZEND_JIT_DEBUG_PERF|ZEND_JIT_DEBUG_VTUNE|ZEND_JIT_DEBUG_PERF_DUMP)) {
                        str = zend_jit_func_name(op_array);
                        if (str) {
@@ -1513,13 +1513,13 @@ static int zend_jit_try_allocate_free_reg(const zend_op_array *op_array, const z
        }
 #endif
 
-    if (hint != ZREG_NONE && freeUntilPos[hint] > zend_interval_end(current)) {
+       if (hint != ZREG_NONE && freeUntilPos[hint] > zend_interval_end(current)) {
                current->reg = hint;
                if (current->used_as_hint) {
                        ZEND_REGSET_INCL(*hints, hint);
                }
                return 1;
-    }
+       }
 
        if (ZEND_REGSET_IS_EMPTY(available)) {
                return 0;
@@ -3031,9 +3031,9 @@ done:
        return SUCCESS;
 
 jit_failure:
-    if (dasm_state) {
+       if (dasm_state) {
                dasm_free(&dasm_state);
-    }
+       }
        if (zend_jit_reg_alloc) {
                zend_arena_release(&CG(arena), checkpoint);
        }
@@ -3063,7 +3063,7 @@ static int zend_real_jit_func(zend_op_array *op_array, zend_script *script, cons
 
        checkpoint = zend_arena_checkpoint(CG(arena));
 
-    /* Build SSA */
+       /* Build SSA */
        memset(&ssa, 0, sizeof(zend_ssa));
 
        if (zend_jit_op_array_analyze1(op_array, script, &ssa) != SUCCESS) {

diff --git a/ext/opcache/jit/zend_jit.h b/ext/opcache/jit/zend_jit.h
index cecd263eb8ad73dd19f0cad771885f1f783573ca..3f8196b30983662d33c800157a234775b717961d 100644 (file)
--- a/ext/opcache/jit/zend_jit.h
+++ b/ext/opcache/jit/zend_jit.h
@@ -118,8 +118,8 @@ struct _zend_lifetime_interval {
                struct {
                ZEND_ENDIAN_LOHI_3(
                        int8_t          reg,
-                       uint8_t                 flags,
-                       uint16_t                reserved
+                       uint8_t         flags,
+                       uint16_t        reserved
                )};
                uint32_t            reg_flags;
        };

diff --git a/ext/opcache/jit/zend_jit_disasm_x86.c b/ext/opcache/jit/zend_jit_disasm_x86.c
index 2ff7b960fdfbea4ddd6c7bd9704910fc990d8714..a847716ace22290cec3976d3c8d7f834cf546d96 100644 (file)
--- a/ext/opcache/jit/zend_jit_disasm_x86.c
+++ b/ext/opcache/jit/zend_jit_disasm_x86.c
@@ -390,7 +390,7 @@ static int zend_jit_disasm_init(void)
 #undef  REGISTER_EG
 #endif
 
-    /* Register JIT helper functions */
+       /* Register JIT helper functions */
 #define REGISTER_HELPER(n)  \
        zend_jit_disasm_add_symbol(#n, \
                (uint64_t)(uintptr_t)n, sizeof(void*));

diff --git a/ext/opcache/jit/zend_jit_gdb.c b/ext/opcache/jit/zend_jit_gdb.c
index 58b075ea8cfd4b978df8206685f144250faec403..2db7246372b487b5d5bcd088326ed735dc1cab14 100644 (file)
--- a/ext/opcache/jit/zend_jit_gdb.c
+++ b/ext/opcache/jit/zend_jit_gdb.c
@@ -92,7 +92,7 @@ enum {
        DW_REG_8, DW_REG_9, DW_REG_10, DW_REG_11,
        DW_REG_12, DW_REG_13, DW_REG_14, DW_REG_15,
        DW_REG_RA,
-    /* TODO: ARM supports? */
+       /* TODO: ARM supports? */
 #else
 #error "Unsupported target architecture"
 #endif
@@ -290,48 +290,48 @@ static void zend_gdbjit_symtab(zend_gdbjit_ctx *ctx)
 #define DSTR(str)   (ctx->p = p, zend_gdbjit_strz(ctx, (str)), p = ctx->p)
 #define DALIGNNOP(s)    while ((uintptr_t)p & ((s)-1)) *p++ = DW_CFA_nop
 #define DSECT(name, stmt) \
-         { uint32_t *szp_##name = (uint32_t *)p; p += 4; stmt \
-        *szp_##name = (uint32_t)((p-(uint8_t *)szp_##name)-4); }
+       { uint32_t *szp_##name = (uint32_t *)p; p += 4; stmt \
+               *szp_##name = (uint32_t)((p-(uint8_t *)szp_##name)-4); }
 
 static void zend_gdbjit_ehframe(zend_gdbjit_ctx *ctx)
 {
-  uint8_t *p = ctx->p;
-  uint8_t *framep = p;
-
-  /* DWARF EH CIE (Common Information Entry) */
-  DSECT(CIE,
-    DU32(0);                                              /* CIE ID. */
-    DB(DW_CIE_VERSION);                            /* Version */
-    DSTR("zR");                                                   /* Augmentation String. */
-    DUV(1);                                                   /* Code alignment factor. */
-    DSV(-(int32_t)sizeof(uintptr_t));              /* Data alignment factor. */
-    DB(DW_REG_RA);                                        /* Return address register. */
-    DB(1); DB(DW_EH_PE_textrel|DW_EH_PE_udata4);   /* Augmentation data. */
-    DB(DW_CFA_def_cfa); DUV(DW_REG_SP); DUV(sizeof(uintptr_t));
-    DB(DW_CFA_offset|DW_REG_RA); DUV(1);
-    DALIGNNOP(sizeof(uintptr_t));
-  )
-
-  /* DWARF EH FDE (Frame Description Entry). */
-  DSECT(FDE,
-    DU32((uint32_t)(p-framep));        /* Offset to CIE Pointer. */
-    DU32(0);                    /* Machine code offset relative to .text. */
-    DU32(ctx->szmcode);                    /* Machine code length. */
-    DB(0);                                 /* Augmentation data. */
-    DB(DW_CFA_def_cfa_offset); DUV(sizeof(uintptr_t));
+       uint8_t *p = ctx->p;
+       uint8_t *framep = p;
+
+       /* DWARF EH CIE (Common Information Entry) */
+       DSECT(CIE,
+               DU32(0);                                       /* CIE ID. */
+               DB(DW_CIE_VERSION);                            /* Version */
+               DSTR("zR");                                    /* Augmentation String. */
+               DUV(1);                                        /* Code alignment factor. */
+               DSV(-(int32_t)sizeof(uintptr_t));              /* Data alignment factor. */
+               DB(DW_REG_RA);                                 /* Return address register. */
+               DB(1); DB(DW_EH_PE_textrel|DW_EH_PE_udata4);   /* Augmentation data. */
+               DB(DW_CFA_def_cfa); DUV(DW_REG_SP); DUV(sizeof(uintptr_t));
+               DB(DW_CFA_offset|DW_REG_RA); DUV(1);
+               DALIGNNOP(sizeof(uintptr_t));
+       )
+
+       /* DWARF EH FDE (Frame Description Entry). */
+       DSECT(FDE,
+               DU32((uint32_t)(p-framep)); /* Offset to CIE Pointer. */
+               DU32(0);                    /* Machine code offset relative to .text. */
+               DU32(ctx->szmcode);         /* Machine code length. */
+               DB(0);                      /* Augmentation data. */
+               DB(DW_CFA_def_cfa_offset); DUV(sizeof(uintptr_t));
 #if defined(__i386__)
-    DB(DW_CFA_advance_loc|3);            /* sub $0xc,%esp */
-    DB(DW_CFA_def_cfa_offset); DUV(16);  /* Aligned stack frame size. */
+               DB(DW_CFA_advance_loc|3);            /* sub $0xc,%esp */
+               DB(DW_CFA_def_cfa_offset); DUV(16);  /* Aligned stack frame size. */
 #elif defined(__x86_64__)
-    DB(DW_CFA_advance_loc|4);            /* sub $0x8,%rsp */
-    DB(DW_CFA_def_cfa_offset); DUV(16);  /* Aligned stack frame size. */
+               DB(DW_CFA_advance_loc|4);            /* sub $0x8,%rsp */
+               DB(DW_CFA_def_cfa_offset); DUV(16);  /* Aligned stack frame size. */
 #else
 # error "Unsupported target architecture"
 #endif
-    DALIGNNOP(sizeof(uintptr_t));
-  )
+               DALIGNNOP(sizeof(uintptr_t));
+       )
 
-  ctx->p = p;
+       ctx->p = p;
 }
 
 static void zend_gdbjit_debuginfo(zend_gdbjit_ctx *ctx)

diff --git a/ext/opcache/jit/zend_jit_perf_dump.c b/ext/opcache/jit/zend_jit_perf_dump.c
index 94b1e4b859c24072d39483910e531ef721a529b4..5ee7f36ef914d1a779bb69da63a1f8cfbf5ea88a 100644 (file)
--- a/ext/opcache/jit/zend_jit_perf_dump.c
+++ b/ext/opcache/jit/zend_jit_perf_dump.c
@@ -63,14 +63,14 @@
 #define PADDING8(size) (ALIGN8(size) - (size))
 
 typedef struct zend_perf_jitdump_header {
-  uint32_t magic;
-  uint32_t version;
-  uint32_t size;
-  uint32_t elf_mach_target;
-  uint32_t reserved;
-  uint32_t process_id;
-  uint64_t time_stamp;
-  uint64_t flags;
+       uint32_t magic;
+       uint32_t version;
+       uint32_t size;
+       uint32_t elf_mach_target;
+       uint32_t reserved;
+       uint32_t process_id;
+       uint64_t time_stamp;
+       uint64_t flags;
 } zend_perf_jitdump_header;
 
 typedef struct _zend_perf_jitdump_record {
@@ -123,7 +123,7 @@ static void zend_jit_perf_jitdump_open(void)
        size_t pathlen = sizeof(path);
        int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1};
        if (sysctl(mib, 4, path, &pathlen, NULL, 0) == -1) {
-             return;
+               return;
        }
        fd = open(path, O_RDONLY);
 #else

diff --git a/ext/opcache/jit/zend_jit_trace.c b/ext/opcache/jit/zend_jit_trace.c
index 42df977078de3cb2d26d427422b8f0ca33d5a0d2..7efe94517f8889200c3a2a5cbbc5d30773f763a7 100644 (file)
--- a/ext/opcache/jit/zend_jit_trace.c
+++ b/ext/opcache/jit/zend_jit_trace.c
@@ -83,7 +83,7 @@ static const void *zend_jit_trace_allocate_exit_group(uint32_t n)
        dasm_free(&dasm_state);
 
 #ifdef HAVE_DISASM
-    if (ZCG(accel_directives).jit_debug & ZEND_JIT_DEBUG_ASM) {
+       if (ZCG(accel_directives).jit_debug & ZEND_JIT_DEBUG_ASM) {
                uint32_t i;
 
                for (i = 0; i < ZEND_JIT_EXIT_POINTS_PER_GROUP; i++) {
@@ -112,7 +112,7 @@ static const void *zend_jit_trace_allocate_exit_point(uint32_t n)
                        group;
                ZEND_JIT_EXIT_NUM += ZEND_JIT_EXIT_POINTS_PER_GROUP;
        } while (n >= ZEND_JIT_EXIT_NUM);
-    return (const void*)
+       return (const void*)
                ((const char*)group +
                ((n % ZEND_JIT_EXIT_POINTS_PER_GROUP) * ZEND_JIT_EXIT_POINTS_SPACING));
 }
@@ -122,7 +122,7 @@ static const void *zend_jit_trace_get_exit_addr(uint32_t n)
        if (UNEXPECTED(n >= ZEND_JIT_EXIT_NUM)) {
                return zend_jit_trace_allocate_exit_point(n);
        }
-    return (const void*)
+       return (const void*)
                ((const char*)zend_jit_exit_groups[n / ZEND_JIT_EXIT_POINTS_PER_GROUP] +
                ((n % ZEND_JIT_EXIT_POINTS_PER_GROUP) * ZEND_JIT_EXIT_POINTS_SPACING));
 }
@@ -1802,7 +1802,7 @@ static zend_lifetime_interval** zend_jit_trace_allocate_registers(zend_jit_trace
        zend_jit_trace_stack *stack;
        uint32_t parent_vars_count = parent_trace ?
                zend_jit_traces[parent_trace].exit_info[exit_num].stack_size : 0;
-    zend_jit_trace_stack *parent_stack = parent_trace ?
+       zend_jit_trace_stack *parent_stack = parent_trace ?
                zend_jit_traces[parent_trace].stack_map +
                zend_jit_traces[parent_trace].exit_info[exit_num].stack_offset : NULL;
        ALLOCA_FLAG(use_heap);
@@ -2620,7 +2620,7 @@ static const void *zend_jit_trace(zend_jit_trace_rec *trace_buffer, uint32_t par
                                uint32_t exit_point = zend_jit_trace_get_exit_point(NULL, NULL, NULL);
 
                                exit_addr = zend_jit_trace_get_exit_addr(exit_point);
-                if (!exit_addr) {
+                               if (!exit_addr) {
                                        goto jit_failure;
                                }
                        }

diff --git a/ext/opcache/jit/zend_jit_vm_helpers.c b/ext/opcache/jit/zend_jit_vm_helpers.c
index 450fa6055d568c1a5ee11dddd575f7165bb022c3..b2faaeb1a09c0b2284fbc67d242794c0aef77637 100644 (file)
--- a/ext/opcache/jit/zend_jit_vm_helpers.c
+++ b/ext/opcache/jit/zend_jit_vm_helpers.c
@@ -600,7 +600,7 @@ zend_jit_trace_stop ZEND_FASTCALL zend_jit_trace_execute(zend_execute_data *ex,
                ce1 = ce2 = NULL;
                op1_type = op2_type = op3_type = IS_UNKNOWN;
                if ((opline->op1_type & (IS_TMP_VAR|IS_VAR|IS_CV))
-                &&     (opline->opcode != ZEND_ROPE_ADD && opline->opcode != ZEND_ROPE_END)) {
+                && (opline->opcode != ZEND_ROPE_ADD && opline->opcode != ZEND_ROPE_END)) {
                        zval *zv = EX_VAR(opline->op1.var);
                        op1_type = Z_TYPE_P(zv);
                        if (op1_type == IS_INDIRECT) {

diff --git a/ext/opcache/jit/zend_jit_x86.dasc b/ext/opcache/jit/zend_jit_x86.dasc
index 205c6dc38a6f6dc59fb311d464d1117e9b120e7c..60992a212828ed0f5a673e7d009907ad54c6d2fc 100644 (file)
--- a/ext/opcache/jit/zend_jit_x86.dasc
+++ b/ext/opcache/jit/zend_jit_x86.dasc
@@ -280,7 +280,7 @@ static void* dasm_labels[zend_lb_MAX];
 |              jmp aword [IP]
 ||     } else {
 |              mov r0, aword EX:FCARG1a->opline
-|              jmp     aword [r0]
+|              jmp aword [r0]
 ||     }
 |.endmacro
 
@@ -298,7 +298,7 @@ static void* dasm_labels[zend_lb_MAX];
 |.endmacro
 
 |.macro ADDR_OP1, addr_ins, addr, tmp_reg
-|      .if X64
+|      .if X64
 ||             if (IS_32BIT(addr)) {
 |                      addr_ins ((ptrdiff_t)addr)
 ||             } else {
@@ -306,12 +306,12 @@ static void* dasm_labels[zend_lb_MAX];
 |                      addr_ins tmp_reg
 ||             }
 |      .else
-|      addr_ins ((ptrdiff_t)addr)
-|      .endif
+|              addr_ins ((ptrdiff_t)addr)
+|      .endif
 |.endmacro
 
 |.macro ADDR_OP2_2, addr_ins, op1, addr, tmp_reg
-|      .if X64
+|      .if X64
 ||             if (IS_32BIT(addr)) {
 |                      addr_ins op1, ((ptrdiff_t)addr)
 ||             } else {
@@ -319,8 +319,8 @@ static void* dasm_labels[zend_lb_MAX];
 |                      addr_ins op1, tmp_reg
 ||             }
 |      .else
-|      addr_ins op1, ((ptrdiff_t)addr)
-|      .endif
+|              addr_ins op1, ((ptrdiff_t)addr)
+|      .endif
 |.endmacro
 
 |.macro PUSH_ADDR, addr, tmp_reg
@@ -341,7 +341,7 @@ static void* dasm_labels[zend_lb_MAX];
 |      .if X64
 ||             if (IS_32BIT(addr)) {
 |                      mem_ins prefix [addr]
-||             } else {
+||             } else {
 |                      mov64 tmp_reg, ((ptrdiff_t)addr)
 |                      mem_ins prefix [tmp_reg]
 ||             }
@@ -351,7 +351,7 @@ static void* dasm_labels[zend_lb_MAX];
 |.endmacro
 
 |.macro MEM_OP2_1, mem_ins, prefix, addr, op2, tmp_reg
-|      .if X64
+|      .if X64
 ||             if (IS_32BIT(addr)) {
 |                      mem_ins prefix [addr], op2
 ||             } else {
@@ -359,12 +359,12 @@ static void* dasm_labels[zend_lb_MAX];
 |                      mem_ins prefix [tmp_reg], op2
 ||             }
 |      .else
-|      mem_ins prefix [addr], op2
-|      .endif
+|              mem_ins prefix [addr], op2
+|      .endif
 |.endmacro
 
 |.macro MEM_OP2_2, mem_ins, op1, prefix, addr, tmp_reg
-|      .if X64
+|      .if X64
 ||             if (IS_32BIT(addr)) {
 |                      mem_ins op1, prefix [addr]
 ||             } else {
@@ -372,17 +372,17 @@ static void* dasm_labels[zend_lb_MAX];
 |                      mem_ins op1, prefix [tmp_reg]
 ||             }
 |      .else
-|      mem_ins op1, prefix [addr]
-|      .endif
+|              mem_ins op1, prefix [addr]
+|      .endif
 |.endmacro
 
 |.macro MEM_OP2_1_ZTS, mem_ins, prefix, struct, field, op2, tmp_reg
 |      .if ZTS
 |              LOAD_TSRM_CACHE tmp_reg
-|      mem_ins prefix [tmp_reg + (struct.._offset + offsetof(zend_..struct, field))], op2
+|              mem_ins prefix [tmp_reg + (struct.._offset + offsetof(zend_..struct, field))], op2
 |      .else
 |              MEM_OP2_1 mem_ins, prefix, &struct.field, op2, tmp_reg
-|      .endif
+|      .endif
 |.endmacro
 
 |.macro MEM_OP2_2_ZTS, mem_ins, op1, prefix, struct, field, tmp_reg
@@ -391,11 +391,11 @@ static void* dasm_labels[zend_lb_MAX];
 |              mem_ins op1, prefix [tmp_reg + (struct.._offset + offsetof(zend_..struct, field))]
 |      .else
 |              MEM_OP2_2 mem_ins, op1, prefix, &struct.field, tmp_reg
-|      .endif
+|      .endif
 |.endmacro
 
 |.macro MEM_OP3_3, mem_ins, op1, op2, prefix, addr, tmp_reg
-|      .if X64
+|      .if X64
 ||             if (IS_32BIT(addr)) {
 |                      mem_ins op1, op2, prefix [addr]
 ||             } else {
@@ -403,8 +403,8 @@ static void* dasm_labels[zend_lb_MAX];
 |                      mem_ins op1, op2, prefix [tmp_reg]
 ||             }
 |      .else
-|      mem_ins op1, op2, prefix [addr]
-|      .endif
+|              mem_ins op1, op2, prefix [addr]
+|      .endif
 |.endmacro
 
 |.macro LOAD_BASE_ADDR, reg, base, offset
@@ -454,7 +454,7 @@ static void* dasm_labels[zend_lb_MAX];
 ||     if (Z_MODE(addr) == IS_CONST_ZVAL) {
 |              LOAD_ADDR reg, Z_ZV(addr)
 ||     } else if (Z_MODE(addr) == IS_MEM_ZVAL) {
-|      LOAD_BASE_ADDR reg, Z_REG(addr), Z_OFFSET(addr)
+|              LOAD_BASE_ADDR reg, Z_REG(addr), Z_OFFSET(addr)
 ||     } else {
 ||             ZEND_ASSERT(0);
 ||     }
@@ -464,7 +464,7 @@ static void* dasm_labels[zend_lb_MAX];
 ||     if (Z_MODE(addr) == IS_CONST_ZVAL) {
 |              PUSH_ADDR Z_ZV(addr), tmp_reg
 ||     } else if (Z_MODE(addr) == IS_MEM_ZVAL) {
-|      PUSH_BASE_ADDR Z_REG(addr), Z_OFFSET(addr), tmp_reg
+|              PUSH_BASE_ADDR Z_REG(addr), Z_OFFSET(addr), tmp_reg
 ||     } else {
 ||             ZEND_ASSERT(0);
 ||     }
@@ -538,9 +538,9 @@ static void* dasm_labels[zend_lb_MAX];
 ||     if (Z_MODE(addr) == IS_CONST_ZVAL) {
 |              MEM_OP2_2 sse_ins, xmm(reg-ZREG_XMM0), qword, Z_ZV(addr), r0
 ||     } else if (Z_MODE(addr) == IS_MEM_ZVAL) {
-|      sse_ins xmm(reg-ZREG_XMM0), qword [Ra(Z_REG(addr))+Z_OFFSET(addr)]
+|              sse_ins xmm(reg-ZREG_XMM0), qword [Ra(Z_REG(addr))+Z_OFFSET(addr)]
 ||     } else if (Z_MODE(addr) == IS_REG) {
-|      sse_ins xmm(reg-ZREG_XMM0), xmm(Z_REG(addr)-ZREG_XMM0)
+|              sse_ins xmm(reg-ZREG_XMM0), xmm(Z_REG(addr)-ZREG_XMM0)
 ||     } else {
 ||             ZEND_ASSERT(0);
 ||     }
@@ -548,20 +548,20 @@ static void* dasm_labels[zend_lb_MAX];
 
 |.macro SSE_AVX_OP, sse_ins, avx_ins, reg, addr
 ||     if (Z_MODE(addr) == IS_CONST_ZVAL) {
-|      .if X64
+|              .if X64
 ||                     if (IS_32BIT(Z_ZV(addr))) {
-|                      SSE_AVX_INS sse_ins, avx_ins, xmm(reg-ZREG_XMM0), qword [Z_ZV(addr)]
+|                              SSE_AVX_INS sse_ins, avx_ins, xmm(reg-ZREG_XMM0), qword [Z_ZV(addr)]
 ||                     } else {
-|                      LOAD_ADDR r0, Z_ZV(addr)
-|                      SSE_AVX_INS sse_ins, avx_ins, xmm(reg-ZREG_XMM0), qword [r0]
+|                              LOAD_ADDR r0, Z_ZV(addr)
+|                              SSE_AVX_INS sse_ins, avx_ins, xmm(reg-ZREG_XMM0), qword [r0]
 ||                     }
-|      .else
-|              SSE_AVX_INS sse_ins, avx_ins, xmm(reg-ZREG_XMM0), qword [Z_ZV(addr)]
-|      .endif
+|              .else
+|                      SSE_AVX_INS sse_ins, avx_ins, xmm(reg-ZREG_XMM0), qword [Z_ZV(addr)]
+|              .endif
 ||     } else if (Z_MODE(addr) == IS_MEM_ZVAL) {
-|      SSE_AVX_INS sse_ins, avx_ins, xmm(reg-ZREG_XMM0), qword [Ra(Z_REG(addr))+Z_OFFSET(addr)]
+|              SSE_AVX_INS sse_ins, avx_ins, xmm(reg-ZREG_XMM0), qword [Ra(Z_REG(addr))+Z_OFFSET(addr)]
 ||     } else if (Z_MODE(addr) == IS_REG) {
-|      SSE_AVX_INS sse_ins, avx_ins, xmm(reg-ZREG_XMM0), xmm(Z_REG(addr)-ZREG_XMM0)
+|              SSE_AVX_INS sse_ins, avx_ins, xmm(reg-ZREG_XMM0), xmm(Z_REG(addr)-ZREG_XMM0)
 ||     } else {
 ||             ZEND_ASSERT(0);
 ||     }
@@ -615,20 +615,20 @@ static void* dasm_labels[zend_lb_MAX];
 |.macro SSE_GET_ZVAL_DVAL, reg, addr
 ||     if (Z_MODE(addr) != IS_REG || reg != Z_REG(addr)) {
 ||             if (Z_MODE(addr) == IS_CONST_ZVAL) {
-|              .if X64
+|                      .if X64
 ||                             if (IS_32BIT(Z_ZV(addr))) {
-|                              SSE_AVX_INS movsd, vmovsd, xmm(reg-ZREG_XMM0), qword [Z_ZV(addr)]
+|                                      SSE_AVX_INS movsd, vmovsd, xmm(reg-ZREG_XMM0), qword [Z_ZV(addr)]
 ||                             } else {
-|                              LOAD_ADDR r0, Z_ZV(addr)
-|                              SSE_AVX_INS movsd, vmovsd, xmm(reg-ZREG_XMM0), qword [r0]
+|                                      LOAD_ADDR r0, Z_ZV(addr)
+|                                      SSE_AVX_INS movsd, vmovsd, xmm(reg-ZREG_XMM0), qword [r0]
 ||                             }
-|              .else
-|                      SSE_AVX_INS movsd, vmovsd, xmm(reg-ZREG_XMM0), qword [Z_ZV(addr)]
-|              .endif
+|                      .else
+|                              SSE_AVX_INS movsd, vmovsd, xmm(reg-ZREG_XMM0), qword [Z_ZV(addr)]
+|                      .endif
 ||             } else if (Z_MODE(addr) == IS_MEM_ZVAL) {
-|              SSE_AVX_INS movsd, vmovsd, xmm(reg-ZREG_XMM0), qword [Ra(Z_REG(addr))+Z_OFFSET(addr)]
+|                      SSE_AVX_INS movsd, vmovsd, xmm(reg-ZREG_XMM0), qword [Ra(Z_REG(addr))+Z_OFFSET(addr)]
 ||             } else if (Z_MODE(addr) == IS_REG) {
-|              SSE_AVX_INS movsd, vmovaps, xmm(reg-ZREG_XMM0), xmm(Z_REG(addr)-ZREG_XMM0)
+|                      SSE_AVX_INS movsd, vmovaps, xmm(reg-ZREG_XMM0), xmm(Z_REG(addr)-ZREG_XMM0)
 ||             } else {
 ||                     ZEND_ASSERT(0);
 ||             }
@@ -684,9 +684,9 @@ static void* dasm_labels[zend_lb_MAX];
 ||     if (Z_MODE(addr) == IS_CONST_ZVAL) {
 |              MEM_OP3_3 avx_ins, xmm(reg-ZREG_XMM0), xmm(op1_reg-ZREG_XMM0), qword, Z_ZV(addr), r0
 ||     } else if (Z_MODE(addr) == IS_MEM_ZVAL) {
-|      avx_ins xmm(reg-ZREG_XMM0), xmm(op1_reg-ZREG_XMM0), qword [Ra(Z_REG(addr))+Z_OFFSET(addr)]
+|              avx_ins xmm(reg-ZREG_XMM0), xmm(op1_reg-ZREG_XMM0), qword [Ra(Z_REG(addr))+Z_OFFSET(addr)]
 ||     } else if (Z_MODE(addr) == IS_REG) {
-|      avx_ins xmm(reg-ZREG_XMM0), xmm(op1_reg-ZREG_XMM0), xmm(Z_REG(addr)-ZREG_XMM0)
+|              avx_ins xmm(reg-ZREG_XMM0), xmm(op1_reg-ZREG_XMM0), xmm(Z_REG(addr)-ZREG_XMM0)
 ||     } else {
 ||             ZEND_ASSERT(0);
 ||     }
@@ -728,25 +728,25 @@ static void* dasm_labels[zend_lb_MAX];
 
 |.macro LONG_OP, long_ins, reg, addr
 ||     if (Z_MODE(addr) == IS_CONST_ZVAL) {
-|      .if X64
-||             if (!IS_SIGNED_32BIT(Z_LVAL_P(Z_ZV(addr)))) {
+|              .if X64
+||                     if (!IS_SIGNED_32BIT(Z_LVAL_P(Z_ZV(addr)))) {
 ||                             if (reg != ZREG_R0) {
-|                                      mov64 r0, Z_LVAL_P(Z_ZV(addr))
-|                              long_ins Ra(reg), r0
+|                                      mov64 r0, Z_LVAL_P(Z_ZV(addr))
+|                                      long_ins Ra(reg), r0
 ||                             } else {
-|                                      mov64 r1, Z_LVAL_P(Z_ZV(addr))
-|                              long_ins Ra(reg), r1
+|                                      mov64 r1, Z_LVAL_P(Z_ZV(addr))
+|                                      long_ins Ra(reg), r1
 ||                             }
-||             } else {
-|                      long_ins Ra(reg), Z_LVAL_P(Z_ZV(addr))
-||             }
-|      .else
-|              long_ins Ra(reg), Z_LVAL_P(Z_ZV(addr))
-|      .endif
+||                     } else {
+|                              long_ins Ra(reg), Z_LVAL_P(Z_ZV(addr))
+||                     }
+|              .else
+|                      long_ins Ra(reg), Z_LVAL_P(Z_ZV(addr))
+|              .endif
 ||     } else if (Z_MODE(addr) == IS_MEM_ZVAL) {
-|      long_ins Ra(reg), aword [Ra(Z_REG(addr))+Z_OFFSET(addr)]
+|              long_ins Ra(reg), aword [Ra(Z_REG(addr))+Z_OFFSET(addr)]
 ||     } else if (Z_MODE(addr) == IS_REG) {
-|      long_ins Ra(reg), Ra(Z_REG(addr))
+|              long_ins Ra(reg), Ra(Z_REG(addr))
 ||     } else {
 ||             ZEND_ASSERT(0);
 ||     }
@@ -755,22 +755,22 @@ static void* dasm_labels[zend_lb_MAX];
 |.macro LONG_OP_WITH_CONST, long_ins, op1_addr, lval
 ||     if (Z_MODE(op1_addr) == IS_MEM_ZVAL) {
 |         .if X64
-||             if (!IS_SIGNED_32BIT(lval)) {
-|                      mov64 r0, lval
+||                     if (!IS_SIGNED_32BIT(lval)) {
+|                              mov64 r0, lval
 |                              long_ins aword [Ra(Z_REG(op1_addr))+Z_OFFSET(op1_addr)], r0
 ||                     } else {
-|                      long_ins aword [Ra(Z_REG(op1_addr))+Z_OFFSET(op1_addr)], lval
+|                              long_ins aword [Ra(Z_REG(op1_addr))+Z_OFFSET(op1_addr)], lval
 ||                     }
 |              .else
 |                      long_ins aword [Ra(Z_REG(op1_addr))+Z_OFFSET(op1_addr)], lval
 |              .endif
 ||     } else if (Z_MODE(op1_addr) == IS_REG) {
 |         .if X64
-||             if (!IS_SIGNED_32BIT(lval)) {
-|                      mov64 r0, lval
+||                     if (!IS_SIGNED_32BIT(lval)) {
+|                              mov64 r0, lval
 |                              long_ins Ra(Z_REG(op1_addr)), r0
 ||                     } else {
-|                      long_ins Ra(Z_REG(op1_addr)), lval
+|                              long_ins Ra(Z_REG(op1_addr)), lval
 ||                     }
 |              .else
 |                      long_ins Ra(Z_REG(op1_addr)), lval
@@ -783,20 +783,20 @@ static void* dasm_labels[zend_lb_MAX];
 |.macro GET_ZVAL_LVAL, reg, addr
 ||     if (Z_MODE(addr) == IS_CONST_ZVAL) {
 ||             if (Z_LVAL_P(Z_ZV(addr)) == 0) {
-|                      xor Ra(reg), Ra(reg)
+|                      xor Ra(reg), Ra(reg)
 ||             } else {
-|              .if X64
-||                     if (!IS_SIGNED_32BIT(Z_LVAL_P(Z_ZV(addr)))) {
-|                              mov64 Ra(reg), Z_LVAL_P(Z_ZV(addr))
-||                     } else {
-|                              mov Ra(reg), Z_LVAL_P(Z_ZV(addr))
-||                     }
-|              .else
-|                      mov Ra(reg), Z_LVAL_P(Z_ZV(addr))
-|              .endif
+|                      .if X64
+||                             if (!IS_SIGNED_32BIT(Z_LVAL_P(Z_ZV(addr)))) {
+|                                      mov64 Ra(reg), Z_LVAL_P(Z_ZV(addr))
+||                             } else {
+|                                      mov Ra(reg), Z_LVAL_P(Z_ZV(addr))
+||                             }
+|                      .else
+|                              mov Ra(reg), Z_LVAL_P(Z_ZV(addr))
+|                      .endif
 ||             }
 ||     } else if (Z_MODE(addr) == IS_MEM_ZVAL) {
-|      mov Ra(reg), aword [Ra(Z_REG(addr))+Z_OFFSET(addr)]
+|              mov Ra(reg), aword [Ra(Z_REG(addr))+Z_OFFSET(addr)]
 ||     } else if (Z_MODE(addr) == IS_REG) {
 ||             if (reg != Z_REG(addr)) {
 |                      mov Ra(reg), Ra(Z_REG(addr))
@@ -879,7 +879,7 @@ static void* dasm_labels[zend_lb_MAX];
 ||                     } else if (!IS_32BIT(zv)) {
 |                              mov64 tmp_reg, ((uintptr_t)zv)
 |                              SSE_AVX_INS movsd, vmovsd, xmm(dst_reg-ZREG_XMM0), qword [tmp_reg]
-|                      .endif
+|                      .endif
 ||                     } else {
 |                              SSE_AVX_INS movsd, vmovsd, xmm(dst_reg-ZREG_XMM0), qword [((uint32_t)(uintptr_t)zv)]
 ||                     }
@@ -933,7 +933,7 @@ static void* dasm_labels[zend_lb_MAX];
 ||                     } else if (!IS_32BIT(zv)) {
 |                              mov64 tmp_reg, ((uintptr_t)zv)
 |                              SSE_AVX_INS movsd, vmovsd, xmm(dst_reg-ZREG_XMM0), qword [tmp_reg]
-|                      .endif
+|                      .endif
 ||                     } else {
 |                              SSE_AVX_INS movsd, vmovsd, xmm(dst_reg-ZREG_XMM0), qword [((uint32_t)(uintptr_t)zv)]
 ||                     }
@@ -1021,13 +1021,13 @@ static void* dasm_labels[zend_lb_MAX];
 ||             if ((src_info & MAY_BE_ANY) == MAY_BE_LONG) {
 ||                     if (Z_MODE(src_addr) == IS_REG) {
 ||                             if (Z_MODE(dst_addr) != IS_REG || Z_REG(dst_addr) != Z_REG(src_addr)) {
-|                                      SET_ZVAL_LVAL dst_addr, Ra(Z_REG(src_addr))
+|                                      SET_ZVAL_LVAL dst_addr, Ra(Z_REG(src_addr))
 ||                             }
 ||                     } else if (Z_MODE(dst_addr) == IS_REG) {
-|                              GET_ZVAL_LVAL Z_REG(dst_addr), src_addr
+|                              GET_ZVAL_LVAL Z_REG(dst_addr), src_addr
 ||                     } else {
-|                              GET_ZVAL_LVAL tmp_reg2, src_addr
-|                              SET_ZVAL_LVAL dst_addr, Ra(tmp_reg2)
+|                              GET_ZVAL_LVAL tmp_reg2, src_addr
+|                              SET_ZVAL_LVAL dst_addr, Ra(tmp_reg2)
 ||                     }
 ||             } else if ((src_info & MAY_BE_ANY) == MAY_BE_DOUBLE) {
 ||                     if (Z_MODE(src_addr) == IS_REG) {
@@ -1039,8 +1039,8 @@ static void* dasm_labels[zend_lb_MAX];
 |                              SSE_SET_ZVAL_DVAL dst_addr, ZREG_XMM0
 ||                     }
 ||             } else if (!(src_info & MAY_BE_DOUBLE)) {
-|                      GET_ZVAL_PTR Ra(tmp_reg2), src_addr
-|                      SET_ZVAL_PTR dst_addr, Ra(tmp_reg2)
+|                      GET_ZVAL_PTR Ra(tmp_reg2), src_addr
+|                      SET_ZVAL_PTR dst_addr, Ra(tmp_reg2)
 ||             } else {
 |                      .if X64
 |                              GET_ZVAL_PTR Ra(tmp_reg2), src_addr
@@ -1061,7 +1061,7 @@ static void* dasm_labels[zend_lb_MAX];
 ||             }
 ||     }
 ||     if ((src_info & (MAY_BE_NULL|MAY_BE_FALSE|MAY_BE_TRUE|MAY_BE_LONG|MAY_BE_DOUBLE)) &&
-||     has_concrete_type(src_info & MAY_BE_ANY)) {
+||             has_concrete_type(src_info & MAY_BE_ANY)) {
 ||             if (Z_MODE(dst_addr) == IS_MEM_ZVAL) {
 ||                     if ((dst_info & (MAY_BE_ANY|MAY_BE_UNDEF|MAY_BE_GUARD)) != (src_info & (MAY_BE_ANY|MAY_BE_UNDEF))) {
 ||                             zend_uchar type = concrete_type(src_info);
@@ -1079,43 +1079,43 @@ static void* dasm_labels[zend_lb_MAX];
 ||             if ((src_info & MAY_BE_ANY) == MAY_BE_LONG) {
 ||                     if (Z_MODE(src_addr) == IS_REG) {
 ||                             if (Z_MODE(dst_addr) != IS_REG || Z_REG(dst_addr) != Z_REG(src_addr)) {
-|                                      SET_ZVAL_LVAL dst_addr, Ra(Z_REG(src_addr))
+|                                      SET_ZVAL_LVAL dst_addr, Ra(Z_REG(src_addr))
 ||                             }
 ||                             if (Z_MODE(res_addr) != IS_REG || Z_REG(res_addr) != Z_REG(src_addr)) {
-|                                      SET_ZVAL_LVAL res_addr, Ra(Z_REG(src_addr))
+|                                      SET_ZVAL_LVAL res_addr, Ra(Z_REG(src_addr))
 ||                             }
 ||                     } else if (Z_MODE(dst_addr) == IS_REG) {
-|                              GET_ZVAL_LVAL Z_REG(dst_addr), src_addr
+|                              GET_ZVAL_LVAL Z_REG(dst_addr), src_addr
 ||                             if (Z_MODE(res_addr) != IS_REG || Z_REG(res_addr) != Z_REG(dst_addr)) {
-|                                      SET_ZVAL_LVAL res_addr, Ra(Z_REG(dst_addr))
+|                                      SET_ZVAL_LVAL res_addr, Ra(Z_REG(dst_addr))
 ||                             }
 ||                     } else if (Z_MODE(res_addr) == IS_REG) {
-|                              GET_ZVAL_LVAL Z_REG(res_addr), src_addr
-|                              SET_ZVAL_LVAL dst_addr, Ra(Z_REG(res_addr))
+|                              GET_ZVAL_LVAL Z_REG(res_addr), src_addr
+|                              SET_ZVAL_LVAL dst_addr, Ra(Z_REG(res_addr))
 ||                     } else {
-|                              GET_ZVAL_LVAL tmp_reg2, src_addr
-|                              SET_ZVAL_LVAL dst_addr, Ra(tmp_reg2)
-|                              SET_ZVAL_LVAL res_addr, Ra(tmp_reg2)
+|                              GET_ZVAL_LVAL tmp_reg2, src_addr
+|                              SET_ZVAL_LVAL dst_addr, Ra(tmp_reg2)
+|                              SET_ZVAL_LVAL res_addr, Ra(tmp_reg2)
 ||                     }
 ||             } else if ((src_info & MAY_BE_ANY) == MAY_BE_DOUBLE) {
 ||                     if (Z_MODE(src_addr) == IS_REG) {
-|                              SSE_SET_ZVAL_DVAL dst_addr, Z_REG(src_addr)
-|                              SSE_SET_ZVAL_DVAL res_addr, Z_REG(src_addr)
+|                              SSE_SET_ZVAL_DVAL dst_addr, Z_REG(src_addr)
+|                              SSE_SET_ZVAL_DVAL res_addr, Z_REG(src_addr)
 ||                     } else if (Z_MODE(dst_addr) == IS_REG) {
 |                              SSE_GET_ZVAL_DVAL Z_REG(dst_addr), src_addr
-|                              SSE_SET_ZVAL_DVAL res_addr, Z_REG(dst_addr)
+|                              SSE_SET_ZVAL_DVAL res_addr, Z_REG(dst_addr)
 ||                     } else if (Z_MODE(res_addr) == IS_REG) {
 |                              SSE_GET_ZVAL_DVAL Z_REG(res_addr), src_addr
-|                              SSE_SET_ZVAL_DVAL dst_addr, Z_REG(res_addr)
+|                              SSE_SET_ZVAL_DVAL dst_addr, Z_REG(res_addr)
 ||                     } else {
 |                              SSE_GET_ZVAL_DVAL ZREG_XMM0, src_addr
 |                              SSE_SET_ZVAL_DVAL dst_addr, ZREG_XMM0
 |                              SSE_SET_ZVAL_DVAL res_addr, ZREG_XMM0
 ||                     }
 ||             } else if (!(src_info & MAY_BE_DOUBLE)) {
-|                      GET_ZVAL_PTR Ra(tmp_reg2), src_addr
-|                      SET_ZVAL_PTR dst_addr, Ra(tmp_reg2)
-|                      SET_ZVAL_PTR res_addr, Ra(tmp_reg2)
+|                      GET_ZVAL_PTR Ra(tmp_reg2), src_addr
+|                      SET_ZVAL_PTR dst_addr, Ra(tmp_reg2)
+|                      SET_ZVAL_PTR res_addr, Ra(tmp_reg2)
 ||             } else {
 |                      .if X64
 |                              GET_ZVAL_PTR Ra(tmp_reg2), src_addr
@@ -1232,11 +1232,11 @@ static void* dasm_labels[zend_lb_MAX];
 |.endmacro
 
 |.macro GC_ADDREF, zv
-|      add     dword [zv], 1
+|      add dword [zv], 1
 |.endmacro
 
 |.macro GC_DELREF, zv
-|      sub     dword [zv], 1
+|      sub dword [zv], 1
 |.endmacro
 
 |.macro IF_GC_MAY_NOT_LEAK, ptr, tmp_reg, label
@@ -1600,7 +1600,7 @@ static uint32_t concrete_type(uint32_t value_type)
 
 static inline zend_bool is_signed(double d)
 {
-    return (((unsigned char*)&d)[sizeof(double)-1] & 0x80) != 0;
+       return (((unsigned char*)&d)[sizeof(double)-1] & 0x80) != 0;
 }
 
 static int zend_jit_interrupt_handler_stub(dasm_State **Dst)
@@ -1739,7 +1739,7 @@ static int zend_jit_leave_throw_stub(dasm_State **Dst)
                |5:
                |       // opline = EG(exception_op);
                |       LOAD_IP_ADDR_ZTS executor_globals, exception_op
-               |       //      HANDLE_EXCEPTION()
+               |       // HANDLE_EXCEPTION()
                |       jmp ->exception_handler
        } else {
                |       GET_IP FCARG1a
@@ -1763,7 +1763,7 @@ static int zend_jit_leave_throw_stub(dasm_State **Dst)
 static int zend_jit_icall_throw_stub(dasm_State **Dst)
 {
        |->icall_throw_handler:
-       |       //      zend_throw_exception_internal(NULL);
+       |       // zend_throw_exception_internal(NULL);
        |.if X64
                |       xor CARG1, CARG1
                |       EXT_CALL zend_throw_exception_internal, r0
@@ -1773,7 +1773,7 @@ static int zend_jit_icall_throw_stub(dasm_State **Dst)
                |       EXT_CALL zend_throw_exception_internal, r0
                |       add r4, 16
        |.endif
-       |       //      HANDLE_EXCEPTION()
+       |       // HANDLE_EXCEPTION()
        |       jmp ->exception_handler
 
        return 1;
@@ -1792,9 +1792,9 @@ static int zend_jit_throw_cannot_pass_by_ref_stub(dasm_State **Dst)
        |       // last EX(call) frame may be delayed
        |       cmp RX, EX->call
        |       je >1
-       |       mov     r1, EX->call
-       |       mov     EX:RX->prev_execute_data, r1
-       |       mov     EX->call, RX
+       |       mov r1, EX->call
+       |       mov EX:RX->prev_execute_data, r1
+       |       mov EX->call, RX
        |1:
        |       mov RX, r0
        |.if X64
@@ -2156,7 +2156,7 @@ static int zend_jit_hybrid_profile_jit_stub(dasm_State **Dst)
        |       jz >1
        |       MEM_OP2_2_ZTS add, r2, aword, compiler_globals, map_ptr_base, r1
        |1:
-       |       mov     r2, aword [r2]
+       |       mov r2, aword [r2]
 #else
 # error "Unknown ZEND_MAP_PTR_KIND"
 #endif
@@ -2164,7 +2164,7 @@ static int zend_jit_hybrid_profile_jit_stub(dasm_State **Dst)
        |       // handler = (const void*)ZEND_FUNC_INFO(op_array);
        |       mov r0, aword [r0 + offsetof(zend_op_array, reserved[zend_func_info_rid])]
        |       // return ((zend_vm_opcode_handler_t)handler)();
-       |       jmp     r0
+       |       jmp r0
        return 1;
 }
 
@@ -2263,7 +2263,7 @@ static int zend_jit_hybrid_trace_counter_stub(dasm_State **Dst, uint32_t cost)
        |       mov r0, EX->func
        |       mov r1, aword [r0 + offsetof(zend_op_array, reserved[zend_func_info_rid])]
        |       mov r1, aword [r1 + offsetof(zend_jit_op_array_trace_extension, offset)]
-       |       mov     r2, aword [IP + r1 + offsetof(zend_op_trace_info, counter)]
+       |       mov r2, aword [IP + r1 + offsetof(zend_op_trace_info, counter)]
        |       sub word [r2], cost
        |       jle >1
        |       jmp aword [IP + r1]
@@ -3634,9 +3634,9 @@ static int zend_jit_math_long_long(dasm_State    **Dst,
                }
        } else if (opcode == ZEND_DIV &&
                        (Z_MODE(op2_addr) == IS_CONST_ZVAL &&
-            is_power_of_two(Z_LVAL_P(Z_ZV(op2_addr))))) {
+                       is_power_of_two(Z_LVAL_P(Z_ZV(op2_addr))))) {
                |       GET_ZVAL_LVAL result_reg, op1_addr
-               |       shr Ra(result_reg), floor_log2(Z_LVAL_P(Z_ZV(op2_addr)))
+               |       shr Ra(result_reg), floor_log2(Z_LVAL_P(Z_ZV(op2_addr)))
        } else {
                |       GET_ZVAL_LVAL result_reg, op1_addr
                if (same_ops && opcode != ZEND_DIV) {
@@ -4785,14 +4785,14 @@ static int zend_jit_fetch_dimension_address_inner(dasm_State **Dst, const zend_o
                                |       IF_Z_TYPE r0, IS_INDIRECT, >1 // SLOW
                                |.cold_code
                                |1:
-                               |       //      retval = Z_INDIRECT_P(retval);
+                               |       // retval = Z_INDIRECT_P(retval);
                                |       GET_Z_PTR r0, r0
                                |       IF_NOT_Z_TYPE r0, IS_UNDEF, >8
                                |2:
                                switch (type) {
                                        case BP_VAR_R:
                                                if (zend_jit_trigger != ZEND_JIT_ON_HOT_TRACE) {
-                                                       //      zend_error(E_NOTICE, "Undefined index: %s", ZSTR_VAL(offset_key));
+                                                       // zend_error(E_NOTICE, "Undefined index: %s", ZSTR_VAL(offset_key));
                                                        |       UNDEFINED_INDEX opline
                                                        |       jmp >9
                                                }
@@ -4954,7 +4954,7 @@ static int zend_jit_simple_assign(dasm_State    **Dst,
                        if (res_addr) {
                                |       SET_ZVAL_TYPE_INFO res_addr, IS_NULL
                        }
-                       |       jmp     >3
+                       |       jmp >3
                        if (in_cold) {
                                |2:
                        } else {
@@ -7517,7 +7517,7 @@ static int zend_jit_push_call_frame(dasm_State **Dst, const zend_op *opline, con
                |       mov FCARG1a, used_stack
                |       jnz >1
                |       // used_stack += (func->op_array.last_var + func->op_array.T - MIN(func->op_array.num_args, num_args)) * sizeof(zval);
-               |       mov     edx, opline->extended_value
+               |       mov edx, opline->extended_value
                |       cmp edx, dword [r0 + offsetof(zend_function, op_array.num_args)]
                |       cmova edx, dword [r0 + offsetof(zend_function, op_array.num_args)]
                |       sub edx, dword [r0 + offsetof(zend_function, op_array.last_var)]
@@ -7741,11 +7741,11 @@ static int zend_jit_init_fcall_guard(dasm_State **Dst, const zend_op *opline, co
                |       mov r1, EX->call
                |       mov r1, aword EX:r1->func
                |   .if X64
-               ||              if (!IS_SIGNED_32BIT(opcodes)) {
-               |                       mov64 r0, ((ptrdiff_t)opcodes)
+               ||              if (!IS_SIGNED_32BIT(opcodes)) {
+               |                       mov64 r0, ((ptrdiff_t)opcodes)
                |                       cmp aword [r1 + offsetof(zend_op_array, opcodes)], r0
                ||              } else {
-               |                       cmp aword [r1 + offsetof(zend_op_array, opcodes)], opcodes
+               |                       cmp aword [r1 + offsetof(zend_op_array, opcodes)], opcodes
                ||              }
                |       .else
                |               cmp aword [r1 + offsetof(zend_op_array, opcodes)], opcodes
@@ -7755,11 +7755,11 @@ static int zend_jit_init_fcall_guard(dasm_State **Dst, const zend_op *opline, co
                |       // call = EX(call);
                |       mov r1, EX->call
                |   .if X64
-               ||              if (!IS_SIGNED_32BIT(func)) {
-               |                       mov64 r0, ((ptrdiff_t)func)
+               ||              if (!IS_SIGNED_32BIT(func)) {
+               |                       mov64 r0, ((ptrdiff_t)func)
                |                       cmp aword EX:r1->func, r0
                ||              } else {
-               |                       cmp aword EX:r1->func, func
+               |                       cmp aword EX:r1->func, func
                ||              }
                |       .else
                |               cmp aword EX:r1->func, func
@@ -7824,10 +7824,10 @@ static int zend_jit_init_fcall(dasm_State **Dst, const zend_op *opline, uint32_t
                /* load constant address later */
        } else if (func && op_array == &func->op_array) {
                /* recursive call */
-               |       mov r0, EX->func
+               |       mov r0, EX->func
        } else {
                |       // if (CACHED_PTR(opline->result.num))
-               |       mov r0, EX->run_time_cache
+               |       mov r0, EX->run_time_cache
                |       mov r0, aword [r0 + opline->result.num]
                |       test r0, r0
                |       jz >1
@@ -7839,7 +7839,7 @@ static int zend_jit_init_fcall(dasm_State **Dst, const zend_op *opline, uint32_t
                 && (func->op_array.fn_flags & ZEND_ACC_IMMUTABLE)) {
                        |       LOAD_ADDR FCARG1a, func
                        |       EXT_CALL zend_jit_init_func_run_time_cache_helper, r0
-                       |       mov r1, EX->run_time_cache
+                       |       mov r1, EX->run_time_cache
                        |       mov aword [r1 + opline->result.num], r0
                        |       jmp >3
                } else {
@@ -7858,7 +7858,7 @@ static int zend_jit_init_fcall(dasm_State **Dst, const zend_op *opline, uint32_t
                                ZEND_ASSERT(0);
                        }
                        |       // CACHE_PTR(opline->result.num, fbc);
-                       |       mov r1, EX->run_time_cache
+                       |       mov r1, EX->run_time_cache
                        |       mov aword [r1 + opline->result.num], r0
                        if (zend_jit_trigger == ZEND_JIT_ON_HOT_TRACE) {
                                if (!func || opline->opcode == ZEND_INIT_FCALL) {
@@ -7869,11 +7869,11 @@ static int zend_jit_init_fcall(dasm_State **Dst, const zend_op *opline, uint32_t
                                        const zend_op *opcodes = func->op_array.opcodes;
 
                                        |   .if X64
-                                       ||              if (!IS_SIGNED_32BIT(opcodes)) {
-                                       |                       mov64 r1, ((ptrdiff_t)opcodes)
+                                       ||              if (!IS_SIGNED_32BIT(opcodes)) {
+                                       |                       mov64 r1, ((ptrdiff_t)opcodes)
                                        |                       cmp aword [r0 + offsetof(zend_op_array, opcodes)], r1
                                        ||              } else {
-                                       |                       cmp aword [r0 + offsetof(zend_op_array, opcodes)], opcodes
+                                       |                       cmp aword [r0 + offsetof(zend_op_array, opcodes)], opcodes
                                        ||              }
                                        |       .else
                                        |               cmp aword [r0 + offsetof(zend_op_array, opcodes)], opcodes
@@ -7881,11 +7881,11 @@ static int zend_jit_init_fcall(dasm_State **Dst, const zend_op *opline, uint32_t
                                        |       jz >3
                                } else {
                                        |   .if X64
-                                       ||              if (!IS_SIGNED_32BIT(func)) {
-                                       |                       mov64 r1, ((ptrdiff_t)func)
+                                       ||              if (!IS_SIGNED_32BIT(func)) {
+                                       |                       mov64 r1, ((ptrdiff_t)func)
                                        |                       cmp r0, r1
                                        ||              } else {
-                                       |                       cmp r0, func
+                                       |                       cmp r0, func
                                        ||              }
                                        |       .else
                                        |               cmp r0, func
@@ -8147,13 +8147,13 @@ static int zend_jit_do_fcall(dasm_State **Dst, const zend_op *opline, const zend
                                        if (func->op_array.fn_flags & ZEND_ACC_IMMUTABLE) {
                                                |       MEM_OP2_2_ZTS add, r2, aword, compiler_globals, map_ptr_base, r1
                                        }
-                                       |       mov     r2, aword [r2]
+                                       |       mov r2, aword [r2]
                                } else {
                                        |       test r2, 1
                                        |       jz >1
                                        |       MEM_OP2_2_ZTS add, r2, aword, compiler_globals, map_ptr_base, r1
                                        |1:
-                                       |       mov     r2, aword [r2]
+                                       |       mov r2, aword [r2]
                                }
 #else
 # error "Unknown ZEND_MAP_PTR_KIND"
@@ -8244,14 +8244,14 @@ static int zend_jit_do_fcall(dasm_State **Dst, const zend_op *opline, const zend
                        if (func) {
                                |       // num_args = EX_NUM_ARGS();
                                |       mov ecx, dword [FP + offsetof(zend_execute_data, This.u2.num_args)]
-                               |       //      if (UNEXPECTED(num_args > first_extra_arg))
+                               |       // if (UNEXPECTED(num_args > first_extra_arg))
                                |       cmp ecx, (func->op_array.num_args)
                        } else {
                                |       // first_extra_arg = op_array->num_args;
                                |       mov edx, dword [r0 + offsetof(zend_op_array, num_args)]
                                |       // num_args = EX_NUM_ARGS();
                                |       mov ecx, dword [FP + offsetof(zend_execute_data, This.u2.num_args)]
-                               |       //      if (UNEXPECTED(num_args > first_extra_arg))
+                               |       // if (UNEXPECTED(num_args > first_extra_arg))
                                |       cmp ecx, edx
                        }
                        |       jg >1
@@ -8554,11 +8554,11 @@ static int zend_jit_send_val(dasm_State **Dst, const zend_op *opline, const zend
                        }
                        |       mov r0, EX:RX->func
                        |       test dword [r0 + offsetof(zend_function, quick_arg_flags)], mask
-                       |       jnz     &exit_addr
+                       |       jnz &exit_addr
                } else {
                        |       mov r0, EX:RX->func
                        |       test dword [r0 + offsetof(zend_function, quick_arg_flags)], mask
-                       |       jnz     >1
+                       |       jnz >1
                        |.cold_code
                        |1:
                        |       SAVE_VALID_OPLINE opline, r0
@@ -8631,7 +8631,7 @@ static int zend_jit_send_ref(dasm_State **Dst, const zend_op *opline, const zend
                        |       GC_ADDREF r1
                        |       SET_ZVAL_PTR arg_addr, r1
                        |       SET_ZVAL_TYPE_INFO arg_addr, IS_REFERENCE_EX
-                       |       jmp     >6
+                       |       jmp >6
                }
                |2:
                |       // ZVAL_NEW_REF(arg, varptr);
@@ -8699,7 +8699,7 @@ static int zend_jit_send_var(dasm_State **Dst, const zend_op *opline, const zend
 
                        |       mov r0, EX:RX->func
                        |       test dword [r0 + offsetof(zend_function, quick_arg_flags)], mask
-                       |       jnz     >1
+                       |       jnz >1
                        |.cold_code
                        |1:
                        if (!zend_jit_send_ref(Dst, opline, op_array, op1_info, 1)) {
@@ -8738,7 +8738,7 @@ static int zend_jit_send_var(dasm_State **Dst, const zend_op *opline, const zend
 
                        |       mov r0, EX:RX->func
                        |       test dword [r0 + offsetof(zend_function, quick_arg_flags)], mask
-                       |       jnz     >1
+                       |       jnz >1
                        |.cold_code
                        |1:
 
@@ -8783,7 +8783,7 @@ static int zend_jit_send_var(dasm_State **Dst, const zend_op *opline, const zend
                        }
                } else {
                        |       test dword [RX + offsetof(zend_execute_data, This.u1.type_info)], ZEND_CALL_SEND_ARG_BY_REF
-                       |       jnz     >1
+                       |       jnz >1
                        |.cold_code
                        |1:
                        if (!zend_jit_send_ref(Dst, opline, op_array, op1_info, 1)) {
@@ -8926,7 +8926,7 @@ static int zend_jit_check_func_arg(dasm_State **Dst, const zend_op *opline, cons
                }
                |       mov r0, EX:RX->func
                |       test dword [r0 + offsetof(zend_function, quick_arg_flags)], mask
-               |       jnz     >1
+               |       jnz >1
                |.cold_code
                |1:
                |       // ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
@@ -8949,9 +8949,9 @@ static int zend_jit_smart_true(dasm_State **Dst, const zend_op *opline, int jmp,
                                |       jmp >7
                        }
                } else if (smart_branch_opcode == ZEND_JMPNZ) {
-                       |       jmp =>target_label
+                       |       jmp =>target_label
                } else if (smart_branch_opcode == ZEND_JMPZNZ) {
-                       |       jmp =>target_label2
+                       |       jmp =>target_label2
                } else {
                        ZEND_ASSERT(0);
                }
@@ -8971,13 +8971,13 @@ static int zend_jit_smart_false(dasm_State **Dst, const zend_op *opline, int jmp
 {
        if (smart_branch_opcode) {
                if (smart_branch_opcode == ZEND_JMPZ) {
-                       |       jmp =>target_label
+                       |       jmp =>target_label
                } else if (smart_branch_opcode == ZEND_JMPNZ) {
                        if (jmp) {
                                |       jmp >7
                        }
                } else if (smart_branch_opcode == ZEND_JMPZNZ) {
-                       |       jmp =>target_label
+                       |       jmp =>target_label
                } else {
                        ZEND_ASSERT(0);
                }
@@ -9014,7 +9014,7 @@ static int zend_jit_defined(dasm_State **Dst, const zend_op *opline, const zend_
        }
 
        |       // if (CACHED_PTR(opline->extended_value)) {
-       |       mov r0, EX->run_time_cache
+       |       mov r0, EX->run_time_cache
        |       mov r0, aword [r0 + opline->extended_value]
        |       test r0, r0
        |       jz >1
@@ -9023,7 +9023,7 @@ static int zend_jit_defined(dasm_State **Dst, const zend_op *opline, const zend_
        |.cold_code
        |4:
        |       MEM_OP2_2_ZTS mov, FCARG1a, aword, executor_globals, zend_constants, FCARG1a
-       |       shr     r0, 1
+       |       shr r0, 1
        |       cmp dword [FCARG1a + offsetof(HashTable, nNumOfElements)], eax
 
        if (smart_branch_opcode) {
@@ -9213,7 +9213,7 @@ static int zend_jit_type_check(dasm_State **Dst, const zend_op *opline, const ze
                                                |       mov cl, byte [FP + opline->op1.var + 8]
                                        }
                                        |2:
-                } else {
+                               } else {
                                        if (op1_info & MAY_BE_REF) {
                                                |       mov cl, byte [r0 + 8]
                                        } else {
@@ -9231,12 +9231,12 @@ static int zend_jit_type_check(dasm_State **Dst, const zend_op *opline, const ze
                                        }
                                } else if (smart_branch_opcode) {
                                        if (smart_branch_opcode == ZEND_JMPZ) {
-                                               |       je =>target_label
+                                               |       je =>target_label
                                        } else if (smart_branch_opcode == ZEND_JMPNZ) {
-                                               |       jne =>target_label
+                                               |       jne =>target_label
                                        } else if (smart_branch_opcode == ZEND_JMPZNZ) {
-                                               |       je =>target_label
-                                               |       jmp =>target_label2
+                                               |       je =>target_label
+                                               |       jmp =>target_label2
                                        } else {
                                                ZEND_ASSERT(0);
                                        }
@@ -9306,12 +9306,12 @@ static int zend_jit_type_check(dasm_State **Dst, const zend_op *opline, const ze
                                        }
                                } else if (smart_branch_opcode) {
                                        if (smart_branch_opcode == ZEND_JMPZ) {
-                                               |       jne =>target_label
+                                               |       jne =>target_label
                                        } else if (smart_branch_opcode == ZEND_JMPNZ) {
-                                               |       je =>target_label
+                                               |       je =>target_label
                                        } else if (smart_branch_opcode == ZEND_JMPZNZ) {
-                                               |       jne =>target_label
-                                               |       jmp =>target_label2
+                                               |       jne =>target_label
+                                               |       jmp =>target_label2
                                        } else {
                                                ZEND_ASSERT(0);
                                        }
@@ -9335,7 +9335,7 @@ static int zend_jit_type_check(dasm_State **Dst, const zend_op *opline, const ze
 
 static uint32_t zend_ssa_cv_info(const zend_op *opline, const zend_op_array *op_array, zend_ssa *ssa, uint32_t var)
 {
-    uint32_t j, info;
+       uint32_t j, info;
 
        if (ssa->vars && ssa->var_info) {
                info = ssa->var_info[var].type;
@@ -10000,7 +10000,7 @@ static int zend_jit_bind_global(dasm_State **Dst, const zend_op *opline, const z
        zend_string *varname = Z_STR_P(RT_CONSTANT(opline, opline->op2));
 
        |       // idx = (uint32_t)(uintptr_t)CACHED_PTR(opline->extended_value) - 1;
-       |       mov     r0, EX->run_time_cache
+       |       mov r0, EX->run_time_cache
        |       mov r0, aword [r0 + opline->extended_value]
        |       sub r0, 1
        |       // if (EXPECTED(idx < EG(symbol_table).nNumUsed * sizeof(Bucket)))
@@ -10066,7 +10066,7 @@ static int zend_jit_bind_global(dasm_State **Dst, const zend_op *opline, const z
        |.cold_code
        |9:
        |       LOAD_ADDR FCARG1a, (ptrdiff_t)varname
-       |       mov     FCARG2a, EX->run_time_cache
+       |       mov FCARG2a, EX->run_time_cache
        if (opline->extended_value) {
                |       add FCARG2a, opline->extended_value
        }
@@ -10131,7 +10131,7 @@ static int zend_jit_recv(dasm_State **Dst, const zend_op *opline, const zend_op_
                                |8:
                                |       SAVE_VALID_OPLINE opline, r0
                                |       mov FCARG1a, r0
-                               |       mov r0, EX->run_time_cache
+                               |       mov r0, EX->run_time_cache
                                |       add r0, opline->extended_value
                                |       mov FCARG2a, EX->func
                                |.if X64WIN
@@ -10278,7 +10278,7 @@ static int zend_jit_recv_init(dasm_State **Dst, const zend_op *opline, const zen
        if (has_slow & 2) {
        |8:
        |       mov FCARG1a, r0
-       |       mov r0, EX->run_time_cache
+       |       mov r0, EX->run_time_cache
        |       lea r0, [r0 + opline->extended_value]
        |       mov FCARG2a, EX->func
        |.if X64WIN
@@ -10430,7 +10430,7 @@ static int zend_jit_fetch_obj_read(dasm_State **Dst, const zend_op *opline, cons
        }
 
        if (offset == ZEND_WRONG_PROPERTY_OFFSET) {
-               |       mov r0, EX->run_time_cache
+               |       mov r0, EX->run_time_cache
                |       mov r2, aword [r0 + (opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS)]
                |       cmp r2, aword [FCARG1a + offsetof(zend_object, ce)]
                |       jne >5
@@ -10768,7 +10768,7 @@ static int zend_jit_switch(dasm_State **Dst, const zend_op *opline, const zend_o
                zend_ssa_op *ssa_op = &ssa->ops[opline - op_array->opcodes];
                uint32_t op1_info = OP1_INFO();
                zend_jit_addr op1_addr = OP1_ADDR();
-               int     b = ssa->cfg.map[ZEND_OFFSET_TO_OPLINE(opline, opline->extended_value) - op_array->opcodes];
+               int b = ssa->cfg.map[ZEND_OFFSET_TO_OPLINE(opline, opline->extended_value) - op_array->opcodes];
                zval *val;
 
                if (opline->opcode == ZEND_SWITCH_LONG) {
@@ -10943,7 +10943,7 @@ static zend_bool zend_jit_verify_return_type(dasm_State **Dst, const zend_op *op
        |.cold_code
        |8:
        |       mov FCARG1a, r0
-       |       mov r0, EX->run_time_cache
+       |       mov r0, EX->run_time_cache
        |       add r0, opline->op2.num
        |       mov FCARG2a, EX->func
        |.if X64

diff --git a/ext/opcache/jit/zend_jit_x86.h b/ext/opcache/jit/zend_jit_x86.h
index 9a81c7f74b6c7ebb693a288f03b08041511ed492..5bf2521815c6c953a0b7e71b0c7e8324b9867a5e 100644 (file)
--- a/ext/opcache/jit/zend_jit_x86.h
+++ b/ext/opcache/jit/zend_jit_x86.h
@@ -75,14 +75,14 @@ typedef struct _zend_jit_registers_buf {
 #endif
 } zend_jit_registers_buf;
 
-#define        ZREG_RAX ZREG_R0
-#define        ZREG_RCX ZREG_R1
-#define        ZREG_RDX ZREG_R2
-#define        ZREG_RBX ZREG_R3
-#define        ZREG_RSP ZREG_R4
-#define        ZREG_RBP ZREG_R5
-#define        ZREG_RSI ZREG_R6
-#define        ZREG_RDI ZREG_R7
+#define ZREG_RAX ZREG_R0
+#define ZREG_RCX ZREG_R1
+#define ZREG_RDX ZREG_R2
+#define ZREG_RBX ZREG_R3
+#define ZREG_RSP ZREG_R4
+#define ZREG_RBP ZREG_R5
+#define ZREG_RSI ZREG_R6
+#define ZREG_RDI ZREG_R7
 
 #ifdef _WIN64
 # define ZREG_FP      ZREG_R14