Merge remote-tracking branch 'origin/master' into native-tls

* origin/master:
  Optimize argument passing handlers:
  Fix pcre non-FAST_ZPP build

Conflicts:
	Zend/zend_compile.c
	Zend/zend_execute.h
	Zend/zend_vm_def.h
	Zend/zend_vm_execute.h
	ext/pcre/php_pcre.c

diff --cc Zend/zend_compile.c
index 6eec6615afc52e186733fb1d8de5d51ce79b826d,95892cbe670c36794312f5d2777f484fdb743f72..c196e398875cfd666ac0f292cddc70e397c6f6e7
--- 1/Zend/zend_compile.c
--- 2/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@@ -2403,9 -2404,10 +2403,10 @@@ uint32_t zend_compile_args(zend_ast *as
                        uses_arg_unpack = 1;
                        fbc = NULL;
                        
 -                      zend_compile_expr(&arg_node, arg->child[0] TSRMLS_CC);
 -                      opline = zend_emit_op(NULL, ZEND_SEND_UNPACK, &arg_node, NULL TSRMLS_CC);
 +                      zend_compile_expr(&arg_node, arg->child[0]);
 +                      opline = zend_emit_op(NULL, ZEND_SEND_UNPACK, &arg_node, NULL);
                        opline->op2.num = arg_count;
+                       opline->result.var = (uint32_t)(zend_intptr_t)ZEND_CALL_ARG(NULL, arg_count);
                        continue;
                }
  
@@@ -2695,10 -2698,10 +2697,10 @@@ int zend_compile_func_cufa(znode *resul
                return FAILURE;
        }
  
-       zend_compile_init_user_func(args->child[0], 1, lcname);
 -      zend_compile_init_user_func(args->child[0], 0, lcname TSRMLS_CC);
 -      zend_compile_expr(&arg_node, args->child[1] TSRMLS_CC);
 -      zend_emit_op(NULL, ZEND_SEND_ARRAY, &arg_node, NULL TSRMLS_CC);
 -      zend_emit_op(result, ZEND_DO_FCALL, NULL, NULL TSRMLS_CC);
++      zend_compile_init_user_func(args->child[0], 0, lcname);
 +      zend_compile_expr(&arg_node, args->child[1]);
 +      zend_emit_op(NULL, ZEND_SEND_ARRAY, &arg_node, NULL);
 +      zend_emit_op(result, ZEND_DO_FCALL, NULL, NULL);
  
        return SUCCESS;
  }
@@@ -2731,14 -2734,15 +2733,15 @@@ int zend_compile_func_cuf(znode *result
                }
  
                if (send_user) {
 -                      opline = zend_emit_op(NULL, ZEND_SEND_USER, &arg_node, NULL TSRMLS_CC);
 +                      opline = zend_emit_op(NULL, ZEND_SEND_USER, &arg_node, NULL);
                } else {
 -                      opline = zend_emit_op(NULL, ZEND_SEND_VAL, &arg_node, NULL TSRMLS_CC);
 +                      opline = zend_emit_op(NULL, ZEND_SEND_VAL, &arg_node, NULL);
                }
  
-               opline->op2.opline_num = i;
+               opline->op2.num = i;
+               opline->result.var = (uint32_t)(zend_intptr_t)ZEND_CALL_ARG(NULL, i);
        }
 -      zend_emit_op(result, ZEND_DO_FCALL, NULL, NULL TSRMLS_CC);
 +      zend_emit_op(result, ZEND_DO_FCALL, NULL, NULL);
  
        return SUCCESS;
  }

diff --cc Zend/zend_execute.h
index a62f809cce389e338f11fd429f0a1e16effe315e,fdf07d52abd5b30b1789a9155f4209b830c00d11..33463e05ac02ba3f0abfa59992372fb7e3c40840
--- 1/Zend/zend_execute.h
--- 2/Zend/zend_execute.h
+++ b/Zend/zend_execute.h
@@@ -143,9 -143,9 +143,9 @@@ static zend_always_inline zval* zend_vm
        return (zval*)top;
  }
  
- static zend_always_inline zend_execute_data *zend_vm_stack_push_call_frame_ex(uint32_t call_info, zend_function *func, uint32_t used_stack, zend_class_entry *called_scope, zend_object *object, zend_execute_data *prev)
 -static zend_always_inline zend_execute_data *zend_vm_stack_push_call_frame_ex(uint32_t used_stack, uint32_t call_info, zend_function *func, uint32_t num_args, zend_class_entry *called_scope, zend_object *object, zend_execute_data *prev TSRMLS_DC)
++static zend_always_inline zend_execute_data *zend_vm_stack_push_call_frame_ex(uint32_t used_stack, uint32_t call_info, zend_function *func, uint32_t num_args, zend_class_entry *called_scope, zend_object *object, zend_execute_data *prev)
  {
 -      zend_execute_data *call = (zend_execute_data*)zend_vm_stack_alloc(used_stack TSRMLS_CC);
 +      zend_execute_data *call = (zend_execute_data*)zend_vm_stack_alloc(used_stack);
  
        call->func = func;
        Z_OBJ(call->This) = object;
@@@ -170,11 -170,11 +170,11 @@@ static zend_always_inline zend_execute_
  {
        uint32_t used_stack = zend_vm_calc_used_stack(num_args, func);
        
-       return zend_vm_stack_push_call_frame_ex(call_info,
-               func, used_stack, called_scope, object, prev);
+       return zend_vm_stack_push_call_frame_ex(used_stack, call_info,
 -              func, num_args, called_scope, object, prev TSRMLS_CC);
++              func, num_args, called_scope, object, prev);
  }
  
 -static zend_always_inline void zend_vm_stack_free_extra_args(zend_execute_data *call TSRMLS_DC)
 +static zend_always_inline void zend_vm_stack_free_extra_args(zend_execute_data *call)
  {
        uint32_t first_extra_arg = call->func->op_array.num_args - ((call->func->common.fn_flags & ZEND_ACC_VARIADIC) != 0);
  

diff --cc Zend/zend_execute_API.c
Simple merge

diff --cc Zend/zend_vm_def.h
index 039020943a766345d9311500b01194ad124d73e2,8bf7986eeb116710ca36060a02f7206df9cc0d52..d9f6f3ef6976210fe8d7d6afa5fd5af739daa685
--- 1/Zend/zend_vm_def.h
--- 2/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@@ -2736,8 -2736,9 +2736,9 @@@ ZEND_VM_HANDLER(61, ZEND_INIT_FCALL, AN
                CACHE_PTR(Z_CACHE_SLOT_P(fname), fbc);
        }
  
-       EX(call) = zend_vm_stack_push_call_frame_ex(ZEND_CALL_NESTED_FUNCTION,
-               fbc, opline->op1.num, NULL, NULL, EX(call));
+       EX(call) = zend_vm_stack_push_call_frame_ex(
+               opline->op1.num, ZEND_CALL_NESTED_FUNCTION,
 -              fbc, opline->extended_value, NULL, NULL, EX(call) TSRMLS_CC);
++              fbc, opline->extended_value, NULL, NULL, EX(call));
  
        FREE_OP2();
  
@@@ -3477,9 -3472,8 +3472,8 @@@ ZEND_VM_HANDLER(119, ZEND_SEND_ARRAY, A
                zval *arg, *param, tmp;
  
  ZEND_VM_C_LABEL(send_array):
-               arg_num = 1;
                ht = Z_ARRVAL_P(args);
 -              zend_vm_stack_extend_call_frame(&EX(call), 0, zend_hash_num_elements(ht) TSRMLS_CC);
 +              zend_vm_stack_extend_call_frame(&EX(call), 0, zend_hash_num_elements(ht));
  
                if (OP1_TYPE != IS_CONST && OP1_TYPE != IS_TMP_VAR && Z_IMMUTABLE_P(args)) {
                        uint32_t i;
@@@ -5675,7 -5672,78 +5672,78 @@@ ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPT
                do {
                        /* If the exception was thrown during a function call there might be
                         * arguments pushed to the stack that have to be dtor'ed. */
 -                      zend_vm_stack_free_args(EX(call) TSRMLS_CC);
+ 
+                       /* find the number of actually passed arguments */
+                       level = 0;
+                       do_exit = 0;
+                       do {
+                               switch (opline->opcode) {
+                                       case ZEND_DO_FCALL:
+                                               level++;
+                                               break;                                                                          
+                                       case ZEND_INIT_FCALL:
+                                       case ZEND_INIT_FCALL_BY_NAME:
+                                       case ZEND_INIT_NS_FCALL_BY_NAME:
+                                       case ZEND_INIT_USER_CALL:
+                                       case ZEND_INIT_METHOD_CALL:
+                                       case ZEND_INIT_STATIC_METHOD_CALL:
+                                       case ZEND_NEW:
+                                               if (level == 0) {
+                                                       ZEND_CALL_NUM_ARGS(call) = 0;
+                                                       do_exit = 1;                                                    
+                                               }
+                                               level--;
+                                               break;
+                                       case ZEND_SEND_VAL:
+                                       case ZEND_SEND_VAL_EX:
+                                       case ZEND_SEND_VAR:
+                                       case ZEND_SEND_VAR_EX:
+                                       case ZEND_SEND_REF:
+                                       case ZEND_SEND_VAR_NO_REF:
+                                       case ZEND_SEND_USER:
+                                               if (level == 0) {
+                                                       ZEND_CALL_NUM_ARGS(call) = opline->op2.num;
+                                                       do_exit = 1;                                                    
+                                               }
+                                               break;
+                                       case ZEND_SEND_ARRAY:
+                                       case ZEND_SEND_UNPACK:
+                                               if (level == 0) {
+                                                       do_exit = 1;
+                                               }
+                                               break;
+                               }
+                               if (!do_exit) {
+                                       opline--;
+                               }
+                       } while (!do_exit);
+                       if (call->prev_execute_data) {
+                               /* skip current call region */
+                               level = 0;
+                               do_exit = 0;
+                               do {
+                                       switch (opline->opcode) {
+                                               case ZEND_DO_FCALL:
+                                                       level++;
+                                                       break;                                                                          
+                                               case ZEND_INIT_FCALL:
+                                               case ZEND_INIT_FCALL_BY_NAME:
+                                               case ZEND_INIT_NS_FCALL_BY_NAME:
+                                               case ZEND_INIT_USER_CALL:
+                                               case ZEND_INIT_METHOD_CALL:
+                                               case ZEND_INIT_STATIC_METHOD_CALL:
+                                               case ZEND_NEW:
+                                                       if (level == 0) {
+                                                               do_exit = 1;                                                    
+                                                       }
+                                                       level--;
+                                                       break;
+                                       }
+                                       opline--;
+                               } while (!do_exit);
+                       }
+ 
 +                      zend_vm_stack_free_args(EX(call));
  
                        if (Z_OBJ(call->This)) {
                                if (ZEND_CALL_INFO(call) & ZEND_CALL_CTOR) {

diff --cc Zend/zend_vm_execute.h
index 5b1d22edccd01692a82ac7043fdc76e7bb1b8de8,f3fb43db962d8714bdaad82316d2e4aa47643ec2..1c2700e3b53106763d9f9af1022dffe284d98758
--- 1/Zend/zend_vm_execute.h
--- 2/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@@ -879,9 -879,8 +879,8 @@@ static int ZEND_FASTCALL  ZEND_SEND_ARR
                zval *arg, *param, tmp;
  
  send_array:
-               arg_num = 1;
                ht = Z_ARRVAL_P(args);
 -              zend_vm_stack_extend_call_frame(&EX(call), 0, zend_hash_num_elements(ht) TSRMLS_CC);
 +              zend_vm_stack_extend_call_frame(&EX(call), 0, zend_hash_num_elements(ht));
  
                if (opline->op1_type != IS_CONST && opline->op1_type != IS_TMP_VAR && Z_IMMUTABLE_P(args)) {
                        uint32_t i;
@@@ -1236,7 -1240,78 +1240,78 @@@ static int ZEND_FASTCALL  ZEND_HANDLE_E
                do {
                        /* If the exception was thrown during a function call there might be
                         * arguments pushed to the stack that have to be dtor'ed. */
 -                      zend_vm_stack_free_args(EX(call) TSRMLS_CC);
+ 
+                       /* find the number of actually passed arguments */
+                       level = 0;
+                       do_exit = 0;
+                       do {
+                               switch (opline->opcode) {
+                                       case ZEND_DO_FCALL:
+                                               level++;
+                                               break;
+                                       case ZEND_INIT_FCALL:
+                                       case ZEND_INIT_FCALL_BY_NAME:
+                                       case ZEND_INIT_NS_FCALL_BY_NAME:
+                                       case ZEND_INIT_USER_CALL:
+                                       case ZEND_INIT_METHOD_CALL:
+                                       case ZEND_INIT_STATIC_METHOD_CALL:
+                                       case ZEND_NEW:
+                                               if (level == 0) {
+                                                       ZEND_CALL_NUM_ARGS(call) = 0;
+                                                       do_exit = 1;
+                                               }
+                                               level--;
+                                               break;
+                                       case ZEND_SEND_VAL:
+                                       case ZEND_SEND_VAL_EX:
+                                       case ZEND_SEND_VAR:
+                                       case ZEND_SEND_VAR_EX:
+                                       case ZEND_SEND_REF:
+                                       case ZEND_SEND_VAR_NO_REF:
+                                       case ZEND_SEND_USER:
+                                               if (level == 0) {
+                                                       ZEND_CALL_NUM_ARGS(call) = opline->op2.num;
+                                                       do_exit = 1;
+                                               }
+                                               break;
+                                       case ZEND_SEND_ARRAY:
+                                       case ZEND_SEND_UNPACK:
+                                               if (level == 0) {
+                                                       do_exit = 1;
+                                               }
+                                               break;
+                               }
+                               if (!do_exit) {
+                                       opline--;
+                               }
+                       } while (!do_exit);
+                       if (call->prev_execute_data) {
+                               /* skip current call region */
+                               level = 0;
+                               do_exit = 0;
+                               do {
+                                       switch (opline->opcode) {
+                                               case ZEND_DO_FCALL:
+                                                       level++;
+                                                       break;
+                                               case ZEND_INIT_FCALL:
+                                               case ZEND_INIT_FCALL_BY_NAME:
+                                               case ZEND_INIT_NS_FCALL_BY_NAME:
+                                               case ZEND_INIT_USER_CALL:
+                                               case ZEND_INIT_METHOD_CALL:
+                                               case ZEND_INIT_STATIC_METHOD_CALL:
+                                               case ZEND_NEW:
+                                                       if (level == 0) {
+                                                               do_exit = 1;
+                                                       }
+                                                       level--;
+                                                       break;
+                                       }
+                                       opline--;
+                               } while (!do_exit);
+                       }
+ 
 +                      zend_vm_stack_free_args(EX(call));
  
                        if (Z_OBJ(call->This)) {
                                if (ZEND_CALL_INFO(call) & ZEND_CALL_CTOR) {
@@@ -1656,8 -1731,9 +1731,9 @@@ static int ZEND_FASTCALL  ZEND_INIT_FCA
                CACHE_PTR(Z_CACHE_SLOT_P(fname), fbc);
        }
  
-       EX(call) = zend_vm_stack_push_call_frame_ex(ZEND_CALL_NESTED_FUNCTION,
-               fbc, opline->op1.num, NULL, NULL, EX(call));
+       EX(call) = zend_vm_stack_push_call_frame_ex(
+               opline->op1.num, ZEND_CALL_NESTED_FUNCTION,
 -              fbc, opline->extended_value, NULL, NULL, EX(call) TSRMLS_CC);
++              fbc, opline->extended_value, NULL, NULL, EX(call));
  
        ZEND_VM_NEXT_OPCODE();
  }
@@@ -23261,9 -23327,8 +23327,8 @@@ static int ZEND_FASTCALL  ZEND_SEND_VAR
        zval *varptr, *arg;
  
  
 -      varptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 +      varptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
-       arg = ZEND_CALL_ARG(EX(call), opline->op2.num);
-       ZEND_CALL_NUM_ARGS(EX(call)) = opline->op2.num;
+       arg = ZEND_CALL_VAR(EX(call), opline->result.var);
        if (Z_ISREF_P(varptr)) {
                ZVAL_COPY(arg, Z_REFVAL_P(varptr));
  
@@@ -23359,9 -23422,8 +23422,8 @@@ static int ZEND_FASTCALL  ZEND_SEND_VAR
        if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, opline->op2.num)) {
                return ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
        }
 -      varptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 +      varptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
-       arg = ZEND_CALL_ARG(EX(call), opline->op2.num);
-       ZEND_CALL_NUM_ARGS(EX(call)) = opline->op2.num;
+       arg = ZEND_CALL_VAR(EX(call), opline->result.var);
        if (Z_ISREF_P(varptr)) {
                ZVAL_COPY(arg, Z_REFVAL_P(varptr));
  
@@@ -23380,8 -23442,8 +23442,8 @@@ static int ZEND_FASTCALL  ZEND_SEND_USE
        zval *arg, *param, tmp;
  
  
 -      arg = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 +      arg = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
-       param = ZEND_CALL_ARG(EX(call), opline->op2.num);
+       param = ZEND_CALL_VAR(EX(call), opline->result.var);
  
        if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, opline->op2.num)) {
                // TODO: Scalar values don't have reference counters anymore.

diff --cc ext/pcre/php_pcre.c
index 0555f596a9b37dee852e2d230a13f14c196acdea,eb3b75abd208e01d619738476e250dda0dac4a61..9ca197eb54e01ca435c7ca57a27eb59e2527d5dc
--- 1/ext/pcre/php_pcre.c
--- 2/ext/pcre/php_pcre.c
+++ b/ext/pcre/php_pcre.c
@@@ -1560,8 -1560,8 +1560,8 @@@ static PHP_FUNCTION(preg_split
  
        /* Get function parameters and do error checking */     
  #ifndef FAST_ZPP
 -      if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SS|ll", &regex,
 +      if (zend_parse_parameters(ZEND_NUM_ARGS(), "SS|ll", &regex,
-                                                         &subject, &subject_len, &limit_val, &flags) == FAILURE) {
+                                                         &subject, &limit_val, &flags) == FAILURE) {
                RETURN_FALSE;
        }
  #else