Namespaces: improved run-time speed

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 99c883e029494792b9cb4de706974e6326c7b79c..6e87c7ebc7e4696d6e44f9e80b2fbe20b78d06c7 100644 (file)
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -1579,7 +1579,7 @@ void zend_do_begin_dynamic_function_call(znode *function_name TSRMLS_DC) /* {{{
 }
 /* }}} */
 
-void zend_resolve_class_name(znode *class_name, ulong *fetch_type TSRMLS_DC) /* {{{ */
+void zend_resolve_class_name(znode *class_name, ulong *fetch_type, int check_ns_name TSRMLS_DC) /* {{{ */
 {
        zstr compound;
        unsigned int lcname_len;
@@ -1642,14 +1642,17 @@ void zend_resolve_class_name(znode *class_name, ulong *fetch_type TSRMLS_DC) /*
                        zval_copy_ctor(&class_name->u.constant);
                } else if (CG(current_namespace)) {
                        zend_class_entry **pce;
-                       unsigned int ns_lcname_len;
-                       zstr ns_lcname = zend_u_str_case_fold(Z_TYPE_P(CG(current_namespace)), Z_UNIVAL_P(CG(current_namespace)), Z_UNILEN_P(CG(current_namespace)), 0, &ns_lcname_len);
 
-                       if (ns_lcname_len == lcname_len &&
-                           memcmp(lcname.v, ns_lcname.v, UG(unicode)?UBYTES(lcname_len):lcname_len) == 0) {
-                               *fetch_type |= ZEND_FETCH_CLASS_RT_NS_NAME;
+                       if (check_ns_name) {
+                               unsigned int ns_lcname_len;
+                               zstr ns_lcname = zend_u_str_case_fold(Z_TYPE_P(CG(current_namespace)), Z_UNIVAL_P(CG(current_namespace)), Z_UNILEN_P(CG(current_namespace)), 0, &ns_lcname_len);
+
+                               if (ns_lcname_len == lcname_len &&
+                                   memcmp(lcname.v, ns_lcname.v, UG(unicode)?UBYTES(lcname_len):lcname_len) == 0) {
+                                       *fetch_type |= ZEND_FETCH_CLASS_RT_NS_NAME;
+                               }
+                               efree(ns_lcname.v);
                        }
-                       efree(ns_lcname.v);
 
                        if (zend_u_hash_find(CG(class_table), Z_TYPE(class_name->u.constant), lcname, lcname_len+1, (void**)&pce) == SUCCESS &&
                            (*pce)->type == ZEND_INTERNAL_CLASS) {
@@ -1690,7 +1693,7 @@ void zend_do_fetch_class(znode *result, znode *class_name TSRMLS_DC) /* {{{ */
                                zval_dtor(&class_name->u.constant);
                                break;
                        default: {
-                               zend_resolve_class_name(class_name, &opline->extended_value TSRMLS_CC);
+                               zend_resolve_class_name(class_name, &opline->extended_value, 0 TSRMLS_CC);
                                opline->op2 = *class_name;
                                break;
                        }
@@ -1761,7 +1764,7 @@ void zend_do_begin_class_member_function_call(znode *class_name, znode *method_n
                method_name->op_type == IS_CONST &&
            ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_TYPE(class_name->u.constant), Z_UNIVAL(class_name->u.constant), Z_UNILEN(class_name->u.constant))) {
                fetch_type = ZEND_FETCH_CLASS_GLOBAL;
-               zend_resolve_class_name(class_name, &fetch_type TSRMLS_CC);
+               zend_resolve_class_name(class_name, &fetch_type, 1 TSRMLS_CC);
                class_node = *class_name;
        } else {
                zend_do_fetch_class(&class_node, class_name TSRMLS_CC);
@@ -1772,6 +1775,58 @@ void zend_do_begin_class_member_function_call(znode *class_name, znode *method_n
        opline->op1 = class_node;
        opline->op2 = *method_name;
 
+       if (class_node.op_type == IS_CONST &&
+               method_name->op_type == IS_CONST) {
+               /* Prebuild ns::func name to speedup run-time check */
+               zstr fname, lcname;
+               unsigned int len, lcname_len;
+
+               opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+               opline->opcode = ZEND_OP_DATA;
+               opline->op1.op_type = IS_CONST;
+               SET_UNUSED(opline->op2);
+       
+               len = Z_UNILEN(class_node.u.constant) + 2 + Z_UNILEN(method_name->u.constant);
+               if (UG(unicode)) {
+                       fname.u = eumalloc(len + 1);
+                       memcpy(fname.u, Z_USTRVAL(class_node.u.constant), UBYTES(Z_USTRLEN(class_node.u.constant)));
+            fname.u[Z_USTRLEN(class_node.u.constant)] = ':';
+                       fname.u[Z_USTRLEN(class_node.u.constant)+1] = ':';
+                       memcpy(fname.u+Z_USTRLEN(class_node.u.constant)+2,
+                               Z_USTRVAL(method_name->u.constant),
+                               UBYTES(Z_USTRLEN(method_name->u.constant)+1));
+                       lcname = zend_u_str_case_fold(IS_UNICODE, fname, len, 1, &lcname_len);
+                       opline->extended_value = zend_u_hash_func(IS_UNICODE, lcname, lcname_len + 1);
+                       ZVAL_UNICODEL(&opline->op1.u.constant, lcname.u, lcname_len, 0);
+               } else {
+                       fname.s = emalloc(len + 1);
+                       memcpy(fname.s, Z_STRVAL(class_node.u.constant), Z_STRLEN(class_node.u.constant));
+            fname.s[Z_STRLEN(class_node.u.constant)] = ':';
+                       fname.s[Z_STRLEN(class_node.u.constant)+1] = ':';
+                       memcpy(fname.s+Z_STRLEN(class_node.u.constant)+2,
+                               Z_STRVAL(method_name->u.constant),
+                               Z_STRLEN(method_name->u.constant)+1);
+                       lcname = zend_u_str_case_fold(IS_STRING, fname, len, 1, &lcname_len);
+                       opline->extended_value = zend_u_hash_func(IS_STRING, lcname, lcname_len + 1);
+                       ZVAL_STRINGL(&opline->op1.u.constant, lcname.s, lcname_len, 0);
+               }
+               efree(fname.v);
+
+               if (fetch_type & ZEND_FETCH_CLASS_RT_NS_NAME) {
+                       zstr colon;
+
+                       if (UG(unicode) && (colon.u = u_memchr(lcname.u, ':', lcname_len)) && colon.u[1] == ':') {
+                               colon.u += 2;
+                               opline->op2.op_type = IS_CONST;
+                               ZVAL_UNICODEL(&opline->op2.u.constant, colon.u, lcname_len - (colon.u - lcname.u), 1);
+                       } else if (!UG(unicode) && (colon.s = memchr(lcname.s, ':', lcname_len)) && colon.s[1] == ':') {
+                               colon.s += 2;
+                               opline->op2.op_type = IS_CONST;
+                               ZVAL_STRINGL(&opline->op2.u.constant, colon.s, lcname_len - (colon.s - lcname.s), 1);
+                       }                       
+               }
+       }
+
        zend_stack_push(&CG(function_call_stack), (void *) &ptr, sizeof(zend_function *));
        zend_do_extended_fcall_begin(TSRMLS_C);
 }
@@ -3658,7 +3713,7 @@ void zend_do_fetch_constant(znode *result, znode *constant_container, znode *con
                                ulong fetch_type;
 
                            if (ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_TYPE(constant_container->u.constant), Z_UNIVAL(constant_container->u.constant), Z_UNILEN(constant_container->u.constant))) {
-                                       zend_resolve_class_name(constant_container, &fetch_type TSRMLS_CC);
+                                       zend_resolve_class_name(constant_container, &fetch_type, 1 TSRMLS_CC);
                                }
                                zend_do_fetch_class_name(NULL, constant_container, constant_name TSRMLS_CC);
                                *result = *constant_container;

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index e0f2eb286727a45b3b2a29b7aaaa88cd60b519d8..546080118a5a9ef19d2d0621ec9c3914b5ecda21 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -1793,33 +1793,11 @@ ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, CONST|VAR, CONST|TMP|VAR|UNUS
 
        if (OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
                /* try a function in namespace */
-               zstr fname, lcname;
-               unsigned int len, lcname_len;
-       
-               len = Z_UNILEN(opline->op1.u.constant) + 2 + Z_UNILEN(opline->op2.u.constant);
-               if (UG(unicode)) {
-                       fname.u = eumalloc(len + 1);
-                       memcpy(fname.u, Z_USTRVAL(opline->op1.u.constant), UBYTES(Z_USTRLEN(opline->op1.u.constant)));
-            fname.u[Z_USTRLEN(opline->op1.u.constant)] = ':';
-                       fname.u[Z_USTRLEN(opline->op1.u.constant)+1] = ':';
-                       memcpy(fname.u+Z_USTRLEN(opline->op1.u.constant)+2,
-                               Z_USTRVAL(opline->op2.u.constant),
-                               UBYTES(Z_USTRLEN(opline->op2.u.constant)+1));
-                       lcname = zend_u_str_case_fold(IS_UNICODE, fname, len, 1, &lcname_len);
-               } else {
-                       fname.s = emalloc(len + 1);
-                       memcpy(fname.s, Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant));
-            fname.s[Z_STRLEN(opline->op1.u.constant)] = ':';
-                       fname.s[Z_STRLEN(opline->op1.u.constant)+1] = ':';
-                       memcpy(fname.s+Z_STRLEN(opline->op1.u.constant)+2,
-                               Z_STRVAL(opline->op2.u.constant),
-                               Z_STRLEN(opline->op2.u.constant)+1);
-                       lcname = zend_u_str_case_fold(IS_STRING, fname, len, 1, &lcname_len);
-               }
-               efree(fname.v);
+               zend_op *op_data = opline+1;
 
-               if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, lcname, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                       efree(lcname.v);
+               ZEND_VM_INC_OPCODE();
+
+               if (zend_u_hash_quick_find(EG(function_table), Z_TYPE(op_data->op1.u.constant), Z_UNIVAL(op_data->op1.u.constant), Z_UNILEN(op_data->op1.u.constant)+1, op_data->extended_value, (void **) &EX(fbc))==SUCCESS) {
                        EX(object) = NULL;
                        ZEND_VM_NEXT_OPCODE();
                }
@@ -1828,34 +1806,24 @@ ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, CONST|VAR, CONST|TMP|VAR|UNUS
                ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant), Z_UNILEN(opline->op1.u.constant), (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) ? (opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK) : opline->extended_value TSRMLS_CC);
                
                if (!ce) {
-                       if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) {
-                               zstr ns;
-
-                               if (UG(unicode) && (ns.u = u_memchr(lcname.u, ':', lcname_len)) && ns.u[1] == ':') {
-                                       ns.u += 2;
-                                       lcname_len -= (ns.u - lcname.u);
-                                       if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, ns, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                                               efree(lcname.v);
-                                               EX(object) = NULL;
-                                               ZEND_VM_NEXT_OPCODE();
-                                       }
-                       } else if (!UG(unicode) && (ns.s = memchr(lcname.s, ':', lcname_len)) && ns.s[1] == ':') {
-                                       ns.s += 2;
-                                       lcname_len -= (ns.s - lcname.s);
-                                       if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, ns, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                                               efree(lcname.v);
-                                               EX(object) = NULL;
-                                               ZEND_VM_NEXT_OPCODE();
-                                       }
+                       if ((opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) &&
+                           op_data->op2.op_type == IS_CONST) {
+
+                               if (zend_u_hash_find(EG(function_table), Z_TYPE(op_data->op2.u.constant), Z_UNIVAL(op_data->op2.u.constant), Z_UNILEN(op_data->op2.u.constant) + 1, (void **) &EX(fbc))==SUCCESS) {
+                                       EX(object) = NULL;
+                                       ZEND_VM_NEXT_OPCODE();
                                }
+
                                if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_CHECK) {
-                                       lcname_len -= Z_UNILEN(opline->op2.u.constant) + 2;
+                                       zstr ce_name;
+                                       unsigned ce_name_len = Z_UNILEN(op_data->op1.u.constant) - (Z_UNILEN(op_data->op2.u.constant) + 2);
                                        if (UG(unicode)) {
-                                               ns.u[lcname_len] = 0;
+                                               ce_name.u = eustrndup(Z_USTRVAL(op_data->op1.u.constant), ce_name_len);
                                        } else {
-                                               ns.s[lcname_len] = 0;
+                                               ce_name.s = estrndup(Z_STRVAL(op_data->op1.u.constant), ce_name_len);
                                        }
-                                       ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), ns, lcname_len, opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK TSRMLS_CC);
+                                       ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), ce_name, ce_name_len, opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK TSRMLS_CC);
+                                       efree(ce_name.v);
                                        if (!ce) {
                                                zend_error(E_ERROR, "Class '%R' not found", Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant));
                                        }
@@ -1866,8 +1834,6 @@ ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, CONST|VAR, CONST|TMP|VAR|UNUS
                                zend_error(E_ERROR, "Class '%R' not found", Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant));
                        }
                }
-
-               efree(lcname.v);
        } else {
                ce = EX_T(opline->op1.u.var).class_entry;
        }

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 2fa433fcaacfd4178b7cea1e97856b9481b5b68e..fa46efb4d117bf2d17a94216439cb1da9420b431 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -2545,33 +2545,11 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HAN
 
        if (IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
                /* try a function in namespace */
-               zstr fname, lcname;
-               unsigned int len, lcname_len;
-
-               len = Z_UNILEN(opline->op1.u.constant) + 2 + Z_UNILEN(opline->op2.u.constant);
-               if (UG(unicode)) {
-                       fname.u = eumalloc(len + 1);
-                       memcpy(fname.u, Z_USTRVAL(opline->op1.u.constant), UBYTES(Z_USTRLEN(opline->op1.u.constant)));
-            fname.u[Z_USTRLEN(opline->op1.u.constant)] = ':';
-                       fname.u[Z_USTRLEN(opline->op1.u.constant)+1] = ':';
-                       memcpy(fname.u+Z_USTRLEN(opline->op1.u.constant)+2,
-                               Z_USTRVAL(opline->op2.u.constant),
-                               UBYTES(Z_USTRLEN(opline->op2.u.constant)+1));
-                       lcname = zend_u_str_case_fold(IS_UNICODE, fname, len, 1, &lcname_len);
-               } else {
-                       fname.s = emalloc(len + 1);
-                       memcpy(fname.s, Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant));
-            fname.s[Z_STRLEN(opline->op1.u.constant)] = ':';
-                       fname.s[Z_STRLEN(opline->op1.u.constant)+1] = ':';
-                       memcpy(fname.s+Z_STRLEN(opline->op1.u.constant)+2,
-                               Z_STRVAL(opline->op2.u.constant),
-                               Z_STRLEN(opline->op2.u.constant)+1);
-                       lcname = zend_u_str_case_fold(IS_STRING, fname, len, 1, &lcname_len);
-               }
-               efree(fname.v);
-
-               if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, lcname, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                       efree(lcname.v);
+               zend_op *op_data = opline+1;
+
+               ZEND_VM_INC_OPCODE();
+
+               if (zend_u_hash_quick_find(EG(function_table), Z_TYPE(op_data->op1.u.constant), Z_UNIVAL(op_data->op1.u.constant), Z_UNILEN(op_data->op1.u.constant)+1, op_data->extended_value, (void **) &EX(fbc))==SUCCESS) {
                        EX(object) = NULL;
                        ZEND_VM_NEXT_OPCODE();
                }
@@ -2580,34 +2558,24 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HAN
                ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant), Z_UNILEN(opline->op1.u.constant), (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) ? (opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK) : opline->extended_value TSRMLS_CC);
 
                if (!ce) {
-                       if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) {
-                               zstr ns;
-
-                               if (UG(unicode) && (ns.u = u_memchr(lcname.u, ':', lcname_len)) && ns.u[1] == ':') {
-                                       ns.u += 2;
-                                       lcname_len -= (ns.u - lcname.u);
-                                       if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, ns, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                                               efree(lcname.v);
-                                               EX(object) = NULL;
-                                               ZEND_VM_NEXT_OPCODE();
-                                       }
-                       } else if (!UG(unicode) && (ns.s = memchr(lcname.s, ':', lcname_len)) && ns.s[1] == ':') {
-                                       ns.s += 2;
-                                       lcname_len -= (ns.s - lcname.s);
-                                       if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, ns, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                                               efree(lcname.v);
-                                               EX(object) = NULL;
-                                               ZEND_VM_NEXT_OPCODE();
-                                       }
+                       if ((opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) &&
+                           op_data->op2.op_type == IS_CONST) {
+
+                               if (zend_u_hash_find(EG(function_table), Z_TYPE(op_data->op2.u.constant), Z_UNIVAL(op_data->op2.u.constant), Z_UNILEN(op_data->op2.u.constant) + 1, (void **) &EX(fbc))==SUCCESS) {
+                                       EX(object) = NULL;
+                                       ZEND_VM_NEXT_OPCODE();
                                }
+
                                if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_CHECK) {
-                                       lcname_len -= Z_UNILEN(opline->op2.u.constant) + 2;
+                                       zstr ce_name;
+                                       unsigned ce_name_len = Z_UNILEN(op_data->op1.u.constant) - (Z_UNILEN(op_data->op2.u.constant) + 2);
                                        if (UG(unicode)) {
-                                               ns.u[lcname_len] = 0;
+                                               ce_name.u = eustrndup(Z_USTRVAL(op_data->op1.u.constant), ce_name_len);
                                        } else {
-                                               ns.s[lcname_len] = 0;
+                                               ce_name.s = estrndup(Z_STRVAL(op_data->op1.u.constant), ce_name_len);
                                        }
-                                       ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), ns, lcname_len, opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK TSRMLS_CC);
+                                       ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), ce_name, ce_name_len, opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK TSRMLS_CC);
+                                       efree(ce_name.v);
                                        if (!ce) {
                                                zend_error(E_ERROR, "Class '%R' not found", Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant));
                                        }
@@ -2618,8 +2586,6 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HAN
                                zend_error(E_ERROR, "Class '%R' not found", Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant));
                        }
                }
-
-               efree(lcname.v);
        } else {
                ce = EX_T(opline->op1.u.var).class_entry;
        }
@@ -3050,33 +3016,11 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDL
 
        if (IS_CONST == IS_CONST && IS_TMP_VAR == IS_CONST) {
                /* try a function in namespace */
-               zstr fname, lcname;
-               unsigned int len, lcname_len;
-
-               len = Z_UNILEN(opline->op1.u.constant) + 2 + Z_UNILEN(opline->op2.u.constant);
-               if (UG(unicode)) {
-                       fname.u = eumalloc(len + 1);
-                       memcpy(fname.u, Z_USTRVAL(opline->op1.u.constant), UBYTES(Z_USTRLEN(opline->op1.u.constant)));
-            fname.u[Z_USTRLEN(opline->op1.u.constant)] = ':';
-                       fname.u[Z_USTRLEN(opline->op1.u.constant)+1] = ':';
-                       memcpy(fname.u+Z_USTRLEN(opline->op1.u.constant)+2,
-                               Z_USTRVAL(opline->op2.u.constant),
-                               UBYTES(Z_USTRLEN(opline->op2.u.constant)+1));
-                       lcname = zend_u_str_case_fold(IS_UNICODE, fname, len, 1, &lcname_len);
-               } else {
-                       fname.s = emalloc(len + 1);
-                       memcpy(fname.s, Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant));
-            fname.s[Z_STRLEN(opline->op1.u.constant)] = ':';
-                       fname.s[Z_STRLEN(opline->op1.u.constant)+1] = ':';
-                       memcpy(fname.s+Z_STRLEN(opline->op1.u.constant)+2,
-                               Z_STRVAL(opline->op2.u.constant),
-                               Z_STRLEN(opline->op2.u.constant)+1);
-                       lcname = zend_u_str_case_fold(IS_STRING, fname, len, 1, &lcname_len);
-               }
-               efree(fname.v);
-
-               if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, lcname, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                       efree(lcname.v);
+               zend_op *op_data = opline+1;
+
+               ZEND_VM_INC_OPCODE();
+
+               if (zend_u_hash_quick_find(EG(function_table), Z_TYPE(op_data->op1.u.constant), Z_UNIVAL(op_data->op1.u.constant), Z_UNILEN(op_data->op1.u.constant)+1, op_data->extended_value, (void **) &EX(fbc))==SUCCESS) {
                        EX(object) = NULL;
                        ZEND_VM_NEXT_OPCODE();
                }
@@ -3085,34 +3029,24 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDL
                ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant), Z_UNILEN(opline->op1.u.constant), (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) ? (opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK) : opline->extended_value TSRMLS_CC);
 
                if (!ce) {
-                       if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) {
-                               zstr ns;
-
-                               if (UG(unicode) && (ns.u = u_memchr(lcname.u, ':', lcname_len)) && ns.u[1] == ':') {
-                                       ns.u += 2;
-                                       lcname_len -= (ns.u - lcname.u);
-                                       if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, ns, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                                               efree(lcname.v);
-                                               EX(object) = NULL;
-                                               ZEND_VM_NEXT_OPCODE();
-                                       }
-                       } else if (!UG(unicode) && (ns.s = memchr(lcname.s, ':', lcname_len)) && ns.s[1] == ':') {
-                                       ns.s += 2;
-                                       lcname_len -= (ns.s - lcname.s);
-                                       if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, ns, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                                               efree(lcname.v);
-                                               EX(object) = NULL;
-                                               ZEND_VM_NEXT_OPCODE();
-                                       }
+                       if ((opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) &&
+                           op_data->op2.op_type == IS_CONST) {
+
+                               if (zend_u_hash_find(EG(function_table), Z_TYPE(op_data->op2.u.constant), Z_UNIVAL(op_data->op2.u.constant), Z_UNILEN(op_data->op2.u.constant) + 1, (void **) &EX(fbc))==SUCCESS) {
+                                       EX(object) = NULL;
+                                       ZEND_VM_NEXT_OPCODE();
                                }
+
                                if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_CHECK) {
-                                       lcname_len -= Z_UNILEN(opline->op2.u.constant) + 2;
+                                       zstr ce_name;
+                                       unsigned ce_name_len = Z_UNILEN(op_data->op1.u.constant) - (Z_UNILEN(op_data->op2.u.constant) + 2);
                                        if (UG(unicode)) {
-                                               ns.u[lcname_len] = 0;
+                                               ce_name.u = eustrndup(Z_USTRVAL(op_data->op1.u.constant), ce_name_len);
                                        } else {
-                                               ns.s[lcname_len] = 0;
+                                               ce_name.s = estrndup(Z_STRVAL(op_data->op1.u.constant), ce_name_len);
                                        }
-                                       ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), ns, lcname_len, opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK TSRMLS_CC);
+                                       ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), ce_name, ce_name_len, opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK TSRMLS_CC);
+                                       efree(ce_name.v);
                                        if (!ce) {
                                                zend_error(E_ERROR, "Class '%R' not found", Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant));
                                        }
@@ -3123,8 +3057,6 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDL
                                zend_error(E_ERROR, "Class '%R' not found", Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant));
                        }
                }
-
-               efree(lcname.v);
        } else {
                ce = EX_T(opline->op1.u.var).class_entry;
        }
@@ -3556,33 +3488,11 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDL
 
        if (IS_CONST == IS_CONST && IS_VAR == IS_CONST) {
                /* try a function in namespace */
-               zstr fname, lcname;
-               unsigned int len, lcname_len;
-
-               len = Z_UNILEN(opline->op1.u.constant) + 2 + Z_UNILEN(opline->op2.u.constant);
-               if (UG(unicode)) {
-                       fname.u = eumalloc(len + 1);
-                       memcpy(fname.u, Z_USTRVAL(opline->op1.u.constant), UBYTES(Z_USTRLEN(opline->op1.u.constant)));
-            fname.u[Z_USTRLEN(opline->op1.u.constant)] = ':';
-                       fname.u[Z_USTRLEN(opline->op1.u.constant)+1] = ':';
-                       memcpy(fname.u+Z_USTRLEN(opline->op1.u.constant)+2,
-                               Z_USTRVAL(opline->op2.u.constant),
-                               UBYTES(Z_USTRLEN(opline->op2.u.constant)+1));
-                       lcname = zend_u_str_case_fold(IS_UNICODE, fname, len, 1, &lcname_len);
-               } else {
-                       fname.s = emalloc(len + 1);
-                       memcpy(fname.s, Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant));
-            fname.s[Z_STRLEN(opline->op1.u.constant)] = ':';
-                       fname.s[Z_STRLEN(opline->op1.u.constant)+1] = ':';
-                       memcpy(fname.s+Z_STRLEN(opline->op1.u.constant)+2,
-                               Z_STRVAL(opline->op2.u.constant),
-                               Z_STRLEN(opline->op2.u.constant)+1);
-                       lcname = zend_u_str_case_fold(IS_STRING, fname, len, 1, &lcname_len);
-               }
-               efree(fname.v);
-
-               if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, lcname, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                       efree(lcname.v);
+               zend_op *op_data = opline+1;
+
+               ZEND_VM_INC_OPCODE();
+
+               if (zend_u_hash_quick_find(EG(function_table), Z_TYPE(op_data->op1.u.constant), Z_UNIVAL(op_data->op1.u.constant), Z_UNILEN(op_data->op1.u.constant)+1, op_data->extended_value, (void **) &EX(fbc))==SUCCESS) {
                        EX(object) = NULL;
                        ZEND_VM_NEXT_OPCODE();
                }
@@ -3591,34 +3501,24 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDL
                ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant), Z_UNILEN(opline->op1.u.constant), (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) ? (opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK) : opline->extended_value TSRMLS_CC);
 
                if (!ce) {
-                       if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) {
-                               zstr ns;
-
-                               if (UG(unicode) && (ns.u = u_memchr(lcname.u, ':', lcname_len)) && ns.u[1] == ':') {
-                                       ns.u += 2;
-                                       lcname_len -= (ns.u - lcname.u);
-                                       if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, ns, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                                               efree(lcname.v);
-                                               EX(object) = NULL;
-                                               ZEND_VM_NEXT_OPCODE();
-                                       }
-                       } else if (!UG(unicode) && (ns.s = memchr(lcname.s, ':', lcname_len)) && ns.s[1] == ':') {
-                                       ns.s += 2;
-                                       lcname_len -= (ns.s - lcname.s);
-                                       if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, ns, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                                               efree(lcname.v);
-                                               EX(object) = NULL;
-                                               ZEND_VM_NEXT_OPCODE();
-                                       }
+                       if ((opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) &&
+                           op_data->op2.op_type == IS_CONST) {
+
+                               if (zend_u_hash_find(EG(function_table), Z_TYPE(op_data->op2.u.constant), Z_UNIVAL(op_data->op2.u.constant), Z_UNILEN(op_data->op2.u.constant) + 1, (void **) &EX(fbc))==SUCCESS) {
+                                       EX(object) = NULL;
+                                       ZEND_VM_NEXT_OPCODE();
                                }
+
                                if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_CHECK) {
-                                       lcname_len -= Z_UNILEN(opline->op2.u.constant) + 2;
+                                       zstr ce_name;
+                                       unsigned ce_name_len = Z_UNILEN(op_data->op1.u.constant) - (Z_UNILEN(op_data->op2.u.constant) + 2);
                                        if (UG(unicode)) {
-                                               ns.u[lcname_len] = 0;
+                                               ce_name.u = eustrndup(Z_USTRVAL(op_data->op1.u.constant), ce_name_len);
                                        } else {
-                                               ns.s[lcname_len] = 0;
+                                               ce_name.s = estrndup(Z_STRVAL(op_data->op1.u.constant), ce_name_len);
                                        }
-                                       ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), ns, lcname_len, opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK TSRMLS_CC);
+                                       ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), ce_name, ce_name_len, opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK TSRMLS_CC);
+                                       efree(ce_name.v);
                                        if (!ce) {
                                                zend_error(E_ERROR, "Class '%R' not found", Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant));
                                        }
@@ -3629,8 +3529,6 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDL
                                zend_error(E_ERROR, "Class '%R' not found", Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant));
                        }
                }
-
-               efree(lcname.v);
        } else {
                ce = EX_T(opline->op1.u.var).class_entry;
        }
@@ -3828,33 +3726,11 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HA
 
        if (IS_CONST == IS_CONST && IS_UNUSED == IS_CONST) {
                /* try a function in namespace */
-               zstr fname, lcname;
-               unsigned int len, lcname_len;
-
-               len = Z_UNILEN(opline->op1.u.constant) + 2 + Z_UNILEN(opline->op2.u.constant);
-               if (UG(unicode)) {
-                       fname.u = eumalloc(len + 1);
-                       memcpy(fname.u, Z_USTRVAL(opline->op1.u.constant), UBYTES(Z_USTRLEN(opline->op1.u.constant)));
-            fname.u[Z_USTRLEN(opline->op1.u.constant)] = ':';
-                       fname.u[Z_USTRLEN(opline->op1.u.constant)+1] = ':';
-                       memcpy(fname.u+Z_USTRLEN(opline->op1.u.constant)+2,
-                               Z_USTRVAL(opline->op2.u.constant),
-                               UBYTES(Z_USTRLEN(opline->op2.u.constant)+1));
-                       lcname = zend_u_str_case_fold(IS_UNICODE, fname, len, 1, &lcname_len);
-               } else {
-                       fname.s = emalloc(len + 1);
-                       memcpy(fname.s, Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant));
-            fname.s[Z_STRLEN(opline->op1.u.constant)] = ':';
-                       fname.s[Z_STRLEN(opline->op1.u.constant)+1] = ':';
-                       memcpy(fname.s+Z_STRLEN(opline->op1.u.constant)+2,
-                               Z_STRVAL(opline->op2.u.constant),
-                               Z_STRLEN(opline->op2.u.constant)+1);
-                       lcname = zend_u_str_case_fold(IS_STRING, fname, len, 1, &lcname_len);
-               }
-               efree(fname.v);
-
-               if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, lcname, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                       efree(lcname.v);
+               zend_op *op_data = opline+1;
+
+               ZEND_VM_INC_OPCODE();
+
+               if (zend_u_hash_quick_find(EG(function_table), Z_TYPE(op_data->op1.u.constant), Z_UNIVAL(op_data->op1.u.constant), Z_UNILEN(op_data->op1.u.constant)+1, op_data->extended_value, (void **) &EX(fbc))==SUCCESS) {
                        EX(object) = NULL;
                        ZEND_VM_NEXT_OPCODE();
                }
@@ -3863,34 +3739,24 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HA
                ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant), Z_UNILEN(opline->op1.u.constant), (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) ? (opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK) : opline->extended_value TSRMLS_CC);
 
                if (!ce) {
-                       if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) {
-                               zstr ns;
-
-                               if (UG(unicode) && (ns.u = u_memchr(lcname.u, ':', lcname_len)) && ns.u[1] == ':') {
-                                       ns.u += 2;
-                                       lcname_len -= (ns.u - lcname.u);
-                                       if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, ns, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                                               efree(lcname.v);
-                                               EX(object) = NULL;
-                                               ZEND_VM_NEXT_OPCODE();
-                                       }
-                       } else if (!UG(unicode) && (ns.s = memchr(lcname.s, ':', lcname_len)) && ns.s[1] == ':') {
-                                       ns.s += 2;
-                                       lcname_len -= (ns.s - lcname.s);
-                                       if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, ns, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                                               efree(lcname.v);
-                                               EX(object) = NULL;
-                                               ZEND_VM_NEXT_OPCODE();
-                                       }
+                       if ((opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) &&
+                           op_data->op2.op_type == IS_CONST) {
+
+                               if (zend_u_hash_find(EG(function_table), Z_TYPE(op_data->op2.u.constant), Z_UNIVAL(op_data->op2.u.constant), Z_UNILEN(op_data->op2.u.constant) + 1, (void **) &EX(fbc))==SUCCESS) {
+                                       EX(object) = NULL;
+                                       ZEND_VM_NEXT_OPCODE();
                                }
+
                                if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_CHECK) {
-                                       lcname_len -= Z_UNILEN(opline->op2.u.constant) + 2;
+                                       zstr ce_name;
+                                       unsigned ce_name_len = Z_UNILEN(op_data->op1.u.constant) - (Z_UNILEN(op_data->op2.u.constant) + 2);
                                        if (UG(unicode)) {
-                                               ns.u[lcname_len] = 0;
+                                               ce_name.u = eustrndup(Z_USTRVAL(op_data->op1.u.constant), ce_name_len);
                                        } else {
-                                               ns.s[lcname_len] = 0;
+                                               ce_name.s = estrndup(Z_STRVAL(op_data->op1.u.constant), ce_name_len);
                                        }
-                                       ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), ns, lcname_len, opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK TSRMLS_CC);
+                                       ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), ce_name, ce_name_len, opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK TSRMLS_CC);
+                                       efree(ce_name.v);
                                        if (!ce) {
                                                zend_error(E_ERROR, "Class '%R' not found", Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant));
                                        }
@@ -3901,8 +3767,6 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HA
                                zend_error(E_ERROR, "Class '%R' not found", Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant));
                        }
                }
-
-               efree(lcname.v);
        } else {
                ce = EX_T(opline->op1.u.var).class_entry;
        }
@@ -4302,33 +4166,11 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLE
 
        if (IS_CONST == IS_CONST && IS_CV == IS_CONST) {
                /* try a function in namespace */
-               zstr fname, lcname;
-               unsigned int len, lcname_len;
-
-               len = Z_UNILEN(opline->op1.u.constant) + 2 + Z_UNILEN(opline->op2.u.constant);
-               if (UG(unicode)) {
-                       fname.u = eumalloc(len + 1);
-                       memcpy(fname.u, Z_USTRVAL(opline->op1.u.constant), UBYTES(Z_USTRLEN(opline->op1.u.constant)));
-            fname.u[Z_USTRLEN(opline->op1.u.constant)] = ':';
-                       fname.u[Z_USTRLEN(opline->op1.u.constant)+1] = ':';
-                       memcpy(fname.u+Z_USTRLEN(opline->op1.u.constant)+2,
-                               Z_USTRVAL(opline->op2.u.constant),
-                               UBYTES(Z_USTRLEN(opline->op2.u.constant)+1));
-                       lcname = zend_u_str_case_fold(IS_UNICODE, fname, len, 1, &lcname_len);
-               } else {
-                       fname.s = emalloc(len + 1);
-                       memcpy(fname.s, Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant));
-            fname.s[Z_STRLEN(opline->op1.u.constant)] = ':';
-                       fname.s[Z_STRLEN(opline->op1.u.constant)+1] = ':';
-                       memcpy(fname.s+Z_STRLEN(opline->op1.u.constant)+2,
-                               Z_STRVAL(opline->op2.u.constant),
-                               Z_STRLEN(opline->op2.u.constant)+1);
-                       lcname = zend_u_str_case_fold(IS_STRING, fname, len, 1, &lcname_len);
-               }
-               efree(fname.v);
-
-               if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, lcname, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                       efree(lcname.v);
+               zend_op *op_data = opline+1;
+
+               ZEND_VM_INC_OPCODE();
+
+               if (zend_u_hash_quick_find(EG(function_table), Z_TYPE(op_data->op1.u.constant), Z_UNIVAL(op_data->op1.u.constant), Z_UNILEN(op_data->op1.u.constant)+1, op_data->extended_value, (void **) &EX(fbc))==SUCCESS) {
                        EX(object) = NULL;
                        ZEND_VM_NEXT_OPCODE();
                }
@@ -4337,34 +4179,24 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLE
                ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant), Z_UNILEN(opline->op1.u.constant), (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) ? (opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK) : opline->extended_value TSRMLS_CC);
 
                if (!ce) {
-                       if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) {
-                               zstr ns;
-
-                               if (UG(unicode) && (ns.u = u_memchr(lcname.u, ':', lcname_len)) && ns.u[1] == ':') {
-                                       ns.u += 2;
-                                       lcname_len -= (ns.u - lcname.u);
-                                       if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, ns, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                                               efree(lcname.v);
-                                               EX(object) = NULL;
-                                               ZEND_VM_NEXT_OPCODE();
-                                       }
-                       } else if (!UG(unicode) && (ns.s = memchr(lcname.s, ':', lcname_len)) && ns.s[1] == ':') {
-                                       ns.s += 2;
-                                       lcname_len -= (ns.s - lcname.s);
-                                       if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, ns, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                                               efree(lcname.v);
-                                               EX(object) = NULL;
-                                               ZEND_VM_NEXT_OPCODE();
-                                       }
+                       if ((opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) &&
+                           op_data->op2.op_type == IS_CONST) {
+
+                               if (zend_u_hash_find(EG(function_table), Z_TYPE(op_data->op2.u.constant), Z_UNIVAL(op_data->op2.u.constant), Z_UNILEN(op_data->op2.u.constant) + 1, (void **) &EX(fbc))==SUCCESS) {
+                                       EX(object) = NULL;
+                                       ZEND_VM_NEXT_OPCODE();
                                }
+
                                if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_CHECK) {
-                                       lcname_len -= Z_UNILEN(opline->op2.u.constant) + 2;
+                                       zstr ce_name;
+                                       unsigned ce_name_len = Z_UNILEN(op_data->op1.u.constant) - (Z_UNILEN(op_data->op2.u.constant) + 2);
                                        if (UG(unicode)) {
-                                               ns.u[lcname_len] = 0;
+                                               ce_name.u = eustrndup(Z_USTRVAL(op_data->op1.u.constant), ce_name_len);
                                        } else {
-                                               ns.s[lcname_len] = 0;
+                                               ce_name.s = estrndup(Z_STRVAL(op_data->op1.u.constant), ce_name_len);
                                        }
-                                       ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), ns, lcname_len, opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK TSRMLS_CC);
+                                       ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), ce_name, ce_name_len, opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK TSRMLS_CC);
+                                       efree(ce_name.v);
                                        if (!ce) {
                                                zend_error(E_ERROR, "Class '%R' not found", Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant));
                                        }
@@ -4375,8 +4207,6 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLE
                                zend_error(E_ERROR, "Class '%R' not found", Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant));
                        }
                }
-
-               efree(lcname.v);
        } else {
                ce = EX_T(opline->op1.u.var).class_entry;
        }
@@ -10208,33 +10038,11 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDL
 
        if (IS_VAR == IS_CONST && IS_CONST == IS_CONST) {
                /* try a function in namespace */
-               zstr fname, lcname;
-               unsigned int len, lcname_len;
-
-               len = Z_UNILEN(opline->op1.u.constant) + 2 + Z_UNILEN(opline->op2.u.constant);
-               if (UG(unicode)) {
-                       fname.u = eumalloc(len + 1);
-                       memcpy(fname.u, Z_USTRVAL(opline->op1.u.constant), UBYTES(Z_USTRLEN(opline->op1.u.constant)));
-            fname.u[Z_USTRLEN(opline->op1.u.constant)] = ':';
-                       fname.u[Z_USTRLEN(opline->op1.u.constant)+1] = ':';
-                       memcpy(fname.u+Z_USTRLEN(opline->op1.u.constant)+2,
-                               Z_USTRVAL(opline->op2.u.constant),
-                               UBYTES(Z_USTRLEN(opline->op2.u.constant)+1));
-                       lcname = zend_u_str_case_fold(IS_UNICODE, fname, len, 1, &lcname_len);
-               } else {
-                       fname.s = emalloc(len + 1);
-                       memcpy(fname.s, Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant));
-            fname.s[Z_STRLEN(opline->op1.u.constant)] = ':';
-                       fname.s[Z_STRLEN(opline->op1.u.constant)+1] = ':';
-                       memcpy(fname.s+Z_STRLEN(opline->op1.u.constant)+2,
-                               Z_STRVAL(opline->op2.u.constant),
-                               Z_STRLEN(opline->op2.u.constant)+1);
-                       lcname = zend_u_str_case_fold(IS_STRING, fname, len, 1, &lcname_len);
-               }
-               efree(fname.v);
-
-               if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, lcname, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                       efree(lcname.v);
+               zend_op *op_data = opline+1;
+
+               ZEND_VM_INC_OPCODE();
+
+               if (zend_u_hash_quick_find(EG(function_table), Z_TYPE(op_data->op1.u.constant), Z_UNIVAL(op_data->op1.u.constant), Z_UNILEN(op_data->op1.u.constant)+1, op_data->extended_value, (void **) &EX(fbc))==SUCCESS) {
                        EX(object) = NULL;
                        ZEND_VM_NEXT_OPCODE();
                }
@@ -10243,34 +10051,24 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDL
                ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant), Z_UNILEN(opline->op1.u.constant), (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) ? (opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK) : opline->extended_value TSRMLS_CC);
 
                if (!ce) {
-                       if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) {
-                               zstr ns;
-
-                               if (UG(unicode) && (ns.u = u_memchr(lcname.u, ':', lcname_len)) && ns.u[1] == ':') {
-                                       ns.u += 2;
-                                       lcname_len -= (ns.u - lcname.u);
-                                       if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, ns, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                                               efree(lcname.v);
-                                               EX(object) = NULL;
-                                               ZEND_VM_NEXT_OPCODE();
-                                       }
-                       } else if (!UG(unicode) && (ns.s = memchr(lcname.s, ':', lcname_len)) && ns.s[1] == ':') {
-                                       ns.s += 2;
-                                       lcname_len -= (ns.s - lcname.s);
-                                       if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, ns, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                                               efree(lcname.v);
-                                               EX(object) = NULL;
-                                               ZEND_VM_NEXT_OPCODE();
-                                       }
+                       if ((opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) &&
+                           op_data->op2.op_type == IS_CONST) {
+
+                               if (zend_u_hash_find(EG(function_table), Z_TYPE(op_data->op2.u.constant), Z_UNIVAL(op_data->op2.u.constant), Z_UNILEN(op_data->op2.u.constant) + 1, (void **) &EX(fbc))==SUCCESS) {
+                                       EX(object) = NULL;
+                                       ZEND_VM_NEXT_OPCODE();
                                }
+
                                if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_CHECK) {
-                                       lcname_len -= Z_UNILEN(opline->op2.u.constant) + 2;
+                                       zstr ce_name;
+                                       unsigned ce_name_len = Z_UNILEN(op_data->op1.u.constant) - (Z_UNILEN(op_data->op2.u.constant) + 2);
                                        if (UG(unicode)) {
-                                               ns.u[lcname_len] = 0;
+                                               ce_name.u = eustrndup(Z_USTRVAL(op_data->op1.u.constant), ce_name_len);
                                        } else {
-                                               ns.s[lcname_len] = 0;
+                                               ce_name.s = estrndup(Z_STRVAL(op_data->op1.u.constant), ce_name_len);
                                        }
-                                       ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), ns, lcname_len, opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK TSRMLS_CC);
+                                       ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), ce_name, ce_name_len, opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK TSRMLS_CC);
+                                       efree(ce_name.v);
                                        if (!ce) {
                                                zend_error(E_ERROR, "Class '%R' not found", Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant));
                                        }
@@ -10281,8 +10079,6 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDL
                                zend_error(E_ERROR, "Class '%R' not found", Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant));
                        }
                }
-
-               efree(lcname.v);
        } else {
                ce = EX_T(opline->op1.u.var).class_entry;
        }
@@ -11945,33 +11741,11 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER
 
        if (IS_VAR == IS_CONST && IS_TMP_VAR == IS_CONST) {
                /* try a function in namespace */
-               zstr fname, lcname;
-               unsigned int len, lcname_len;
-
-               len = Z_UNILEN(opline->op1.u.constant) + 2 + Z_UNILEN(opline->op2.u.constant);
-               if (UG(unicode)) {
-                       fname.u = eumalloc(len + 1);
-                       memcpy(fname.u, Z_USTRVAL(opline->op1.u.constant), UBYTES(Z_USTRLEN(opline->op1.u.constant)));
-            fname.u[Z_USTRLEN(opline->op1.u.constant)] = ':';
-                       fname.u[Z_USTRLEN(opline->op1.u.constant)+1] = ':';
-                       memcpy(fname.u+Z_USTRLEN(opline->op1.u.constant)+2,
-                               Z_USTRVAL(opline->op2.u.constant),
-                               UBYTES(Z_USTRLEN(opline->op2.u.constant)+1));
-                       lcname = zend_u_str_case_fold(IS_UNICODE, fname, len, 1, &lcname_len);
-               } else {
-                       fname.s = emalloc(len + 1);
-                       memcpy(fname.s, Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant));
-            fname.s[Z_STRLEN(opline->op1.u.constant)] = ':';
-                       fname.s[Z_STRLEN(opline->op1.u.constant)+1] = ':';
-                       memcpy(fname.s+Z_STRLEN(opline->op1.u.constant)+2,
-                               Z_STRVAL(opline->op2.u.constant),
-                               Z_STRLEN(opline->op2.u.constant)+1);
-                       lcname = zend_u_str_case_fold(IS_STRING, fname, len, 1, &lcname_len);
-               }
-               efree(fname.v);
-
-               if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, lcname, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                       efree(lcname.v);
+               zend_op *op_data = opline+1;
+
+               ZEND_VM_INC_OPCODE();
+
+               if (zend_u_hash_quick_find(EG(function_table), Z_TYPE(op_data->op1.u.constant), Z_UNIVAL(op_data->op1.u.constant), Z_UNILEN(op_data->op1.u.constant)+1, op_data->extended_value, (void **) &EX(fbc))==SUCCESS) {
                        EX(object) = NULL;
                        ZEND_VM_NEXT_OPCODE();
                }
@@ -11980,34 +11754,24 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER
                ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant), Z_UNILEN(opline->op1.u.constant), (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) ? (opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK) : opline->extended_value TSRMLS_CC);
 
                if (!ce) {
-                       if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) {
-                               zstr ns;
-
-                               if (UG(unicode) && (ns.u = u_memchr(lcname.u, ':', lcname_len)) && ns.u[1] == ':') {
-                                       ns.u += 2;
-                                       lcname_len -= (ns.u - lcname.u);
-                                       if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, ns, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                                               efree(lcname.v);
-                                               EX(object) = NULL;
-                                               ZEND_VM_NEXT_OPCODE();
-                                       }
-                       } else if (!UG(unicode) && (ns.s = memchr(lcname.s, ':', lcname_len)) && ns.s[1] == ':') {
-                                       ns.s += 2;
-                                       lcname_len -= (ns.s - lcname.s);
-                                       if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, ns, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                                               efree(lcname.v);
-                                               EX(object) = NULL;
-                                               ZEND_VM_NEXT_OPCODE();
-                                       }
+                       if ((opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) &&
+                           op_data->op2.op_type == IS_CONST) {
+
+                               if (zend_u_hash_find(EG(function_table), Z_TYPE(op_data->op2.u.constant), Z_UNIVAL(op_data->op2.u.constant), Z_UNILEN(op_data->op2.u.constant) + 1, (void **) &EX(fbc))==SUCCESS) {
+                                       EX(object) = NULL;
+                                       ZEND_VM_NEXT_OPCODE();
                                }
+
                                if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_CHECK) {
-                                       lcname_len -= Z_UNILEN(opline->op2.u.constant) + 2;
+                                       zstr ce_name;
+                                       unsigned ce_name_len = Z_UNILEN(op_data->op1.u.constant) - (Z_UNILEN(op_data->op2.u.constant) + 2);
                                        if (UG(unicode)) {
-                                               ns.u[lcname_len] = 0;
+                                               ce_name.u = eustrndup(Z_USTRVAL(op_data->op1.u.constant), ce_name_len);
                                        } else {
-                                               ns.s[lcname_len] = 0;
+                                               ce_name.s = estrndup(Z_STRVAL(op_data->op1.u.constant), ce_name_len);
                                        }
-                                       ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), ns, lcname_len, opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK TSRMLS_CC);
+                                       ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), ce_name, ce_name_len, opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK TSRMLS_CC);
+                                       efree(ce_name.v);
                                        if (!ce) {
                                                zend_error(E_ERROR, "Class '%R' not found", Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant));
                                        }
@@ -12018,8 +11782,6 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER
                                zend_error(E_ERROR, "Class '%R' not found", Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant));
                        }
                }
-
-               efree(lcname.v);
        } else {
                ce = EX_T(opline->op1.u.var).class_entry;
        }
@@ -13674,33 +13436,11 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER
 
        if (IS_VAR == IS_CONST && IS_VAR == IS_CONST) {
                /* try a function in namespace */
-               zstr fname, lcname;
-               unsigned int len, lcname_len;
-
-               len = Z_UNILEN(opline->op1.u.constant) + 2 + Z_UNILEN(opline->op2.u.constant);
-               if (UG(unicode)) {
-                       fname.u = eumalloc(len + 1);
-                       memcpy(fname.u, Z_USTRVAL(opline->op1.u.constant), UBYTES(Z_USTRLEN(opline->op1.u.constant)));
-            fname.u[Z_USTRLEN(opline->op1.u.constant)] = ':';
-                       fname.u[Z_USTRLEN(opline->op1.u.constant)+1] = ':';
-                       memcpy(fname.u+Z_USTRLEN(opline->op1.u.constant)+2,
-                               Z_USTRVAL(opline->op2.u.constant),
-                               UBYTES(Z_USTRLEN(opline->op2.u.constant)+1));
-                       lcname = zend_u_str_case_fold(IS_UNICODE, fname, len, 1, &lcname_len);
-               } else {
-                       fname.s = emalloc(len + 1);
-                       memcpy(fname.s, Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant));
-            fname.s[Z_STRLEN(opline->op1.u.constant)] = ':';
-                       fname.s[Z_STRLEN(opline->op1.u.constant)+1] = ':';
-                       memcpy(fname.s+Z_STRLEN(opline->op1.u.constant)+2,
-                               Z_STRVAL(opline->op2.u.constant),
-                               Z_STRLEN(opline->op2.u.constant)+1);
-                       lcname = zend_u_str_case_fold(IS_STRING, fname, len, 1, &lcname_len);
-               }
-               efree(fname.v);
-
-               if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, lcname, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                       efree(lcname.v);
+               zend_op *op_data = opline+1;
+
+               ZEND_VM_INC_OPCODE();
+
+               if (zend_u_hash_quick_find(EG(function_table), Z_TYPE(op_data->op1.u.constant), Z_UNIVAL(op_data->op1.u.constant), Z_UNILEN(op_data->op1.u.constant)+1, op_data->extended_value, (void **) &EX(fbc))==SUCCESS) {
                        EX(object) = NULL;
                        ZEND_VM_NEXT_OPCODE();
                }
@@ -13709,34 +13449,24 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER
                ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant), Z_UNILEN(opline->op1.u.constant), (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) ? (opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK) : opline->extended_value TSRMLS_CC);
 
                if (!ce) {
-                       if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) {
-                               zstr ns;
-
-                               if (UG(unicode) && (ns.u = u_memchr(lcname.u, ':', lcname_len)) && ns.u[1] == ':') {
-                                       ns.u += 2;
-                                       lcname_len -= (ns.u - lcname.u);
-                                       if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, ns, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                                               efree(lcname.v);
-                                               EX(object) = NULL;
-                                               ZEND_VM_NEXT_OPCODE();
-                                       }
-                       } else if (!UG(unicode) && (ns.s = memchr(lcname.s, ':', lcname_len)) && ns.s[1] == ':') {
-                                       ns.s += 2;
-                                       lcname_len -= (ns.s - lcname.s);
-                                       if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, ns, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                                               efree(lcname.v);
-                                               EX(object) = NULL;
-                                               ZEND_VM_NEXT_OPCODE();
-                                       }
+                       if ((opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) &&
+                           op_data->op2.op_type == IS_CONST) {
+
+                               if (zend_u_hash_find(EG(function_table), Z_TYPE(op_data->op2.u.constant), Z_UNIVAL(op_data->op2.u.constant), Z_UNILEN(op_data->op2.u.constant) + 1, (void **) &EX(fbc))==SUCCESS) {
+                                       EX(object) = NULL;
+                                       ZEND_VM_NEXT_OPCODE();
                                }
+
                                if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_CHECK) {
-                                       lcname_len -= Z_UNILEN(opline->op2.u.constant) + 2;
+                                       zstr ce_name;
+                                       unsigned ce_name_len = Z_UNILEN(op_data->op1.u.constant) - (Z_UNILEN(op_data->op2.u.constant) + 2);
                                        if (UG(unicode)) {
-                                               ns.u[lcname_len] = 0;
+                                               ce_name.u = eustrndup(Z_USTRVAL(op_data->op1.u.constant), ce_name_len);
                                        } else {
-                                               ns.s[lcname_len] = 0;
+                                               ce_name.s = estrndup(Z_STRVAL(op_data->op1.u.constant), ce_name_len);
                                        }
-                                       ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), ns, lcname_len, opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK TSRMLS_CC);
+                                       ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), ce_name, ce_name_len, opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK TSRMLS_CC);
+                                       efree(ce_name.v);
                                        if (!ce) {
                                                zend_error(E_ERROR, "Class '%R' not found", Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant));
                                        }
@@ -13747,8 +13477,6 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER
                                zend_error(E_ERROR, "Class '%R' not found", Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant));
                        }
                }
-
-               efree(lcname.v);
        } else {
                ce = EX_T(opline->op1.u.var).class_entry;
        }
@@ -14601,33 +14329,11 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HAND
 
        if (IS_VAR == IS_CONST && IS_UNUSED == IS_CONST) {
                /* try a function in namespace */
-               zstr fname, lcname;
-               unsigned int len, lcname_len;
-
-               len = Z_UNILEN(opline->op1.u.constant) + 2 + Z_UNILEN(opline->op2.u.constant);
-               if (UG(unicode)) {
-                       fname.u = eumalloc(len + 1);
-                       memcpy(fname.u, Z_USTRVAL(opline->op1.u.constant), UBYTES(Z_USTRLEN(opline->op1.u.constant)));
-            fname.u[Z_USTRLEN(opline->op1.u.constant)] = ':';
-                       fname.u[Z_USTRLEN(opline->op1.u.constant)+1] = ':';
-                       memcpy(fname.u+Z_USTRLEN(opline->op1.u.constant)+2,
-                               Z_USTRVAL(opline->op2.u.constant),
-                               UBYTES(Z_USTRLEN(opline->op2.u.constant)+1));
-                       lcname = zend_u_str_case_fold(IS_UNICODE, fname, len, 1, &lcname_len);
-               } else {
-                       fname.s = emalloc(len + 1);
-                       memcpy(fname.s, Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant));
-            fname.s[Z_STRLEN(opline->op1.u.constant)] = ':';
-                       fname.s[Z_STRLEN(opline->op1.u.constant)+1] = ':';
-                       memcpy(fname.s+Z_STRLEN(opline->op1.u.constant)+2,
-                               Z_STRVAL(opline->op2.u.constant),
-                               Z_STRLEN(opline->op2.u.constant)+1);
-                       lcname = zend_u_str_case_fold(IS_STRING, fname, len, 1, &lcname_len);
-               }
-               efree(fname.v);
-
-               if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, lcname, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                       efree(lcname.v);
+               zend_op *op_data = opline+1;
+
+               ZEND_VM_INC_OPCODE();
+
+               if (zend_u_hash_quick_find(EG(function_table), Z_TYPE(op_data->op1.u.constant), Z_UNIVAL(op_data->op1.u.constant), Z_UNILEN(op_data->op1.u.constant)+1, op_data->extended_value, (void **) &EX(fbc))==SUCCESS) {
                        EX(object) = NULL;
                        ZEND_VM_NEXT_OPCODE();
                }
@@ -14636,34 +14342,24 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HAND
                ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant), Z_UNILEN(opline->op1.u.constant), (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) ? (opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK) : opline->extended_value TSRMLS_CC);
 
                if (!ce) {
-                       if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) {
-                               zstr ns;
-
-                               if (UG(unicode) && (ns.u = u_memchr(lcname.u, ':', lcname_len)) && ns.u[1] == ':') {
-                                       ns.u += 2;
-                                       lcname_len -= (ns.u - lcname.u);
-                                       if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, ns, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                                               efree(lcname.v);
-                                               EX(object) = NULL;
-                                               ZEND_VM_NEXT_OPCODE();
-                                       }
-                       } else if (!UG(unicode) && (ns.s = memchr(lcname.s, ':', lcname_len)) && ns.s[1] == ':') {
-                                       ns.s += 2;
-                                       lcname_len -= (ns.s - lcname.s);
-                                       if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, ns, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                                               efree(lcname.v);
-                                               EX(object) = NULL;
-                                               ZEND_VM_NEXT_OPCODE();
-                                       }
+                       if ((opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) &&
+                           op_data->op2.op_type == IS_CONST) {
+
+                               if (zend_u_hash_find(EG(function_table), Z_TYPE(op_data->op2.u.constant), Z_UNIVAL(op_data->op2.u.constant), Z_UNILEN(op_data->op2.u.constant) + 1, (void **) &EX(fbc))==SUCCESS) {
+                                       EX(object) = NULL;
+                                       ZEND_VM_NEXT_OPCODE();
                                }
+
                                if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_CHECK) {
-                                       lcname_len -= Z_UNILEN(opline->op2.u.constant) + 2;
+                                       zstr ce_name;
+                                       unsigned ce_name_len = Z_UNILEN(op_data->op1.u.constant) - (Z_UNILEN(op_data->op2.u.constant) + 2);
                                        if (UG(unicode)) {
-                                               ns.u[lcname_len] = 0;
+                                               ce_name.u = eustrndup(Z_USTRVAL(op_data->op1.u.constant), ce_name_len);
                                        } else {
-                                               ns.s[lcname_len] = 0;
+                                               ce_name.s = estrndup(Z_STRVAL(op_data->op1.u.constant), ce_name_len);
                                        }
-                                       ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), ns, lcname_len, opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK TSRMLS_CC);
+                                       ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), ce_name, ce_name_len, opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK TSRMLS_CC);
+                                       efree(ce_name.v);
                                        if (!ce) {
                                                zend_error(E_ERROR, "Class '%R' not found", Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant));
                                        }
@@ -14674,8 +14370,6 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HAND
                                zend_error(E_ERROR, "Class '%R' not found", Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant));
                        }
                }
-
-               efree(lcname.v);
        } else {
                ce = EX_T(opline->op1.u.var).class_entry;
        }
@@ -15980,33 +15674,11 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_
 
        if (IS_VAR == IS_CONST && IS_CV == IS_CONST) {
                /* try a function in namespace */
-               zstr fname, lcname;
-               unsigned int len, lcname_len;
-
-               len = Z_UNILEN(opline->op1.u.constant) + 2 + Z_UNILEN(opline->op2.u.constant);
-               if (UG(unicode)) {
-                       fname.u = eumalloc(len + 1);
-                       memcpy(fname.u, Z_USTRVAL(opline->op1.u.constant), UBYTES(Z_USTRLEN(opline->op1.u.constant)));
-            fname.u[Z_USTRLEN(opline->op1.u.constant)] = ':';
-                       fname.u[Z_USTRLEN(opline->op1.u.constant)+1] = ':';
-                       memcpy(fname.u+Z_USTRLEN(opline->op1.u.constant)+2,
-                               Z_USTRVAL(opline->op2.u.constant),
-                               UBYTES(Z_USTRLEN(opline->op2.u.constant)+1));
-                       lcname = zend_u_str_case_fold(IS_UNICODE, fname, len, 1, &lcname_len);
-               } else {
-                       fname.s = emalloc(len + 1);
-                       memcpy(fname.s, Z_STRVAL(opline->op1.u.constant), Z_STRLEN(opline->op1.u.constant));
-            fname.s[Z_STRLEN(opline->op1.u.constant)] = ':';
-                       fname.s[Z_STRLEN(opline->op1.u.constant)+1] = ':';
-                       memcpy(fname.s+Z_STRLEN(opline->op1.u.constant)+2,
-                               Z_STRVAL(opline->op2.u.constant),
-                               Z_STRLEN(opline->op2.u.constant)+1);
-                       lcname = zend_u_str_case_fold(IS_STRING, fname, len, 1, &lcname_len);
-               }
-               efree(fname.v);
-
-               if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, lcname, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                       efree(lcname.v);
+               zend_op *op_data = opline+1;
+
+               ZEND_VM_INC_OPCODE();
+
+               if (zend_u_hash_quick_find(EG(function_table), Z_TYPE(op_data->op1.u.constant), Z_UNIVAL(op_data->op1.u.constant), Z_UNILEN(op_data->op1.u.constant)+1, op_data->extended_value, (void **) &EX(fbc))==SUCCESS) {
                        EX(object) = NULL;
                        ZEND_VM_NEXT_OPCODE();
                }
@@ -16015,34 +15687,24 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_
                ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant), Z_UNILEN(opline->op1.u.constant), (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) ? (opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK) : opline->extended_value TSRMLS_CC);
 
                if (!ce) {
-                       if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) {
-                               zstr ns;
-
-                               if (UG(unicode) && (ns.u = u_memchr(lcname.u, ':', lcname_len)) && ns.u[1] == ':') {
-                                       ns.u += 2;
-                                       lcname_len -= (ns.u - lcname.u);
-                                       if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, ns, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                                               efree(lcname.v);
-                                               EX(object) = NULL;
-                                               ZEND_VM_NEXT_OPCODE();
-                                       }
-                       } else if (!UG(unicode) && (ns.s = memchr(lcname.s, ':', lcname_len)) && ns.s[1] == ':') {
-                                       ns.s += 2;
-                                       lcname_len -= (ns.s - lcname.s);
-                                       if (zend_u_hash_find(EG(function_table), ZEND_STR_TYPE, ns, lcname_len+1, (void **) &EX(fbc))==SUCCESS) {
-                                               efree(lcname.v);
-                                               EX(object) = NULL;
-                                               ZEND_VM_NEXT_OPCODE();
-                                       }
+                       if ((opline->extended_value & ZEND_FETCH_CLASS_RT_NS_NAME) &&
+                           op_data->op2.op_type == IS_CONST) {
+
+                               if (zend_u_hash_find(EG(function_table), Z_TYPE(op_data->op2.u.constant), Z_UNIVAL(op_data->op2.u.constant), Z_UNILEN(op_data->op2.u.constant) + 1, (void **) &EX(fbc))==SUCCESS) {
+                                       EX(object) = NULL;
+                                       ZEND_VM_NEXT_OPCODE();
                                }
+
                                if (opline->extended_value & ZEND_FETCH_CLASS_RT_NS_CHECK) {
-                                       lcname_len -= Z_UNILEN(opline->op2.u.constant) + 2;
+                                       zstr ce_name;
+                                       unsigned ce_name_len = Z_UNILEN(op_data->op1.u.constant) - (Z_UNILEN(op_data->op2.u.constant) + 2);
                                        if (UG(unicode)) {
-                                               ns.u[lcname_len] = 0;
+                                               ce_name.u = eustrndup(Z_USTRVAL(op_data->op1.u.constant), ce_name_len);
                                        } else {
-                                               ns.s[lcname_len] = 0;
+                                               ce_name.s = estrndup(Z_STRVAL(op_data->op1.u.constant), ce_name_len);
                                        }
-                                       ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), ns, lcname_len, opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK TSRMLS_CC);
+                                       ce = zend_u_fetch_class(Z_TYPE(opline->op1.u.constant), ce_name, ce_name_len, opline->extended_value & ~ZEND_FETCH_CLASS_RT_NS_CHECK TSRMLS_CC);
+                                       efree(ce_name.v);
                                        if (!ce) {
                                                zend_error(E_ERROR, "Class '%R' not found", Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant));
                                        }
@@ -16053,8 +15715,6 @@ static int ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_
                                zend_error(E_ERROR, "Class '%R' not found", Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant));
                        }
                }
-
-               efree(lcname.v);
        } else {
                ce = EX_T(opline->op1.u.var).class_entry;
        }