summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authordkf <donal.k.fellows@manchester.ac.uk>2012-11-29 21:25:34 (GMT)
committerdkf <donal.k.fellows@manchester.ac.uk>2012-11-29 21:25:34 (GMT)
commit2fe9a622d1374c3f1ecd188087a7fb836da49fab (patch)
tree394ecba96bd8a8acf83f0753bad2f90e77d4fcac
parent74628e76c19dab883bb362fababc98e9029d47e3 (diff)
downloadtcl-2fe9a622d1374c3f1ecd188087a7fb836da49fab.zip
tcl-2fe9a622d1374c3f1ecd188087a7fb836da49fab.tar.gz
tcl-2fe9a622d1374c3f1ecd188087a7fb836da49fab.tar.bz2
Reducing the complexity of the bytecodes as an experiment.
Diffstat
-rw-r--r--generic/tclAssembly.c222
-rw-r--r--generic/tclCompCmds.c120
-rw-r--r--generic/tclCompCmdsSZ.c138
-rw-r--r--generic/tclCompExpr.c6
-rw-r--r--generic/tclCompile.c392
-rw-r--r--generic/tclCompile.h401
-rw-r--r--generic/tclExecute.c260
-rw-r--r--tests/assemble.test12
8 files changed, 515 insertions, 1036 deletions
diff --git a/generic/tclAssembly.c b/generic/tclAssembly.c
index 7833105..97d08b8 100644
--- a/generic/tclAssembly.c
+++ b/generic/tclAssembly.c
@@ -113,8 +113,6 @@ enum BasicBlockFlags {
* traversal */
BB_FALLTHRU = (1 << 1), /* Control may pass from this block to a
* successor */
- BB_JUMP1 = (1 << 2), /* Basic block ends with a 1-byte-offset jump
- * and may need expansion */
BB_JUMPTABLE = (1 << 3), /* Basic block ends with a jump table */
BB_BEGINCATCH = (1 << 4), /* Block ends with a 'beginCatch' instruction,
* marking it as the start of a 'catch'
@@ -151,11 +149,9 @@ typedef enum TalInstType {
* compiling it in line with the assembly
* code! I love Tcl!) */
ASSEM_INDEX, /* 4 byte operand, integer or end-integer */
- ASSEM_INVOKE, /* 1- or 4-byte operand count, must be
- * strictly positive, consumes N, produces
- * 1. */
+ ASSEM_INVOKE, /* 4-byte operand count, must be strictly
+ * positive, consumes N, produces 1. */
ASSEM_JUMP, /* Jump instructions */
- ASSEM_JUMP4, /* Jump instructions forcing a 4-byte offset */
ASSEM_JUMPTABLE, /* Jumptable (switch -exact) */
ASSEM_LABEL, /* The assembly directive that defines a
* label */
@@ -165,11 +161,7 @@ typedef enum TalInstType {
* consumses N, produces 1 */
ASSEM_LSET_FLAT, /* 4-byte operand count, must be >= 3,
* consumes N, produces 1 */
- ASSEM_LVT, /* One operand that references a local
- * variable */
- ASSEM_LVT1, /* One 1-byte operand that references a local
- * variable */
- ASSEM_LVT1_SINT1, /* One 1-byte operand that references a local
+ ASSEM_LVT4_SINT1, /* One 4-byte operand that references a local
* variable, one signed-integer 1-byte
* operand */
ASSEM_LVT4, /* One 4-byte operand that references a local
@@ -244,8 +236,6 @@ static void BBEmitInstInt1(AssemblyEnv* assemEnvPtr, int tblIdx,
int opnd, int count);
static void BBEmitInstInt4(AssemblyEnv* assemEnvPtr, int tblIdx,
int opnd, int count);
-static void BBEmitInst1or4(AssemblyEnv* assemEnvPtr, int tblIdx,
- int param, int count);
static void BBEmitOpcode(AssemblyEnv* assemEnvPtr, int tblIdx,
int count);
static int BuildExceptionRanges(AssemblyEnv* assemEnvPtr);
@@ -352,14 +342,11 @@ static const Tcl_ObjType assembleCodeType = {
static const TalInstDesc TalInstructionTable[] = {
/* PUSH must be first, see the code near the end of TclAssembleCode */
- {"push", ASSEM_PUSH, (INST_PUSH1<<8
- | INST_PUSH4), 0, 1},
+ {"push", ASSEM_PUSH, INST_PUSH, 0, 1},
{"add", ASSEM_1BYTE, INST_ADD, 2, 1},
- {"append", ASSEM_LVT, (INST_APPEND_SCALAR1<<8
- | INST_APPEND_SCALAR4),1, 1},
- {"appendArray", ASSEM_LVT, (INST_APPEND_ARRAY1<<8
- | INST_APPEND_ARRAY4), 2, 1},
+ {"append", ASSEM_LVT4, INST_APPEND_SCALAR, 1, 1},
+ {"appendArray", ASSEM_LVT4, INST_APPEND_ARRAY, 2, 1},
{"appendArrayStk", ASSEM_1BYTE, INST_APPEND_ARRAY_STK, 3, 1},
{"appendStk", ASSEM_1BYTE, INST_APPEND_STK, 2, 1},
{"arrayExistsImm", ASSEM_LVT4, INST_ARRAY_EXISTS_IMM, 0, 1},
@@ -367,12 +354,12 @@ static const TalInstDesc TalInstructionTable[] = {
{"arrayMakeImm", ASSEM_LVT4, INST_ARRAY_MAKE_IMM, 0, 0},
{"arrayMakeStk", ASSEM_1BYTE, INST_ARRAY_MAKE_STK, 1, 0},
{"beginCatch", ASSEM_BEGIN_CATCH,
- INST_BEGIN_CATCH4, 0, 0},
+ INST_BEGIN_CATCH, 0, 0},
{"bitand", ASSEM_1BYTE, INST_BITAND, 2, 1},
{"bitnot", ASSEM_1BYTE, INST_BITNOT, 1, 1},
{"bitor", ASSEM_1BYTE, INST_BITOR, 2, 1},
{"bitxor", ASSEM_1BYTE, INST_BITXOR, 2, 1},
- {"concat", ASSEM_CONCAT1, INST_CONCAT1, INT_MIN,1},
+ {"concat", ASSEM_CONCAT1, INST_CONCAT, INT_MIN,1},
{"coroName", ASSEM_1BYTE, INST_COROUTINE_NAME, 0, 1},
{"currentNamespace",ASSEM_1BYTE, INST_NS_CURRENT, 0, 1},
{"dictAppend", ASSEM_LVT4, INST_DICT_APPEND, 2, 1},
@@ -402,35 +389,28 @@ static const TalInstDesc TalInstructionTable[] = {
{"exprStk", ASSEM_1BYTE, INST_EXPR_STK, 1, 1},
{"ge", ASSEM_1BYTE, INST_GE, 2, 1},
{"gt", ASSEM_1BYTE, INST_GT, 2, 1},
- {"incr", ASSEM_LVT1, INST_INCR_SCALAR1, 1, 1},
- {"incrArray", ASSEM_LVT1, INST_INCR_ARRAY1, 2, 1},
- {"incrArrayImm", ASSEM_LVT1_SINT1,
- INST_INCR_ARRAY1_IMM, 1, 1},
+ {"incr", ASSEM_LVT4, INST_INCR_SCALAR, 1, 1},
+ {"incrArray", ASSEM_LVT4, INST_INCR_ARRAY, 2, 1},
+ {"incrArrayImm", ASSEM_LVT4_SINT1,
+ INST_INCR_ARRAY_IMM, 1, 1},
{"incrArrayStk", ASSEM_1BYTE, INST_INCR_ARRAY_STK, 3, 1},
{"incrArrayStkImm", ASSEM_SINT1, INST_INCR_ARRAY_STK_IMM,2, 1},
- {"incrImm", ASSEM_LVT1_SINT1,
- INST_INCR_SCALAR1_IMM, 0, 1},
+ {"incrImm", ASSEM_LVT4_SINT1,
+ INST_INCR_SCALAR_IMM, 0, 1},
{"incrStk", ASSEM_1BYTE, INST_INCR_SCALAR_STK, 2, 1},
{"incrStkImm", ASSEM_SINT1, INST_INCR_SCALAR_STK_IMM,
1, 1},
{"infoLevelArgs", ASSEM_1BYTE, INST_INFO_LEVEL_ARGS, 1, 1},
{"infoLevelNumber", ASSEM_1BYTE, INST_INFO_LEVEL_NUM, 0, 1},
- {"invokeStk", ASSEM_INVOKE, (INST_INVOKE_STK1 << 8
- | INST_INVOKE_STK4), INT_MIN,1},
- {"jump", ASSEM_JUMP, INST_JUMP1, 0, 0},
- {"jump4", ASSEM_JUMP4, INST_JUMP4, 0, 0},
- {"jumpFalse", ASSEM_JUMP, INST_JUMP_FALSE1, 1, 0},
- {"jumpFalse4", ASSEM_JUMP4, INST_JUMP_FALSE4, 1, 0},
+ {"invokeStk", ASSEM_INVOKE, INST_INVOKE_STK, INT_MIN,1},
+ {"jump", ASSEM_JUMP, INST_JUMP, 0, 0},
+ {"jumpFalse", ASSEM_JUMP, INST_JUMP_FALSE, 1, 0},
{"jumpTable", ASSEM_JUMPTABLE,INST_JUMP_TABLE, 1, 0},
- {"jumpTrue", ASSEM_JUMP, INST_JUMP_TRUE1, 1, 0},
- {"jumpTrue4", ASSEM_JUMP4, INST_JUMP_TRUE4, 1, 0},
+ {"jumpTrue", ASSEM_JUMP, INST_JUMP_TRUE, 1, 0},
{"label", ASSEM_LABEL, 0, 0, 0},
{"land", ASSEM_1BYTE, INST_LAND, 2, 1},
- {"lappend", ASSEM_LVT, (INST_LAPPEND_SCALAR1<<8
- | INST_LAPPEND_SCALAR4),
- 1, 1},
- {"lappendArray", ASSEM_LVT, (INST_LAPPEND_ARRAY1<<8
- | INST_LAPPEND_ARRAY4),2, 1},
+ {"lappend", ASSEM_LVT4, INST_LAPPEND_SCALAR, 1, 1},
+ {"lappendArray", ASSEM_LVT4, INST_LAPPEND_ARRAY, 2, 1},
{"lappendArrayStk", ASSEM_1BYTE, INST_LAPPEND_ARRAY_STK, 3, 1},
{"lappendStk", ASSEM_1BYTE, INST_LAPPEND_STK, 2, 1},
{"le", ASSEM_1BYTE, INST_LE, 2, 1},
@@ -442,10 +422,8 @@ static const TalInstDesc TalInstructionTable[] = {
{"listIndexImm", ASSEM_INDEX, INST_LIST_INDEX_IMM, 1, 1},
{"listLength", ASSEM_1BYTE, INST_LIST_LENGTH, 1, 1},
{"listNotIn", ASSEM_1BYTE, INST_LIST_NOT_IN, 2, 1},
- {"load", ASSEM_LVT, (INST_LOAD_SCALAR1 << 8
- | INST_LOAD_SCALAR4), 0, 1},
- {"loadArray", ASSEM_LVT, (INST_LOAD_ARRAY1<<8
- | INST_LOAD_ARRAY4), 1, 1},
+ {"load", ASSEM_LVT4, INST_LOAD_SCALAR, 0, 1},
+ {"loadArray", ASSEM_LVT4, INST_LOAD_ARRAY, 1, 1},
{"loadArrayStk", ASSEM_1BYTE, INST_LOAD_ARRAY_STK, 2, 1},
{"loadStk", ASSEM_1BYTE, INST_LOAD_SCALAR_STK, 1, 1},
{"lor", ASSEM_1BYTE, INST_LOR, 2, 1},
@@ -469,10 +447,8 @@ static const TalInstDesc TalInstructionTable[] = {
{"resolveCmd", ASSEM_1BYTE, INST_RESOLVE_COMMAND, 1, 1},
{"reverse", ASSEM_REVERSE, INST_REVERSE, INT_MIN,-1-0},
{"rshift", ASSEM_1BYTE, INST_RSHIFT, 2, 1},
- {"store", ASSEM_LVT, (INST_STORE_SCALAR1<<8
- | INST_STORE_SCALAR4), 1, 1},
- {"storeArray", ASSEM_LVT, (INST_STORE_ARRAY1<<8
- | INST_STORE_ARRAY4), 2, 1},
+ {"store", ASSEM_LVT4, INST_STORE_SCALAR, 1, 1},
+ {"storeArray", ASSEM_LVT4, INST_STORE_ARRAY, 2, 1},
{"storeArrayStk", ASSEM_1BYTE, INST_STORE_ARRAY_STK, 3, 1},
{"storeStk", ASSEM_1BYTE, INST_STORE_SCALAR_STK, 2, 1},
{"strcmp", ASSEM_1BYTE, INST_STR_CMP, 2, 1},
@@ -513,19 +489,17 @@ static const TalInstDesc TalInstructionTable[] = {
*/
static const unsigned char NonThrowingByteCodes[] = {
- INST_PUSH1, INST_PUSH4, INST_POP, INST_DUP, /* 1-4 */
- INST_JUMP1, INST_JUMP4, /* 34-35 */
- INST_END_CATCH, INST_PUSH_RESULT, INST_PUSH_RETURN_CODE, /* 70-72 */
- INST_OVER, /* 95 */
- INST_PUSH_RETURN_OPTIONS, /* 108 */
- INST_REVERSE, /* 126 */
- INST_NOP, /* 132 */
- INST_STR_MAP, /* 143 */
- INST_STR_FIND, /* 144 */
- INST_COROUTINE_NAME, /* 149 */
- INST_NS_CURRENT, /* 151 */
- INST_INFO_LEVEL_NUM, /* 152 */
- INST_RESOLVE_COMMAND /* 154 */
+ INST_PUSH, INST_POP, INST_DUP, /* 1-3 */
+ INST_JUMP, /* 28 */
+ INST_END_CATCH, INST_PUSH_RESULT, INST_PUSH_RETURN_CODE, /* 64- */
+ INST_PUSH_RETURN_OPTIONS, /* -67 */
+ INST_OVER, /* 117 */
+ INST_REVERSE, INST_NOP, /* 119-120 */
+ INST_STR_MAP, INST_STR_FIND, /* 130-131 */
+ INST_COROUTINE_NAME, /* 136 */
+ INST_NS_CURRENT, /* 138 */
+ INST_INFO_LEVEL_NUM, /* 139 */
+ INST_RESOLVE_COMMAND /* 141 */
};
/*
@@ -702,45 +676,6 @@ BBEmitInstInt4(
/*
*-----------------------------------------------------------------------------
*
- * BBEmitInst1or4 --
- *
- * Emits a 1- or 4-byte operation according to the magnitude of the
- * operand
- *
- *-----------------------------------------------------------------------------
- */
-
-static void
-BBEmitInst1or4(
- AssemblyEnv* assemEnvPtr, /* Assembly environment */
- int tblIdx, /* Index in TalInstructionTable of op */
- int param, /* Variable-length parameter */
- int count) /* Arity if variadic */
-{
- CompileEnv* envPtr = assemEnvPtr->envPtr;
- /* Compilation environment */
- BasicBlock* bbPtr = assemEnvPtr->curr_bb;
- /* Current basic block */
- int op = TalInstructionTable[tblIdx].tclInstCode;
-
- if (param <= 0xff) {
- op >>= 8;
- } else {
- op &= 0xff;
- }
- TclEmitInt1(op, envPtr);
- if (param <= 0xff) {
- TclEmitInt1(param, envPtr);
- } else {
- TclEmitInt4(param, envPtr);
- }
- envPtr->atCmdStart = ((op) == INST_START_CMD);
- BBUpdateStackReqs(bbPtr, tblIdx, count);
-}
-
-/*
- *-----------------------------------------------------------------------------
- *
* Tcl_AssembleObjCmd, TclNRAssembleObjCmd --
*
* Direct evaluation path for tcl::unsupported::assemble
@@ -1331,7 +1266,7 @@ AssembleOneLine(
}
operand1 = Tcl_GetStringFromObj(operand1Obj, &operand1Len);
litIndex = TclRegisterNewLiteral(envPtr, operand1, operand1Len);
- BBEmitInst1or4(assemEnvPtr, tblIdx, litIndex, 0);
+ BBEmitInstInt4(assemEnvPtr, tblIdx, litIndex, 0);
break;
case ASSEM_1BYTE:
@@ -1485,7 +1420,7 @@ AssembleOneLine(
* Assumes that PUSH is the first slot!
*/
- BBEmitInst1or4(assemEnvPtr, 0, litIndex, 0);
+ BBEmitInstInt4(assemEnvPtr, 0, litIndex, 0);
BBEmitOpcode(assemEnvPtr, tblIdx, 0);
}
break;
@@ -1500,11 +1435,10 @@ AssembleOneLine(
goto cleanup;
}
- BBEmitInst1or4(assemEnvPtr, tblIdx, opnd, opnd);
+ BBEmitInstInt4(assemEnvPtr, tblIdx, opnd, opnd);
break;
case ASSEM_JUMP:
- case ASSEM_JUMP4:
if (parsePtr->numWords != 2) {
Tcl_WrongNumArgs(interp, 1, &instNameObj, "label");
goto cleanup;
@@ -1513,13 +1447,8 @@ AssembleOneLine(
goto cleanup;
}
assemEnvPtr->curr_bb->jumpOffset = envPtr->codeNext-envPtr->codeStart;
- if (instType == ASSEM_JUMP) {
- flags = BB_JUMP1;
- BBEmitInstInt1(assemEnvPtr, tblIdx, 0, 0);
- } else {
- flags = 0;
- BBEmitInstInt4(assemEnvPtr, tblIdx, 0, 0);
- }
+ flags = 0;
+ BBEmitInstInt4(assemEnvPtr, tblIdx, 0, 0);
/*
* Start a new basic block at the instruction following the jump.
@@ -1632,42 +1561,18 @@ AssembleOneLine(
BBEmitInstInt4(assemEnvPtr, tblIdx, opnd, opnd);
break;
- case ASSEM_LVT:
- if (parsePtr->numWords != 2) {
- Tcl_WrongNumArgs(interp, 1, &instNameObj, "varname");
- goto cleanup;
- }
- localVar = FindLocalVar(assemEnvPtr, &tokenPtr);
- if (localVar < 0) {
- goto cleanup;
- }
- BBEmitInst1or4(assemEnvPtr, tblIdx, localVar, 0);
- break;
-
- case ASSEM_LVT1:
- if (parsePtr->numWords != 2) {
- Tcl_WrongNumArgs(interp, 1, &instNameObj, "varname");
- goto cleanup;
- }
- localVar = FindLocalVar(assemEnvPtr, &tokenPtr);
- if (localVar < 0 || CheckOneByte(interp, localVar)) {
- goto cleanup;
- }
- BBEmitInstInt1(assemEnvPtr, tblIdx, localVar, 0);
- break;
-
- case ASSEM_LVT1_SINT1:
+ case ASSEM_LVT4_SINT1:
if (parsePtr->numWords != 3) {
Tcl_WrongNumArgs(interp, 1, &instNameObj, "varName imm8");
goto cleanup;
}
localVar = FindLocalVar(assemEnvPtr, &tokenPtr);
- if (localVar < 0 || CheckOneByte(interp, localVar)
+ if (localVar < 0
|| GetIntegerOperand(assemEnvPtr, &tokenPtr, &opnd) != TCL_OK
|| CheckSignedOneByte(interp, opnd)) {
goto cleanup;
}
- BBEmitInstInt1(assemEnvPtr, tblIdx, localVar, 0);
+ BBEmitInstInt4(assemEnvPtr, tblIdx, localVar, 0);
TclEmitInt1(opnd, envPtr);
break;
@@ -2794,15 +2699,9 @@ CalculateJumpRelocations(
int* mustMove) /* OUTPUT: Number of bytes that have been
* added to the code */
{
- CompileEnv* envPtr = assemEnvPtr->envPtr;
- /* Compilation environment */
BasicBlock* bbPtr; /* Pointer to a basic block being checked */
Tcl_HashEntry* entry; /* Exit label's entry in the symbol table */
- BasicBlock* jumpTarget; /* Basic block where the jump goes */
int motion; /* Amount by which the code has expanded */
- int offset; /* Offset in the bytecode from a jump
- * instruction to its target */
- unsigned opcode; /* Opcode in the bytecode being adjusted */
/*
* Iterate through basic blocks as long as a change results in code
@@ -2836,26 +2735,6 @@ CalculateJumpRelocations(
bbPtr->jumpTarget);
return TCL_ERROR;
}
-
- /*
- * If the instruction is a JUMP1, turn it into a JUMP4 if its
- * target is out of range.
- */
-
- jumpTarget = Tcl_GetHashValue(entry);
- if (bbPtr->flags & BB_JUMP1) {
- offset = jumpTarget->startOffset
- - (bbPtr->jumpOffset + motion);
- if (offset < -0x80 || offset > 0x7f) {
- opcode = TclGetUInt1AtPtr(envPtr->codeStart
- + bbPtr->jumpOffset);
- ++opcode;
- TclStoreInt1AtPtr(opcode,
- envPtr->codeStart + bbPtr->jumpOffset);
- motion += 3;
- bbPtr->flags &= ~BB_JUMP1;
- }
- }
}
/*
@@ -3041,13 +2920,8 @@ FillInJumpOffsets(
jumpTarget = Tcl_GetHashValue(entry);
fromOffset = bbPtr->jumpOffset;
targetOffset = jumpTarget->startOffset;
- if (bbPtr->flags & BB_JUMP1) {
- TclStoreInt1AtPtr(targetOffset - fromOffset,
- envPtr->codeStart + fromOffset + 1);
- } else {
- TclStoreInt4AtPtr(targetOffset - fromOffset,
- envPtr->codeStart + fromOffset + 1);
- }
+ TclStoreInt4AtPtr(targetOffset - fromOffset,
+ envPtr->codeStart + fromOffset + 1);
}
if (bbPtr->flags & BB_JUMPTABLE) {
ResolveJumpTableTargets(assemEnvPtr, bbPtr);
@@ -3576,7 +3450,7 @@ StackCheckExit(
* Assumes that 'push' is at slot 0 in TalInstructionTable.
*/
- BBEmitInst1or4(assemEnvPtr, 0, litIndex, 0);
+ BBEmitInstInt4(assemEnvPtr, 0, litIndex, 0);
++depth;
}
@@ -4197,13 +4071,13 @@ RestoreEmbeddedExceptionRanges(
/*
* Walk through the bytecode of the basic block, and relocate
- * INST_BEGIN_CATCH4 instructions to the new locations
+ * INST_BEGIN_CATCH instructions to the new locations
*/
i = bbPtr->startOffset;
while (i < bbPtr->successor1->startOffset) {
opcode = envPtr->codeStart[i];
- if (opcode == INST_BEGIN_CATCH4) {
+ if (opcode == INST_BEGIN_CATCH) {
catchIndex = TclGetUInt4AtPtr(envPtr->codeStart + i + 1);
if (catchIndex >= bbPtr->foreignExceptionBase
&& catchIndex < (bbPtr->foreignExceptionBase +
diff --git a/generic/tclCompCmds.c b/generic/tclCompCmds.c
index 160fa3c..151a245 100644
--- a/generic/tclCompCmds.c
+++ b/generic/tclCompCmds.c
@@ -96,11 +96,7 @@ static int CompileDictEachCmd(Tcl_Interp *interp,
*/
#define Emit14Inst(nm,idx,envPtr) \
- if (idx <= 255) { \
- TclEmitInstInt1(nm##1,idx,envPtr); \
- } else { \
- TclEmitInstInt4(nm##4,idx,envPtr); \
- }
+ TclEmitInstInt4(nm,idx,envPtr)
/*
* Flags bits used by PushVarName.
@@ -309,15 +305,15 @@ TclCompileArraySetCmd(
if (tokenPtr->type == TCL_TOKEN_SIMPLE_WORD && tokenPtr[1].size == 0) {
if (localIndex >= 0) {
TclEmitInstInt4(INST_ARRAY_EXISTS_IMM, localIndex, envPtr);
- TclEmitInstInt1(INST_JUMP_TRUE1, 7, envPtr);
+ TclEmitInstInt4(INST_JUMP_TRUE, 10, envPtr);
TclEmitInstInt4(INST_ARRAY_MAKE_IMM, localIndex, envPtr);
} else {
TclEmitOpcode( INST_DUP, envPtr);
TclEmitOpcode( INST_ARRAY_EXISTS_STK, envPtr);
- TclEmitInstInt1(INST_JUMP_TRUE1, 5, envPtr);
+ TclEmitInstInt4(INST_JUMP_TRUE, 11, envPtr);
savedStackDepth = envPtr->currStackDepth;
TclEmitOpcode( INST_ARRAY_MAKE_STK, envPtr);
- TclEmitInstInt1(INST_JUMP1, 3, envPtr);
+ TclEmitInstInt4(INST_JUMP, 6, envPtr);
envPtr->currStackDepth = savedStackDepth;
TclEmitOpcode( INST_POP, envPtr);
}
@@ -357,7 +353,7 @@ TclCompileArraySetCmd(
PushLiteral(envPtr, "1", 1);
TclEmitOpcode( INST_BITAND, envPtr);
offsetFwd = CurrentOffset(envPtr);
- TclEmitInstInt1( INST_JUMP_FALSE1, 0, envPtr);
+ TclEmitInstInt4( INST_JUMP_FALSE, 0, envPtr);
savedStackDepth = envPtr->currStackDepth;
PushLiteral(envPtr, "list must have an even number of elements",
strlen("list must have an even number of elements"));
@@ -367,40 +363,40 @@ TclCompileArraySetCmd(
TclEmitInt4( 0, envPtr);
envPtr->currStackDepth = savedStackDepth;
fwd = CurrentOffset(envPtr) - offsetFwd;
- TclStoreInt1AtPtr(fwd, envPtr->codeStart+offsetFwd+1);
+ TclStoreInt4AtPtr(fwd, envPtr->codeStart+offsetFwd+1);
Emit14Inst( INST_STORE_SCALAR, dataVar, envPtr);
TclEmitOpcode( INST_POP, envPtr);
if (localIndex >= 0) {
TclEmitInstInt4(INST_ARRAY_EXISTS_IMM, localIndex, envPtr);
- TclEmitInstInt1(INST_JUMP_TRUE1, 7, envPtr);
+ TclEmitInstInt4(INST_JUMP_TRUE, 10, envPtr);
TclEmitInstInt4(INST_ARRAY_MAKE_IMM, localIndex, envPtr);
- TclEmitInstInt4(INST_FOREACH_START4, infoIndex, envPtr);
+ TclEmitInstInt4(INST_FOREACH_START, infoIndex, envPtr);
offsetBack = CurrentOffset(envPtr);
- TclEmitInstInt4(INST_FOREACH_STEP4, infoIndex, envPtr);
+ TclEmitInstInt4(INST_FOREACH_STEP, infoIndex, envPtr);
offsetFwd = CurrentOffset(envPtr);
- TclEmitInstInt1(INST_JUMP_FALSE1, 0, envPtr);
+ TclEmitInstInt4(INST_JUMP_FALSE, 0, envPtr);
savedStackDepth = envPtr->currStackDepth;
Emit14Inst( INST_LOAD_SCALAR, keyVar, envPtr);
Emit14Inst( INST_LOAD_SCALAR, valVar, envPtr);
Emit14Inst( INST_STORE_ARRAY, localIndex, envPtr);
TclEmitOpcode( INST_POP, envPtr);
back = offsetBack - CurrentOffset(envPtr);
- TclEmitInstInt1(INST_JUMP1, back, envPtr);
+ TclEmitInstInt4(INST_JUMP, back, envPtr);
fwd = CurrentOffset(envPtr) - offsetFwd;
- TclStoreInt1AtPtr(fwd, envPtr->codeStart+offsetFwd+1);
+ TclStoreInt4AtPtr(fwd, envPtr->codeStart+offsetFwd+1);
envPtr->currStackDepth = savedStackDepth;
} else {
TclEmitOpcode( INST_DUP, envPtr);
TclEmitOpcode( INST_ARRAY_EXISTS_STK, envPtr);
- TclEmitInstInt1(INST_JUMP_TRUE1, 4, envPtr);
+ TclEmitInstInt4(INST_JUMP_TRUE, 4, envPtr);
TclEmitOpcode( INST_DUP, envPtr);
TclEmitOpcode( INST_ARRAY_MAKE_STK, envPtr);
- TclEmitInstInt4(INST_FOREACH_START4, infoIndex, envPtr);
+ TclEmitInstInt4(INST_FOREACH_START, infoIndex, envPtr);
offsetBack = CurrentOffset(envPtr);
- TclEmitInstInt4(INST_FOREACH_STEP4, infoIndex, envPtr);
+ TclEmitInstInt4(INST_FOREACH_STEP, infoIndex, envPtr);
offsetFwd = CurrentOffset(envPtr);
- TclEmitInstInt1(INST_JUMP_FALSE1, 0, envPtr);
+ TclEmitInstInt4(INST_JUMP_FALSE, 0, envPtr);
savedStackDepth = envPtr->currStackDepth;
TclEmitOpcode( INST_DUP, envPtr);
Emit14Inst( INST_LOAD_SCALAR, keyVar, envPtr);
@@ -408,9 +404,9 @@ TclCompileArraySetCmd(
TclEmitOpcode( INST_STORE_ARRAY_STK, envPtr);
TclEmitOpcode( INST_POP, envPtr);
back = offsetBack - CurrentOffset(envPtr);
- TclEmitInstInt1(INST_JUMP1, back, envPtr);
+ TclEmitInstInt4(INST_JUMP, back, envPtr);
fwd = CurrentOffset(envPtr) - offsetFwd;
- TclStoreInt1AtPtr(fwd, envPtr->codeStart+offsetFwd+1);
+ TclStoreInt4AtPtr(fwd, envPtr->codeStart+offsetFwd+1);
envPtr->currStackDepth = savedStackDepth;
TclEmitOpcode( INST_POP, envPtr);
}
@@ -445,16 +441,16 @@ TclCompileArrayUnsetCmd(
if (localIndex >= 0) {
TclEmitInstInt4(INST_ARRAY_EXISTS_IMM, localIndex, envPtr);
- TclEmitInstInt1(INST_JUMP_FALSE1, 8, envPtr);
+ TclEmitInstInt4(INST_JUMP_FALSE, 11, envPtr);
TclEmitInstInt1(INST_UNSET_SCALAR, 1, envPtr);
TclEmitInt4( localIndex, envPtr);
} else {
TclEmitOpcode( INST_DUP, envPtr);
TclEmitOpcode( INST_ARRAY_EXISTS_STK, envPtr);
- TclEmitInstInt1(INST_JUMP_FALSE1, 6, envPtr);
+ TclEmitInstInt4(INST_JUMP_FALSE, 12, envPtr);
savedStackDepth = envPtr->currStackDepth;
TclEmitInstInt1(INST_UNSET_STK, 1, envPtr);
- TclEmitInstInt1(INST_JUMP1, 3, envPtr);
+ TclEmitInstInt4(INST_JUMP, 6, envPtr);
envPtr->currStackDepth = savedStackDepth;
TclEmitOpcode( INST_POP, envPtr);
}
@@ -622,13 +618,13 @@ TclCompileCatchCmd(
SetLineInformation(1);
if (cmdTokenPtr->type == TCL_TOKEN_SIMPLE_WORD) {
savedStackDepth = envPtr->currStackDepth;
- TclEmitInstInt4( INST_BEGIN_CATCH4, range, envPtr);
+ TclEmitInstInt4( INST_BEGIN_CATCH, range, envPtr);
ExceptionRangeStarts(envPtr, range);
CompileBody(envPtr, cmdTokenPtr, interp);
} else {
CompileTokens(envPtr, cmdTokenPtr, interp);
savedStackDepth = envPtr->currStackDepth;
- TclEmitInstInt4( INST_BEGIN_CATCH4, range, envPtr);
+ TclEmitInstInt4( INST_BEGIN_CATCH, range, envPtr);
ExceptionRangeStarts(envPtr, range);
TclEmitOpcode( INST_DUP, envPtr);
TclEmitOpcode( INST_EVAL_STK, envPtr);
@@ -648,7 +644,7 @@ TclCompileCatchCmd(
TclEmitOpcode( INST_POP, envPtr);
PushLiteral(envPtr, "0", 1);
- TclEmitInstInt1( INST_JUMP1, 3, envPtr);
+ TclEmitInstInt4( INST_JUMP, 6, envPtr);
envPtr->currStackDepth = savedStackDepth;
ExceptionRangeTarget(envPtr, range, catchOffset);
TclEmitOpcode( INST_PUSH_RETURN_CODE, envPtr);
@@ -1259,7 +1255,7 @@ TclCompileDictMergeCmd(
*/
outLoop = DeclareExceptionRange(envPtr, CATCH_EXCEPTION_RANGE);
- TclEmitInstInt4( INST_BEGIN_CATCH4, outLoop, envPtr);
+ TclEmitInstInt4( INST_BEGIN_CATCH, outLoop, envPtr);
ExceptionRangeStarts(envPtr, outLoop);
for (i=2 ; i<parsePtr->numWords ; i++) {
/*
@@ -1270,14 +1266,14 @@ TclCompileDictMergeCmd(
tokenPtr = TokenAfter(tokenPtr);
CompileWord(envPtr, tokenPtr, interp, i);
TclEmitInstInt4( INST_DICT_FIRST, infoIndex, envPtr);
- TclEmitInstInt1( INST_JUMP_TRUE1, 24, envPtr);
+ TclEmitInstInt4( INST_JUMP_TRUE, 30, envPtr);
TclEmitInstInt4( INST_REVERSE, 2, envPtr);
TclEmitInstInt4( INST_DICT_SET, 1, envPtr);
TclEmitInt4( workerIndex, envPtr);
TclAdjustStackDepth(-1, envPtr);
TclEmitOpcode( INST_POP, envPtr);
TclEmitInstInt4( INST_DICT_NEXT, infoIndex, envPtr);
- TclEmitInstInt1( INST_JUMP_FALSE1, -20, envPtr);
+ TclEmitInstInt4( INST_JUMP_FALSE, -20, envPtr);
TclEmitOpcode( INST_POP, envPtr);
TclEmitOpcode( INST_POP, envPtr);
TclEmitInstInt1( INST_UNSET_SCALAR, 0, envPtr);
@@ -1293,7 +1289,7 @@ TclCompileDictMergeCmd(
Emit14Inst( INST_LOAD_SCALAR, workerIndex, envPtr);
TclEmitInstInt1( INST_UNSET_SCALAR, 0, envPtr);
TclEmitInt4( workerIndex, envPtr);
- TclEmitInstInt1( INST_JUMP1, 18, envPtr);
+ TclEmitInstInt4( INST_JUMP, 21, envPtr);
/*
* If an exception happens when starting to iterate over the second (and
@@ -1463,7 +1459,7 @@ CompileDictEachCmd(
CompileWord(envPtr, dictTokenPtr, interp, 3);
TclEmitInstInt4( INST_DICT_FIRST, infoIndex, envPtr);
emptyTargetOffset = CurrentOffset(envPtr);
- TclEmitInstInt4( INST_JUMP_TRUE4, 0, envPtr);
+ TclEmitInstInt4( INST_JUMP_TRUE, 0, envPtr);
/*
* Now we catch errors from here on so that we can finalize the search
@@ -1471,7 +1467,7 @@ CompileDictEachCmd(
*/
catchRange = DeclareExceptionRange(envPtr, CATCH_EXCEPTION_RANGE);
- TclEmitInstInt4( INST_BEGIN_CATCH4, catchRange, envPtr);
+ TclEmitInstInt4( INST_BEGIN_CATCH, catchRange, envPtr);
ExceptionRangeStarts(envPtr, catchRange);
/*
@@ -1523,7 +1519,7 @@ CompileDictEachCmd(
ExceptionRangeTarget(envPtr, loopRange, continueOffset);
TclEmitInstInt4( INST_DICT_NEXT, infoIndex, envPtr);
jumpDisplacement = bodyTargetOffset - CurrentOffset(envPtr);
- TclEmitInstInt4( INST_JUMP_FALSE4, jumpDisplacement, envPtr);
+ TclEmitInstInt4( INST_JUMP_FALSE, jumpDisplacement, envPtr);
TclEmitOpcode( INST_POP, envPtr);
TclEmitOpcode( INST_POP, envPtr);
@@ -1540,7 +1536,7 @@ CompileDictEachCmd(
TclEmitInt4( infoIndex, envPtr);
TclEmitOpcode( INST_END_CATCH, envPtr);
endTargetOffset = CurrentOffset(envPtr);
- TclEmitInstInt4( INST_JUMP4, 0, envPtr);
+ TclEmitInstInt4( INST_JUMP, 0, envPtr);
/*
* Error handler "finally" clause, which force-terminates the iteration
@@ -1567,7 +1563,7 @@ CompileDictEachCmd(
envPtr->currStackDepth = savedStackDepth + 2;
jumpDisplacement = CurrentOffset(envPtr) - emptyTargetOffset;
- TclUpdateInstInt4AtPc(INST_JUMP_TRUE4, jumpDisplacement,
+ TclUpdateInstInt4AtPc(INST_JUMP_TRUE, jumpDisplacement,
envPtr->codeStart + emptyTargetOffset);
TclEmitOpcode( INST_POP, envPtr);
TclEmitOpcode( INST_POP, envPtr);
@@ -1581,7 +1577,7 @@ CompileDictEachCmd(
*/
jumpDisplacement = CurrentOffset(envPtr) - endTargetOffset;
- TclUpdateInstInt4AtPc(INST_JUMP4, jumpDisplacement,
+ TclUpdateInstInt4AtPc(INST_JUMP, jumpDisplacement,
envPtr->codeStart + endTargetOffset);
if (collect == TCL_EACH_COLLECT) {
Emit14Inst( INST_LOAD_SCALAR, collectVar, envPtr);
@@ -1715,7 +1711,7 @@ TclCompileDictUpdateCmd(
TclEmitInt4( infoIndex, envPtr);
range = DeclareExceptionRange(envPtr, CATCH_EXCEPTION_RANGE);
- TclEmitInstInt4( INST_BEGIN_CATCH4, range, envPtr);
+ TclEmitInstInt4( INST_BEGIN_CATCH, range, envPtr);
ExceptionRangeStarts(envPtr, range);
envPtr->currStackDepth++;
@@ -1818,7 +1814,7 @@ TclCompileDictAppendCmd(
tokenPtr = TokenAfter(tokenPtr);
}
if (parsePtr->numWords > 4) {
- TclEmitInstInt1(INST_CONCAT1, parsePtr->numWords-3, envPtr);
+ TclEmitInstInt1(INST_CONCAT, parsePtr->numWords-3, envPtr);
}
/*
@@ -2071,7 +2067,7 @@ TclCompileDictWithCmd(
*/
range = DeclareExceptionRange(envPtr, CATCH_EXCEPTION_RANGE);
- TclEmitInstInt4( INST_BEGIN_CATCH4, range, envPtr);
+ TclEmitInstInt4( INST_BEGIN_CATCH, range, envPtr);
ExceptionRangeStarts(envPtr, range);
envPtr->currStackDepth++;
@@ -2426,11 +2422,7 @@ TclCompileForCmd(
envPtr->currStackDepth = savedStackDepth + 1;
jumpDist = CurrentOffset(envPtr) - bodyCodeOffset;
- if (jumpDist > 127) {
- TclEmitInstInt4(INST_JUMP_TRUE4, -jumpDist, envPtr);
- } else {
- TclEmitInstInt1(INST_JUMP_TRUE1, -jumpDist, envPtr);
- }
+ TclEmitInstInt4(INST_JUMP_TRUE, -jumpDist, envPtr);
/*
* Fix the starting points of the exception ranges (may have moved due to
@@ -2738,7 +2730,7 @@ CompileEachloopCmd(
* Initialize the temporary var that holds the count of loop iterations.
*/
- TclEmitInstInt4( INST_FOREACH_START4, infoIndex, envPtr);
+ TclEmitInstInt4( INST_FOREACH_START, infoIndex, envPtr);
/*
* Top of loop code: assign each loop variable and check whether
@@ -2746,7 +2738,7 @@ CompileEachloopCmd(
*/
ExceptionRangeTarget(envPtr, range, continueOffset);
- TclEmitInstInt4( INST_FOREACH_STEP4, infoIndex, envPtr);
+ TclEmitInstInt4( INST_FOREACH_STEP, infoIndex, envPtr);
TclEmitForwardJump(envPtr, TCL_FALSE_JUMP, &jumpFalseFixup);
/*
@@ -2773,11 +2765,7 @@ CompileEachloopCmd(
jumpBackOffset = CurrentOffset(envPtr);
jumpBackDist = jumpBackOffset-envPtr->exceptArrayPtr[range].continueOffset;
- if (jumpBackDist > 120) {
- TclEmitInstInt4(INST_JUMP4, -jumpBackDist, envPtr);
- } else {
- TclEmitInstInt1(INST_JUMP1, -jumpBackDist, envPtr);
- }
+ TclEmitInstInt4(INST_JUMP, -jumpBackDist, envPtr);
/*
* Fix the target of the jump after the foreach_step test.
@@ -2798,11 +2786,7 @@ CompileEachloopCmd(
jumpBackOffset += 3;
jumpPc = (envPtr->codeStart + jumpBackOffset);
jumpBackDist += 3;
- if (jumpBackDist > 120) {
- TclUpdateInstInt4AtPc(INST_JUMP4, -jumpBackDist, jumpPc);
- } else {
- TclUpdateInstInt1AtPc(INST_JUMP1, -jumpBackDist, jumpPc);
- }
+ TclUpdateInstInt4AtPc(INST_JUMP, -jumpBackDist, jumpPc);
}
/*
@@ -3185,7 +3169,7 @@ TclCompileFormatCmd(
* Do the concatenation, which produces the result.
*/
- TclEmitInstInt1(INST_CONCAT1, i, envPtr);
+ TclEmitInstInt1(INST_CONCAT, i, envPtr);
} else {
/*
* EVIL HACK! Force there to be a string representation in the case
@@ -3569,11 +3553,7 @@ TclCompileIfCmd(
+ jumpFalseFixupArray.fixup[jumpIndex].codeOffset;
unsigned char opCode = *ifFalsePc;
- if (opCode == INST_JUMP_FALSE1) {
- jumpFalseDist = TclGetInt1AtPtr(ifFalsePc + 1);
- jumpFalseDist += 3;
- TclStoreInt1AtPtr(jumpFalseDist, (ifFalsePc + 1));
- } else if (opCode == INST_JUMP_FALSE4) {
+ if (opCode == INST_JUMP_FALSE) {
jumpFalseDist = TclGetInt4AtPtr(ifFalsePc + 1);
jumpFalseDist += 3;
TclStoreInt4AtPtr(jumpFalseDist, (ifFalsePc + 1));
@@ -3679,10 +3659,10 @@ TclCompileIncrCmd(
} else if (isScalar) { /* Simple scalar variable. */
if (localIndex >= 0) {
if (haveImmValue) {
- TclEmitInstInt1(INST_INCR_SCALAR1_IMM, localIndex, envPtr);
+ TclEmitInstInt4(INST_INCR_SCALAR_IMM, localIndex, envPtr);
TclEmitInt1(immValue, envPtr);
} else {
- TclEmitInstInt1(INST_INCR_SCALAR1, localIndex, envPtr);
+ TclEmitInstInt4(INST_INCR_SCALAR, localIndex, envPtr);
}
} else {
if (haveImmValue) {
@@ -3694,10 +3674,10 @@ TclCompileIncrCmd(
} else { /* Simple array variable. */
if (localIndex >= 0) {
if (haveImmValue) {
- TclEmitInstInt1(INST_INCR_ARRAY1_IMM, localIndex, envPtr);
+ TclEmitInstInt4(INST_INCR_ARRAY_IMM, localIndex, envPtr);
TclEmitInt1(immValue, envPtr);
} else {
- TclEmitInstInt1(INST_INCR_ARRAY1, localIndex, envPtr);
+ TclEmitInstInt4(INST_INCR_ARRAY, localIndex, envPtr);
}
} else {
if (haveImmValue) {
@@ -3778,7 +3758,7 @@ TclCompileInfoCommandsCmd(
TclEmitOpcode( INST_RESOLVE_COMMAND, envPtr);
TclEmitOpcode( INST_DUP, envPtr);
TclEmitOpcode( INST_STR_LEN, envPtr);
- TclEmitInstInt1( INST_JUMP_FALSE1, 7, envPtr);
+ TclEmitInstInt4( INST_JUMP_FALSE, 10, envPtr);
TclEmitInstInt4( INST_LIST, 1, envPtr);
return TCL_OK;
@@ -4946,7 +4926,7 @@ TclCompileNamespaceQualifiersCmd(
PushLiteral(envPtr, ":", 1);
TclEmitOpcode( INST_STR_EQ, envPtr);
off = off - CurrentOffset(envPtr);
- TclEmitInstInt1( INST_JUMP_TRUE1, off, envPtr);
+ TclEmitInstInt4( INST_JUMP_TRUE, off, envPtr);
TclEmitOpcode( INST_STR_RANGE, envPtr);
return TCL_OK;
}
diff --git a/generic/tclCompCmdsSZ.c b/generic/tclCompCmdsSZ.c
index 9c93fb2..27017b7 100644
--- a/generic/tclCompCmdsSZ.c
+++ b/generic/tclCompCmdsSZ.c
@@ -218,26 +218,18 @@ TclCompileSetCmd(
TclEmitOpcode((isAssignment?
INST_STORE_SCALAR_STK : INST_LOAD_SCALAR_STK),
envPtr);
- } else if (localIndex <= 255) {
- TclEmitInstInt1((isAssignment?
- INST_STORE_SCALAR1 : INST_LOAD_SCALAR1),
- localIndex, envPtr);
} else {
TclEmitInstInt4((isAssignment?
- INST_STORE_SCALAR4 : INST_LOAD_SCALAR4),
+ INST_STORE_SCALAR : INST_LOAD_SCALAR),
localIndex, envPtr);
}
} else {
if (localIndex < 0) {
TclEmitOpcode((isAssignment?
INST_STORE_ARRAY_STK : INST_LOAD_ARRAY_STK), envPtr);
- } else if (localIndex <= 255) {
- TclEmitInstInt1((isAssignment?
- INST_STORE_ARRAY1 : INST_LOAD_ARRAY1),
- localIndex, envPtr);
} else {
TclEmitInstInt4((isAssignment?
- INST_STORE_ARRAY4 : INST_LOAD_ARRAY4),
+ INST_STORE_ARRAY : INST_LOAD_ARRAY),
localIndex, envPtr);
}
}
@@ -802,7 +794,7 @@ TclSubstCompile(
/*
* Tricky point! If the first token does not result in a *guaranteed* push
* of a Tcl_Obj on the stack, we must push an empty object. Otherwise it
- * is possible to get to an INST_CONCAT1 or INST_DONE without enough
+ * is possible to get to an INST_CONCAT or INST_DONE without enough
* values on the stack, resulting in a crash. Thanks to Joe Mistachkin for
* identifying a script that could trigger this case.
*/
@@ -839,11 +831,11 @@ TclSubstCompile(
}
while (count > 255) {
- OP1( CONCAT1, 255);
+ OP1( CONCAT, 255);
count -= 254;
}
if (count > 1) {
- OP1( CONCAT1, count);
+ OP1( CONCAT, count);
count = 1;
}
@@ -853,7 +845,7 @@ TclSubstCompile(
/* Jump to the end (all BREAKs land here) */
breakOffset = CurrentOffset(envPtr);
- TclEmitInstInt4(INST_JUMP4, 0, envPtr);
+ TclEmitInstInt4(INST_JUMP, 0, envPtr);
/* Start */
if (TclFixupForwardJumpToHere(envPtr, &startFixup, 127)) {
@@ -864,7 +856,7 @@ TclSubstCompile(
envPtr->line = bline;
catchRange = DeclareExceptionRange(envPtr, CATCH_EXCEPTION_RANGE);
- OP4( BEGIN_CATCH4, catchRange);
+ OP4( BEGIN_CATCH, catchRange);
ExceptionRangeStarts(envPtr, catchRange);
switch (tokenPtr->type) {
@@ -899,6 +891,9 @@ TclSubstCompile(
/* ERROR -> reraise it */
OP( RETURN_STK);
OP( NOP);
+ OP( NOP);
+ OP( NOP);
+ OP( NOP);
/* RETURN */
TclEmitForwardJump(envPtr, TCL_UNCONDITIONAL_JUMP, &returnFixup);
@@ -921,11 +916,7 @@ TclSubstCompile(
OP( POP);
breakJump = CurrentOffset(envPtr) - breakOffset;
- if (breakJump > 127) {
- OP4(JUMP4, -breakJump);
- } else {
- OP1(JUMP1, -breakJump);
- }
+ OP4( JUMP, -breakJump);
/* CONTINUE destination */
if (TclFixupForwardJumpToHere(envPtr, &continueFixup, 127)) {
@@ -970,7 +961,7 @@ TclSubstCompile(
(int) (CurrentOffset(envPtr) - okFixup.codeOffset));
}
if (count > 1) {
- OP1(CONCAT1, count);
+ OP1(CONCAT, count);
count = 1;
}
@@ -983,11 +974,11 @@ TclSubstCompile(
}
while (count > 255) {
- OP1( CONCAT1, 255);
+ OP1( CONCAT, 255);
count -= 254;
}
if (count > 1) {
- OP1( CONCAT1, count);
+ OP1( CONCAT, count);
}
Tcl_FreeParse(&parse);
@@ -1000,7 +991,7 @@ TclSubstCompile(
/* Final target of the multi-jump from all BREAKs */
if (breakOffset > 0) {
- TclUpdateInstInt4AtPc(INST_JUMP4, CurrentOffset(envPtr) - breakOffset,
+ TclUpdateInstInt4AtPc(INST_JUMP, CurrentOffset(envPtr) - breakOffset,
envPtr->codeStart + breakOffset);
}
}
@@ -1682,7 +1673,7 @@ IssueSwitchJumpTable(
jumpLocation = CurrentOffset(envPtr);
OP4( JUMP_TABLE, infoIndex);
jumpToDefault = CurrentOffset(envPtr);
- OP4( JUMP4, 0);
+ OP4( JUMP, 0);
for (i=0 ; i<numBodyTokens ; i+=2) {
/*
@@ -1774,7 +1765,7 @@ IssueSwitchJumpTable(
* rewriting when we fixed this all up.
*/
- OP4( JUMP4, 0);
+ OP4( JUMP, 0);
}
}
@@ -2029,7 +2020,7 @@ TclCompileThrowCmd(
OP4( REVERSE, 3);
OP( DUP);
OP( LIST_LENGTH);
- OP1( JUMP_FALSE1, 16);
+ OP4( JUMP_FALSE, 19);
OP4( LIST, 2);
OP44( RETURN_IMM, 1, 0);
@@ -2330,21 +2321,21 @@ IssueTryInstructions(
*/
range = DeclareExceptionRange(envPtr, CATCH_EXCEPTION_RANGE);
- OP4( BEGIN_CATCH4, range);
+ OP4( BEGIN_CATCH, range);
ExceptionRangeStarts(envPtr, range);
BODY( bodyToken, 1);
ExceptionRangeEnds(envPtr, range);
PUSH( "0");
OP4( REVERSE, 2);
- OP1( JUMP1, 4);
+ OP4( JUMP, 7);
ExceptionRangeTarget(envPtr, range, catchOffset);
OP( PUSH_RETURN_CODE);
OP( PUSH_RESULT);
OP( PUSH_RETURN_OPTIONS);
OP( END_CATCH);
- STORE( optionsVar);
+ OP4( STORE_SCALAR, optionsVar);
OP( POP);
- STORE( resultVar);
+ OP4( STORE_SCALAR, resultVar);
OP( POP);
/*
@@ -2362,7 +2353,7 @@ IssueTryInstructions(
OP( DUP);
PUSH( buf);
OP( EQ);
- JUMP(notCodeJumpSource, JUMP_FALSE4);
+ JUMP(notCodeJumpSource, JUMP_FALSE);
if (matchClauses[i]) {
Tcl_ListObjLength(NULL, matchClauses[i], &len);
@@ -2370,14 +2361,15 @@ IssueTryInstructions(
* Match the errorcode according to try/trap rules.
*/
- LOAD( optionsVar);
+
+ OP4( LOAD_SCALAR, optionsVar);
PUSH( "-errorcode");
OP4( DICT_GET, 1);
TclAdjustStackDepth(-1, envPtr);
OP44( LIST_RANGE_IMM, 0, len-1);
PUSH( TclGetString(matchClauses[i]));
OP( STR_EQ);
- JUMP(notECJumpSource, JUMP_FALSE4);
+ JUMP(notECJumpSource, JUMP_FALSE);
} else {
notECJumpSource = -1; /* LINT */
}
@@ -2390,18 +2382,18 @@ IssueTryInstructions(
*/
if (resultVars[i] >= 0) {
- LOAD( resultVar);
- STORE( resultVars[i]);
+ OP4( LOAD_SCALAR, resultVar);
+ OP4( STORE_SCALAR, resultVars[i]);
OP( POP);
if (optionVars[i] >= 0) {
- LOAD( optionsVar);
- STORE( optionVars[i]);
+ OP4( LOAD_SCALAR, optionsVar);
+ OP4( STORE_SCALAR, optionVars[i]);
OP( POP);
}
}
if (!handlerTokens[i]) {
forwardsNeedFixing = 1;
- JUMP(forwardsToFix[i], JUMP4);
+ JUMP(forwardsToFix[i], JUMP);
} else {
forwardsToFix[i] = -1;
if (forwardsNeedFixing) {
@@ -2418,7 +2410,7 @@ IssueTryInstructions(
BODY( handlerTokens[i], 5+i*4);
}
- JUMP(addrsToFix[i], JUMP4);
+ JUMP(addrsToFix[i], JUMP);
if (matchClauses[i]) {
FIXJUMP(notECJumpSource);
}
@@ -2432,8 +2424,8 @@ IssueTryInstructions(
*/
OP( POP);
- LOAD( optionsVar);
- LOAD( resultVar);
+ OP4( LOAD_SCALAR, optionsVar);
+ OP4( LOAD_SCALAR, resultVar);
OP( RETURN_STK);
/*
@@ -2481,22 +2473,22 @@ IssueTryFinallyInstructions(
*/
range = DeclareExceptionRange(envPtr, CATCH_EXCEPTION_RANGE);
- OP4( BEGIN_CATCH4, range);
+ OP4( BEGIN_CATCH, range);
ExceptionRangeStarts(envPtr, range);
envPtr->currStackDepth = savedStackDepth;
BODY( bodyToken, 1);
ExceptionRangeEnds(envPtr, range);
PUSH( "0");
OP4( REVERSE, 2);
- OP1( JUMP1, 4);
+ OP4( JUMP, 7);
ExceptionRangeTarget(envPtr, range, catchOffset);
OP( PUSH_RETURN_CODE);
OP( PUSH_RESULT);
OP( PUSH_RETURN_OPTIONS);
OP( END_CATCH);
- STORE( optionsVar);
+ OP4( STORE_SCALAR, optionsVar);
OP( POP);
- STORE( resultVar);
+ OP4( STORE_SCALAR, resultVar);
OP( POP);
envPtr->currStackDepth = savedStackDepth + 1;
@@ -2517,7 +2509,7 @@ IssueTryFinallyInstructions(
OP( DUP);
PUSH( buf);
OP( EQ);
- JUMP(notCodeJumpSource, JUMP_FALSE4);
+ JUMP(notCodeJumpSource, JUMP_FALSE);
if (matchClauses[i]) {
Tcl_ListObjLength(NULL, matchClauses[i], &len);
@@ -2525,14 +2517,14 @@ IssueTryFinallyInstructions(
* Match the errorcode according to try/trap rules.
*/
- LOAD( optionsVar);
+ OP4( LOAD_SCALAR, optionsVar);
PUSH( "-errorcode");
OP4( DICT_GET, 1);
TclAdjustStackDepth(-1, envPtr);
OP44( LIST_RANGE_IMM, 0, len-1);
PUSH( TclGetString(matchClauses[i]));
OP( STR_EQ);
- JUMP(notECJumpSource, JUMP_FALSE4);
+ JUMP(notECJumpSource, JUMP_FALSE);
} else {
notECJumpSource = -1; /* LINT */
}
@@ -2546,16 +2538,16 @@ IssueTryFinallyInstructions(
if (resultVars[i] >= 0 || handlerTokens[i]) {
range = DeclareExceptionRange(envPtr, CATCH_EXCEPTION_RANGE);
- OP4( BEGIN_CATCH4, range);
+ OP4( BEGIN_CATCH, range);
ExceptionRangeStarts(envPtr, range);
}
if (resultVars[i] >= 0) {
- LOAD( resultVar);
- STORE( resultVars[i]);
+ OP4( LOAD_SCALAR, resultVar);
+ OP4( STORE_SCALAR, resultVars[i]);
OP( POP);
if (optionVars[i] >= 0) {
- LOAD( optionsVar);
- STORE( optionVars[i]);
+ OP4( LOAD_SCALAR, optionsVar);
+ OP4( STORE_SCALAR, optionVars[i]);
OP( POP);
}
@@ -2569,7 +2561,7 @@ IssueTryFinallyInstructions(
ExceptionRangeEnds(envPtr, range);
OP( END_CATCH);
forwardsNeedFixing = 1;
- JUMP(forwardsToFix[i], JUMP4);
+ JUMP(forwardsToFix[i], JUMP);
goto finishTrapCatchHandling;
}
} else if (!handlerTokens[i]) {
@@ -2579,7 +2571,7 @@ IssueTryFinallyInstructions(
*/
forwardsNeedFixing = 1;
- JUMP(forwardsToFix[i], JUMP4);
+ JUMP(forwardsToFix[i], JUMP);
goto endOfThisArm;
}
@@ -2591,7 +2583,7 @@ IssueTryFinallyInstructions(
if (forwardsNeedFixing) {
forwardsNeedFixing = 0;
- OP1( JUMP1, 7);
+ OP4( JUMP, 10);
for (j=0 ; j<i ; j++) {
if (forwardsToFix[j] == -1) {
continue;
@@ -2599,14 +2591,14 @@ IssueTryFinallyInstructions(
FIXJUMP(forwardsToFix[j]);
forwardsToFix[j] = -1;
}
- OP4( BEGIN_CATCH4, range);
+ OP4( BEGIN_CATCH, range);
}
envPtr->currStackDepth = savedStackDepth;
BODY( handlerTokens[i], 5+i*4);
ExceptionRangeEnds(envPtr, range);
OP( PUSH_RETURN_OPTIONS);
OP4( REVERSE, 2);
- OP1( JUMP1, 4);
+ OP4( JUMP, 7);
forwardsToFix[i] = -1;
/*
@@ -2621,14 +2613,14 @@ IssueTryFinallyInstructions(
OP( PUSH_RETURN_OPTIONS);
OP( PUSH_RESULT);
OP( END_CATCH);
- STORE( resultVar);
+ OP4( STORE_SCALAR, resultVar);
OP( POP);
- STORE( optionsVar);
+ OP4( STORE_SCALAR, optionsVar);
OP( POP);
endOfThisArm:
if (i+1 < numHandlers) {
- JUMP(addrsToFix[i], JUMP4);
+ JUMP(addrsToFix[i], JUMP);
}
if (matchClauses[i]) {
FIXJUMP(notECJumpSource);
@@ -2665,8 +2657,8 @@ IssueTryFinallyInstructions(
envPtr->currStackDepth = savedStackDepth;
BODY( finallyToken, 3 + 4*numHandlers);
OP( POP);
- LOAD( optionsVar);
- LOAD( resultVar);
+ OP4( LOAD_SCALAR, optionsVar);
+ OP4( LOAD_SCALAR, resultVar);
OP( RETURN_STK);
envPtr->currStackDepth = savedStackDepth + 1;
@@ -2917,18 +2909,10 @@ TclCompileWhileCmd(
envPtr->currStackDepth = savedStackDepth + 1;
jumpDist = CurrentOffset(envPtr) - bodyCodeOffset;
- if (jumpDist > 127) {
- TclEmitInstInt4(INST_JUMP_TRUE4, -jumpDist, envPtr);
- } else {
- TclEmitInstInt1(INST_JUMP_TRUE1, -jumpDist, envPtr);
- }
+ TclEmitInstInt4(INST_JUMP_TRUE, -jumpDist, envPtr);
} else {
jumpDist = CurrentOffset(envPtr) - bodyCodeOffset;
- if (jumpDist > 127) {
- TclEmitInstInt4(INST_JUMP4, -jumpDist, envPtr);
- } else {
- TclEmitInstInt1(INST_JUMP1, -jumpDist, envPtr);
- }
+ TclEmitInstInt4(INST_JUMP, -jumpDist, envPtr);
}
/*
@@ -3408,14 +3392,14 @@ CompileComparisonOpCmd(
CompileWord(envPtr, tokenPtr, interp, 1);
tokenPtr = TokenAfter(tokenPtr);
CompileWord(envPtr, tokenPtr, interp, 2);
- STORE(tmpIndex);
+ OP4( STORE_SCALAR, tmpIndex);
TclEmitOpcode(instruction, envPtr);
for (words=3 ; words<parsePtr->numWords ;) {
- LOAD(tmpIndex);
+ OP4( LOAD_SCALAR, tmpIndex);
tokenPtr = TokenAfter(tokenPtr);
CompileWord(envPtr, tokenPtr, interp, words);
if (++words < parsePtr->numWords) {
- STORE(tmpIndex);
+ OP4( STORE_SCALAR, tmpIndex);
}
TclEmitOpcode(instruction, envPtr);
}
diff --git a/generic/tclCompExpr.c b/generic/tclCompExpr.c
index 890d518..9638b77 100644
--- a/generic/tclCompExpr.c
+++ b/generic/tclCompExpr.c
@@ -2353,11 +2353,7 @@ CompileExprTree(
* command with the correct number of arguments.
*/
- if (numWords < 255) {
- TclEmitInstInt1(INST_INVOKE_STK1, numWords, envPtr);
- } else {
- TclEmitInstInt4(INST_INVOKE_STK4, numWords, envPtr);
- }
+ TclEmitInstInt4(INST_INVOKE_STK, numWords, envPtr);
/*
* Restore any saved numWords value.
diff --git a/generic/tclCompile.c b/generic/tclCompile.c
index 309682d..9d511ed 100644
--- a/generic/tclCompile.c
+++ b/generic/tclCompile.c
@@ -54,69 +54,57 @@ InstructionDesc const tclInstructionTable[] = {
/* Name Bytes stackEffect #Opnds Operand types */
{"done", 1, -1, 0, {OPERAND_NONE}},
/* Finish ByteCode execution and return stktop (top stack item) */
- {"push1", 2, +1, 1, {OPERAND_UINT1}},
- /* Push object at ByteCode objArray[op1] */
- {"push4", 5, +1, 1, {OPERAND_UINT4}},
+ {"push", 5, +1, 1, {OPERAND_UINT4}},
/* Push object at ByteCode objArray[op4] */
{"pop", 1, -1, 0, {OPERAND_NONE}},
/* Pop the topmost stack object */
{"dup", 1, +1, 0, {OPERAND_NONE}},
/* Duplicate the topmost stack object and push the result */
- {"concat1", 2, INT_MIN, 1, {OPERAND_UINT1}},
+ {"concat", 2, INT_MIN, 1, {OPERAND_UINT1}},
/* Concatenate the top op1 items and push result */
- {"invokeStk1", 2, INT_MIN, 1, {OPERAND_UINT1}},
- /* Invoke command named objv[0]; <objc,objv> = <op1,top op1> */
- {"invokeStk4", 5, INT_MIN, 1, {OPERAND_UINT4}},
+ {"invokeStk", 5, INT_MIN, 1, {OPERAND_UINT4}},
/* Invoke command named objv[0]; <objc,objv> = <op4,top op4> */
{"evalStk", 1, 0, 0, {OPERAND_NONE}},
/* Evaluate command in stktop using Tcl_EvalObj. */
{"exprStk", 1, 0, 0, {OPERAND_NONE}},
/* Execute expression in stktop using Tcl_ExprStringObj. */
- {"loadScalar1", 2, 1, 1, {OPERAND_LVT1}},
- /* Load scalar variable at index op1 <= 255 in call frame */
- {"loadScalar4", 5, 1, 1, {OPERAND_LVT4}},
- /* Load scalar variable at index op1 >= 256 in call frame */
+ {"loadScalar", 5, 1, 1, {OPERAND_LVT4}},
+ /* Load scalar variable at index op1 in call frame */
{"loadScalarStk", 1, 0, 0, {OPERAND_NONE}},
/* Load scalar variable; scalar's name is stktop */
- {"loadArray1", 2, 0, 1, {OPERAND_LVT1}},
- /* Load array element; array at slot op1<=255, element is stktop */
- {"loadArray4", 5, 0, 1, {OPERAND_LVT4}},
+ {"loadArray", 5, 0, 1, {OPERAND_LVT4}},
/* Load array element; array at slot op1 > 255, element is stktop */
{"loadArrayStk", 1, -1, 0, {OPERAND_NONE}},
/* Load array element; element is stktop, array name is stknext */
{"loadStk", 1, 0, 0, {OPERAND_NONE}},
/* Load general variable; unparsed variable name is stktop */
- {"storeScalar1", 2, 0, 1, {OPERAND_LVT1}},
- /* Store scalar variable at op1<=255 in frame; value is stktop */
- {"storeScalar4", 5, 0, 1, {OPERAND_LVT4}},
- /* Store scalar variable at op1 > 255 in frame; value is stktop */
+ {"storeScalar", 5, 0, 1, {OPERAND_LVT4}},
+ /* Store scalar variable at op1 in frame; value is stktop */
{"storeScalarStk", 1, -1, 0, {OPERAND_NONE}},
/* Store scalar; value is stktop, scalar name is stknext */
- {"storeArray1", 2, -1, 1, {OPERAND_LVT1}},
- /* Store array element; array at op1<=255, value is top then elem */
- {"storeArray4", 5, -1, 1, {OPERAND_LVT4}},
+ {"storeArray", 5, -1, 1, {OPERAND_LVT4}},
/* Store array element; array at op1>=256, value is top then elem */
{"storeArrayStk", 1, -2, 0, {OPERAND_NONE}},
/* Store array element; value is stktop, then elem, array names */
{"storeStk", 1, -1, 0, {OPERAND_NONE}},
/* Store general variable; value is stktop, then unparsed name */
- {"incrScalar1", 2, 0, 1, {OPERAND_LVT1}},
- /* Incr scalar at index op1<=255 in frame; incr amount is stktop */
+ {"incrScalar", 5, 0, 1, {OPERAND_LVT4}},
+ /* Incr scalar at index op1 in frame; incr amount is stktop */
{"incrScalarStk", 1, -1, 0, {OPERAND_NONE}},
/* Incr scalar; incr amount is stktop, scalar's name is stknext */
- {"incrArray1", 2, -1, 1, {OPERAND_LVT1}},
- /* Incr array elem; arr at slot op1<=255, amount is top then elem */
+ {"incrArray", 5, -1, 1, {OPERAND_LVT4}},
+ /* Incr array elem; arr at slot op1, amount is top then elem */
{"incrArrayStk", 1, -2, 0, {OPERAND_NONE}},
/* Incr array element; amount is top then elem then array names */
{"incrStk", 1, -1, 0, {OPERAND_NONE}},
/* Incr general variable; amount is stktop then unparsed var name */
- {"incrScalar1Imm", 3, +1, 2, {OPERAND_LVT1, OPERAND_INT1}},
+ {"incrScalarImm", 6, +1, 2, {OPERAND_LVT4, OPERAND_INT1}},
/* Incr scalar at slot op1 <= 255; amount is 2nd operand byte */
{"incrScalarStkImm", 2, 0, 1, {OPERAND_INT1}},
/* Incr scalar; scalar name is stktop; incr amount is op1 */
- {"incrArray1Imm", 3, 0, 2, {OPERAND_LVT1, OPERAND_INT1}},
+ {"incrArrayImm", 6, 0, 2, {OPERAND_LVT4, OPERAND_INT1}},
/* Incr array elem; array at slot op1 <= 255, elem is stktop,
* amount is 2nd operand byte */
{"incrArrayStkImm", 2, -1, 1, {OPERAND_INT1}},
@@ -124,17 +112,11 @@ InstructionDesc const tclInstructionTable[] = {
{"incrStkImm", 2, 0, 1, {OPERAND_INT1}},
/* Incr general variable; unparsed name is top, amount is op1 */
- {"jump1", 2, 0, 1, {OPERAND_INT1}},
- /* Jump relative to (pc + op1) */
- {"jump4", 5, 0, 1, {OPERAND_INT4}},
+ {"jump", 5, 0, 1, {OPERAND_INT4}},
/* Jump relative to (pc + op4) */
- {"jumpTrue1", 2, -1, 1, {OPERAND_INT1}},
- /* Jump relative to (pc + op1) if stktop expr object is true */
- {"jumpTrue4", 5, -1, 1, {OPERAND_INT4}},
+ {"jumpTrue", 5, -1, 1, {OPERAND_INT4}},
/* Jump relative to (pc + op4) if stktop expr object is true */
- {"jumpFalse1", 2, -1, 1, {OPERAND_INT1}},
- /* Jump relative to (pc + op1) if stktop expr object is false */
- {"jumpFalse4", 5, -1, 1, {OPERAND_INT4}},
+ {"jumpFalse", 5, -1, 1, {OPERAND_INT4}},
/* Jump relative to (pc + op4) if stktop expr object is false */
{"lor", 1, -1, 0, {OPERAND_NONE}},
@@ -181,27 +163,32 @@ InstructionDesc const tclInstructionTable[] = {
/* Bitwise not: push ~stktop */
{"not", 1, 0, 0, {OPERAND_NONE}},
/* Logical not: push !stktop */
- {"callBuiltinFunc1", 2, 1, 1, {OPERAND_UINT1}},
+ {"callBuiltinFunc", 2, 1, 1, {OPERAND_UINT1}},
/* Call builtin math function with index op1; any args are on stk */
- {"callFunc1", 2, INT_MIN, 1, {OPERAND_UINT1}},
+ {"callFunc", 2, INT_MIN, 1, {OPERAND_UINT1}},
/* Call non-builtin func objv[0]; <objc,objv>=<op1,top op1> */
{"tryCvtToNumeric", 1, 0, 0, {OPERAND_NONE}},
/* Try converting stktop to first int then double if possible. */
+ {"expon", 1, -1, 0, {OPERAND_NONE}},
+ /* Binary exponentiation operator: push (stknext ** stktop) */
+ {"listIn", 1, -1, 0, {OPERAND_NONE}},
+ /* List containment: push [lsearch stktop stknext]>=0) */
+ {"listNotIn", 1, -1, 0, {OPERAND_NONE}},
+ /* List negated containment: push [lsearch stktop stknext]<0) */
- {"break", 1, 0, 0, {OPERAND_NONE}},
- /* Abort closest enclosing loop; if none, return TCL_BREAK code. */
- {"continue", 1, 0, 0, {OPERAND_NONE}},
- /* Skip to next iteration of closest enclosing loop; if none, return
- * TCL_CONTINUE code. */
-
- {"foreach_start4", 5, 0, 1, {OPERAND_AUX4}},
+ {"foreach_start", 5, 0, 1, {OPERAND_AUX4}},
/* Initialize execution of a foreach loop. Operand is aux data index
* of the ForeachInfo structure for the foreach command. */
- {"foreach_step4", 5, +1, 1, {OPERAND_AUX4}},
+ {"foreach_step", 5, +1, 1, {OPERAND_AUX4}},
/* "Step" or begin next iteration of foreach loop. Push 0 if to
* terminate loop, else push 1. */
- {"beginCatch4", 5, 0, 1, {OPERAND_UINT4}},
+ {"break", 1, 0, 0, {OPERAND_NONE}},
+ /* Abort closest enclosing loop; if none, return TCL_BREAK code. */
+ {"continue", 1, 0, 0, {OPERAND_NONE}},
+ /* Skip to next iteration of closest enclosing loop; if none, return
+ * TCL_CONTINUE code. */
+ {"beginCatch", 5, 0, 1, {OPERAND_UINT4}},
/* Record start of catch with the operand's exception index. Push the
* current stack depth onto a special catch stack. */
{"endCatch", 1, 0, 0, {OPERAND_NONE}},
@@ -211,6 +198,19 @@ InstructionDesc const tclInstructionTable[] = {
{"pushReturnCode", 1, +1, 0, {OPERAND_NONE}},
/* Push interpreter's return code (e.g. TCL_OK or TCL_ERROR) as a new
* object onto the stack. */
+ {"pushReturnOpts", 1, +1, 0, {OPERAND_NONE}},
+ /* Push the interpreter's return option dictionary as an object on the
+ * stack. */
+ {"returnStk", 1, -2, 0, {OPERAND_NONE}},
+ /* Compiled [return]; options and result are on the stack, code and
+ * level are in the options. */
+ {"returnImm", 9, -1, 2, {OPERAND_INT4, OPERAND_UINT4}},
+ /* Compiled [return], code, level are operands; options and result
+ * are on the stack. */
+ {"returnCodeBranch", 1, -1, 0, {OPERAND_NONE}},
+ /* Jump to next instruction based on the return code on top of stack
+ * ERROR: +1; RETURN: +6; BREAK: +11; CONTINUE: +16;
+ * Other non-OK: +21 */
{"streq", 1, -1, 0, {OPERAND_NONE}},
/* Str Equal: push (stknext eq stktop) */
@@ -232,25 +232,18 @@ InstructionDesc const tclInstructionTable[] = {
{"listLength", 1, 0, 0, {OPERAND_NONE}},
/* List Len: push (listlength stktop) */
- {"appendScalar1", 2, 0, 1, {OPERAND_LVT1}},
- /* Append scalar variable at op1<=255 in frame; value is stktop */
- {"appendScalar4", 5, 0, 1, {OPERAND_LVT4}},
+ {"appendScalar", 5, 0, 1, {OPERAND_LVT4}},
/* Append scalar variable at op1 > 255 in frame; value is stktop */
- {"appendArray1", 2, -1, 1, {OPERAND_LVT1}},
- /* Append array element; array at op1<=255, value is top then elem */
- {"appendArray4", 5, -1, 1, {OPERAND_LVT4}},
+ {"appendArray", 5, -1, 1, {OPERAND_LVT4}},
/* Append array element; array at op1>=256, value is top then elem */
{"appendArrayStk", 1, -2, 0, {OPERAND_NONE}},
/* Append array element; value is stktop, then elem, array names */
{"appendStk", 1, -1, 0, {OPERAND_NONE}},
/* Append general variable; value is stktop, then unparsed name */
- {"lappendScalar1", 2, 0, 1, {OPERAND_LVT1}},
- /* Lappend scalar variable at op1<=255 in frame; value is stktop */
- {"lappendScalar4", 5, 0, 1, {OPERAND_LVT4}},
+
+ {"lappendScalar", 5, 0, 1, {OPERAND_LVT4}},
/* Lappend scalar variable at op1 > 255 in frame; value is stktop */
- {"lappendArray1", 2, -1, 1, {OPERAND_LVT1}},
- /* Lappend array element; array at op1<=255, value is top then elem */
- {"lappendArray4", 5, -1, 1, {OPERAND_LVT4}},
+ {"lappendArray", 5, -1, 1, {OPERAND_LVT4}},
/* Lappend array element; array at op1>=256, value is top then elem */
{"lappendArrayStk", 1, -2, 0, {OPERAND_NONE}},
/* Lappend array element; value is stktop, then elem, array names */
@@ -261,8 +254,7 @@ InstructionDesc const tclInstructionTable[] = {
/* Lindex with generalized args, operand is number of stacked objs
* used: (operand-1) entries from stktop are the indices; then list to
* process. */
- {"over", 5, +1, 1, {OPERAND_UINT4}},
- /* Duplicate the arg-th element from top of stack (TOS=0) */
+
{"lsetList", 1, -2, 0, {OPERAND_NONE}},
/* Four-arg version of 'lset'. stktop is old value; next is new
* element value, next is the index list; pushes new value */
@@ -272,12 +264,6 @@ InstructionDesc const tclInstructionTable[] = {
* (operand-2) indices; pushes the new value.
*/
- {"returnImm", 9, -1, 2, {OPERAND_INT4, OPERAND_UINT4}},
- /* Compiled [return], code, level are operands; options and result
- * are on the stack. */
- {"expon", 1, -1, 0, {OPERAND_NONE}},
- /* Binary exponentiation operator: push (stknext ** stktop) */
-
/*
* NOTE: the stack effects of expandStkTop and invokeExpanded are wrong -
* but it cannot be done right at compile time, the stack effect is only
@@ -297,22 +283,11 @@ InstructionDesc const tclInstructionTable[] = {
/* List Index: push (lindex stktop op4) */
{"listRangeImm", 9, 0, 2, {OPERAND_IDX4, OPERAND_IDX4}},
/* List Range: push (lrange stktop op4 op4) */
+
{"startCommand", 9, 0, 2, {OPERAND_INT4,OPERAND_UINT4}},
/* Start of bytecoded command: op is the length of the cmd's code, op2
* is number of commands here */
- {"listIn", 1, -1, 0, {OPERAND_NONE}},
- /* List containment: push [lsearch stktop stknext]>=0) */
- {"listNotIn", 1, -1, 0, {OPERAND_NONE}},
- /* List negated containment: push [lsearch stktop stknext]<0) */
-
- {"pushReturnOpts", 1, +1, 0, {OPERAND_NONE}},
- /* Push the interpreter's return option dictionary as an object on the
- * stack. */
- {"returnStk", 1, -2, 0, {OPERAND_NONE}},
- /* Compiled [return]; options and result are on the stack, code and
- * level are in the options. */
-
{"dictGet", 5, INT_MIN, 1, {OPERAND_UINT4}},
/* The top op4 words (min 1) are a key path into the dictionary just
* below the keys on the stack, and all those values are replaced by
@@ -365,6 +340,30 @@ InstructionDesc const tclInstructionTable[] = {
* argument. The list of keys (popped from the stack) must be the same
* length as the list of variables.
* Stack: ... keyList => ... */
+ {"dictExpand", 1, -1, 0, {OPERAND_NONE}},
+ /* Probe into a dict and extract it (or a subdict of it) into
+ * variables with matched names. Produces list of keys bound as
+ * result. Part of [dict with].
+ * Stack: ... dict path => ... keyList */
+ {"dictRecombineStk", 1, -3, 0, {OPERAND_NONE}},
+ /* Map variable contents back into a dictionary in a variable. Part of
+ * [dict with].
+ * Stack: ... dictVarName path keyList => ... */
+ {"dictRecombineImm", 1, -2, 1, {OPERAND_LVT4}},
+ /* Map variable contents back into a dictionary in the local variable
+ * indicated by the LVT index. Part of [dict with].
+ * Stack: ... path keyList => ... */
+ {"dictExists", 5, INT_MIN, 1, {OPERAND_UINT4}},
+ /* The top op4 words (min 1) are a key path into the dictionary just
+ * below the keys on the stack, and all those values are replaced by a
+ * boolean indicating whether it is possible to read out a value from
+ * that key-path (like [dict exists]).
+ * Stack: ... dict key1 ... keyN => ... boolean */
+ {"verifyDict", 1, -1, 0, {OPERAND_NONE}},
+ /* Verifies that the word on the top of the stack is a dictionary,
+ * popping it if it is and throwing an error if it is not.
+ * Stack: ... value => ... */
+
{"jumpTable", 5, -1, 1, {OPERAND_AUX4}},
/* Jump according to the jump-table (in AuxData as indicated by the
* operand) and the argument popped from the list. Always executes the
@@ -372,6 +371,7 @@ InstructionDesc const tclInstructionTable[] = {
* Stack: ... value => ...
* Note that the jump table contains offsets relative to the PC when
* it points to this instruction; the code is relocatable. */
+
{"upvar", 5, -1, 1, {OPERAND_LVT4}},
/* finds level and otherName in stack, links to local variable at
* index op1. Leaves the level on stack. */
@@ -381,10 +381,15 @@ InstructionDesc const tclInstructionTable[] = {
{"variable", 5, -1, 1, {OPERAND_LVT4}},
/* finds namespace and otherName in stack, links to local variable at
* index op1. Leaves the namespace on stack. */
+
+ {"over", 5, +1, 1, {OPERAND_UINT4}},
+ /* Duplicate the arg-th element from top of stack (TOS=0) */
{"syntax", 9, -1, 2, {OPERAND_INT4, OPERAND_UINT4}},
/* Compiled bytecodes to signal syntax error. */
{"reverse", 5, 0, 1, {OPERAND_UINT4}},
/* Reverse the order of the arg elements at the top of stack */
+ {"nop", 1, 0, 0, {OPERAND_NONE}},
+ /* Do nothing */
{"regexp", 2, -1, 1, {OPERAND_INT1}},
/* Regexp: push (regexp stknext stktop) opnd == nocase */
@@ -400,13 +405,6 @@ InstructionDesc const tclInstructionTable[] = {
{"existStk", 1, 0, 0, {OPERAND_NONE}},
/* Test if general variable exists; unparsed variable name is stktop*/
- {"nop", 1, 0, 0, {OPERAND_NONE}},
- /* Do nothing */
- {"returnCodeBranch", 1, -1, 0, {OPERAND_NONE}},
- /* Jump to next instruction based on the return code on top of stack
- * ERROR: +1; RETURN: +3; BREAK: +5; CONTINUE: +7;
- * Other non-OK: +9
- */
{"unsetScalar", 6, 0, 2, {OPERAND_UINT1, OPERAND_LVT4}},
/* Make scalar variable at index op2 in call frame cease to exist;
@@ -421,30 +419,6 @@ InstructionDesc const tclInstructionTable[] = {
/* Make general variable cease to exist; unparsed variable name is
* stktop; op1 is 1 for errors on problems, 0 otherwise */
- {"dictExpand", 1, -1, 0, {OPERAND_NONE}},
- /* Probe into a dict and extract it (or a subdict of it) into
- * variables with matched names. Produces list of keys bound as
- * result. Part of [dict with].
- * Stack: ... dict path => ... keyList */
- {"dictRecombineStk", 1, -3, 0, {OPERAND_NONE}},
- /* Map variable contents back into a dictionary in a variable. Part of
- * [dict with].
- * Stack: ... dictVarName path keyList => ... */
- {"dictRecombineImm", 1, -2, 1, {OPERAND_LVT4}},
- /* Map variable contents back into a dictionary in the local variable
- * indicated by the LVT index. Part of [dict with].
- * Stack: ... path keyList => ... */
- {"dictExists", 5, INT_MIN, 1, {OPERAND_UINT4}},
- /* The top op4 words (min 1) are a key path into the dictionary just
- * below the keys on the stack, and all those values are replaced by a
- * boolean indicating whether it is possible to read out a value from
- * that key-path (like [dict exists]).
- * Stack: ... dict key1 ... keyN => ... boolean */
- {"verifyDict", 1, -1, 0, {OPERAND_NONE}},
- /* Verifies that the word on the top of the stack is a dictionary,
- * popping it if it is and throwing an error if it is not.
- * Stack: ... value => ... */
-
{"strmap", 1, -2, 0, {OPERAND_NONE}},
/* Simplified version of [string map] that only applies one change
* string, and only case-sensitively.
@@ -1948,11 +1922,7 @@ TclCompileScript(
&isnew);
Tcl_SetHashValue(hePtr, INT2PTR(wlineat));
- if (wordIdx <= 255) {
- TclEmitInstInt1(INST_INVOKE_STK1, wordIdx, envPtr);
- } else {
- TclEmitInstInt4(INST_INVOKE_STK4, wordIdx, envPtr);
- }
+ TclEmitInstInt4(INST_INVOKE_STK, wordIdx, envPtr);
}
/*
@@ -2089,19 +2059,15 @@ TclCompileVarSubst(
if (tokenPtr->numComponents == 1) {
if (localVar < 0) {
TclEmitOpcode(INST_LOAD_SCALAR_STK, envPtr);
- } else if (localVar <= 255) {
- TclEmitInstInt1(INST_LOAD_SCALAR1, localVar, envPtr);
} else {
- TclEmitInstInt4(INST_LOAD_SCALAR4, localVar, envPtr);
+ TclEmitInstInt4(INST_LOAD_SCALAR, localVar, envPtr);
}
} else {
TclCompileTokens(interp, tokenPtr+2, tokenPtr->numComponents-1, envPtr);
if (localVar < 0) {
TclEmitOpcode(INST_LOAD_ARRAY_STK, envPtr);
- } else if (localVar <= 255) {
- TclEmitInstInt1(INST_LOAD_ARRAY1, localVar, envPtr);
} else {
- TclEmitInstInt4(INST_LOAD_ARRAY4, localVar, envPtr);
+ TclEmitInstInt4(INST_LOAD_ARRAY, localVar, envPtr);
}
}
}
@@ -2273,11 +2239,11 @@ TclCompileTokens(
*/
while (numObjsToConcat > 255) {
- TclEmitInstInt1(INST_CONCAT1, 255, envPtr);
+ TclEmitInstInt1(INST_CONCAT, 255, envPtr);
numObjsToConcat -= 254; /* concat pushes 1 obj, the result */
}
if (numObjsToConcat > 1) {
- TclEmitInstInt1(INST_CONCAT1, numObjsToConcat, envPtr);
+ TclEmitInstInt1(INST_CONCAT, numObjsToConcat, envPtr);
}
/*
@@ -2408,11 +2374,11 @@ TclCompileExprWords(
}
concatItems = 2*numWords - 1;
while (concatItems > 255) {
- TclEmitInstInt1(INST_CONCAT1, 255, envPtr);
+ TclEmitInstInt1(INST_CONCAT, 255, envPtr);
concatItems -= 254;
}
if (concatItems > 1) {
- TclEmitInstInt1(INST_CONCAT1, concatItems, envPtr);
+ TclEmitInstInt1(INST_CONCAT, concatItems, envPtr);
}
TclEmitOpcode(INST_EXPR_STK, envPtr);
}
@@ -3333,13 +3299,13 @@ TclEmitForwardJump(
switch (jumpType) {
case TCL_UNCONDITIONAL_JUMP:
- TclEmitInstInt1(INST_JUMP1, 0, envPtr);
+ TclEmitInstInt4(INST_JUMP, 0, envPtr);
break;
case TCL_TRUE_JUMP:
- TclEmitInstInt1(INST_JUMP_TRUE1, 0, envPtr);
+ TclEmitInstInt4(INST_JUMP_TRUE, 0, envPtr);
break;
default:
- TclEmitInstInt1(INST_JUMP_FALSE1, 0, envPtr);
+ TclEmitInstInt4(INST_JUMP_FALSE, 0, envPtr);
break;
}
}
@@ -3377,157 +3343,23 @@ TclFixupForwardJump(
JumpFixup *jumpFixupPtr, /* Points to the JumpFixup structure that
* describes the forward jump. */
int jumpDist, /* Jump distance to set in jump instr. */
- int distThreshold) /* Maximum distance before the two byte jump
+ int ignored) /* Maximum distance before the two byte jump
* is grown to five bytes. */
{
- unsigned char *jumpPc, *p;
- int firstCmd, lastCmd, firstRange, lastRange, k;
- unsigned numBytes;
-
- if (jumpDist <= distThreshold) {
- jumpPc = envPtr->codeStart + jumpFixupPtr->codeOffset;
- switch (jumpFixupPtr->jumpType) {
- case TCL_UNCONDITIONAL_JUMP:
- TclUpdateInstInt1AtPc(INST_JUMP1, jumpDist, jumpPc);
- break;
- case TCL_TRUE_JUMP:
- TclUpdateInstInt1AtPc(INST_JUMP_TRUE1, jumpDist, jumpPc);
- break;
- default:
- TclUpdateInstInt1AtPc(INST_JUMP_FALSE1, jumpDist, jumpPc);
- break;
- }
- return 0;
- }
+ unsigned char *jumpPc = envPtr->codeStart + jumpFixupPtr->codeOffset;
- /*
- * We must grow the jump then move subsequent instructions down. Note that
- * if we expand the space for generated instructions, code addresses might
- * change; be careful about updating any of these addresses held in
- * variables.
- */
-
- if ((envPtr->codeNext + 3) > envPtr->codeEnd) {
- TclExpandCodeArray(envPtr);
- }
- jumpPc = envPtr->codeStart + jumpFixupPtr->codeOffset;
- numBytes = envPtr->codeNext-jumpPc-2;
- p = jumpPc+2;
- memmove(p+3, p, numBytes);
-
- envPtr->codeNext += 3;
- jumpDist += 3;
switch (jumpFixupPtr->jumpType) {
case TCL_UNCONDITIONAL_JUMP:
- TclUpdateInstInt4AtPc(INST_JUMP4, jumpDist, jumpPc);
+ TclUpdateInstInt4AtPc(INST_JUMP, jumpDist, jumpPc);
break;
case TCL_TRUE_JUMP:
- TclUpdateInstInt4AtPc(INST_JUMP_TRUE4, jumpDist, jumpPc);
+ TclUpdateInstInt4AtPc(INST_JUMP_TRUE, jumpDist, jumpPc);
break;
default:
- TclUpdateInstInt4AtPc(INST_JUMP_FALSE4, jumpDist, jumpPc);
+ TclUpdateInstInt4AtPc(INST_JUMP_FALSE, jumpDist, jumpPc);
break;
}
-
- /*
- * Adjust the code offsets for any commands and any ExceptionRange records
- * between the jump and the current code address.
- */
-
- firstCmd = jumpFixupPtr->cmdIndex;
- lastCmd = envPtr->numCommands - 1;
- if (firstCmd < lastCmd) {
- for (k = firstCmd; k <= lastCmd; k++) {
- envPtr->cmdMapPtr[k].codeOffset += 3;
- }
- }
-
- firstRange = jumpFixupPtr->exceptIndex;
- lastRange = envPtr->exceptArrayNext - 1;
- for (k = firstRange; k <= lastRange; k++) {
- ExceptionRange *rangePtr = &envPtr->exceptArrayPtr[k];
-
- rangePtr->codeOffset += 3;
- switch (rangePtr->type) {
- case LOOP_EXCEPTION_RANGE:
- rangePtr->breakOffset += 3;
- if (rangePtr->continueOffset != -1) {
- rangePtr->continueOffset += 3;
- }
- break;
- case CATCH_EXCEPTION_RANGE:
- rangePtr->catchOffset += 3;
- break;
- default:
- Tcl_Panic("TclFixupForwardJump: bad ExceptionRange type %d",
- rangePtr->type);
- }
- }
-
- /*
- * TIP #280: Adjust the mapping from PC values to the per-command
- * information about arguments and their line numbers.
- *
- * Note: We cannot simply remove an out-of-date entry and then reinsert
- * with the proper PC, because then we might overwrite another entry which
- * was at that location. Therefore we pull (copy + delete) all effected
- * entries (beyond the fixed PC) into an array, update them there, and at
- * last reinsert them all.
- */
-
- {
- ExtCmdLoc* eclPtr = envPtr->extCmdMapPtr;
-
- /* A helper structure */
-
- typedef struct {
- int pc;
- int cmd;
- } MAP;
-
- /*
- * And the helper array. At most the whole hashtable is placed into
- * this.
- */
-
- MAP *map = (MAP*) ckalloc (sizeof(MAP) * eclPtr->litInfo.numEntries);
-
- Tcl_HashSearch hSearch;
- Tcl_HashEntry* hPtr;
- int n, k, isnew;
-
- /*
- * Phase I: Locate the affected entries, and save them in adjusted
- * form to the array. This removes them from the hash.
- */
-
- for (n = 0, hPtr = Tcl_FirstHashEntry(&eclPtr->litInfo, &hSearch);
- hPtr != NULL;
- hPtr = Tcl_NextHashEntry(&hSearch)) {
-
- map [n].cmd = PTR2INT(Tcl_GetHashValue(hPtr));
- map [n].pc = PTR2INT(Tcl_GetHashKey (&eclPtr->litInfo,hPtr));
-
- if (map[n].pc >= (jumpFixupPtr->codeOffset + 2)) {
- Tcl_DeleteHashEntry(hPtr);
- map [n].pc += 3;
- n++;
- }
- }
-
- /*
- * Phase II: Re-insert the modified entries into the hash.
- */
-
- for (k=0;k<n;k++) {
- hPtr = Tcl_CreateHashEntry(&eclPtr->litInfo, INT2PTR(map[k].pc), &isnew);
- Tcl_SetHashValue(hPtr, INT2PTR(map[k].cmd));
- }
-
- ckfree (map);
- }
-
- return 1; /* the jump was grown */
+ return 0;
}
/*
@@ -4354,16 +4186,12 @@ FormatInstruction(
switch (instDesc->opTypes[i]) {
case OPERAND_INT1:
opnd = TclGetInt1AtPtr(pc+numBytes); numBytes++;
- if (opCode == INST_JUMP1 || opCode == INST_JUMP_TRUE1
- || opCode == INST_JUMP_FALSE1) {
- sprintf(suffixBuffer, "pc %u", pcOffset+opnd);
- }
Tcl_AppendPrintfToObj(bufferObj, "%+d ", opnd);
break;
case OPERAND_INT4:
opnd = TclGetInt4AtPtr(pc+numBytes); numBytes += 4;
- if (opCode == INST_JUMP4 || opCode == INST_JUMP_TRUE4
- || opCode == INST_JUMP_FALSE4) {
+ if (opCode == INST_JUMP || opCode == INST_JUMP_TRUE
+ || opCode == INST_JUMP_FALSE) {
sprintf(suffixBuffer, "pc %u", pcOffset+opnd);
} else if (opCode == INST_START_CMD) {
sprintf(suffixBuffer, "next cmd at pc %u", pcOffset+opnd);
@@ -4372,15 +4200,12 @@ FormatInstruction(
break;
case OPERAND_UINT1:
opnd = TclGetUInt1AtPtr(pc+numBytes); numBytes++;
- if (opCode == INST_PUSH1) {
- suffixObj = codePtr->objArrayPtr[opnd];
- }
Tcl_AppendPrintfToObj(bufferObj, "%u ", (unsigned) opnd);
break;
case OPERAND_AUX4:
case OPERAND_UINT4:
opnd = TclGetUInt4AtPtr(pc+numBytes); numBytes += 4;
- if (opCode == INST_PUSH4) {
+ if (opCode == INST_PUSH) {
suffixObj = codePtr->objArrayPtr[opnd];
} else if (opCode == INST_START_CMD && opnd != 1) {
sprintf(suffixBuffer+strlen(suffixBuffer),
@@ -4401,14 +4226,9 @@ FormatInstruction(
Tcl_AppendPrintfToObj(bufferObj, "end-%d ", -2-opnd);
}
break;
- case OPERAND_LVT1:
- opnd = TclGetUInt1AtPtr(pc+numBytes);
- numBytes++;
- goto printLVTindex;
case OPERAND_LVT4:
opnd = TclGetUInt4AtPtr(pc+numBytes);
numBytes += 4;
- printLVTindex:
if (localPtr != NULL) {
if (opnd >= localCt) {
Tcl_Panic("FormatInstruction: bad local var index %u (%u locals)",
@@ -4525,13 +4345,9 @@ TclGetInnerContext(
objc = 2;
break;
- case INST_INVOKE_STK4:
+ case INST_INVOKE_STK:
objc = TclGetUInt4AtPtr(pc+1);
break;
-
- case INST_INVOKE_STK1:
- objc = TclGetUInt1AtPtr(pc+1);
- break;
}
result = iPtr->innerContext;
diff --git a/generic/tclCompile.h b/generic/tclCompile.h
index 3302f9b..06b398b 100644
--- a/generic/tclCompile.h
+++ b/generic/tclCompile.h
@@ -455,264 +455,223 @@ typedef struct ByteCode {
* tclExecute.c.
*/
-/* Opcodes 0 to 9 */
+/* Opcodes 0 to 7 */
#define INST_DONE 0
-#define INST_PUSH1 1
-#define INST_PUSH4 2
-#define INST_POP 3
-#define INST_DUP 4
-#define INST_CONCAT1 5
-#define INST_INVOKE_STK1 6
-#define INST_INVOKE_STK4 7
-#define INST_EVAL_STK 8
-#define INST_EXPR_STK 9
-
-/* Opcodes 10 to 23 */
-#define INST_LOAD_SCALAR1 10
-#define INST_LOAD_SCALAR4 11
-#define INST_LOAD_SCALAR_STK 12
-#define INST_LOAD_ARRAY1 13
-#define INST_LOAD_ARRAY4 14
-#define INST_LOAD_ARRAY_STK 15
-#define INST_LOAD_STK 16
-#define INST_STORE_SCALAR1 17
-#define INST_STORE_SCALAR4 18
-#define INST_STORE_SCALAR_STK 19
-#define INST_STORE_ARRAY1 20
-#define INST_STORE_ARRAY4 21
-#define INST_STORE_ARRAY_STK 22
-#define INST_STORE_STK 23
-
-/* Opcodes 24 to 33 */
-#define INST_INCR_SCALAR1 24
-#define INST_INCR_SCALAR_STK 25
-#define INST_INCR_ARRAY1 26
-#define INST_INCR_ARRAY_STK 27
-#define INST_INCR_STK 28
-#define INST_INCR_SCALAR1_IMM 29
-#define INST_INCR_SCALAR_STK_IMM 30
-#define INST_INCR_ARRAY1_IMM 31
-#define INST_INCR_ARRAY_STK_IMM 32
-#define INST_INCR_STK_IMM 33
-
-/* Opcodes 34 to 39 */
-#define INST_JUMP1 34
-#define INST_JUMP4 35
-#define INST_JUMP_TRUE1 36
-#define INST_JUMP_TRUE4 37
-#define INST_JUMP_FALSE1 38
-#define INST_JUMP_FALSE4 39
-
-/* Opcodes 40 to 64 */
-#define INST_LOR 40
-#define INST_LAND 41
-#define INST_BITOR 42
-#define INST_BITXOR 43
-#define INST_BITAND 44
-#define INST_EQ 45
-#define INST_NEQ 46
-#define INST_LT 47
-#define INST_GT 48
-#define INST_LE 49
-#define INST_GE 50
-#define INST_LSHIFT 51
-#define INST_RSHIFT 52
-#define INST_ADD 53
-#define INST_SUB 54
-#define INST_MULT 55
-#define INST_DIV 56
-#define INST_MOD 57
-#define INST_UPLUS 58
-#define INST_UMINUS 59
-#define INST_BITNOT 60
-#define INST_LNOT 61
-#define INST_CALL_BUILTIN_FUNC1 62
-#define INST_CALL_FUNC1 63
-#define INST_TRY_CVT_TO_NUMERIC 64
-
-/* Opcodes 65 to 66 */
-#define INST_BREAK 65
-#define INST_CONTINUE 66
-
-/* Opcodes 67 to 68 */
-#define INST_FOREACH_START4 67
-#define INST_FOREACH_STEP4 68
-
-/* Opcodes 69 to 72 */
-#define INST_BEGIN_CATCH4 69
-#define INST_END_CATCH 70
-#define INST_PUSH_RESULT 71
-#define INST_PUSH_RETURN_CODE 72
-
-/* Opcodes 73 to 78 */
-#define INST_STR_EQ 73
-#define INST_STR_NEQ 74
-#define INST_STR_CMP 75
-#define INST_STR_LEN 76
-#define INST_STR_INDEX 77
-#define INST_STR_MATCH 78
-
-/* Opcodes 78 to 81 */
-#define INST_LIST 79
-#define INST_LIST_INDEX 80
-#define INST_LIST_LENGTH 81
-
-/* Opcodes 82 to 87 */
-#define INST_APPEND_SCALAR1 82
-#define INST_APPEND_SCALAR4 83
-#define INST_APPEND_ARRAY1 84
-#define INST_APPEND_ARRAY4 85
-#define INST_APPEND_ARRAY_STK 86
-#define INST_APPEND_STK 87
-
-/* Opcodes 88 to 93 */
-#define INST_LAPPEND_SCALAR1 88
-#define INST_LAPPEND_SCALAR4 89
-#define INST_LAPPEND_ARRAY1 90
-#define INST_LAPPEND_ARRAY4 91
-#define INST_LAPPEND_ARRAY_STK 92
-#define INST_LAPPEND_STK 93
+#define INST_PUSH 1
+#define INST_POP 2
+#define INST_DUP 3
+#define INST_CONCAT 4
+#define INST_INVOKE_STK 5
+#define INST_EVAL_STK 6
+#define INST_EXPR_STK 7
+
+/* Opcodes 8 to 17: [set] */
+#define INST_LOAD_SCALAR 8
+#define INST_LOAD_SCALAR_STK 9
+#define INST_LOAD_ARRAY 10
+#define INST_LOAD_ARRAY_STK 11
+#define INST_LOAD_STK 12
+#define INST_STORE_SCALAR 13
+#define INST_STORE_SCALAR_STK 14
+#define INST_STORE_ARRAY 15
+#define INST_STORE_ARRAY_STK 16
+#define INST_STORE_STK 17
+
+/* Opcodes 18 to 27: [incr] */
+#define INST_INCR_SCALAR 18
+#define INST_INCR_SCALAR_STK 19
+#define INST_INCR_ARRAY 20
+#define INST_INCR_ARRAY_STK 21
+#define INST_INCR_STK 22
+#define INST_INCR_SCALAR_IMM 23
+#define INST_INCR_SCALAR_STK_IMM 24
+#define INST_INCR_ARRAY_IMM 25
+#define INST_INCR_ARRAY_STK_IMM 26
+#define INST_INCR_STK_IMM 27
+
+/* Opcodes 28 to 30 */
+#define INST_JUMP 28
+#define INST_JUMP_TRUE 29
+#define INST_JUMP_FALSE 30
+
+/* Opcodes 31 to 58: operators */
+#define INST_LOR 31
+#define INST_LAND 32
+#define INST_BITOR 33
+#define INST_BITXOR 34
+#define INST_BITAND 35
+#define INST_EQ 36
+#define INST_NEQ 37
+#define INST_LT 38
+#define INST_GT 39
+#define INST_LE 40
+#define INST_GE 41
+#define INST_LSHIFT 42
+#define INST_RSHIFT 43
+#define INST_ADD 44
+#define INST_SUB 45
+#define INST_MULT 46
+#define INST_DIV 47
+#define INST_MOD 48
+#define INST_UPLUS 49
+#define INST_UMINUS 50
+#define INST_BITNOT 51
+#define INST_LNOT 52
+#define INST_CALL_BUILTIN_FUNC 53
+#define INST_CALL_FUNC 54
+#define INST_TRY_CVT_TO_NUMERIC 55
+#define INST_EXPON 56
+#define INST_LIST_IN 57
+#define INST_LIST_NOT_IN 58
+
+/* Opcodes 59 to 60 */
+#define INST_FOREACH_START 59
+#define INST_FOREACH_STEP 60
+
+/* Opcodes 61 to 70 */
+#define INST_BREAK 61
+#define INST_CONTINUE 62
+#define INST_BEGIN_CATCH 63
+#define INST_END_CATCH 64
+#define INST_PUSH_RESULT 65
+#define INST_PUSH_RETURN_CODE 66
+#define INST_PUSH_RETURN_OPTIONS 67
+#define INST_RETURN_STK 68
+#define INST_RETURN_IMM 69
+#define INST_RETURN_CODE_BRANCH 70
+
+/* Opcodes 71 to 76 */
+#define INST_STR_EQ 71
+#define INST_STR_NEQ 72
+#define INST_STR_CMP 73
+#define INST_STR_LEN 74
+#define INST_STR_INDEX 75
+#define INST_STR_MATCH 76
+
+/* Opcodes 77 to 79 */
+#define INST_LIST 77
+#define INST_LIST_INDEX 78
+#define INST_LIST_LENGTH 79
+
+/* Opcodes 80 to 83: [append] */
+#define INST_APPEND_SCALAR 80
+#define INST_APPEND_ARRAY 81
+#define INST_APPEND_ARRAY_STK 82
+#define INST_APPEND_STK 83
+
+/* Opcodes 84 to 87: [lappend] */
+#define INST_LAPPEND_SCALAR 84
+#define INST_LAPPEND_ARRAY 85
+#define INST_LAPPEND_ARRAY_STK 86
+#define INST_LAPPEND_STK 87
/* TIP #22 - LINDEX operator with flat arg list */
+#define INST_LIST_INDEX_MULTI 88
-#define INST_LIST_INDEX_MULTI 94
-
-/*
- * TIP #33 - 'lset' command. Code gen also required a Forth-like
- * OVER operation.
- */
-
-#define INST_OVER 95
-#define INST_LSET_LIST 96
-#define INST_LSET_FLAT 97
-
-/* TIP#90 - 'return' command. */
-
-#define INST_RETURN_IMM 98
-
-/* TIP#123 - exponentiation operator. */
-
-#define INST_EXPON 99
+/* TIP #33 - 'lset' command. */
+#define INST_LSET_LIST 89
+#define INST_LSET_FLAT 90
/* TIP #157 - {*}... (word expansion) language syntax support. */
-
-#define INST_EXPAND_START 100
-#define INST_EXPAND_STKTOP 101
-#define INST_INVOKE_EXPANDED 102
+#define INST_EXPAND_START 91
+#define INST_EXPAND_STKTOP 92
+#define INST_INVOKE_EXPANDED 93
/*
* TIP #57 - 'lassign' command. Code generation requires immediate
* LINDEX and LRANGE operators.
*/
-#define INST_LIST_INDEX_IMM 103
-#define INST_LIST_RANGE_IMM 104
-
-#define INST_START_CMD 105
-
-#define INST_LIST_IN 106
-#define INST_LIST_NOT_IN 107
-
-#define INST_PUSH_RETURN_OPTIONS 108
-#define INST_RETURN_STK 109
-
-/*
- * Dictionary (TIP#111) related commands.
- */
-
-#define INST_DICT_GET 110
-#define INST_DICT_SET 111
-#define INST_DICT_UNSET 112
-#define INST_DICT_INCR_IMM 113
-#define INST_DICT_APPEND 114
-#define INST_DICT_LAPPEND 115
-#define INST_DICT_FIRST 116
-#define INST_DICT_NEXT 117
-#define INST_DICT_DONE 118
-#define INST_DICT_UPDATE_START 119
-#define INST_DICT_UPDATE_END 120
+#define INST_LIST_INDEX_IMM 94
+#define INST_LIST_RANGE_IMM 95
+
+#define INST_START_CMD 96
+
+/* Dictionary (TIP#111) related commands. */
+#define INST_DICT_GET 97
+#define INST_DICT_SET 98
+#define INST_DICT_UNSET 99
+#define INST_DICT_INCR_IMM 100
+#define INST_DICT_APPEND 101
+#define INST_DICT_LAPPEND 102
+#define INST_DICT_FIRST 103
+#define INST_DICT_NEXT 104
+#define INST_DICT_DONE 105
+#define INST_DICT_UPDATE_START 106
+#define INST_DICT_UPDATE_END 107
+#define INST_DICT_EXPAND 108
+#define INST_DICT_RECOMBINE_STK 109
+#define INST_DICT_RECOMBINE_IMM 110
+#define INST_DICT_EXISTS 111
+#define INST_DICT_VERIFY 112
/*
* Instruction to support jumps defined by tables (instead of the classic
* [switch] technique of chained comparisons).
*/
-#define INST_JUMP_TABLE 121
+#define INST_JUMP_TABLE 113
/*
* Instructions to support compilation of global, variable, upvar and
* [namespace upvar].
*/
-#define INST_UPVAR 122
-#define INST_NSUPVAR 123
-#define INST_VARIABLE 124
-
-/* Instruction to support compiling syntax error to bytecode */
+#define INST_UPVAR 114
+#define INST_NSUPVAR 115
+#define INST_VARIABLE 116
-#define INST_SYNTAX 125
-
-/* Instruction to reverse N items on top of stack */
-
-#define INST_REVERSE 126
+/* Utilities */
+#define INST_OVER 117
+#define INST_SYNTAX 118
+#define INST_REVERSE 119
+#define INST_NOP 120
/* regexp instruction */
-
-#define INST_REGEXP 127
+#define INST_REGEXP 121
/* For [info exists] compilation */
-#define INST_EXIST_SCALAR 128
-#define INST_EXIST_ARRAY 129
-#define INST_EXIST_ARRAY_STK 130
-#define INST_EXIST_STK 131
-
-/* For [subst] compilation */
-#define INST_NOP 132
-#define INST_RETURN_CODE_BRANCH 133
+#define INST_EXIST_SCALAR 122
+#define INST_EXIST_ARRAY 123
+#define INST_EXIST_ARRAY_STK 124
+#define INST_EXIST_STK 125
/* For [unset] compilation */
-#define INST_UNSET_SCALAR 134
-#define INST_UNSET_ARRAY 135
-#define INST_UNSET_ARRAY_STK 136
-#define INST_UNSET_STK 137
-
-/* For [dict with], [dict exists], [dict create] and [dict merge] */
-#define INST_DICT_EXPAND 138
-#define INST_DICT_RECOMBINE_STK 139
-#define INST_DICT_RECOMBINE_IMM 140
-#define INST_DICT_EXISTS 141
-#define INST_DICT_VERIFY 142
+#define INST_UNSET_SCALAR 126
+#define INST_UNSET_ARRAY 127
+#define INST_UNSET_ARRAY_STK 128
+#define INST_UNSET_STK 129
/* For [string map] and [regsub] compilation */
-#define INST_STR_MAP 143
-#define INST_STR_FIND 144
-#define INST_STR_FIND_LAST 145
-#define INST_STR_RANGE_IMM 146
-#define INST_STR_RANGE 147
+#define INST_STR_MAP 130
+#define INST_STR_FIND 131
+#define INST_STR_FIND_LAST 132
+#define INST_STR_RANGE_IMM 133
+#define INST_STR_RANGE 134
/* For operations to do with coroutines and other NRE-manipulators */
-#define INST_YIELD 148
-#define INST_COROUTINE_NAME 149
-#define INST_TAILCALL 150
+#define INST_YIELD 135
+#define INST_COROUTINE_NAME 136
+#define INST_TAILCALL 137
/* For compilation of basic information operations */
-#define INST_NS_CURRENT 151
-#define INST_INFO_LEVEL_NUM 152
-#define INST_INFO_LEVEL_ARGS 153
-#define INST_RESOLVE_COMMAND 154
-#define INST_TCLOO_SELF 155
-#define INST_TCLOO_CLASS 156
-#define INST_TCLOO_NS 157
-#define INST_TCLOO_IS_OBJECT 158
+#define INST_NS_CURRENT 138
+#define INST_INFO_LEVEL_NUM 139
+#define INST_INFO_LEVEL_ARGS 140
+#define INST_RESOLVE_COMMAND 141
+#define INST_TCLOO_SELF 142
+#define INST_TCLOO_CLASS 143
+#define INST_TCLOO_NS 144
+#define INST_TCLOO_IS_OBJECT 145
/* For compilation of [array] subcommands */
-#define INST_ARRAY_EXISTS_STK 159
-#define INST_ARRAY_EXISTS_IMM 160
-#define INST_ARRAY_MAKE_STK 161
-#define INST_ARRAY_MAKE_IMM 162
+#define INST_ARRAY_EXISTS_STK 146
+#define INST_ARRAY_EXISTS_IMM 147
+#define INST_ARRAY_MAKE_STK 148
+#define INST_ARRAY_MAKE_IMM 149
/* The last opcode */
-#define LAST_INST_OPCODE 162
+#define LAST_INST_OPCODE 149
/*
* Table describing the Tcl bytecode instructions: their name (for displaying
@@ -733,8 +692,6 @@ typedef enum InstOperandType {
OPERAND_UINT4, /* Four byte unsigned integer. */
OPERAND_IDX4, /* Four byte signed index (actually an
* integer, but displayed differently.) */
- OPERAND_LVT1, /* One byte unsigned index into the local
- * variable table. */
OPERAND_LVT4, /* Four byte unsigned index into the local
* variable table. */
OPERAND_AUX4 /* Four byte unsigned index into the aux data
@@ -1189,11 +1146,7 @@ MODULE_SCOPE Tcl_Obj *TclNewInstNameObj(unsigned char inst);
#define TclEmitPush(objIndex, envPtr) \
do { \
register int objIndexCopy = (objIndex); \
- if (objIndexCopy <= 255) { \
- TclEmitInstInt1(INST_PUSH1, objIndexCopy, (envPtr)); \
- } else { \
- TclEmitInstInt4(INST_PUSH4, objIndexCopy, (envPtr)); \
- } \
+ TclEmitInstInt4(INST_PUSH, objIndexCopy, (envPtr)); \
} while (0)
/*
diff --git a/generic/tclExecute.c b/generic/tclExecute.c
index cb1864c40..f2200c8 100644
--- a/generic/tclExecute.c
+++ b/generic/tclExecute.c
@@ -2229,10 +2229,10 @@ TEBCresume(
* reduces total obj size.
*/
- if (*pc == INST_LOAD_SCALAR1) {
- goto instLoadScalar1;
- } else if (*pc == INST_PUSH1) {
- goto instPush1Peephole;
+ if (*pc == INST_LOAD_SCALAR) {
+ goto instLoadScalar;
+ } else if (*pc == INST_PUSH) {
+ goto instPushPeephole;
}
switch (*pc) {
@@ -2392,28 +2392,23 @@ TEBCresume(
(void) POP_OBJECT();
goto abnormalReturn;
- case INST_PUSH1:
- instPush1Peephole:
- PUSH_OBJECT(codePtr->objArrayPtr[TclGetUInt1AtPtr(pc+1)]);
- TRACE_WITH_OBJ(("%u => ", TclGetInt1AtPtr(pc+1)), OBJ_AT_TOS);
- pc += 2;
+ case INST_PUSH:
+ instPushPeephole:
+ PUSH_OBJECT(codePtr->objArrayPtr[TclGetUInt4AtPtr(pc+1)]);
+ TRACE_WITH_OBJ(("%u => ", TclGetInt4AtPtr(pc+1)), OBJ_AT_TOS);
+ pc += 5;
#if !TCL_COMPILE_DEBUG
/*
* Runtime peephole optimisation: check if we are pushing again.
*/
- if (*pc == INST_PUSH1) {
+ if (*pc == INST_PUSH) {
TCL_DTRACE_INST_NEXT();
- goto instPush1Peephole;
+ goto instPushPeephole;
}
#endif
NEXT_INST_F(0, 0, 0);
- case INST_PUSH4:
- objResultPtr = codePtr->objArrayPtr[TclGetUInt4AtPtr(pc+1)];
- TRACE_WITH_OBJ(("%u => ", TclGetUInt4AtPtr(pc+1)), objResultPtr);
- NEXT_INST_F(5, 0, 1);
-
case INST_POP:
TRACE_WITH_OBJ(("=> discarding "), OBJ_AT_TOS);
objPtr = POP_OBJECT();
@@ -2507,7 +2502,7 @@ TEBCresume(
NEXT_INST_F(5, 0, 0);
}
- case INST_CONCAT1: {
+ case INST_CONCAT: {
int appendLen = 0;
char *bytes, *p;
Tcl_Obj **currPtr;
@@ -2775,15 +2770,9 @@ TEBCresume(
TclNewObj(objResultPtr);
NEXT_INST_F(1, 0, 1);
- case INST_INVOKE_STK4:
+ case INST_INVOKE_STK:
objc = TclGetUInt4AtPtr(pc+1);
pcAdjustment = 5;
- goto doInvocation;
-
- case INST_INVOKE_STK1:
- objc = TclGetUInt1AtPtr(pc+1);
- pcAdjustment = 2;
-
doInvocation:
objv = &OBJ_AT_DEPTH(objc-1);
cleanup = objc;
@@ -2835,10 +2824,10 @@ TEBCresume(
* changes to add a ::tcl::mathfunc namespace in 8.5.
*/
- case INST_CALL_BUILTIN_FUNC1:
- Tcl_Panic("TclNRExecuteByteCode: obsolete INST_CALL_BUILTIN_FUNC1 found");
- case INST_CALL_FUNC1:
- Tcl_Panic("TclNRExecuteByteCode: obsolete INST_CALL_FUNC1 found");
+ case INST_CALL_BUILTIN_FUNC:
+ Tcl_Panic("TclNRExecuteByteCode: obsolete INST_CALL_BUILTIN_FUNC found");
+ case INST_CALL_FUNC:
+ Tcl_Panic("TclNRExecuteByteCode: obsolete INST_CALL_FUNC found");
/*
* -----------------------------------------------------------------
@@ -2849,30 +2838,8 @@ TEBCresume(
* common execution code.
*/
- case INST_LOAD_SCALAR1:
- instLoadScalar1:
- opnd = TclGetUInt1AtPtr(pc+1);
- varPtr = LOCAL(opnd);
- while (TclIsVarLink(varPtr)) {
- varPtr = varPtr->value.linkPtr;
- }
- TRACE(("%u => ", opnd));
- if (TclIsVarDirectReadable(varPtr)) {
- /*
- * No errors, no traces: just get the value.
- */
-
- objResultPtr = varPtr->value.objPtr;
- TRACE_APPEND(("%.30s\n", O2S(objResultPtr)));
- NEXT_INST_F(2, 0, 1);
- }
- pcAdjustment = 2;
- cleanup = 0;
- arrayPtr = NULL;
- part1Ptr = part2Ptr = NULL;
- goto doCallPtrGetVar;
-
- case INST_LOAD_SCALAR4:
+ case INST_LOAD_SCALAR:
+ instLoadScalar:
opnd = TclGetUInt4AtPtr(pc+1);
varPtr = LOCAL(opnd);
while (TclIsVarLink(varPtr)) {
@@ -2894,16 +2861,8 @@ TEBCresume(
part1Ptr = part2Ptr = NULL;
goto doCallPtrGetVar;
- case INST_LOAD_ARRAY4:
+ case INST_LOAD_ARRAY:
opnd = TclGetUInt4AtPtr(pc+1);
- pcAdjustment = 5;
- goto doLoadArray;
-
- case INST_LOAD_ARRAY1:
- opnd = TclGetUInt1AtPtr(pc+1);
- pcAdjustment = 2;
-
- doLoadArray:
part1Ptr = NULL;
part2Ptr = OBJ_AT_TOS;
arrayPtr = LOCAL(opnd);
@@ -2920,7 +2879,7 @@ TEBCresume(
objResultPtr = varPtr->value.objPtr;
TRACE_APPEND(("%.30s\n", O2S(objResultPtr)));
- NEXT_INST_F(pcAdjustment, 1, 1);
+ NEXT_INST_F(5, 1, 1);
}
}
varPtr = TclLookupArrayElement(interp, part1Ptr, part2Ptr,
@@ -2930,6 +2889,7 @@ TEBCresume(
goto gotError;
}
cleanup = 1;
+ pcAdjustment = 5;
goto doCallPtrGetVar;
case INST_LOAD_ARRAY_STK:
@@ -2998,16 +2958,10 @@ TEBCresume(
{
int storeFlags;
- case INST_STORE_ARRAY4:
+ case INST_STORE_ARRAY:
opnd = TclGetUInt4AtPtr(pc+1);
pcAdjustment = 5;
- goto doStoreArrayDirect;
-
- case INST_STORE_ARRAY1:
- opnd = TclGetUInt1AtPtr(pc+1);
- pcAdjustment = 2;
- doStoreArrayDirect:
valuePtr = OBJ_AT_TOS;
part2Ptr = OBJ_UNDER_TOS;
arrayPtr = LOCAL(opnd);
@@ -3030,16 +2984,10 @@ TEBCresume(
part1Ptr = NULL;
goto doStoreArrayDirectFailed;
- case INST_STORE_SCALAR4:
+ case INST_STORE_SCALAR:
opnd = TclGetUInt4AtPtr(pc+1);
pcAdjustment = 5;
- goto doStoreScalarDirect;
- case INST_STORE_SCALAR1:
- opnd = TclGetUInt1AtPtr(pc+1);
- pcAdjustment = 2;
-
- doStoreScalarDirect:
valuePtr = OBJ_AT_TOS;
varPtr = LOCAL(opnd);
TRACE(("%u <- \"%.30s\" => ", opnd, O2S(valuePtr)));
@@ -3136,31 +3084,17 @@ TEBCresume(
opnd = -1;
goto doCallPtrSetVar;
- case INST_LAPPEND_ARRAY4:
+ case INST_LAPPEND_ARRAY:
opnd = TclGetUInt4AtPtr(pc+1);
pcAdjustment = 5;
storeFlags = (TCL_LEAVE_ERR_MSG | TCL_APPEND_VALUE
| TCL_LIST_ELEMENT);
goto doStoreArray;
- case INST_LAPPEND_ARRAY1:
- opnd = TclGetUInt1AtPtr(pc+1);
- pcAdjustment = 2;
- storeFlags = (TCL_LEAVE_ERR_MSG | TCL_APPEND_VALUE
- | TCL_LIST_ELEMENT);
- goto doStoreArray;
-
- case INST_APPEND_ARRAY4:
+ case INST_APPEND_ARRAY:
opnd = TclGetUInt4AtPtr(pc+1);
pcAdjustment = 5;
storeFlags = (TCL_LEAVE_ERR_MSG | TCL_APPEND_VALUE);
- goto doStoreArray;
-
- case INST_APPEND_ARRAY1:
- opnd = TclGetUInt1AtPtr(pc+1);
- pcAdjustment = 2;
- storeFlags = (TCL_LEAVE_ERR_MSG | TCL_APPEND_VALUE);
- goto doStoreArray;
doStoreArray:
valuePtr = OBJ_AT_TOS;
@@ -3183,31 +3117,17 @@ TEBCresume(
}
goto doCallPtrSetVar;
- case INST_LAPPEND_SCALAR4:
+ case INST_LAPPEND_SCALAR:
opnd = TclGetUInt4AtPtr(pc+1);
pcAdjustment = 5;
storeFlags = (TCL_LEAVE_ERR_MSG | TCL_APPEND_VALUE
| TCL_LIST_ELEMENT);
goto doStoreScalar;
- case INST_LAPPEND_SCALAR1:
- opnd = TclGetUInt1AtPtr(pc+1);
- pcAdjustment = 2;
- storeFlags = (TCL_LEAVE_ERR_MSG | TCL_APPEND_VALUE
- | TCL_LIST_ELEMENT);
- goto doStoreScalar;
-
- case INST_APPEND_SCALAR4:
+ case INST_APPEND_SCALAR:
opnd = TclGetUInt4AtPtr(pc+1);
pcAdjustment = 5;
storeFlags = (TCL_LEAVE_ERR_MSG | TCL_APPEND_VALUE);
- goto doStoreScalar;
-
- case INST_APPEND_SCALAR1:
- opnd = TclGetUInt1AtPtr(pc+1);
- pcAdjustment = 2;
- storeFlags = (TCL_LEAVE_ERR_MSG | TCL_APPEND_VALUE);
- goto doStoreScalar;
doStoreScalar:
valuePtr = OBJ_AT_TOS;
@@ -3257,19 +3177,19 @@ TEBCresume(
#endif
long increment;
- case INST_INCR_SCALAR1:
- case INST_INCR_ARRAY1:
+ case INST_INCR_SCALAR:
+ case INST_INCR_ARRAY:
case INST_INCR_ARRAY_STK:
case INST_INCR_SCALAR_STK:
case INST_INCR_STK:
- opnd = TclGetUInt1AtPtr(pc+1);
+ opnd = TclGetUInt4AtPtr(pc+1);
incrPtr = POP_OBJECT();
switch (*pc) {
- case INST_INCR_SCALAR1:
- pcAdjustment = 2;
+ case INST_INCR_SCALAR:
+ pcAdjustment = 5;
goto doIncrScalar;
- case INST_INCR_ARRAY1:
- pcAdjustment = 2;
+ case INST_INCR_ARRAY:
+ pcAdjustment = 5;
goto doIncrArray;
default:
pcAdjustment = 1;
@@ -3310,12 +3230,12 @@ TEBCresume(
cleanup = ((part2Ptr == NULL)? 1 : 2);
goto doIncrVar;
- case INST_INCR_ARRAY1_IMM:
- opnd = TclGetUInt1AtPtr(pc+1);
- increment = TclGetInt1AtPtr(pc+2);
+ case INST_INCR_ARRAY_IMM:
+ opnd = TclGetUInt4AtPtr(pc+1);
+ increment = TclGetInt1AtPtr(pc+5);
incrPtr = Tcl_NewIntObj(increment);
Tcl_IncrRefCount(incrPtr);
- pcAdjustment = 3;
+ pcAdjustment = 6;
doIncrArray:
part1Ptr = NULL;
@@ -3335,10 +3255,10 @@ TEBCresume(
}
goto doIncrVar;
- case INST_INCR_SCALAR1_IMM:
- opnd = TclGetUInt1AtPtr(pc+1);
- increment = TclGetInt1AtPtr(pc+2);
- pcAdjustment = 3;
+ case INST_INCR_SCALAR_IMM:
+ opnd = TclGetUInt4AtPtr(pc+1);
+ increment = TclGetInt1AtPtr(pc+5);
+ pcAdjustment = 6;
cleanup = 0;
varPtr = LOCAL(opnd);
while (TclIsVarLink(varPtr)) {
@@ -3966,13 +3886,7 @@ TEBCresume(
* -----------------------------------------------------------------
*/
- case INST_JUMP1:
- opnd = TclGetInt1AtPtr(pc+1);
- TRACE(("%d => new pc %u\n", opnd,
- (unsigned)(pc + opnd - codePtr->codeStart)));
- NEXT_INST_F(opnd, 0, 0);
-
- case INST_JUMP4:
+ case INST_JUMP:
opnd = TclGetInt4AtPtr(pc+1);
TRACE(("%d => new pc %u\n", opnd,
(unsigned)(pc + opnd - codePtr->codeStart)));
@@ -3983,24 +3897,14 @@ TEBCresume(
/* TODO: consider rewrite so we don't compute the offset we're not
* going to take. */
- case INST_JUMP_FALSE4:
+ case INST_JUMP_FALSE:
jmpOffset[0] = TclGetInt4AtPtr(pc+1); /* FALSE offset */
jmpOffset[1] = 5; /* TRUE offset */
goto doCondJump;
- case INST_JUMP_TRUE4:
+ case INST_JUMP_TRUE:
jmpOffset[0] = 5;
jmpOffset[1] = TclGetInt4AtPtr(pc+1);
- goto doCondJump;
-
- case INST_JUMP_FALSE1:
- jmpOffset[0] = TclGetInt1AtPtr(pc+1);
- jmpOffset[1] = 2;
- goto doCondJump;
-
- case INST_JUMP_TRUE1:
- jmpOffset[0] = 2;
- jmpOffset[1] = TclGetInt1AtPtr(pc+1);
doCondJump:
valuePtr = OBJ_AT_TOS;
@@ -4008,15 +3912,15 @@ TEBCresume(
/* TODO - check claim that taking address of b harms performance */
/* TODO - consider optimization search for constants */
if (TclGetBooleanFromObj(interp, valuePtr, &b) != TCL_OK) {
- TRACE_WITH_OBJ(("%d => ERROR: ", jmpOffset[
- ((*pc == INST_JUMP_FALSE1) || (*pc == INST_JUMP_FALSE4))
- ? 0 : 1]), Tcl_GetObjResult(interp));
+ TRACE_WITH_OBJ(("%d => ERROR: ",
+ jmpOffset[(*pc == INST_JUMP_FALSE) ? 0 : 1]),
+ Tcl_GetObjResult(interp));
goto gotError;
}
#ifdef TCL_COMPILE_DEBUG
if (b) {
- if ((*pc == INST_JUMP_TRUE1) || (*pc == INST_JUMP_TRUE4)) {
+ if (*pc == INST_JUMP_TRUE) {
TRACE(("%d => %.20s true, new pc %u\n", jmpOffset[1],
O2S(valuePtr),
(unsigned)(pc + jmpOffset[1] - codePtr->codeStart)));
@@ -4024,7 +3928,7 @@ TEBCresume(
TRACE(("%d => %.20s true\n", jmpOffset[0], O2S(valuePtr)));
}
} else {
- if ((*pc == INST_JUMP_TRUE1) || (*pc == INST_JUMP_TRUE4)) {
+ if (*pc == INST_JUMP_TRUE) {
TRACE(("%d => %.20s false\n", jmpOffset[0], O2S(valuePtr)));
} else {
TRACE(("%d => %.20s false, new pc %u\n", jmpOffset[0],
@@ -4588,13 +4492,9 @@ TEBCresume(
pc++;
#ifndef TCL_COMPILE_DEBUG
switch (*pc) {
- case INST_JUMP_FALSE1:
- NEXT_INST_F((match ? 2 : TclGetInt1AtPtr(pc+1)), 2, 0);
- case INST_JUMP_TRUE1:
- NEXT_INST_F((match ? TclGetInt1AtPtr(pc+1) : 2), 2, 0);
- case INST_JUMP_FALSE4:
+ case INST_JUMP_FALSE:
NEXT_INST_F((match ? 5 : TclGetInt4AtPtr(pc+1)), 2, 0);
- case INST_JUMP_TRUE4:
+ case INST_JUMP_TRUE:
NEXT_INST_F((match ? TclGetInt4AtPtr(pc+1) : 5), 2, 0);
}
#endif
@@ -4997,13 +4897,9 @@ TEBCresume(
pc += 2;
#ifndef TCL_COMPILE_DEBUG
switch (*pc) {
- case INST_JUMP_FALSE1:
- NEXT_INST_F((match? 2 : TclGetInt1AtPtr(pc+1)), 2, 0);
- case INST_JUMP_TRUE1:
- NEXT_INST_F((match? TclGetInt1AtPtr(pc+1) : 2), 2, 0);
- case INST_JUMP_FALSE4:
+ case INST_JUMP_FALSE:
NEXT_INST_F((match? 5 : TclGetInt4AtPtr(pc+1)), 2, 0);
- case INST_JUMP_TRUE4:
+ case INST_JUMP_TRUE:
NEXT_INST_F((match? TclGetInt4AtPtr(pc+1) : 5), 2, 0);
}
#endif
@@ -5050,13 +4946,9 @@ TEBCresume(
pc += 2;
#ifndef TCL_COMPILE_DEBUG
switch (*pc) {
- case INST_JUMP_FALSE1:
- NEXT_INST_F((match? 2 : TclGetInt1AtPtr(pc+1)), 2, 0);
- case INST_JUMP_TRUE1:
- NEXT_INST_F((match? TclGetInt1AtPtr(pc+1) : 2), 2, 0);
- case INST_JUMP_FALSE4:
+ case INST_JUMP_FALSE:
NEXT_INST_F((match? 5 : TclGetInt4AtPtr(pc+1)), 2, 0);
- case INST_JUMP_TRUE4:
+ case INST_JUMP_TRUE:
NEXT_INST_F((match? TclGetInt4AtPtr(pc+1) : 5), 2, 0);
}
#endif
@@ -5162,13 +5054,9 @@ TEBCresume(
pc++;
#ifndef TCL_COMPILE_DEBUG
switch (*pc) {
- case INST_JUMP_FALSE1:
- NEXT_INST_F((iResult? 2 : TclGetInt1AtPtr(pc+1)), 2, 0);
- case INST_JUMP_TRUE1:
- NEXT_INST_F((iResult? TclGetInt1AtPtr(pc+1) : 2), 2, 0);
- case INST_JUMP_FALSE4:
+ case INST_JUMP_FALSE:
NEXT_INST_F((iResult? 5 : TclGetInt4AtPtr(pc+1)), 2, 0);
- case INST_JUMP_TRUE4:
+ case INST_JUMP_TRUE:
NEXT_INST_F((iResult? TclGetInt4AtPtr(pc+1) : 5), 2, 0);
}
#endif
@@ -5783,7 +5671,7 @@ TEBCresume(
int varIndex, valIndex, continueLoop, j, iterTmpIndex;
long i;
- case INST_FOREACH_START4:
+ case INST_FOREACH_START:
/*
* Initialize the temporary local var that holds the count of the
* number of iterations of the loop body to -1.
@@ -5816,7 +5704,7 @@ TEBCresume(
NEXT_INST_F(5, 0, 0);
#endif
- case INST_FOREACH_STEP4:
+ case INST_FOREACH_STEP:
/*
* "Step" a foreach loop (i.e., begin its next iteration) by assigning
* the next value list element to each loop var.
@@ -5929,14 +5817,10 @@ TEBCresume(
*/
pc += 5;
- if (*pc == INST_JUMP_FALSE1) {
- NEXT_INST_F((continueLoop? 2 : TclGetInt1AtPtr(pc+1)), 0, 0);
- } else {
- NEXT_INST_F((continueLoop? 5 : TclGetInt4AtPtr(pc+1)), 0, 0);
- }
+ NEXT_INST_F((continueLoop? 5 : TclGetInt4AtPtr(pc+1)), 0, 0);
}
- case INST_BEGIN_CATCH4:
+ case INST_BEGIN_CATCH:
/*
* Record start of the catch command with exception range index equal
* to the operand. Push the current stack depth onto the special catch
@@ -5993,9 +5877,9 @@ TEBCresume(
Tcl_Panic("INST_RETURN_CODE_BRANCH: TOS is TCL_OK!");
}
if (code < TCL_ERROR || code > TCL_CONTINUE) {
- code = TCL_CONTINUE + 1;
+ NEXT_INST_F(21, 1, 0);
}
- NEXT_INST_F(2*code -1, 1, 0);
+ NEXT_INST_F(5*code -4, 1, 0);
}
/*
@@ -6375,13 +6259,9 @@ TEBCresume(
pc += 5;
switch (*pc) {
- case INST_JUMP_FALSE1:
- NEXT_INST_F((done ? 2 : TclGetInt1AtPtr(pc+1)), 0, 0);
- case INST_JUMP_FALSE4:
+ case INST_JUMP_FALSE:
NEXT_INST_F((done ? 5 : TclGetInt4AtPtr(pc+1)), 0, 0);
- case INST_JUMP_TRUE1:
- NEXT_INST_F((done ? TclGetInt1AtPtr(pc+1) : 2), 0, 0);
- case INST_JUMP_TRUE4:
+ case INST_JUMP_TRUE:
NEXT_INST_F((done ? TclGetInt4AtPtr(pc+1) : 5), 0, 0);
default:
pc -= 5;
@@ -6621,11 +6501,7 @@ TEBCresume(
processExceptionReturn:
#if TCL_COMPILE_DEBUG
switch (*pc) {
- case INST_INVOKE_STK1:
- opnd = TclGetUInt1AtPtr(pc+1);
- TRACE(("%u => ... after \"%.20s\": ", opnd, cmdNameBuf));
- break;
- case INST_INVOKE_STK4:
+ case INST_INVOKE_STK:
opnd = TclGetUInt4AtPtr(pc+1);
TRACE(("%u => ... after \"%.20s\": ", opnd, cmdNameBuf));
break;
diff --git a/tests/assemble.test b/tests/assemble.test
index 942b763..48e87a1 100644
--- a/tests/assemble.test
+++ b/tests/assemble.test
@@ -1364,10 +1364,10 @@ test assemble-12.6 {incr, stupid stack restriction} {
set y 5
assemble {push 3; incr y}
"
- list [catch {x} result] $result $errorCode
+ x
}
- -result {1 {operand does not fit in one byte} {TCL ASSEM 1BYTE}}
- -cleanup {unset result; rename x {}}
+ -result 8
+ -cleanup {rename x {}}
}
# assemble-13 -- ASSEM_LVT1_SINT1 - incrImm and incrArrayImm
@@ -1455,10 +1455,10 @@ test assemble-13.9 {incrImm, stupid stack restriction} {
set y 5
assemble {incrImm y 3}
"
- list [catch {x} result] $result $errorCode
+ x
}
- -result {1 {operand does not fit in one byte} {TCL ASSEM 1BYTE}}
- -cleanup {unset result; rename x {}}
+ -result 8
+ -cleanup {rename x {}}
}
# assemble-14 -- ASSEM_SINT1 (incrArrayStkImm and incrStkImm)
generated by cgit v0.12 at 2025-04-05 01:37:20 (GMT)