CONCAT/FAST_CONCAT micro-optimization

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index e7777e0098712da4f732d3c5a4bc5d33e442d205..0513034107b2dfedfbf7424617bde62b80867acc 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -297,38 +297,36 @@ ZEND_VM_HANDLER(8, ZEND_CONCAT, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
                zend_string *op2_str = Z_STR_P(op2);
                zend_string *str;
 
-               do {
-                       if (OP1_TYPE != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
-                                       FREE_OP1();
-                                       break;
-                               }
-                       }
-                       if (OP2_TYPE != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
-                                       FREE_OP1();
-                                       break;
-                               }
+               if (OP1_TYPE != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
+                       if (OP2_TYPE == IS_CONST || OP2_TYPE == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
+                       } else {
+                               ZVAL_STR(EX_VAR(opline->result.var), op2_str);
                        }
-                       if (OP1_TYPE != IS_CONST && OP1_TYPE != IS_CV &&
-                           !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-                           size_t len = ZSTR_LEN(op1_str);
-
-                               str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
-                               break;
+                       FREE_OP1();
+               } else if (OP2_TYPE != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
+                       if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
                        } else {
-                               str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
-                               memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+                               ZVAL_STR(EX_VAR(opline->result.var), op1_str);
                        }
+                       FREE_OP2();
+               } else if (OP1_TYPE != IS_CONST && OP1_TYPE != IS_CV &&
+                   !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
+                   size_t len = ZSTR_LEN(op1_str);
+
+                       str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+                       FREE_OP2();
+               } else {
+                       str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
+                       memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
                        FREE_OP1();
-               } while (0);
-               FREE_OP2();
+                       FREE_OP2();
+               }
                ZEND_VM_NEXT_OPCODE();
        } else {
                SAVE_OPLINE();
@@ -2734,38 +2732,36 @@ ZEND_VM_HANDLER(53, ZEND_FAST_CONCAT, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
                zend_string *op2_str = Z_STR_P(op2);
                zend_string *str;
 
-               do {
-                       if (OP1_TYPE != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
-                                       FREE_OP1();
-                                       break;
-                               }
-                       }
-                       if (OP2_TYPE != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
-                                       FREE_OP1();
-                                       break;
-                               }
+               if (OP1_TYPE != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
+                       if (OP2_TYPE == IS_CONST || OP2_TYPE == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
+                       } else {
+                               ZVAL_STR(EX_VAR(opline->result.var), op2_str);
                        }
-                       if (OP1_TYPE != IS_CONST && OP1_TYPE != IS_CV &&
-                           !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-                           size_t len = ZSTR_LEN(op1_str);
-
-                               str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
-                               break;
+                       FREE_OP1();
+               } else if (OP2_TYPE != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
+                       if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
                        } else {
-                               str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
-                               memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+                               ZVAL_STR(EX_VAR(opline->result.var), op1_str);
                        }
+                       FREE_OP2();
+               } else if (OP1_TYPE != IS_CONST && OP1_TYPE != IS_CV &&
+                   !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
+                   size_t len = ZSTR_LEN(op1_str);
+
+                       str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+                       FREE_OP2();
+               } else {
+                       str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
+                       memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
                        FREE_OP1();
-               } while (0);
-               FREE_OP2();
+                       FREE_OP2();
+               }
                ZEND_VM_NEXT_OPCODE();
        }
 

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 57b2f82fc06927f4796bef9b5782ad587d5fa9d8..185a89a496106061da9a87afc447fa2c784767f8 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -4411,38 +4411,36 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_CONST_HANDLE
                zend_string *op2_str = Z_STR_P(op2);
                zend_string *str;
 
-               do {
-                       if (IS_CONST != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
-
-                                       break;
-                               }
-                       }
-                       if (IS_CONST != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
-
-                                       break;
-                               }
+               if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
+                       if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
+                       } else {
+                               ZVAL_STR(EX_VAR(opline->result.var), op2_str);
                        }
-                       if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
-                           !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-                           size_t len = ZSTR_LEN(op1_str);
 
-                               str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
-                               break;
+               } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
+                       if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
                        } else {
-                               str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
-                               memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+                               ZVAL_STR(EX_VAR(opline->result.var), op1_str);
                        }
 
-               } while (0);
+               } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
+                   !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
+                   size_t len = ZSTR_LEN(op1_str);
+
+                       str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+
+               } else {
+                       str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
+                       memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
 
+
+               }
                ZEND_VM_NEXT_OPCODE();
        } else {
                SAVE_OPLINE();
@@ -5265,38 +5263,36 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CONST_CONST_H
                zend_string *op2_str = Z_STR_P(op2);
                zend_string *str;
 
-               do {
-                       if (IS_CONST != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
-
-                                       break;
-                               }
-                       }
-                       if (IS_CONST != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
-
-                                       break;
-                               }
+               if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
+                       if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
+                       } else {
+                               ZVAL_STR(EX_VAR(opline->result.var), op2_str);
                        }
-                       if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
-                           !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-                           size_t len = ZSTR_LEN(op1_str);
 
-                               str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
-                               break;
+               } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
+                       if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
                        } else {
-                               str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
-                               memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+                               ZVAL_STR(EX_VAR(opline->result.var), op1_str);
                        }
 
-               } while (0);
+               } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
+                   !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
+                   size_t len = ZSTR_LEN(op1_str);
+
+                       str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
 
+               } else {
+                       str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
+                       memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+
+
+               }
                ZEND_VM_NEXT_OPCODE();
        }
 
@@ -8590,38 +8586,36 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_CV_HANDLER(Z
                zend_string *op2_str = Z_STR_P(op2);
                zend_string *str;
 
-               do {
-                       if (IS_CONST != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
-
-                                       break;
-                               }
-                       }
-                       if (IS_CV != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
-
-                                       break;
-                               }
+               if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
+                       if (IS_CV == IS_CONST || IS_CV == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
+                       } else {
+                               ZVAL_STR(EX_VAR(opline->result.var), op2_str);
                        }
-                       if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
-                           !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-                           size_t len = ZSTR_LEN(op1_str);
 
-                               str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
-                               break;
+               } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
+                       if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
                        } else {
-                               str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
-                               memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+                               ZVAL_STR(EX_VAR(opline->result.var), op1_str);
                        }
 
-               } while (0);
+               } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
+                   !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
+                   size_t len = ZSTR_LEN(op1_str);
+
+                       str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+
+               } else {
+                       str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
+                       memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+
 
+               }
                ZEND_VM_NEXT_OPCODE();
        } else {
                SAVE_OPLINE();
@@ -9377,38 +9371,36 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CONST_CV_HAND
                zend_string *op2_str = Z_STR_P(op2);
                zend_string *str;
 
-               do {
-                       if (IS_CONST != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
-
-                                       break;
-                               }
-                       }
-                       if (IS_CV != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
-
-                                       break;
-                               }
+               if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
+                       if (IS_CV == IS_CONST || IS_CV == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
+                       } else {
+                               ZVAL_STR(EX_VAR(opline->result.var), op2_str);
                        }
-                       if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
-                           !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-                           size_t len = ZSTR_LEN(op1_str);
 
-                               str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
-                               break;
+               } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
+                       if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
                        } else {
-                               str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
-                               memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+                               ZVAL_STR(EX_VAR(opline->result.var), op1_str);
                        }
 
-               } while (0);
+               } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
+                   !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
+                   size_t len = ZSTR_LEN(op1_str);
+
+                       str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+
+               } else {
+                       str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
+                       memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
 
+
+               }
                ZEND_VM_NEXT_OPCODE();
        }
 
@@ -10699,38 +10691,36 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDL
                zend_string *op2_str = Z_STR_P(op2);
                zend_string *str;
 
-               do {
-                       if (IS_CONST != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
-
-                                       break;
-                               }
-                       }
-                       if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
-
-                                       break;
-                               }
+               if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
+                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
+                       } else {
+                               ZVAL_STR(EX_VAR(opline->result.var), op2_str);
                        }
-                       if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
-                           !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-                           size_t len = ZSTR_LEN(op1_str);
 
-                               str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
-                               break;
+               } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
+                       if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
                        } else {
-                               str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
-                               memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+                               ZVAL_STR(EX_VAR(opline->result.var), op1_str);
                        }
+                       zval_ptr_dtor_nogc(free_op2);
+               } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
+                   !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
+                   size_t len = ZSTR_LEN(op1_str);
 
-               } while (0);
-               zval_ptr_dtor_nogc(free_op2);
+                       str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+                       zval_ptr_dtor_nogc(free_op2);
+               } else {
+                       str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
+                       memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+
+                       zval_ptr_dtor_nogc(free_op2);
+               }
                ZEND_VM_NEXT_OPCODE();
        } else {
                SAVE_OPLINE();
@@ -11452,38 +11442,36 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_
                zend_string *op2_str = Z_STR_P(op2);
                zend_string *str;
 
-               do {
-                       if (IS_CONST != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
-
-                                       break;
-                               }
-                       }
-                       if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
-
-                                       break;
-                               }
+               if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
+                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
+                       } else {
+                               ZVAL_STR(EX_VAR(opline->result.var), op2_str);
                        }
-                       if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
-                           !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-                           size_t len = ZSTR_LEN(op1_str);
 
-                               str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
-                               break;
+               } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
+                       if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
                        } else {
-                               str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
-                               memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+                               ZVAL_STR(EX_VAR(opline->result.var), op1_str);
                        }
+                       zval_ptr_dtor_nogc(free_op2);
+               } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
+                   !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
+                   size_t len = ZSTR_LEN(op1_str);
 
-               } while (0);
-               zval_ptr_dtor_nogc(free_op2);
+                       str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+                       zval_ptr_dtor_nogc(free_op2);
+               } else {
+                       str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
+                       memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+
+                       zval_ptr_dtor_nogc(free_op2);
+               }
                ZEND_VM_NEXT_OPCODE();
        }
 
@@ -35257,38 +35245,36 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CONST_HANDLER(Z
                zend_string *op2_str = Z_STR_P(op2);
                zend_string *str;
 
-               do {
-                       if (IS_CV != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
-
-                                       break;
-                               }
-                       }
-                       if (IS_CONST != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
-
-                                       break;
-                               }
+               if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
+                       if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
+                       } else {
+                               ZVAL_STR(EX_VAR(opline->result.var), op2_str);
                        }
-                       if (IS_CV != IS_CONST && IS_CV != IS_CV &&
-                           !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-                           size_t len = ZSTR_LEN(op1_str);
 
-                               str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
-                               break;
+               } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
+                       if (IS_CV == IS_CONST || IS_CV == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
                        } else {
-                               str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
-                               memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+                               ZVAL_STR(EX_VAR(opline->result.var), op1_str);
                        }
 
-               } while (0);
+               } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
+                   !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
+                   size_t len = ZSTR_LEN(op1_str);
+
+                       str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+
+               } else {
+                       str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
+                       memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+
 
+               }
                ZEND_VM_NEXT_OPCODE();
        } else {
                SAVE_OPLINE();
@@ -37841,38 +37827,36 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_CONST_HAND
                zend_string *op2_str = Z_STR_P(op2);
                zend_string *str;
 
-               do {
-                       if (IS_CV != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
-
-                                       break;
-                               }
-                       }
-                       if (IS_CONST != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
-
-                                       break;
-                               }
+               if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
+                       if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
+                       } else {
+                               ZVAL_STR(EX_VAR(opline->result.var), op2_str);
                        }
-                       if (IS_CV != IS_CONST && IS_CV != IS_CV &&
-                           !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-                           size_t len = ZSTR_LEN(op1_str);
 
-                               str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
-                               break;
+               } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
+                       if (IS_CV == IS_CONST || IS_CV == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
                        } else {
-                               str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
-                               memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+                               ZVAL_STR(EX_VAR(opline->result.var), op1_str);
                        }
 
-               } while (0);
+               } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
+                   !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
+                   size_t len = ZSTR_LEN(op1_str);
+
+                       str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+
+               } else {
+                       str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
+                       memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
 
+
+               }
                ZEND_VM_NEXT_OPCODE();
        }
 
@@ -41812,38 +41796,36 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND
                zend_string *op2_str = Z_STR_P(op2);
                zend_string *str;
 
-               do {
-                       if (IS_CV != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
-
-                                       break;
-                               }
-                       }
-                       if (IS_CV != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
-
-                                       break;
-                               }
+               if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
+                       if (IS_CV == IS_CONST || IS_CV == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
+                       } else {
+                               ZVAL_STR(EX_VAR(opline->result.var), op2_str);
                        }
-                       if (IS_CV != IS_CONST && IS_CV != IS_CV &&
-                           !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-                           size_t len = ZSTR_LEN(op1_str);
 
-                               str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
-                               break;
+               } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
+                       if (IS_CV == IS_CONST || IS_CV == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
                        } else {
-                               str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
-                               memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+                               ZVAL_STR(EX_VAR(opline->result.var), op1_str);
                        }
 
-               } while (0);
+               } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
+                   !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
+                   size_t len = ZSTR_LEN(op1_str);
+
+                       str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
 
+               } else {
+                       str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
+                       memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+
+
+               }
                ZEND_VM_NEXT_OPCODE();
        } else {
                SAVE_OPLINE();
@@ -44385,38 +44367,36 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_CV_HANDLER
                zend_string *op2_str = Z_STR_P(op2);
                zend_string *str;
 
-               do {
-                       if (IS_CV != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
-
-                                       break;
-                               }
-                       }
-                       if (IS_CV != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
-
-                                       break;
-                               }
+               if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
+                       if (IS_CV == IS_CONST || IS_CV == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
+                       } else {
+                               ZVAL_STR(EX_VAR(opline->result.var), op2_str);
                        }
-                       if (IS_CV != IS_CONST && IS_CV != IS_CV &&
-                           !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-                           size_t len = ZSTR_LEN(op1_str);
 
-                               str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
-                               break;
+               } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
+                       if (IS_CV == IS_CONST || IS_CV == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
                        } else {
-                               str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
-                               memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+                               ZVAL_STR(EX_VAR(opline->result.var), op1_str);
                        }
 
-               } while (0);
+               } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
+                   !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
+                   size_t len = ZSTR_LEN(op1_str);
+
+                       str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+
+               } else {
+                       str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
+                       memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+
 
+               }
                ZEND_VM_NEXT_OPCODE();
        }
 
@@ -45550,38 +45530,36 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER(
                zend_string *op2_str = Z_STR_P(op2);
                zend_string *str;
 
-               do {
-                       if (IS_CV != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
-
-                                       break;
-                               }
-                       }
-                       if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
-
-                                       break;
-                               }
+               if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
+                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
+                       } else {
+                               ZVAL_STR(EX_VAR(opline->result.var), op2_str);
                        }
-                       if (IS_CV != IS_CONST && IS_CV != IS_CV &&
-                           !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-                           size_t len = ZSTR_LEN(op1_str);
 
-                               str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
-                               break;
+               } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
+                       if (IS_CV == IS_CONST || IS_CV == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
                        } else {
-                               str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
-                               memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+                               ZVAL_STR(EX_VAR(opline->result.var), op1_str);
                        }
+                       zval_ptr_dtor_nogc(free_op2);
+               } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
+                   !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
+                   size_t len = ZSTR_LEN(op1_str);
 
-               } while (0);
-               zval_ptr_dtor_nogc(free_op2);
+                       str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+                       zval_ptr_dtor_nogc(free_op2);
+               } else {
+                       str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
+                       memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+
+                       zval_ptr_dtor_nogc(free_op2);
+               }
                ZEND_VM_NEXT_OPCODE();
        } else {
                SAVE_OPLINE();
@@ -47981,38 +47959,36 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HAN
                zend_string *op2_str = Z_STR_P(op2);
                zend_string *str;
 
-               do {
-                       if (IS_CV != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
-
-                                       break;
-                               }
-                       }
-                       if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
-
-                                       break;
-                               }
+               if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
+                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
+                       } else {
+                               ZVAL_STR(EX_VAR(opline->result.var), op2_str);
                        }
-                       if (IS_CV != IS_CONST && IS_CV != IS_CV &&
-                           !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-                           size_t len = ZSTR_LEN(op1_str);
 
-                               str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
-                               break;
+               } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
+                       if (IS_CV == IS_CONST || IS_CV == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
                        } else {
-                               str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
-                               memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+                               ZVAL_STR(EX_VAR(opline->result.var), op1_str);
                        }
+                       zval_ptr_dtor_nogc(free_op2);
+               } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
+                   !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
+                   size_t len = ZSTR_LEN(op1_str);
 
-               } while (0);
-               zval_ptr_dtor_nogc(free_op2);
+                       str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+                       zval_ptr_dtor_nogc(free_op2);
+               } else {
+                       str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
+                       memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+
+                       zval_ptr_dtor_nogc(free_op2);
+               }
                ZEND_VM_NEXT_OPCODE();
        }
 
@@ -49546,38 +49522,36 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDL
                zend_string *op2_str = Z_STR_P(op2);
                zend_string *str;
 
-               do {
-                       if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
-                                       zval_ptr_dtor_nogc(free_op1);
-                                       break;
-                               }
-                       }
-                       if (IS_CONST != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
-                                       zval_ptr_dtor_nogc(free_op1);
-                                       break;
-                               }
+               if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
+                       if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
+                       } else {
+                               ZVAL_STR(EX_VAR(opline->result.var), op2_str);
                        }
-                       if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
-                           !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-                           size_t len = ZSTR_LEN(op1_str);
-
-                               str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
-                               break;
+                       zval_ptr_dtor_nogc(free_op1);
+               } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
+                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
                        } else {
-                               str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
-                               memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+                               ZVAL_STR(EX_VAR(opline->result.var), op1_str);
                        }
+
+               } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
+                   !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
+                   size_t len = ZSTR_LEN(op1_str);
+
+                       str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+
+               } else {
+                       str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
+                       memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
                        zval_ptr_dtor_nogc(free_op1);
-               } while (0);
 
+               }
                ZEND_VM_NEXT_OPCODE();
        } else {
                SAVE_OPLINE();
@@ -50185,38 +50159,36 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_
                zend_string *op2_str = Z_STR_P(op2);
                zend_string *str;
 
-               do {
-                       if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
-                                       zval_ptr_dtor_nogc(free_op1);
-                                       break;
-                               }
-                       }
-                       if (IS_CONST != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
-                                       zval_ptr_dtor_nogc(free_op1);
-                                       break;
-                               }
+               if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
+                       if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
+                       } else {
+                               ZVAL_STR(EX_VAR(opline->result.var), op2_str);
                        }
-                       if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
-                           !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-                           size_t len = ZSTR_LEN(op1_str);
-
-                               str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
-                               break;
+                       zval_ptr_dtor_nogc(free_op1);
+               } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
+                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
                        } else {
-                               str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
-                               memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+                               ZVAL_STR(EX_VAR(opline->result.var), op1_str);
                        }
+
+               } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
+                   !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
+                   size_t len = ZSTR_LEN(op1_str);
+
+                       str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+
+               } else {
+                       str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
+                       memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
                        zval_ptr_dtor_nogc(free_op1);
-               } while (0);
 
+               }
                ZEND_VM_NEXT_OPCODE();
        }
 
@@ -52006,38 +51978,36 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER(
                zend_string *op2_str = Z_STR_P(op2);
                zend_string *str;
 
-               do {
-                       if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
-                                       zval_ptr_dtor_nogc(free_op1);
-                                       break;
-                               }
-                       }
-                       if (IS_CV != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
-                                       zval_ptr_dtor_nogc(free_op1);
-                                       break;
-                               }
+               if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
+                       if (IS_CV == IS_CONST || IS_CV == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
+                       } else {
+                               ZVAL_STR(EX_VAR(opline->result.var), op2_str);
                        }
-                       if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
-                           !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-                           size_t len = ZSTR_LEN(op1_str);
-
-                               str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
-                               break;
+                       zval_ptr_dtor_nogc(free_op1);
+               } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
+                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
                        } else {
-                               str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
-                               memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+                               ZVAL_STR(EX_VAR(opline->result.var), op1_str);
                        }
+
+               } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
+                   !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
+                   size_t len = ZSTR_LEN(op1_str);
+
+                       str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+
+               } else {
+                       str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
+                       memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
                        zval_ptr_dtor_nogc(free_op1);
-               } while (0);
 
+               }
                ZEND_VM_NEXT_OPCODE();
        } else {
                SAVE_OPLINE();
@@ -52576,38 +52546,36 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HAN
                zend_string *op2_str = Z_STR_P(op2);
                zend_string *str;
 
-               do {
-                       if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
-                                       zval_ptr_dtor_nogc(free_op1);
-                                       break;
-                               }
-                       }
-                       if (IS_CV != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
-                                       zval_ptr_dtor_nogc(free_op1);
-                                       break;
-                               }
+               if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
+                       if (IS_CV == IS_CONST || IS_CV == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
+                       } else {
+                               ZVAL_STR(EX_VAR(opline->result.var), op2_str);
                        }
-                       if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
-                           !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-                           size_t len = ZSTR_LEN(op1_str);
-
-                               str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
-                               break;
+                       zval_ptr_dtor_nogc(free_op1);
+               } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
+                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
                        } else {
-                               str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
-                               memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+                               ZVAL_STR(EX_VAR(opline->result.var), op1_str);
                        }
+
+               } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
+                   !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
+                   size_t len = ZSTR_LEN(op1_str);
+
+                       str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+
+               } else {
+                       str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
+                       memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
                        zval_ptr_dtor_nogc(free_op1);
-               } while (0);
 
+               }
                ZEND_VM_NEXT_OPCODE();
        }
 
@@ -53365,38 +53333,36 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HAND
                zend_string *op2_str = Z_STR_P(op2);
                zend_string *str;
 
-               do {
-                       if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
-                                       zval_ptr_dtor_nogc(free_op1);
-                                       break;
-                               }
-                       }
-                       if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
-                                       zval_ptr_dtor_nogc(free_op1);
-                                       break;
-                               }
+               if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
+                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
+                       } else {
+                               ZVAL_STR(EX_VAR(opline->result.var), op2_str);
                        }
-                       if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
-                           !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-                           size_t len = ZSTR_LEN(op1_str);
-
-                               str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
-                               break;
+                       zval_ptr_dtor_nogc(free_op1);
+               } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
+                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
                        } else {
-                               str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
-                               memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+                               ZVAL_STR(EX_VAR(opline->result.var), op1_str);
                        }
+                       zval_ptr_dtor_nogc(free_op2);
+               } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
+                   !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
+                   size_t len = ZSTR_LEN(op1_str);
+
+                       str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+                       zval_ptr_dtor_nogc(free_op2);
+               } else {
+                       str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
+                       memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
                        zval_ptr_dtor_nogc(free_op1);
-               } while (0);
-               zval_ptr_dtor_nogc(free_op2);
+                       zval_ptr_dtor_nogc(free_op2);
+               }
                ZEND_VM_NEXT_OPCODE();
        } else {
                SAVE_OPLINE();
@@ -53936,38 +53902,36 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR
                zend_string *op2_str = Z_STR_P(op2);
                zend_string *str;
 
-               do {
-                       if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
-                                       zval_ptr_dtor_nogc(free_op1);
-                                       break;
-                               }
-                       }
-                       if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
-                               if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
-                                       ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
-                                       zval_ptr_dtor_nogc(free_op1);
-                                       break;
-                               }
+               if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
+                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
+                       } else {
+                               ZVAL_STR(EX_VAR(opline->result.var), op2_str);
                        }
-                       if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
-                           !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-                           size_t len = ZSTR_LEN(op1_str);
-
-                               str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
-                               break;
+                       zval_ptr_dtor_nogc(free_op1);
+               } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
+                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
+                               ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
                        } else {
-                               str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
-                               memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
-                               memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
-                               ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+                               ZVAL_STR(EX_VAR(opline->result.var), op1_str);
                        }
+                       zval_ptr_dtor_nogc(free_op2);
+               } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
+                   !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
+                   size_t len = ZSTR_LEN(op1_str);
+
+                       str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
+                       zval_ptr_dtor_nogc(free_op2);
+               } else {
+                       str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
+                       memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
+                       memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
+                       ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
                        zval_ptr_dtor_nogc(free_op1);
-               } while (0);
-               zval_ptr_dtor_nogc(free_op2);
+                       zval_ptr_dtor_nogc(free_op2);
+               }
                ZEND_VM_NEXT_OPCODE();
        }