pike.git / src / interpret_functions.h

version» Context lines:

pike.git/src/interpret_functions.h:4:   || for more information.   */      /*    * Opcode definitions for the interpreter.    */      #include "global.h"      #undef CJUMP - #undef AUTO_BIGNUM_LOOP_TEST +    #undef LOOP   #undef COMPARISON   #undef MKAPPLY   #undef DO_CALL_BUILTIN    - #undef DO_IF_BIGNUM - #ifdef AUTO_BIGNUM - #define DO_IF_BIGNUM(CODE) CODE - #else /* !AUTO_BIGNUM */ - #define DO_IF_BIGNUM(CODE) - #endif /* AUTO_BIGNUM */ -  +    #undef DO_IF_ELSE_COMPUTED_GOTO   #ifdef HAVE_COMPUTED_GOTO   #define DO_IF_ELSE_COMPUTED_GOTO(A, B) (A)   #else /* !HAVE_COMPUTED_GOTO */   #define DO_IF_ELSE_COMPUTED_GOTO(A, B) (B)   #endif /* HAVE_COMPUTED_GOTO */      #ifdef GEN_PROTOS   /* Used to generate the interpret_protos.h file. */   #define OPCODE0(A, B, F, C) OPCODE0(A, B, F) --- C
pike.git/src/interpret_functions.h:364:   });      OPCODE2_TAIL(F_MARK_AND_EXTERNAL, "mark & external", I_UPDATE_SP|I_UPDATE_M_SP, {    *(Pike_mark_sp++)=Pike_sp;       OPCODE2(F_EXTERNAL,"external", I_UPDATE_SP, {    LOCAL_VAR(struct external_variable_context loc);       loc.o=Pike_fp->current_object;    loc.parent_identifier=Pike_fp->fun; -  if (loc.o->prog) -  loc.inherit=INHERIT_FROM_INT(loc.o->prog, loc.parent_identifier); +  loc.inherit=Pike_fp->context;    find_external_context(&loc, arg2);       DO_IF_DEBUG({    TRACE((5,"- Identifier=%d Offset=%d\n",    arg1,    loc.inherit->identifier_level));    });       if (arg1 == IDREF_MAGIC_THIS)    /* Special treatment to allow doing Foo::this on destructed
pike.git/src/interpret_functions.h:393:    }    print_return_value();    });   });      OPCODE2(F_EXTERNAL_LVALUE, "& external", I_UPDATE_SP, {    LOCAL_VAR(struct external_variable_context loc);       loc.o=Pike_fp->current_object;    loc.parent_identifier=Pike_fp->fun; -  if (loc.o->prog) -  loc.inherit=INHERIT_FROM_INT(loc.o->prog, loc.parent_identifier); +  loc.inherit=Pike_fp->context;    find_external_context(&loc, arg2);       if (!loc.o->prog)    Pike_error ("Cannot access variable in destructed parent object.\n");       DO_IF_DEBUG({    TRACE((5,"- Identifier=%d Offset=%d\n",    arg1,    loc.inherit->identifier_level));    });
pike.git/src/interpret_functions.h:504:    {    SET_SVAL(locals[arg1+e], PIKE_T_INT, NUMBER_NUMBER, integer, 0);    }   });      OPCODE1(F_CLEAR_LOCAL, "clear local", 0, {    free_svalue(Pike_fp->locals + arg1);    SET_SVAL(Pike_fp->locals[arg1], PIKE_T_INT, NUMBER_NUMBER, integer, 0);   });    - OPCODE2(F_ADD_LOCALS_AND_POP, "local += local", 0,{ + OPCODE2(F_ADD_LOCALS_AND_POP, "local += local", 0, + {    struct svalue *dst = Pike_fp->locals+arg1;    struct svalue *src = Pike_fp->locals+arg2; -  if( dst->type == PIKE_T_INT -  && src->type == PIKE_T_INT -  DO_IF_BIGNUM( -  &&(!INT_TYPE_ADD_OVERFLOW(src->u.integer,dst->u.integer)))) +  if( (dst->type|src->type) == PIKE_T_INT +  && !INT_TYPE_ADD_OVERFLOW(src->u.integer,dst->u.integer) )    {    SET_SVAL_SUBTYPE(*dst,NUMBER_NUMBER);    dst->u.integer += src->u.integer;    } -  +  else if( dst->type == src->type && dst->type == PIKE_T_STRING ) +  { +  struct pike_string *srcs = src->u.string; +  struct pike_string *dsts = dst->u.string; +  if( dsts->len && srcs->len ) +  { +  size_t tmp = dsts->len; +  size_t tmp2 = srcs->len; +  /* +  * in case srcs==dsts +  * pike_string_cpy(MKPCHARP_STR_OFF(dsts,tmp), srcs); +  * does bad stuff +  */ +  dsts = new_realloc_shared_string( dsts, tmp+srcs->len, MAXIMUM(srcs->size_shift,dsts->size_shift) ); +  update_flags_for_add( dsts, srcs ); +  generic_memcpy(MKPCHARP_STR_OFF(dsts,tmp), MKPCHARP_STR(srcs), tmp2); +  dst->u.string = low_end_shared_string( dsts ); +  } +  else if( !dsts->len ) +  { +  free_string( dsts ); +  dst->u.string = srcs; +  srcs->refs++; +  } +  }    else    { -  push_svalue( dst ); +  *Pike_sp++ = *dst; +  SET_SVAL_TYPE(*dst,PIKE_T_INT);    push_svalue( src );    f_add(2); -  assign_svalue( Pike_fp->locals+arg1,Pike_sp-1); -  pop_stack(); +  *dst = *--Pike_sp;    }   });      OPCODE2(F_ADD_LOCAL_INT_AND_POP, "local += number", 0,{    struct svalue *dst = Pike_fp->locals+arg1;    if( dst->type == PIKE_T_INT -  DO_IF_BIGNUM( -  &&(!INT_TYPE_ADD_OVERFLOW(dst->u.integer,arg2)))) +  && !INT_TYPE_ADD_OVERFLOW(dst->u.integer,arg2) )    {    SET_SVAL_SUBTYPE(*dst,NUMBER_NUMBER);    dst->u.integer += arg2;    }    else    { -  push_svalue( dst ); +  *Pike_sp++ = *dst; +  SET_SVAL_TYPE(*dst,PIKE_T_INT);    push_int( arg2 );    f_add(2); -  assign_svalue( Pike_fp->locals+arg1,Pike_sp-1); -  pop_stack(); +  *dst = *--Pike_sp;    }   });      OPCODE2(F_ADD_LOCAL_INT, "local += number local", 0,{    struct svalue *dst = Pike_fp->locals+arg1;    if( dst->type == PIKE_T_INT -  DO_IF_BIGNUM( -  &&(!INT_TYPE_ADD_OVERFLOW(dst->u.integer,arg2)))) +  && !INT_TYPE_ADD_OVERFLOW(dst->u.integer,arg2) )    {    SET_SVAL_SUBTYPE(*dst,NUMBER_NUMBER);    dst->u.integer += arg2;    push_int( dst->u.integer );    }    else    { -  push_svalue( dst ); +  *Pike_sp++ = *dst; +  SET_SVAL_TYPE(*dst,PIKE_T_INT);    push_int( arg2 );    f_add(2); -  assign_svalue( Pike_fp->locals+arg1,Pike_sp-1); +  *dst = *--Pike_sp;    }   });      OPCODE1(F_INC_LOCAL, "++local", I_UPDATE_SP, { -  if( (TYPEOF(Pike_fp->locals[arg1]) == PIKE_T_INT) -  DO_IF_BIGNUM( -  && (!INT_TYPE_ADD_OVERFLOW(Pike_fp->locals[arg1].u.integer, 1)) -  ) -  ) +  struct svalue *dst = Pike_fp->locals+arg1; +  if( (TYPEOF(*dst) == PIKE_T_INT) +  && !INT_TYPE_ADD_OVERFLOW(dst->u.integer, 1) )    { -  push_int(++(Pike_fp->locals[arg1].u.integer)); -  SET_SVAL_SUBTYPE(Pike_fp->locals[arg1], NUMBER_NUMBER); /* Could have UNDEFINED there before. */ +  push_int(++dst->u.integer); +  SET_SVAL_SUBTYPE(*dst, NUMBER_NUMBER); /* Could have UNDEFINED there before. */    } else { -  push_svalue(Pike_fp->locals+arg1); +  *Pike_sp++ = *dst; +  SET_SVAL_TYPE(*dst,PIKE_T_INT);    push_int(1);    f_add(2); -  assign_svalue(Pike_fp->locals+arg1,Pike_sp-1); +  assign_svalue(dst, Pike_sp-1);    }   });      OPCODE1(F_POST_INC_LOCAL, "local++", I_UPDATE_SP, { -  push_svalue( Pike_fp->locals + arg1); -  -  if( (TYPEOF(Pike_fp->locals[arg1]) == PIKE_T_INT) -  DO_IF_BIGNUM( -  && (!INT_TYPE_ADD_OVERFLOW(Pike_fp->locals[arg1].u.integer, 1)) -  ) -  ) +  struct svalue *dst = Pike_fp->locals+arg1; +  if( (TYPEOF(*dst) == PIKE_T_INT) +  && !INT_TYPE_ADD_OVERFLOW(dst->u.integer, 1) )    { -  Pike_fp->locals[arg1].u.integer++; -  SET_SVAL_SUBTYPE(Pike_fp->locals[arg1], NUMBER_NUMBER); /* Could have UNDEFINED there before. */ +  push_int( dst->u.integer++ ); +  SET_SVAL_SUBTYPE(*dst, NUMBER_NUMBER); /* Could have UNDEFINED there before. */    } else { -  push_svalue(Pike_fp->locals + arg1); +  push_svalue( dst ); +  push_svalue( dst );    push_int(1);    f_add(2); -  stack_pop_to(Pike_fp->locals + arg1); +  stack_pop_to(dst);    }   });      OPCODE1(F_INC_LOCAL_AND_POP, "++local and pop", 0, { -  if( (TYPEOF(Pike_fp->locals[arg1]) == PIKE_T_INT) -  DO_IF_BIGNUM( -  && (!INT_TYPE_ADD_OVERFLOW(Pike_fp->locals[arg1].u.integer, 1)) -  ) -  ) +  struct svalue *dst = Pike_fp->locals+arg1; +  if( (TYPEOF(*dst) == PIKE_T_INT) +  && !INT_TYPE_ADD_OVERFLOW(dst->u.integer, 1) )    { -  Pike_fp->locals[arg1].u.integer++; -  SET_SVAL_SUBTYPE(Pike_fp->locals[arg1], NUMBER_NUMBER); /* Could have UNDEFINED there before. */ +  dst->u.integer++; +  SET_SVAL_SUBTYPE(*dst, NUMBER_NUMBER); /* Could have UNDEFINED there before. */    } else { -  push_svalue( Pike_fp->locals + arg1); +  *Pike_sp++ = *dst; +  SET_SVAL_TYPE(*dst,PIKE_T_INT);    push_int(1);    f_add(2); -  stack_pop_to(Pike_fp->locals + arg1); +  *dst = *--Pike_sp;    }   });      OPCODE1(F_DEC_LOCAL, "--local", I_UPDATE_SP, { -  if( (TYPEOF(Pike_fp->locals[arg1]) == PIKE_T_INT) -  DO_IF_BIGNUM( -  && (!INT_TYPE_SUB_OVERFLOW(Pike_fp->locals[arg1].u.integer, 1)) -  ) -  ) +  struct svalue *dst = Pike_fp->locals+arg1; +  if( (TYPEOF(*dst) == PIKE_T_INT) +  && !INT_TYPE_SUB_OVERFLOW(dst->u.integer, 1) )    { -  push_int(--(Pike_fp->locals[arg1].u.integer)); -  SET_SVAL_SUBTYPE(Pike_fp->locals[arg1], NUMBER_NUMBER); /* Could have UNDEFINED there before. */ +  push_int(--(dst->u.integer)); +  SET_SVAL_SUBTYPE(*dst, NUMBER_NUMBER); /* Could have UNDEFINED there before. */    } else { -  push_svalue(Pike_fp->locals+arg1); +  *Pike_sp++ = *dst; +  SET_SVAL_TYPE(*dst,PIKE_T_INT);    push_int(1);    o_subtract(); -  assign_svalue(Pike_fp->locals+arg1,Pike_sp-1); +  assign_svalue(dst,Pike_sp-1);    }   });      OPCODE1(F_POST_DEC_LOCAL, "local--", I_UPDATE_SP, {    push_svalue( Pike_fp->locals + arg1);       if( (TYPEOF(Pike_fp->locals[arg1]) == PIKE_T_INT) -  DO_IF_BIGNUM( -  && (!INT_TYPE_SUB_OVERFLOW(Pike_fp->locals[arg1].u.integer, 1)) -  ) -  ) +  && !INT_TYPE_SUB_OVERFLOW(Pike_fp->locals[arg1].u.integer, 1) )    {    Pike_fp->locals[arg1].u.integer--;    SET_SVAL_SUBTYPE(Pike_fp->locals[arg1], NUMBER_NUMBER); /* Could have UNDEFINED there before. */    } else {    push_svalue(Pike_fp->locals + arg1);    push_int(1);    o_subtract();    stack_pop_to(Pike_fp->locals + arg1);    }   });      OPCODE1(F_DEC_LOCAL_AND_POP, "--local and pop", 0, { -  if( (TYPEOF(Pike_fp->locals[arg1]) == PIKE_T_INT) -  DO_IF_BIGNUM( -  && (!INT_TYPE_SUB_OVERFLOW(Pike_fp->locals[arg1].u.integer, 1)) -  ) -  ) +  struct svalue *dst = Pike_fp->locals+arg1; +  if( (TYPEOF(*dst) == PIKE_T_INT) +  && !INT_TYPE_SUB_OVERFLOW(dst->u.integer, 1) )    { -  Pike_fp->locals[arg1].u.integer--; -  SET_SVAL_SUBTYPE(Pike_fp->locals[arg1], NUMBER_NUMBER); /* Could have UNDEFINED there before. */ +  --dst->u.integer; +  SET_SVAL_SUBTYPE(*dst, NUMBER_NUMBER); /* Could have UNDEFINED there before. */    } else { -  push_svalue(Pike_fp->locals + arg1); +  *Pike_sp++ = *dst; +  SET_SVAL_TYPE(*dst,PIKE_T_INT);    push_int(1);    o_subtract(); -  stack_pop_to(Pike_fp->locals + arg1); +  *dst = *--Pike_sp;    }   });      /* lval[0], lval[1], *Pike_sp    * ->    * lval[0], lval[1], result, *Pike_sp    */   OPCODE0(F_LTOSVAL, "lvalue to svalue", I_UPDATE_SP, {    dmalloc_touch_svalue(Pike_sp-2);    dmalloc_touch_svalue(Pike_sp-1);
pike.git/src/interpret_functions.h:786:   OPCODE0(F_ADD_TO, "+=", I_UPDATE_SP, {    ONERROR uwp;    move_svalue (Pike_sp, Pike_sp - 1);    mark_free_svalue (Pike_sp - 1);    Pike_sp++;    lvalue_to_svalue_no_free(Pike_sp-2,Pike_sp-4);       if( TYPEOF(Pike_sp[-1]) == PIKE_T_INT &&    TYPEOF(Pike_sp[-2]) == PIKE_T_INT )    { -  DO_IF_BIGNUM( +     if(!INT_TYPE_ADD_OVERFLOW(Pike_sp[-1].u.integer, Pike_sp[-2].u.integer)) -  ) +     {    /* Optimization for a rather common case. Makes it 30% faster. */    INT_TYPE val = (Pike_sp[-1].u.integer += Pike_sp[-2].u.integer);    SET_SVAL_SUBTYPE(Pike_sp[-1], NUMBER_NUMBER); /* Could have UNDEFINED there before. */    assign_lvalue(Pike_sp-4,Pike_sp-1);    Pike_sp-=2;    pop_2_elems();    push_int(val);    goto add_to_done;    }
pike.git/src/interpret_functions.h:853:   OPCODE0(F_ADD_TO_AND_POP, "+= and pop", I_UPDATE_SP, {    ONERROR uwp;    move_svalue (Pike_sp, Pike_sp - 1);    mark_free_svalue (Pike_sp - 1);    Pike_sp++;    lvalue_to_svalue_no_free(Pike_sp-2,Pike_sp-4);       if( TYPEOF(Pike_sp[-1]) == PIKE_T_INT &&    TYPEOF(Pike_sp[-2]) == PIKE_T_INT )    { -  DO_IF_BIGNUM( +     if(!INT_TYPE_ADD_OVERFLOW(Pike_sp[-1].u.integer, Pike_sp[-2].u.integer)) -  ) +     {    /* Optimization for a rather common case. Makes it 30% faster. */    Pike_sp[-1].u.integer += Pike_sp[-2].u.integer;    SET_SVAL_SUBTYPE(Pike_sp[-1], NUMBER_NUMBER); /* Could have UNDEFINED there before. */    assign_lvalue(Pike_sp-4,Pike_sp-1);    Pike_sp-=2;    pop_2_elems();    goto add_to_and_pop_done;    }    }
pike.git/src/interpret_functions.h:915:    ; /* make gcc happy */   });      OPCODE1(F_GLOBAL_LVALUE, "& global", I_UPDATE_SP, {    ref_push_object(Pike_fp->current_object);    push_obj_index(arg1 + Pike_fp->context->identifier_level);   });      OPCODE0(F_INC, "++x", I_UPDATE_SP, {    union anything *u=get_pointer_if_this_type(Pike_sp-2, PIKE_T_INT); -  if(u -  DO_IF_BIGNUM( -  && !INT_TYPE_ADD_OVERFLOW(u->integer, 1) -  ) -  ) +  if(u && !INT_TYPE_ADD_OVERFLOW(u->integer, 1))    {    INT_TYPE val = ++u->integer;    pop_2_elems();    push_int(val);    } else {    lvalue_to_svalue_no_free(Pike_sp, Pike_sp-2); Pike_sp++;    push_int(1);    f_add(2);    assign_lvalue(Pike_sp-3, Pike_sp-1);    stack_pop_2_elems_keep_top();    }   });      OPCODE0(F_DEC, "--x", I_UPDATE_SP, {    union anything *u=get_pointer_if_this_type(Pike_sp-2, PIKE_T_INT); -  if(u -  DO_IF_BIGNUM( -  && !INT_TYPE_SUB_OVERFLOW(u->integer, 1) -  ) -  ) +  if(u && !INT_TYPE_SUB_OVERFLOW(u->integer, 1))    {    INT_TYPE val = --u->integer;    pop_2_elems();    push_int(val);    } else {    lvalue_to_svalue_no_free(Pike_sp, Pike_sp-2); Pike_sp++;    push_int(1);    o_subtract();    assign_lvalue(Pike_sp-3, Pike_sp-1);    stack_pop_2_elems_keep_top();    }   });      OPCODE0(F_DEC_AND_POP, "x-- and pop", I_UPDATE_SP, {    union anything *u=get_pointer_if_this_type(Pike_sp-2, PIKE_T_INT); -  if(u -  DO_IF_BIGNUM( -  && !INT_TYPE_SUB_OVERFLOW(u->integer, 1) -  ) - ) +  if(u && !INT_TYPE_SUB_OVERFLOW(u->integer, 1))    {    --u->integer;    pop_2_elems();    }else{    lvalue_to_svalue_no_free(Pike_sp, Pike_sp-2); Pike_sp++;    push_int(1);    o_subtract();    assign_lvalue(Pike_sp-3, Pike_sp-1);    pop_n_elems(3);    }   });      OPCODE0(F_INC_AND_POP, "x++ and pop", I_UPDATE_SP, {    union anything *u=get_pointer_if_this_type(Pike_sp-2, PIKE_T_INT); -  if(u -  DO_IF_BIGNUM( -  && !INT_TYPE_ADD_OVERFLOW(u->integer, 1) -  ) -  ) +  if(u && !INT_TYPE_ADD_OVERFLOW(u->integer, 1))    {    ++u->integer;    pop_2_elems();    } else {    lvalue_to_svalue_no_free(Pike_sp, Pike_sp-2); Pike_sp++;    push_int(1);    f_add(2);    assign_lvalue(Pike_sp-3, Pike_sp-1);    pop_n_elems(3);    }   });      OPCODE0(F_POST_INC, "x++", I_UPDATE_SP, {    union anything *u=get_pointer_if_this_type(Pike_sp-2, PIKE_T_INT); -  if(u -  DO_IF_BIGNUM( -  && !INT_TYPE_ADD_OVERFLOW(u->integer, 1) -  ) -  ) +  if(u && !INT_TYPE_ADD_OVERFLOW(u->integer, 1))    {    INT_TYPE val = u->integer++;    pop_2_elems();    push_int(val);    } else {    lvalue_to_svalue_no_free(Pike_sp, Pike_sp-2); Pike_sp++;    stack_dup();    push_int(1);    f_add(2);    assign_lvalue(Pike_sp-4, Pike_sp-1);    pop_stack();    stack_pop_2_elems_keep_top();    print_return_value();    }   });      OPCODE0(F_POST_DEC, "x--", I_UPDATE_SP, {    union anything *u=get_pointer_if_this_type(Pike_sp-2, PIKE_T_INT); -  if(u -  DO_IF_BIGNUM( -  && !INT_TYPE_SUB_OVERFLOW(u->integer, 1) -  ) -  ) +  if(u && !INT_TYPE_SUB_OVERFLOW(u->integer, 1))    {    INT_TYPE val = u->integer--;    pop_2_elems();    push_int(val);    } else {    lvalue_to_svalue_no_free(Pike_sp, Pike_sp-2); Pike_sp++;    stack_dup();    push_int(1);    o_subtract();    assign_lvalue(Pike_sp-4, Pike_sp-1);
pike.git/src/interpret_functions.h:1539:    constants[arg2].sval.u.array,Pike_fp->locals + arg1);    addr = DO_IF_ELSE_COMPUTED_GOTO(addr, (PIKE_OPCODE_T *)    DO_ALIGN(PTR_TO_INT(addr),    ((ptrdiff_t)sizeof(INT32))));    addr = (PIKE_OPCODE_T *)(((INT32 *)addr) + (tmp>=0 ? 1+tmp*2 : 2*~tmp));    if(*(INT32*)addr < 0) FAST_CHECK_THREADS_ON_BRANCH();    DO_JUMP_TO(addr + *(INT32*)addr);   });       - #ifdef AUTO_BIGNUM - #define AUTO_BIGNUM_LOOP_TEST(X,Y) INT_TYPE_ADD_OVERFLOW(X,Y) - #else - #define AUTO_BIGNUM_LOOP_TEST(X,Y) 0 - #endif -  -  /* FIXME: Does this need bignum tests? /Fixed - Hubbe */ +     /* LOOP(OPCODE, INCREMENT, OPERATOR, IS_OPERATOR) */   #define LOOP(ID, DESC, INC, OP2, OP4) \    OPCODE0_BRANCH(ID, DESC, 0, { \    union anything *i=get_pointer_if_this_type(Pike_sp-2, T_INT); \ -  if(i && !AUTO_BIGNUM_LOOP_TEST(i->integer,INC) && \ +  if(i && !INT_TYPE_ADD_OVERFLOW(i->integer,INC) && \    TYPEOF(Pike_sp[-3]) == T_INT) \    { \    i->integer += INC; \    if(i->integer OP2 Pike_sp[-3].u.integer) \    { \    DO_BRANCH(); \    }else{ \    /* write_to_stderr("loop\n", 8); */ \    DONT_BRANCH(); \    } \
pike.git/src/interpret_functions.h:1708:    DO_RETURN;   });      OPCODE0_RETURN(F_DUMB_RETURN,"dumb return", I_UPDATE_FP, {    DO_DUMB_RETURN;   });      OPCODE0(F_NEGATE, "unary minus", 0, {    if(TYPEOF(Pike_sp[-1]) == PIKE_T_INT)    { -  DO_IF_BIGNUM( +     if(INT_TYPE_NEG_OVERFLOW(Pike_sp[-1].u.integer))    {    convert_stack_top_to_bignum();    o_negate();    }    else -  ) +     {    Pike_sp[-1].u.integer =- Pike_sp[-1].u.integer;    SET_SVAL_SUBTYPE(Pike_sp[-1], NUMBER_NUMBER); /* Could have UNDEFINED there before. */    }    }    else if(TYPEOF(Pike_sp[-1]) == PIKE_T_FLOAT)    {    Pike_sp[-1].u.float_number =- Pike_sp[-1].u.float_number;    }else{    o_negate();
pike.git/src/interpret_functions.h:1783:   COMPARISON(F_LE, "<=", is_le(Pike_sp-2,Pike_sp-1));      /* Used with F_LTOSVAL*_AND_FREE - must not release interpreter lock. */   OPCODE0(F_ADD, "+", I_UPDATE_SP, {    f_add(2);   });      /* Used with F_LTOSVAL*_AND_FREE - must not release interpreter lock. */   OPCODE0(F_ADD_INTS, "int+int", I_UPDATE_SP, {    if(TYPEOF(Pike_sp[-1]) == T_INT && TYPEOF(Pike_sp[-2]) == T_INT -  DO_IF_BIGNUM( -  && (!INT_TYPE_ADD_OVERFLOW(Pike_sp[-1].u.integer, Pike_sp[-2].u.integer)) -  ) -  ) +  && !INT_TYPE_ADD_OVERFLOW(Pike_sp[-1].u.integer, Pike_sp[-2].u.integer))    {    Pike_sp[-2].u.integer+=Pike_sp[-1].u.integer;    SET_SVAL_SUBTYPE(Pike_sp[-2], NUMBER_NUMBER); /* Could have UNDEFINED there before. */    dmalloc_touch_svalue(Pike_sp-1);    Pike_sp--;    }else{    f_add(2);    }   });   
pike.git/src/interpret_functions.h:1820:   OPCODE0_ALIAS(F_SUBTRACT, "-", I_UPDATE_SP, o_subtract);   OPCODE0_ALIAS(F_AND, "&", I_UPDATE_SP, o_and);   OPCODE0_ALIAS(F_OR, "|", I_UPDATE_SP, o_or);   OPCODE0_ALIAS(F_XOR, "^", I_UPDATE_SP, o_xor);   OPCODE0_ALIAS(F_MULTIPLY, "*", I_UPDATE_SP, o_multiply);   OPCODE0_ALIAS(F_DIVIDE, "/", I_UPDATE_SP, o_divide);   OPCODE0_ALIAS(F_MOD, "%", I_UPDATE_SP, o_mod);      OPCODE1(F_ADD_INT, "add integer", 0, {    if(TYPEOF(Pike_sp[-1]) == T_INT -  DO_IF_BIGNUM( -  && (!INT_TYPE_ADD_OVERFLOW(Pike_sp[-1].u.integer, arg1)) -  ) -  ) +  && !INT_TYPE_ADD_OVERFLOW(Pike_sp[-1].u.integer, arg1))    {    Pike_sp[-1].u.integer+=arg1;    SET_SVAL_SUBTYPE(Pike_sp[-1], NUMBER_NUMBER); /* Could have UNDEFINED there before. */    }else{    push_int(arg1);    f_add(2);    }   });      OPCODE1(F_ADD_NEG_INT, "add -integer", 0, {    if(TYPEOF(Pike_sp[-1]) == T_INT -  DO_IF_BIGNUM( -  && (!INT_TYPE_ADD_OVERFLOW(Pike_sp[-1].u.integer, -arg1)) -  ) -  ) +  && !INT_TYPE_ADD_OVERFLOW(Pike_sp[-1].u.integer, -arg1))    {    Pike_sp[-1].u.integer-=arg1;    SET_SVAL_SUBTYPE(Pike_sp[-1], NUMBER_NUMBER); /* Could have UNDEFINED there before. */    }else{    push_int(-arg1);    f_add(2);    }   });      OPCODE0(F_PUSH_ARRAY, "@", I_UPDATE_SP, {
pike.git/src/interpret_functions.h:2141:    PIKE_OPCODE_T *addr = Pike_fp->pc; \    DO_IF_DEBUG(Pike_fp->next->pc=0); \    unlink_previous_frame(); \    DO_JUMP_TO(addr); \    }else{ \    DO_DUMB_RETURN; \    } \   })       - MKAPPLY2(OPCODE1,CALL_LFUN,"call lfun",APPLY_LOW, + OPCODE1_JUMP(F_CALL_LFUN , "call lfun", I_UPDATE_ALL, { +  JUMP_SET_TO_PC_AT_NEXT (Pike_fp->return_addr); +  if(lower_mega_apply(DO_NOT_WARN((INT32)(Pike_sp - *--Pike_mark_sp)),    Pike_fp->current_object, -  (void *)(ptrdiff_t)(arg1+Pike_fp->context->identifier_level)); +  (arg1+Pike_fp->context->identifier_level) )) +  { +  Pike_fp->flags |= PIKE_FRAME_RETURN_INTERNAL; +  DO_JUMP_TO(Pike_fp->pc); +  } +  else +  { +  DO_JUMP_TO_NEXT; +  } +  });    -  + OPCODE1_JUMP(F_CALL_LFUN_AND_POP, "call lfun & pop", I_UPDATE_ALL, { +  JUMP_SET_TO_PC_AT_NEXT (Pike_fp->return_addr); +  +  if(lower_mega_apply(DO_NOT_WARN((INT32)(Pike_sp - *--Pike_mark_sp)), +  Pike_fp->current_object, +  (arg1+Pike_fp->context->identifier_level))) +  { +  Pike_fp->flags |= PIKE_FRAME_RETURN_INTERNAL | PIKE_FRAME_RETURN_POP; +  DO_JUMP_TO(Pike_fp->pc); +  } +  else +  { +  pop_stack(); +  DO_JUMP_TO_NEXT; +  } +  }); +  + OPCODE1_RETURN(F_CALL_LFUN_AND_RETURN , "call lfun & return", I_UPDATE_ALL, { +  if(lower_mega_apply(DO_NOT_WARN((INT32)(Pike_sp - *--Pike_mark_sp)), +  Pike_fp->current_object, +  (arg1+Pike_fp->context->identifier_level))) +  { +  PIKE_OPCODE_T *addr = Pike_fp->pc; +  DO_IF_DEBUG(Pike_fp->next->pc=0); +  unlink_previous_frame(); +  DO_JUMP_TO(addr); +  }else{ +  DO_DUMB_RETURN; +  } +  }); +  + OPCODE1_JUMP(F_MARK_CALL_LFUN, "mark, call lfun" , I_UPDATE_ALL, { +  JUMP_SET_TO_PC_AT_NEXT (Pike_fp->return_addr); +  if(lower_mega_apply(0, Pike_fp->current_object, +  (arg1+Pike_fp->context->identifier_level))) { +  Pike_fp->flags |= PIKE_FRAME_RETURN_INTERNAL; +  DO_JUMP_TO(Pike_fp->pc); +  } else { +  DO_JUMP_TO_NEXT; +  } +  }); +  + OPCODE1_JUMP( F_MARK_CALL_LFUN_AND_POP , "mark, call lfun & pop", I_UPDATE_ALL, { +  JUMP_SET_TO_PC_AT_NEXT (Pike_fp->return_addr); +  if(lower_mega_apply(0, Pike_fp->current_object, +  (arg1+Pike_fp->context->identifier_level) )) +  { +  Pike_fp->flags |= PIKE_FRAME_RETURN_INTERNAL | PIKE_FRAME_RETURN_POP; +  DO_JUMP_TO(Pike_fp->pc); +  } +  else +  { +  pop_stack(); +  DO_JUMP_TO_NEXT; +  } +  }); +  + OPCODE1_RETURN(F_MARK_CALL_LFUN_AND_RETURN , "mark, call lfun & return", I_UPDATE_ALL, { +  if(lower_mega_apply(0, Pike_fp->current_object, +  (arg1+Pike_fp->context->identifier_level))) +  { +  PIKE_OPCODE_T *addr = Pike_fp->pc; +  DO_IF_DEBUG(Pike_fp->next->pc=0); +  unlink_previous_frame(); +  DO_JUMP_TO(addr); +  } +  else +  { +  DO_DUMB_RETURN; +  } +  }); +    MKAPPLY2(OPCODE1,APPLY,"apply",APPLY_SVALUE_STRICT,    &((Pike_fp->context->prog->constants + arg1)->sval),0);      MKAPPLY(OPCODE0,CALL_FUNCTION,"call function",APPLY_STACK, 0,0);      OPCODE1_JUMP(F_CALL_OTHER,"call other", I_UPDATE_ALL, {    INT32 args=DO_NOT_WARN((INT32)(Pike_sp - *--Pike_mark_sp));    LOCAL_VAR(struct svalue *s);    s = Pike_sp-args;    JUMP_SET_TO_PC_AT_NEXT (Pike_fp->return_addr);
pike.git/src/interpret_functions.h:2171:    {    p = p->inherits[SUBTYPEOF(*s)].prog;    if(FIND_LFUN(p, LFUN_ARROW) == -1)    {    int fun;    fun=find_shared_string_identifier(Pike_fp->context->prog->strings[arg1],    p);    if(fun >= 0)    {    fun += o->prog->inherits[SUBTYPEOF(*s)].identifier_level; -  if(low_mega_apply(APPLY_LOW, args-1, o, (void *)(ptrdiff_t)fun)) +  if(lower_mega_apply(args-1, o, fun))    {    Pike_fp->save_sp--;    Pike_fp->flags |= PIKE_FRAME_RETURN_INTERNAL;    DO_JUMP_TO(Pike_fp->pc);    }    stack_pop_keep_top();    DO_JUMP_TO_NEXT;    }    }    }
pike.git/src/interpret_functions.h:2228:    {    p = p->inherits[SUBTYPEOF(*s)].prog;    if(FIND_LFUN(p, LFUN_ARROW) == -1)    {    int fun;    fun=find_shared_string_identifier(Pike_fp->context->prog->strings[arg1],    p);    if(fun >= 0)    {    fun += o->prog->inherits[SUBTYPEOF(*s)].identifier_level; -  if(low_mega_apply(APPLY_LOW, args-1, o, (void *)(ptrdiff_t)fun)) +  if(lower_mega_apply(args-1, o, fun))    {    Pike_fp->save_sp--;    Pike_fp->flags |=    PIKE_FRAME_RETURN_INTERNAL |    PIKE_FRAME_RETURN_POP;    DO_JUMP_TO(Pike_fp->pc);    }    pop_2_elems();    DO_JUMP_TO_NEXT;    }
pike.git/src/interpret_functions.h:2287:    {    p = p->inherits[SUBTYPEOF(*s)].prog;    if(FIND_LFUN(p, LFUN_ARROW) == -1)    {    int fun;    fun=find_shared_string_identifier(Pike_fp->context->prog->strings[arg1],    p);    if(fun >= 0)    {    fun += o->prog->inherits[SUBTYPEOF(*s)].identifier_level; -  if(low_mega_apply(APPLY_LOW, args-1, o, (void *)(ptrdiff_t)fun)) +  if(lower_mega_apply(args-1, o, fun))    {    PIKE_OPCODE_T *addr = Pike_fp->pc;    Pike_fp->save_sp--;    DO_IF_DEBUG(Pike_fp->next->pc=0);    unlink_previous_frame();    DO_JUMP_TO(addr);    }    stack_pop_keep_top();    DO_DUMB_RETURN;    }
pike.git/src/interpret_functions.h:2546:    INT32 args = DO_NOT_WARN((INT32)(Pike_sp - *--Pike_mark_sp)); \    \    DO_IF_SECURITY(CHECK_DATA_SECURITY_OR_ERROR(Pike_fp->current_object, \    SECURITY_BIT_CALL, \    ("Function call permission denied.\n"))); \    \    FAST_CHECK_THREADS_ON_CALL(); \    check_stack(256); \    \    new_frame=alloc_pike_frame(); \ -  \ -  new_frame->refs=1; /* FIXME: Is this needed? */ \ +     new_frame->next=Pike_fp; \    \ -  JUMP_SET_TO_PC_AT_NEXT (addr); \ -  Pike_fp->return_addr = (PIKE_OPCODE_T *)(((INT32 *) addr) + 1); \ -  addr += GET_JUMP(); \ +  JUMP_SET_TO_PC_AT_NEXT (addr); \ +  Pike_fp->return_addr = (PIKE_OPCODE_T *)(((INT32 *) addr) + 1); \ +  addr += GET_JUMP(); \    \    addr += ENTRY_PROLOGUE_SIZE; \    \ -  if (Pike_interpreter.trace_level > 3) { \ -  fprintf(stderr, "- Addr = 0x%+lx\n", addr); \ -  } \ -  \ -  new_frame->args = args; \ +  new_frame->args = args; \    new_frame->locals=new_frame->save_sp=new_frame->expendible=Pike_sp-args; \    new_frame->save_mark_sp = new_frame->mark_sp_base = Pike_mark_sp; \    DO_IF_DEBUG(new_frame->num_args=0;new_frame->num_locals=0;); \    SET_PROG_COUNTER(addr); \    new_frame->fun=Pike_fp->fun; \    DO_IF_PROFILING( new_frame->ident=Pike_fp->ident ); \    new_frame->current_storage=Pike_fp->current_storage; \    if(Pike_fp->scope) add_ref(new_frame->scope=Pike_fp->scope); \    add_ref(new_frame->current_object = Pike_fp->current_object); \    add_ref(new_frame->current_program = Pike_fp->current_program); \
pike.git/src/interpret_functions.h:2597:    }); \    }); \    \    Pike_fp=new_frame; \    new_frame->flags=PIKE_FRAME_RETURN_INTERNAL | XFLAGS; \    \    DO_IF_SECURITY(if(!CHECK_DATA_SECURITY(Pike_fp->current_object, \    SECURITY_BIT_NOT_SETUID)) \    SET_CURRENT_CREDS(Pike_fp->current_object->prot)); \    \ +  \ +  if (UNLIKELY(Pike_interpreter.trace_level > 3)) { \ +  fprintf(stderr, "- Addr = 0x%lx\n", (unsigned long) addr); \ +  } \ +  \    FETCH; \    JUMP_DONE; \   }while(0)      /* Assume that the number of arguments is correct */   OPCODE1_PTRJUMP(F_COND_RECUR, "recur if not overloaded", I_UPDATE_ALL, {    PIKE_OPCODE_T *addr;    LOCAL_VAR(struct program *p);    p = Pike_fp->current_program;    JUMP_SET_TO_PC_AT_NEXT (addr);
pike.git/src/interpret_functions.h:2636:    (ID_FROM_INT(p, arg1+Pike_fp->context->identifier_level)->    identifier_flags & IDENTIFIER_SCOPE_USED))    {    PIKE_OPCODE_T *faddr;    ptrdiff_t num_locals;    INT32 args = DO_NOT_WARN((INT32)(Pike_sp - *--Pike_mark_sp));       JUMP_SET_TO_PC_AT_NEXT (faddr);    faddr += GET_JUMP();    -  if(low_mega_apply(APPLY_LOW, -  args, +  if(lower_mega_apply(args,    Pike_fp->current_object, -  (void *)(ptrdiff_t)(arg1+ -  Pike_fp->context->identifier_level))) +  (arg1+Pike_fp->context->identifier_level)))    {    Pike_fp->flags |= PIKE_FRAME_RETURN_INTERNAL;    addr = Pike_fp->pc;    }    DO_JUMP_TO(addr);    }       /* FALL THROUGH */       /* Assume that the number of arguments is correct */
pike.git/src/interpret_functions.h:2666:      /* Ugly code duplication */   OPCODE0_PTRJUMP(F_RECUR_AND_POP, "recur & pop", I_UPDATE_ALL, {    DO_RECUR(PIKE_FRAME_RETURN_POP);   });         /* Assume that the number of arguments is correct */   /* FIXME: adjust Pike_mark_sp */   OPCODE0_PTRJUMP(F_TAIL_RECUR, "tail recursion", I_UPDATE_ALL, { -  INT32 num_locals; +     PIKE_OPCODE_T *addr;    INT32 args = DO_NOT_WARN((INT32)(Pike_sp - *--Pike_mark_sp));       FAST_CHECK_THREADS_ON_CALL();       JUMP_SET_TO_PC_AT_NEXT (addr);    addr += GET_JUMP();    addr += ENTRY_PROLOGUE_SIZE;    SET_PROG_COUNTER(addr);   
pike.git/src/interpret_functions.h:2750:      OPCODE0(F_DUP,"dup",I_UPDATE_SP,{    stack_dup();   });      OPCODE2(F_THIS, "this", I_UPDATE_SP, {    LOCAL_VAR(struct external_variable_context loc);       loc.o = Pike_fp->current_object;    loc.parent_identifier = Pike_fp->fun; -  if (loc.o->prog) -  loc.inherit = INHERIT_FROM_INT(loc.o->prog, loc.parent_identifier); +  loc.inherit = Pike_fp->context;    find_external_context(&loc, arg1);       DO_IF_DEBUG({    TRACE((5,"- Identifier=%d Offset=%d\n",    arg1,    loc.inherit->identifier_level));    });    if ((arg2 < 0) || !loc.o->prog) {    ref_push_object(loc.o);    } else {