pike.git / src / interpret_functions.h

version» Context lines:

pike.git/src/interpret_functions.h:1:   /*   || This file is part of Pike. For copyright information see COPYRIGHT.   || Pike is distributed under GPL, LGPL and MPL. See the file COPYING   || for more information. - || $Id: interpret_functions.h,v 1.153 2003/08/03 02:34:46 mast Exp $ + || $Id: interpret_functions.h,v 1.154 2003/08/06 18:05:26 mast Exp $   */      /*    * Opcode definitions for the interpreter.    */      #include "global.h"      #undef CJUMP   #undef AUTO_BIGNUM_LOOP_TEST
pike.git/src/interpret_functions.h:39:   #define OPCODE2(A, B, F, C) OPCODE2(A, B, F) --- C   #define OPCODE0_TAIL(A, B, F, C) OPCODE0_TAIL(A, B, F) --- C   #define OPCODE1_TAIL(A, B, F, C) OPCODE1_TAIL(A, B, F) --- C   #define OPCODE2_TAIL(A, B, F, C) OPCODE2_TAIL(A, B, F) --- C   #define OPCODE0_JUMP(A, B, F, C) OPCODE0_JUMP(A, B, F) --- C   #define OPCODE1_JUMP(A, B, F, C) OPCODE1_JUMP(A, B, F) --- C   #define OPCODE2_JUMP(A, B, F, C) OPCODE2_JUMP(A, B, F) --- C   #define OPCODE0_TAILJUMP(A, B, F, C) OPCODE0_TAILJUMP(A, B, F) --- C   #define OPCODE1_TAILJUMP(A, B, F, C) OPCODE1_TAILJUMP(A, B, F) --- C   #define OPCODE2_TAILJUMP(A, B, F, C) OPCODE2_TAILJUMP(A, B, F) --- C + #define OPCODE0_PTRJUMP(A, B, F, C) OPCODE0_PTRJUMP(A, B, F) --- C + #define OPCODE1_PTRJUMP(A, B, F, C) OPCODE1_PTRJUMP(A, B, F) --- C + #define OPCODE2_PTRJUMP(A, B, F, C) OPCODE2_PTRJUMP(A, B, F) --- C + #define OPCODE0_TAILPTRJUMP(A, B, F, C) OPCODE0_TAILPTRJUMP(A, B, F) --- C + #define OPCODE1_TAILPTRJUMP(A, B, F, C) OPCODE1_TAILPTRJUMP(A, B, F) --- C + #define OPCODE2_TAILPTRJUMP(A, B, F, C) OPCODE2_TAILPTRJUMP(A, B, F) --- C   #define OPCODE0_RETURN(A, B, F, C) OPCODE0_RETURN(A, B, F) --- C   #define OPCODE1_RETURN(A, B, F, C) OPCODE1_RETURN(A, B, F) --- C   #define OPCODE2_RETURN(A, B, F, C) OPCODE2_RETURN(A, B, F) --- C   #define OPCODE0_TAILRETURN(A, B, F, C) OPCODE0_TAILRETURN(A, B, F) --- C   #define OPCODE1_TAILRETURN(A, B, F, C) OPCODE1_TAILRETURN(A, B, F) --- C   #define OPCODE2_TAILRETURN(A, B, F, C) OPCODE2_TAILRETURN(A, B, F) --- C   #define OPCODE0_BRANCH(A, B, F, C) OPCODE0_BRANCH(A, B, F) --- C   #define OPCODE1_BRANCH(A, B, F, C) OPCODE1_BRANCH(A, B, F) --- C   #define OPCODE2_BRANCH(A, B, F, C) OPCODE2_BRANCH(A, B, F) --- C   #define OPCODE0_TAILBRANCH(A, B, F, C) OPCODE0_TAILBRANCH(A, B, F) --- C
pike.git/src/interpret_functions.h:116:   #define SKIPJUMP() (GET_JUMP(), LOW_SKIPJUMP())      #else /* !PIKE_DEBUG */      #define GET_JUMP() LOW_GET_JUMP()   #define SKIPJUMP() LOW_SKIPJUMP()      #endif /* PIKE_DEBUG */      #define DOJUMP() do { \ +  PIKE_OPCODE_T *addr; \    INT32 tmp; \ -  +  JUMP_SET_TO_PC_AT_NEXT (addr); \    tmp = GET_JUMP(); \ -  SET_PROG_COUNTER(PROG_COUNTER + tmp); \ +  SET_PROG_COUNTER(addr + tmp); \    FETCH; \    if(tmp < 0) \    fast_check_threads_etc(6); \    } while(0)      #endif /* OVERRIDE_JUMPS */         /* WARNING:    * The surgeon general has stated that define code blocks    * without do{}while() can be hazardous to your health.    * However, in these cases it is required to handle break    * properly. -Hubbe    */   #undef DO_JUMP_TO   #define DO_JUMP_TO(NEWPC) { \    SET_PROG_COUNTER(NEWPC); \    FETCH; \ -  DONE; \ +  JUMP_DONE; \   }      #undef DO_DUMB_RETURN   #define DO_DUMB_RETURN { \    if(Pike_fp -> flags & PIKE_FRAME_RETURN_INTERNAL) \    { \    int f=Pike_fp->flags; \    if(f & PIKE_FRAME_RETURN_POP) \    low_return_pop(); \    else \
pike.git/src/interpret_functions.h:171:   #ifndef PIKE_DEBUG   #define DO_RETURN DO_DUMB_RETURN   #else   #define DO_RETURN { \    if(d_flag>3) do_gc(NULL, 0); \    if(d_flag>4) do_debug(); \    DO_DUMB_RETURN; \   }   #endif    + #ifdef OPCODE_RETURN_JUMPADDR + #define DO_JUMP_TO_NEXT do { \ +  PIKE_OPCODE_T *next_addr; \ +  JUMP_SET_TO_PC_AT_NEXT (next_addr); \ +  SET_PROG_COUNTER (next_addr); \ +  FETCH; \ +  JUMP_DONE; \ +  } while (0) + #else /* !OPCODE_RETURN_JUMPADDR */ + #define JUMP_SET_TO_PC_AT_NEXT(PC) ((PC) = PROG_COUNTER) + #define DO_JUMP_TO_NEXT JUMP_DONE + #endif /* !OPCODE_RETURN_JUMPADDR */ +    #undef DO_INDEX   #define DO_INDEX do { \    struct svalue s; \    index_no_free(&s,Pike_sp-2,Pike_sp-1); \    pop_2_elems(); \    *Pike_sp=s; \    Pike_sp++; \    dmalloc_touch_svalue(Pike_sp-1); \    print_return_value(); \   }while(0)
pike.git/src/interpret_functions.h:304:    tmp2.type = PIKE_T_STRING;    tmp2.u.string = lfun_strings[arg1];    tmp2.subtype = 1;    index_no_free(&tmp, Pike_sp-1, &tmp2);    }    free_svalue(Pike_sp-1);    Pike_sp[-1] = tmp;    print_return_value();   });    - OPCODE0(F_FLOAT, "push float", 0, { + OPCODE0_JUMP(F_FLOAT, "push float", 0, {    /* FIXME, this opcode uses 'PROG_COUNTER' which is not allowed.. */ -  MEMCPY((void *)&Pike_sp->u.float_number, PROG_COUNTER, sizeof(FLOAT_TYPE)); +  PIKE_OPCODE_T *next_addr; +  JUMP_SET_TO_PC_AT_NEXT (next_addr); +  MEMCPY((void *)&Pike_sp->u.float_number, next_addr, sizeof(FLOAT_TYPE));    Pike_sp->type=PIKE_T_FLOAT;    Pike_sp++; -  DO_JUMP_TO((PIKE_OPCODE_T *)(((FLOAT_TYPE *)PROG_COUNTER) + 1)); +  DO_JUMP_TO((PIKE_OPCODE_T *)(((FLOAT_TYPE *) next_addr) + 1));   });      OPCODE1(F_LFUN, "local function", 0, {    ref_push_function (Pike_fp->current_object,    arg1+Pike_fp->context.identifier_level);    print_return_value();   });      OPCODE2(F_TRAMPOLINE, "trampoline", 0, {    struct object *o=low_clone(pike_trampoline_program);
pike.git/src/interpret_functions.h:1199:    }else{    DO_BRANCH();    pop_2_elems();    push_int(0);    }   });      /* This instruction can't currently be a branch, since    * it has more than two continuation paths.    */ - OPCODE0_JUMP(F_CATCH, "catch", 0, { + OPCODE0_PTRJUMP(F_CATCH, "catch", 0, { +  PIKE_OPCODE_T *next_addr; +  JUMP_SET_TO_PC_AT_NEXT (next_addr);    check_c_stack(8192); -  switch (o_catch((PIKE_OPCODE_T *)(((INT32 *)PROG_COUNTER)+1))) +  switch (o_catch((PIKE_OPCODE_T *)(((INT32 *)next_addr)+1)))    {    case 1:    /* There was a return inside the evaluated code */    DO_DUMB_RETURN;    case 2:    /* Escape catch, continue after the escape instruction. */    DO_JUMP_TO(Pike_fp->pc);    break;    default:    DOJUMP();    }    /* NOT_REACHED in byte-code and computed goto cases. */   });    - OPCODE0_RETURN(F_ESCAPE_CATCH, "escape catch", 0, { -  Pike_fp->pc = PROG_COUNTER; + OPCODE0_RETURN(F_ESCAPE_CATCH, "escape catch", I_PC_AT_NEXT, { +  JUMP_SET_TO_PC_AT_NEXT (Pike_fp->pc);    INTER_ESCAPE_CATCH;   });    - OPCODE0_RETURN(F_EXIT_CATCH, "exit catch", 0, { + OPCODE0_RETURN(F_EXIT_CATCH, "exit catch", I_PC_AT_NEXT, {    push_undefined(); -  Pike_fp->pc = PROG_COUNTER; +  JUMP_SET_TO_PC_AT_NEXT (Pike_fp->pc);    INTER_ESCAPE_CATCH;   });    - OPCODE1(F_SWITCH, "switch", 0, { + OPCODE1_JUMP(F_SWITCH, "switch", 0, {    INT32 tmp; -  PIKE_OPCODE_T *addr = PROG_COUNTER; +  PIKE_OPCODE_T *addr; +  JUMP_SET_TO_PC_AT_NEXT (addr);    tmp=switch_lookup(Pike_fp->context.prog->    constants[arg1].sval.u.array,Pike_sp-1);    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_etc(7);    pop_stack();    DO_JUMP_TO(addr + *(INT32*)addr);   });    - OPCODE1(F_SWITCH_ON_INDEX, "switch on index", 0, { + OPCODE1_JUMP(F_SWITCH_ON_INDEX, "switch on index", 0, {    INT32 tmp;    struct svalue s; -  PIKE_OPCODE_T *addr = PROG_COUNTER; +  PIKE_OPCODE_T *addr; +  JUMP_SET_TO_PC_AT_NEXT (addr);    index_no_free(&s,Pike_sp-2,Pike_sp-1);    Pike_sp++[0]=s;       tmp=switch_lookup(Pike_fp->context.prog->    constants[arg1].sval.u.array,Pike_sp-1);    pop_n_elems(3);    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_etc(7);    DO_JUMP_TO(addr + *(INT32*)addr);   });    - OPCODE2(F_SWITCH_ON_LOCAL, "switch on local", 0, { + OPCODE2_JUMP(F_SWITCH_ON_LOCAL, "switch on local", 0, {    INT32 tmp; -  PIKE_OPCODE_T *addr = PROG_COUNTER; +  PIKE_OPCODE_T *addr; +  JUMP_SET_TO_PC_AT_NEXT (addr);    tmp=switch_lookup(Pike_fp->context.prog->    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_etc(7);    DO_JUMP_TO(addr + *(INT32*)addr);   });   
pike.git/src/interpret_functions.h:1392:    }else{    push_svalue(Pike_fp->locals + arg1);    }    DO_DUMB_RETURN;   });         OPCODE0_RETURN(F_RETURN_IF_TRUE,"return if true",0,{    if(!UNSAFE_IS_ZERO(Pike_sp-1)) DO_RETURN;    pop_stack(); +  DO_JUMP_TO_NEXT;   });      OPCODE0_RETURN(F_RETURN_1,"return 1",0,{    push_int(1);    DO_RETURN;   });      OPCODE0_RETURN(F_RETURN_0,"return 0",0,{    push_int(0);    DO_RETURN;
pike.git/src/interpret_functions.h:1777:    push_int(val);   });      OPCODE1(F_SIZEOF_LOCAL, "sizeof local", 0, {    push_int(pike_sizeof(Pike_fp->locals+arg1));   });      OPCODE1_ALIAS(F_SSCANF, "sscanf", 0, o_sscanf);      #define MKAPPLY(OP,OPCODE,NAME,TYPE, ARG2, ARG3) \ - OP(PIKE_CONCAT(F_,OPCODE),NAME, I_PC_AT_NEXT, { \ - Pike_fp->pc=PROG_COUNTER; \ + PIKE_CONCAT(OP,_JUMP)(PIKE_CONCAT(F_,OPCODE),NAME, I_PC_AT_NEXT, { \ + JUMP_SET_TO_PC_AT_NEXT (Pike_fp->pc); \   if(low_mega_apply(TYPE,DO_NOT_WARN((INT32)(Pike_sp - *--Pike_mark_sp)), \    ARG2, ARG3)) \   { \    Pike_fp->flags |= PIKE_FRAME_RETURN_INTERNAL; \    DO_JUMP_TO(Pike_fp->pc); \   } \ -  + else { \ +  DO_JUMP_TO_NEXT; \ + } \   }); \    \ - OP(PIKE_CONCAT3(F_,OPCODE,_AND_POP),NAME " & pop", I_PC_AT_NEXT, { \ -  Pike_fp->pc=PROG_COUNTER; \ + PIKE_CONCAT(OP,_JUMP)(PIKE_CONCAT3(F_,OPCODE,_AND_POP),NAME " & pop", I_PC_AT_NEXT, { \ +  JUMP_SET_TO_PC_AT_NEXT (Pike_fp->pc); \    if(low_mega_apply(TYPE, DO_NOT_WARN((INT32)(Pike_sp - *--Pike_mark_sp)), \    ARG2, ARG3)) \    { \    Pike_fp->flags |= PIKE_FRAME_RETURN_INTERNAL | PIKE_FRAME_RETURN_POP; \    DO_JUMP_TO(Pike_fp->pc); \    }else{ \    pop_stack(); \ -  +  DO_JUMP_TO_NEXT; \    } \   }); \    \   PIKE_CONCAT(OP,_RETURN)(PIKE_CONCAT3(F_,OPCODE,_AND_RETURN), \    NAME " & return", 0, { \    if(low_mega_apply(TYPE,DO_NOT_WARN((INT32)(Pike_sp - *--Pike_mark_sp)), \    ARG2,ARG3)) \    { \    PIKE_OPCODE_T *addr = Pike_fp->pc; \    DO_IF_DEBUG(Pike_fp->next->pc=0); \
pike.git/src/interpret_functions.h:1818:    }else{ \    DO_DUMB_RETURN; \    } \   }); \         #define MKAPPLY2(OP,OPCODE,NAME,TYPE, ARG2, ARG3) \    \   MKAPPLY(OP,OPCODE,NAME,TYPE, ARG2, ARG3) \    \ - OP(PIKE_CONCAT(F_MARK_,OPCODE),"mark, " NAME, I_PC_AT_NEXT, { \ -  Pike_fp->pc=PROG_COUNTER; \ + PIKE_CONCAT(OP,_JUMP)(PIKE_CONCAT(F_MARK_,OPCODE),"mark, " NAME, I_PC_AT_NEXT, { \ +  JUMP_SET_TO_PC_AT_NEXT (Pike_fp->pc); \    if(low_mega_apply(TYPE, 0, \    ARG2, ARG3)) \    { \    Pike_fp->flags |= PIKE_FRAME_RETURN_INTERNAL; \    DO_JUMP_TO(Pike_fp->pc); \    } \ -  +  else { \ +  DO_JUMP_TO_NEXT; \ +  } \   }); \    \ - OP(PIKE_CONCAT3(F_MARK_,OPCODE,_AND_POP),"mark, " NAME " & pop", I_PC_AT_NEXT, { \ -  Pike_fp->pc=PROG_COUNTER; \ + PIKE_CONCAT(OP,_JUMP)(PIKE_CONCAT3(F_MARK_,OPCODE,_AND_POP), \ +  "mark, " NAME " & pop", I_PC_AT_NEXT, { \ +  JUMP_SET_TO_PC_AT_NEXT (Pike_fp->pc); \    if(low_mega_apply(TYPE, 0, \    ARG2, ARG3)) \    { \    Pike_fp->flags |= PIKE_FRAME_RETURN_INTERNAL | PIKE_FRAME_RETURN_POP; \    DO_JUMP_TO(Pike_fp->pc); \    }else{ \    pop_stack(); \ -  +  DO_JUMP_TO_NEXT; \    } \   }); \    \   PIKE_CONCAT(OP,_RETURN)(PIKE_CONCAT3(F_MARK_,OPCODE,_AND_RETURN), \    "mark, " NAME " & return", 0, { \    if(low_mega_apply(TYPE, 0, \    ARG2,ARG3)) \    { \    PIKE_OPCODE_T *addr = Pike_fp->pc; \    DO_IF_DEBUG(Pike_fp->next->pc=0); \
pike.git/src/interpret_functions.h:1864:      MKAPPLY2(OPCODE1,CALL_LFUN,"call lfun",APPLY_LOW,    Pike_fp->current_object,    (void *)(ptrdiff_t)(arg1+Pike_fp->context.identifier_level));      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(F_CALL_OTHER,"call other", I_PC_AT_NEXT, { + OPCODE1_JUMP(F_CALL_OTHER,"call other", I_PC_AT_NEXT, {    INT32 args=DO_NOT_WARN((INT32)(Pike_sp - *--Pike_mark_sp));    struct svalue *s=Pike_sp-args; -  Pike_fp->pc=PROG_COUNTER; +  JUMP_SET_TO_PC_AT_NEXT (Pike_fp->pc);    if(s->type == T_OBJECT)    {    struct object *o=s->u.object;    struct program *p;    if((p=o->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)    {    if(low_mega_apply(APPLY_LOW, args-1, o, (void *)(ptrdiff_t)fun))    {    Pike_fp->save_sp--;    Pike_fp->flags |= PIKE_FRAME_RETURN_INTERNAL;    DO_JUMP_TO(Pike_fp->pc);    }    stack_pop_keep_top(); -  DONE; +  DO_JUMP_TO_NEXT;    }    }    }    }       {    struct svalue tmp;    struct svalue tmp2;       tmp.type=PIKE_T_STRING;
pike.git/src/interpret_functions.h:1912:    index_no_free(&tmp2, s, &tmp);    free_svalue(s);    *s=tmp2;    print_return_value();       if(low_mega_apply(APPLY_STACK, args, 0, 0))    {    Pike_fp->flags |= PIKE_FRAME_RETURN_INTERNAL;    DO_JUMP_TO(Pike_fp->pc);    } -  DONE; +  else { +  DO_JUMP_TO_NEXT;    } -  +  }   });    - OPCODE1(F_CALL_OTHER_AND_POP,"call other & pop", I_PC_AT_NEXT, { + OPCODE1_JUMP(F_CALL_OTHER_AND_POP,"call other & pop", I_PC_AT_NEXT, {    INT32 args=DO_NOT_WARN((INT32)(Pike_sp - *--Pike_mark_sp));    struct svalue *s=Pike_sp-args; -  Pike_fp->pc=PROG_COUNTER; +  JUMP_SET_TO_PC_AT_NEXT (Pike_fp->pc);    if(s->type == T_OBJECT)    {    struct object *o=s->u.object;    struct program *p;    if((p=o->prog))    {    if(FIND_LFUN(p, LFUN_ARROW) == -1)    {    int fun;    fun=find_shared_string_identifier(Pike_fp->context.prog->strings[arg1],
pike.git/src/interpret_functions.h:1942:    {    if(low_mega_apply(APPLY_LOW, args-1, o, (void *)(ptrdiff_t)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(); -  DONE; +  DO_JUMP_TO_NEXT;    }    }    }    }       {    struct svalue tmp;    struct svalue tmp2;       tmp.type=PIKE_T_STRING;
pike.git/src/interpret_functions.h:1966:    index_no_free(&tmp2, s, &tmp);    free_svalue(s);    *s=tmp2;    print_return_value();       if(low_mega_apply(APPLY_STACK, args, 0, 0))    {    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(F_CALL_OTHER_AND_RETURN,"call other & return", 0, { + OPCODE1_JUMP(F_CALL_OTHER_AND_RETURN,"call other & return", 0, {    INT32 args=DO_NOT_WARN((INT32)(Pike_sp - *--Pike_mark_sp));    struct svalue *s=Pike_sp-args;    if(s->type == T_OBJECT)    {    struct object *o=s->u.object;    struct program *p;    if((p=o->prog))    {    if(FIND_LFUN(p, LFUN_ARROW) == -1)    {
pike.git/src/interpret_functions.h:2124:    ("Function call permission denied.\n"))); \    \    fast_check_threads_etc(6); \    check_stack(256); \    \    new_frame=alloc_pike_frame(); \    \    new_frame->refs=1; /* FIXME: Is this needed? */ \    new_frame->next=Pike_fp; \    \ -  Pike_fp->pc = (PIKE_OPCODE_T *)(((INT32 *)PROG_COUNTER) + 1); \ -  addr = PROG_COUNTER+GET_JUMP(); \ +  JUMP_SET_TO_PC_AT_NEXT (addr); \ +  Pike_fp->pc = (PIKE_OPCODE_T *)(((INT32 *) addr) + 1); \ +  addr += GET_JUMP(); \    \    new_frame->num_locals = READ_INCR_BYTE(addr); \    args = READ_INCR_BYTE(addr); \    addr += ENTRY_PROLOGUE_SIZE; \    \    new_frame->num_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; \    \    push_zeroes(new_frame->num_locals - args); \
pike.git/src/interpret_functions.h:2162:    if(new_frame->context.parent) \    add_ref(new_frame->context.parent); \    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)); \    \    FETCH; \ -  DONE; \ +  JUMP_DONE; \   }while(0)      /* Assume that the number of arguments is correct */ - OPCODE1_JUMP(F_COND_RECUR, "recur if not overloaded", I_PC_AT_NEXT, { + OPCODE1_PTRJUMP(F_COND_RECUR, "recur if not overloaded", I_PC_AT_NEXT, {    struct program *p = Pike_fp->current_object->prog; -  PIKE_OPCODE_T *addr = (PIKE_OPCODE_T *)(((INT32 *)PROG_COUNTER) + 1); -  Pike_fp->pc=addr; +  PIKE_OPCODE_T *addr; +  JUMP_SET_TO_PC_AT_NEXT (addr); +  Pike_fp->pc = (PIKE_OPCODE_T *)(((INT32 *)addr) + 1);       /* Test if the function is overloaded.    *    * Note: The second part of the test is sufficient, but    * the since first case is much simpler to test and    * is common, it should offer a speed improvement.    *    * /grubba 2002-11-14    *    * Also test if the function uses scoping. DO_RECUR() doesn't
pike.git/src/interpret_functions.h:2191:    *    * /grubba 2003-03-25    */    if(((p != Pike_fp->context.prog) &&    (p->inherits[p->identifier_references[Pike_fp->context.identifier_level +    arg1].inherit_offset].prog !=    Pike_fp->context.prog)) ||    (ID_FROM_INT(p, arg1+Pike_fp->context.identifier_level)->    identifier_flags & IDENTIFIER_SCOPE_USED))    { -  PIKE_OPCODE_T *faddr = PROG_COUNTER+GET_JUMP(); -  ptrdiff_t num_locals = READ_INCR_BYTE(faddr); /* ignored */ -  ptrdiff_t args = READ_INCR_BYTE(faddr); +  PIKE_OPCODE_T *faddr; +  ptrdiff_t num_locals; +  ptrdiff_t args;    -  +  JUMP_SET_TO_PC_AT_NEXT (faddr); +  faddr += GET_JUMP(); +  num_locals = READ_INCR_BYTE(faddr); /* ignored */ +  args = READ_INCR_BYTE(faddr); +     if(low_mega_apply(APPLY_LOW,    args,    Pike_fp->current_object,    (void *)(ptrdiff_t)(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 */    -  OPCODE0_TAILJUMP(F_RECUR, "recur", 0, { +  OPCODE0_TAILPTRJUMP(F_RECUR, "recur", 0, {    DO_RECUR(0);    });   });      /* Ugly code duplication */ - OPCODE0_JUMP(F_RECUR_AND_POP, "recur & pop", 0, { + OPCODE0_PTRJUMP(F_RECUR_AND_POP, "recur & pop", 0, {    DO_RECUR(PIKE_FRAME_RETURN_POP);   });         /* Assume that the number of arguments is correct */   /* FIXME: adjust Pike_mark_sp */ - OPCODE0_JUMP(F_TAIL_RECUR, "tail recursion", 0, { + OPCODE0_PTRJUMP(F_TAIL_RECUR, "tail recursion", 0, {    INT32 num_locals;    PIKE_OPCODE_T *addr;    INT32 args;       fast_check_threads_etc(6);    -  addr = PROG_COUNTER+GET_JUMP(); +  JUMP_SET_TO_PC_AT_NEXT (addr); +  addr += GET_JUMP();    num_locals = READ_INCR_BYTE(addr);    args = READ_INCR_BYTE(addr);    addr += ENTRY_PROLOGUE_SIZE;    SET_PROG_COUNTER(addr);       if(Pike_sp-args != Pike_fp->locals)    {    DO_IF_DEBUG({    if (Pike_sp < Pike_fp->locals + args)    Pike_fatal("Pike_sp (%p) < Pike_fp->locals (%p) + args (%d)\n",
pike.git/src/interpret_functions.h:2256:    }       push_zeroes(num_locals - args);       DO_IF_DEBUG({    if(Pike_sp != Pike_fp->locals + Pike_fp->num_locals)    Pike_fatal("Sp whacked!\n");    });       FETCH; -  DONE; +  JUMP_DONE;   });    - OPCODE0(F_BREAKPOINT, "breakpoint", 0, { + #if 0 + /* This opcode needs mending if it is to work with machine code. */ + OPCODE0_JUMP(F_BREAKPOINT, "breakpoint", 0, {    extern void o_breakpoint(void);    o_breakpoint();    DO_JUMP_TO(PROG_COUNTER-1);   }); -  + #endif      OPCODE1(F_THIS_OBJECT, "this_object", 0, {    struct object *o = Pike_fp->current_object;    int level;    for (level = 0; level < arg1; level++) {    struct program *p = o->prog;    if (!p)    Pike_error ("Object %d level(s) up is destructed - cannot get the parent.\n",    level);    if (!(p->flags & PROGRAM_USES_PARENT))