Menu
▾
▴
[PlaneShift-svn] SF.net SVN: planeshift:[5029] trunk/src/tools/fparser
|
From: <wel...@us...> - 2009-12-22 19:26:05
|
Revision: 5029
http://planeshift.svn.sourceforge.net/planeshift/?rev=5029&view=rev
Author: weltall2
Date: 2009-12-22 19:25:57 +0000 (Tue, 22 Dec 2009)
Log Message:
-----------
updated fparser to 4.0.3
* New optimization rules in both Parse() and Optimize().
* Fixed optimizer bugs: Functions of the form "cosh(x^2)" and "-x<3" were wrongly optimized.
Modified Paths:
--------------
trunk/src/tools/fparser/fp_opcode_add.inc
trunk/src/tools/fparser/fparser.cpp
trunk/src/tools/fparser/fparser.h
trunk/src/tools/fparser/fparser.html
trunk/src/tools/fparser/fparser_gmpint.h
trunk/src/tools/fparser/fparser_mpfr.h
trunk/src/tools/fparser/fpaux.h
trunk/src/tools/fparser/fpconfig.h
trunk/src/tools/fparser/fpoptimizer.cpp
trunk/src/tools/fparser/fptypes.h
Modified: trunk/src/tools/fparser/fp_opcode_add.inc
===================================================================
--- trunk/src/tools/fparser/fp_opcode_add.inc 2009-12-22 17:46:51 UTC (rev 5028)
+++ trunk/src/tools/fparser/fp_opcode_add.inc 2009-12-22 19:25:57 UTC (rev 5029)
@@ -1,4 +1,4 @@
-/* Function Parser for C++ v4.0.2
+/* Function Parser for C++ v4.0.3
Note: This file contains generated code and is thus not
intended to be to be modified by hand. It was generated by
@@ -10,2335 +10,4267 @@
file is internally #included by fparser.cpp.
*/
-#define FP_TRACE_BYTECODE_OPTIMIZATION(from,to)
-//#define FP_TRACE_BYTECODE_OPTIMIZATION(from,to) std::cout << "Changing \"" from "\"\n into \"" to "\"\n"
+#define FP_TRACE_OPCODENAME(op) \
+ (op < VarBegin \
+ ? FP_GetOpcodeName(OPCODE(op)) \
+ : findName(data->namePtrs,op,NameData<Value_t>::VARIABLE))
+#define FP_TRACE_BYTECODE_OPTIMIZATION(srcline,from,to,with) \
+ /*std::cout << "Changing \"" from "\"\t(line " #srcline ")\n" \
+ " into \"" to "\"\n" with*/
+
+ static unsigned DummyOpList[1] = {cNop};
+ /* DummyOpList is needed to prevent crash when 1+x
+ * is changed into x+1 and the bytecode containing just "x"
+ * is tested against the rule which changes "x x" into "x cDup".
+ */
unsigned* ByteCodePtr;
Value_t* ImmedPtr;
+
#define FP_ReDefinePointers() \
- ByteCodePtr = !data->ByteCode.empty() ? &data->ByteCode[0] + data->ByteCode.size() - 1 : 0; \
+ ByteCodePtr = !data->ByteCode.empty() ? &data->ByteCode[0] + data->ByteCode.size() - 1 : &DummyOpList[0]; \
ImmedPtr = !data->Immed.empty() ? &data->Immed[0] + data->Immed.size() - 1 : 0;
FP_ReDefinePointers();
+
#if(!FP_FLOAT_VERSION)
- Value_t x;
- unsigned A;
- Value_t y;
- switch(opcode)
- {
- TailCall_cNeg:
- case cNeg:
- switch(ByteCodePtr[0])
- {
- case cMul:
- switch(ByteCodePtr[-1])
- {
- case cImmed:
- x = ImmedPtr[0];
- FP_TRACE_BYTECODE_OPTIMIZATION("x cMul cNeg", "[-x] cMul");
- /* ByteCodePtr[-1] = cImmed; */ // redundant, matches x @ 2
- /* ByteCodePtr[0] = cMul; */ // redundant, matches cMul @ 1
- goto Laa;
- }
- break;
- case cNeg:
- FP_TRACE_BYTECODE_OPTIMIZATION("cNeg cNeg", "");
- goto Lab;
- case cImmed:
- x = ImmedPtr[0];
- FP_TRACE_BYTECODE_OPTIMIZATION("x cNeg", "[-x]");
- /* ByteCodePtr[0] = cImmed; */ // redundant, matches x @ 1
- goto Laa;
- }
- break;
- TailCall_cInv:
- case cInv:
- switch(ByteCodePtr[0])
- {
- case cInv:
- FP_TRACE_BYTECODE_OPTIMIZATION("cInv cInv", "");
- goto Lab;
- case cImmed:
- x = ImmedPtr[0];
- if(x!=Value_t(0))
- {
- FP_TRACE_BYTECODE_OPTIMIZATION("x[x!=Value_t(0)] cInv", "[Value_t(1)/x]");
- /* ByteCodePtr[0] = cImmed; */ // redundant, matches x @ 1
- goto Lac;
- }
- break;
- }
- break;
- TailCall_cMul:
- case cMul:
- switch(ByteCodePtr[0])
- {
- case cInv:
- FP_TRACE_BYTECODE_OPTIMIZATION("cInv cMul", "cDiv");
- goto Lad;
- case cImmed:
- x = ImmedPtr[0];
- if(x==Value_t(0))
- {
- switch(ByteCodePtr[-1])
- {
- case cImmed: break;
- default:
- A = ByteCodePtr[-1];
- if(A >= VarBegin)
- {
- FP_TRACE_BYTECODE_OPTIMIZATION("A[A >= VarBegin] x[x==Value_t(0)] cMul", "[x]");
- /* ImmedPtr[0] = x; */ // redundant, matches x @ 1
- goto Lae;
- }
- }
- }
- switch(ByteCodePtr[-1])
- {
- case cNeg:
- FP_TRACE_BYTECODE_OPTIMIZATION("cNeg x cMul", "[-x] cMul");
- /* opcode = cMul; */ // redundant, matches cMul @ 0
- goto Laf;
- case cMul:
- switch(ByteCodePtr[-2])
- {
- case cImmed:
- y = ImmedPtr[-1];
- FP_TRACE_BYTECODE_OPTIMIZATION("y cMul x cMul", "[y*x] cMul");
- /* ByteCodePtr[-2] = cImmed; */ // redundant, matches y @ 3
- /* ByteCodePtr[-1] = cMul; */ // redundant, matches cMul @ 2
- goto Lag;
- }
- break;
- case cImmed:
- y = ImmedPtr[-1];
- FP_TRACE_BYTECODE_OPTIMIZATION("y x cMul", "[y*x]");
- /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
- goto Lag;
- }
- if(x==Value_t(1))
- {
- FP_TRACE_BYTECODE_OPTIMIZATION("x[x==Value_t(1)] cMul", "");
- goto Lah;
- }
- if(x==Value_t(2))
- {
- FP_TRACE_BYTECODE_OPTIMIZATION("x[x==Value_t(2)] cMul", "cDup cAdd");
- goto Lai;
- }
- if(x==Value_t(-1))
- {
- FP_TRACE_BYTECODE_OPTIMIZATION("x[x==Value_t(-1)] cMul", "cNeg");
- goto Laj;
- }
- break;
- default:
- A = ByteCodePtr[0];
- FP_TRACE_BYTECODE_OPTIMIZATION("A cMul", "[DO_MAYBE_SQR]");
- if(A >= VarBegin)
- {
- if(A == ByteCodePtr[-1])
- { ByteCodePtr[0] = cSqr; return; }
- if(ByteCodePtr[-1] == cMul && A == ByteCodePtr[-2])
- { ByteCodePtr[0] = cMul; ByteCodePtr[-1] = cSqr; return; }
- }
- }
- break;
- TailCall_cDiv:
- case cDiv:
- switch(ByteCodePtr[0])
- {
- case cImmed:
- x = ImmedPtr[0];
- if(x!=Value_t(0))
- {
- switch(ByteCodePtr[-1])
- {
- case cImmed:
- y = ImmedPtr[-1];
- FP_TRACE_BYTECODE_OPTIMIZATION("y x[x!=Value_t(0)] cDiv", "[y/x]");
- /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
- goto Lak;
- }
- }
- switch(ByteCodePtr[-1])
- {
- case cNeg:
- FP_TRACE_BYTECODE_OPTIMIZATION("cNeg x cDiv", "[-x] cDiv");
- /* opcode = cDiv; */ // redundant, matches cDiv @ 0
- goto Lal;
- }
- if(x==Value_t(1))
- {
- FP_TRACE_BYTECODE_OPTIMIZATION("x[x==Value_t(1)] cDiv", "");
- goto Lah;
- }
- break;
- }
- break;
- TailCall_cMod:
- case cMod:
- switch(ByteCodePtr[0])
- {
- case cImmed:
- x = ImmedPtr[0];
- if(x!=Value_t(0))
- {
- switch(ByteCodePtr[-1])
- {
- case cImmed:
- y = ImmedPtr[-1];
- FP_TRACE_BYTECODE_OPTIMIZATION("y x[x!=Value_t(0)] cMod", "[fp_mod(y,x)]");
- /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
- goto Lam;
- }
- }
- break;
- }
- break;
- TailCall_cAdd:
- case cAdd:
- switch(ByteCodePtr[0])
- {
- case cDup:
- switch(ByteCodePtr[-1])
- {
- case cAdd:
- switch(ByteCodePtr[-2])
- {
- case cDup:
- FP_TRACE_BYTECODE_OPTIMIZATION("cDup cAdd cDup cAdd", "[4] cMul");
- goto Lan;
- }
- break;
- }
- break;
- case cNeg:
- FP_TRACE_BYTECODE_OPTIMIZATION("cNeg cAdd", "cSub");
- goto Lba;
- case cImmed:
- x = ImmedPtr[0];
- switch(ByteCodePtr[-1])
- {
- case cAdd:
- switch(ByteCodePtr[-2])
- {
- case cImmed:
- y = ImmedPtr[-1];
- FP_TRACE_BYTECODE_OPTIMIZATION("y cAdd x cAdd", "[y+x] cAdd");
- /* ByteCodePtr[-2] = cImmed; */ // redundant, matches y @ 3
- /* ByteCodePtr[-1] = cAdd; */ // redundant, matches cAdd @ 2
- goto Lbb;
- }
- break;
- case cSub:
- switch(ByteCodePtr[-2])
- {
- case cImmed:
- y = ImmedPtr[-1];
- FP_TRACE_BYTECODE_OPTIMIZATION("y cSub x cAdd", "[y-x] cSub");
- /* ByteCodePtr[-2] = cImmed; */ // redundant, matches y @ 3
- /* ByteCodePtr[-1] = cSub; */ // redundant, matches cSub @ 2
- goto Lbc;
- }
- break;
- case cImmed:
- y = ImmedPtr[-1];
- FP_TRACE_BYTECODE_OPTIMIZATION("y x cAdd", "[y+x]");
- /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
- goto Lbb;
- }
- if(x==Value_t(0))
- {
- FP_TRACE_BYTECODE_OPTIMIZATION("x[x==Value_t(0)] cAdd", "");
- goto Lah;
- }
- break;
- }
- break;
- TailCall_cSub:
- case cSub:
- switch(ByteCodePtr[0])
- {
- case cNeg:
- FP_TRACE_BYTECODE_OPTIMIZATION("cNeg cSub", "cAdd");
- goto Lbd;
- case cImmed:
- x = ImmedPtr[0];
- switch(ByteCodePtr[-1])
- {
- case cSub:
- switch(ByteCodePtr[-2])
- {
- case cImmed:
- y = ImmedPtr[-1];
- FP_TRACE_BYTECODE_OPTIMIZATION("y cSub x cSub", "[y+x] cSub");
- /* ByteCodePtr[-2] = cImmed; */ // redundant, matches y @ 3
- /* ByteCodePtr[-1] = cSub; */ // redundant, matches cSub @ 2
- goto Lbb;
- }
- break;
- case cAdd:
- switch(ByteCodePtr[-2])
- {
- case cImmed:
- y = ImmedPtr[-1];
- FP_TRACE_BYTECODE_OPTIMIZATION("y cAdd x cSub", "[y-x] cAdd");
- /* ByteCodePtr[-2] = cImmed; */ // redundant, matches y @ 3
- /* ByteCodePtr[-1] = cAdd; */ // redundant, matches cAdd @ 2
- goto Lbc;
- }
- break;
- case cImmed:
- y = ImmedPtr[-1];
- FP_TRACE_BYTECODE_OPTIMIZATION("y x cSub", "[y-x]");
- /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
- goto Lbc;
- }
- if(x==Value_t(0))
- {
- FP_TRACE_BYTECODE_OPTIMIZATION("x[x==Value_t(0)] cSub", "");
- goto Lah;
- }
- break;
- }
- break;
- TailCall_cMin:
- case cMin:
- switch(ByteCodePtr[0])
- {
- case cImmed:
- x = ImmedPtr[0];
- switch(ByteCodePtr[-1])
- {
- case cImmed:
- y = ImmedPtr[-1];
- FP_TRACE_BYTECODE_OPTIMIZATION("y x cMin", "[Min(x,y)]");
- /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
- goto Lbe;
- }
- break;
- }
- break;
- TailCall_cMax:
- case cMax:
- switch(ByteCodePtr[0])
- {
- case cImmed:
- x = ImmedPtr[0];
- switch(ByteCodePtr[-1])
- {
- case cImmed:
- y = ImmedPtr[-1];
- FP_TRACE_BYTECODE_OPTIMIZATION("y x cMax", "[Max(x,y)]");
- /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
- goto Lbf;
- }
- break;
- }
- break;
- TailCall_cNot:
- case cNot:
- switch(ByteCodePtr[0])
- {
- case cLess:
- FP_TRACE_BYTECODE_OPTIMIZATION("cLess cNot", "cGreaterOrEq");
- goto Lbg;
- case cLessOrEq:
- FP_TRACE_BYTECODE_OPTIMIZATION("cLessOrEq cNot", "cGreater");
- goto Lbh;
- case cGreater:
- FP_TRACE_BYTECODE_OPTIMIZATION("cGreater cNot", "cLessOrEq");
- goto Lbi;
- case cGreaterOrEq:
- FP_TRACE_BYTECODE_OPTIMIZATION("cGreaterOrEq cNot", "cLess");
- goto Lbj;
- case cEqual:
- FP_TRACE_BYTECODE_OPTIMIZATION("cEqual cNot", "cNEqual");
- goto Lbk;
- case cNEqual:
- FP_TRACE_BYTECODE_OPTIMIZATION("cNEqual cNot", "cEqual");
- goto Lbl;
- case cNeg:
- FP_TRACE_BYTECODE_OPTIMIZATION("cNeg cNot", "cNot");
- /* opcode = cNot; */ // redundant, matches cNot @ 0
- goto Lbm;
- case cAbs:
- FP_TRACE_BYTECODE_OPTIMIZATION("cAbs cNot", "cNot");
- /* opcode = cNot; */ // redundant, matches cNot @ 0
- goto Lbm;
- case cNot:
- FP_TRACE_BYTECODE_OPTIMIZATION("cNot cNot", "cNotNot");
- goto Lbn;
- case cNotNot:
- FP_TRACE_BYTECODE_OPTIMIZATION("cNotNot cNot", "cNot");
- /* opcode = cNot; */ // redundant, matches cNot @ 0
- goto Lbm;
- case cAbsNotNot:
- FP_TRACE_BYTECODE_OPTIMIZATION("cAbsNotNot cNot", "cAbsNot");
- goto Lca;
- case cAbsNot:
- switch(ByteCodePtr[-1])
- {
- case cImmed: break;
- default:
- A = ByteCodePtr[-1];
- if(IsLogicalOpcode(A))
- {
- FP_TRACE_BYTECODE_OPTIMIZATION("A[IsLogicalOpcode(A)] cAbsNot cNot", "A");
- /* ByteCodePtr[-1] = A; */ // redundant, matches A @ 2
- goto Lab;
- }
- FP_TRACE_BYTECODE_OPTIMIZATION("A cAbsNot cNot", "A cAbsNotNot");
- /* ByteCodePtr[-1] = A; */ // redundant, matches A @ 2
- goto Lcb;
- }
- break;
- case cImmed:
- x = ImmedPtr[0];
- FP_TRACE_BYTECODE_OPTIMIZATION("x cNot", "[!truthValue(x)]");
- /* ByteCodePtr[0] = cImmed; */ // redundant, matches x @ 1
- goto Lcc;
- default:
- A = ByteCodePtr[0];
- if(IsNeverNegativeValueOpcode(A))
- {
- FP_TRACE_BYTECODE_OPTIMIZATION("A[IsNeverNegativeValueOpcode(A)] cNot", "A cAbsNot");
- /* ByteCodePtr[0] = A; */ // redundant, matches A @ 1
- goto Lcd;
- }
- }
- break;
- TailCall_cLess:
- case cLess:
- switch(ByteCodePtr[0])
- {
- case cImmed:
- x = ImmedPtr[0];
- if(x==Value_t(0))
- {
- switch(ByteCodePtr[-1])
- {
- case cImmed: break;
- default:
- A = ByteCodePtr[-1];
- if(IsNeverNegativeValueOpcode(A))
- {
- FP_TRACE_BYTECODE_OPTIMIZATION("A[IsNeverNegativeValueOpcode(A)] x[x==Value_t(0)] cLess", "A [x] cMul");
- /* ByteCodePtr[-1] = A; */ // redundant, matches A @ 2
- /* ImmedPtr[0] = x; */ // redundant, matches x @ 1
- /* ByteCodePtr[0] = cImmed; */ // redundant, matches x @ 1
- goto Lce;
- }
- }
- }
- switch(ByteCodePtr[-1])
- {
- case cImmed:
- y = ImmedPtr[-1];
- FP_TRACE_BYTECODE_OPTIMIZATION("y x cLess", "[fp_less(y,x)]");
- /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
- goto Lcf;
- }
- break;
- }
- break;
- TailCall_cLessOrEq:
- case cLessOrEq:
- switch(ByteCodePtr[0])
- {
- case cImmed:
- x = ImmedPtr[0];
- switch(ByteCodePtr[-1])
- {
- case cImmed:
- y = ImmedPtr[-1];
- FP_TRACE_BYTECODE_OPTIMIZATION("y x cLessOrEq", "[fp_lessOrEq(y,x)]");
- /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
- goto Lcg;
- }
- break;
- }
- break;
- TailCall_cGreater:
- case cGreater:
- switch(ByteCodePtr[0])
- {
- case cImmed:
- x = ImmedPtr[0];
- switch(ByteCodePtr[-1])
- {
- case cImmed:
- y = ImmedPtr[-1];
- FP_TRACE_BYTECODE_OPTIMIZATION("y x cGreater", "[fp_less(x,y)]");
- /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
- goto Lch;
- }
- break;
- }
- break;
- TailCall_cGreaterOrEq:
- case cGreaterOrEq:
- switch(ByteCodePtr[0])
- {
- case cImmed:
- x = ImmedPtr[0];
- switch(ByteCodePtr[-1])
- {
- case cImmed:
- y = ImmedPtr[-1];
- FP_TRACE_BYTECODE_OPTIMIZATION("y x cGreaterOrEq", "[fp_lessOrEq(x,y)]");
- /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
- goto Lci;
- }
- break;
- }
- break;
- TailCall_cEqual:
- case cEqual:
- switch(ByteCodePtr[0])
- {
- case cImmed:
- x = ImmedPtr[0];
- switch(ByteCodePtr[-1])
- {
- case cImmed:
- y = ImmedPtr[-1];
- FP_TRACE_BYTECODE_OPTIMIZATION("y x cEqual", "[fp_equal(y,x)]");
- /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
- goto Lcj;
- }
- break;
- }
- break;
- TailCall_cNEqual:
- case cNEqual:
- switch(ByteCodePtr[0])
- {
- case cImmed:
- x = ImmedPtr[0];
- switch(ByteCodePtr[-1])
- {
- case cImmed:
- y = ImmedPtr[-1];
- FP_TRACE_BYTECODE_OPTIMIZATION("y x cNEqual", "[fp_nequal(y,x)]");
- /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
- goto Lck;
- }
- break;
- }
- break;
- TailCall_cAnd:
- case cAnd:
- switch(ByteCodePtr[0])
- {
- case cImmed:
- x = ImmedPtr[0];
- switch(ByteCodePtr[-1])
- {
- case cImmed:
- y = ImmedPtr[-1];
- FP_TRACE_BYTECODE_OPTIMIZATION("y x cAnd", "[truthValue(x)&&truthValue(y)]");
- /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
- goto Lcl;
- }
- break;
- }
- break;
- TailCall_cOr:
- case cOr:
- switch(ByteCodePtr[0])
- {
- case cImmed:
- x = ImmedPtr[0];
- switch(ByteCodePtr[-1])
- {
- case cImmed:
- y = ImmedPtr[-1];
- FP_TRACE_BYTECODE_OPTIMIZATION("y x cOr", "[truthValue(x)||truthValue(y)]");
- /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
- goto Lcm;
- }
- break;
- }
- break;
- TailCall_cAbs:
- case cAbs:
- switch(ByteCodePtr[0])
- {
- case cNeg:
- FP_TRACE_BYTECODE_OPTIMIZATION("cNeg cAbs", "cAbs");
- /* opcode = cAbs; */ // redundant, matches cAbs @ 0
- goto Lcn;
- case cImmed: break;
- default:
- A = ByteCodePtr[0];
- if(IsNeverNegativeValueOpcode(A))
- {
- FP_TRACE_BYTECODE_OPTIMIZATION("A[IsNeverNegativeValueOpcode(A)] cAbs", "A");
- /* ByteCodePtr[0] = A; */ // redundant, matches A @ 1
- return;
- }
- }
- break;
- }
- goto Lda;
-Laa: ImmedPtr[0] = -x; return;
-Lab: data->ByteCode.pop_back(); return;
-Lac: ImmedPtr[0] = Value_t(1)/x; return;
+ Value_t x;
+ unsigned A;
+ Value_t y;
+ unsigned B;
+ unsigned C;
+ unsigned D;
+ switch(opcode)
+ {
+ TailCall_cAbs:
+ case cAbs:
+ switch(ByteCodePtr[0])
+ {
+ case cNeg:
+ FP_TRACE_BYTECODE_OPTIMIZATION(189,"cNeg cAbs", "cAbs", "");
+ /* opcode = cAbs; */ // redundant, matches cAbs @ 0
+ goto Laa;
+ case cImmed:
+ x = ImmedPtr[0];
+ FP_TRACE_BYTECODE_OPTIMIZATION(40,
+ "x cAbs",
+ "[fp_abs(x)]",
+ " with x = " << x << "\n");
+ /* ByteCodePtr[0] = cImmed; */ // redundant, matches x @ 1
+ goto Lab;
+ default:
+ A = ByteCodePtr[0];
+ if(IsNeverNegativeValueOpcode(A))
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(244,
+ "A[IsNeverNegativeValueOpcode(A)] cAbs",
+ "A",
+ " with A = " << FP_TRACE_OPCODENAME(A) << "\n");
+ /* ByteCodePtr[0] = A; */ // redundant, matches A @ 1
+ return;
+ }
+ }
+ goto Default0;
+ TailCall_cAdd:
+ case cAdd:
+ switch(ByteCodePtr[0])
+ {
+ case cDup:
+ if(ByteCodePtr[-1] == cAdd)
+ {
+ if(ByteCodePtr[-2] == cDup)
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(108,"cDup cAdd cDup cAdd", "[Value_t(4)] cMul", "");
+ goto Lac;
+ }
+ }
+ break;
+ case cNeg:
+ FP_TRACE_BYTECODE_OPTIMIZATION(196,"cNeg cAdd", "cSub", "");
+ goto Lad;
+ case cImmed:
+ x = ImmedPtr[0];
+ switch(ByteCodePtr[-1])
+ {
+ case cAdd:
+ if(ByteCodePtr[-2] == cImmed)
+ {
+ y = ImmedPtr[-1];
+ FP_TRACE_BYTECODE_OPTIMIZATION(142,
+ "y cAdd x cAdd",
+ "[y+x] cAdd",
+ " with x = " << x
+ << ", y = " << y
+ << "\n");
+ /* ByteCodePtr[-2] = cImmed; */ // redundant, matches y @ 3
+ /* opcode = cAdd; */ // redundant, matches cAdd @ 0
+ goto Lae;
+ }
+ break;
+ case cImmed:
+ y = ImmedPtr[-1];
+ FP_TRACE_BYTECODE_OPTIMIZATION(76,
+ "y x cAdd",
+ "[y+x]",
+ " with x = " << x
+ << ", y = " << y
+ << "\n");
+ /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
+ goto Laf;
+ }
+ if(x==Value_t(0))
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(75,
+ "x[x==Value_t(0)] cAdd",
+ "",
+ " with x = " << x << "\n");
+ goto Lag;
+ }
+ break;
+ }
+ goto Default0;
+ TailCall_cAnd:
+ case cAnd:
+ if(ByteCodePtr[0] == cImmed)
+ {
+ x = ImmedPtr[0];
+ if(ByteCodePtr[-1] == cImmed)
+ {
+ y = ImmedPtr[-1];
+ FP_TRACE_BYTECODE_OPTIMIZATION(131,
+ "y x cAnd",
+ "[truthValue(x)&&truthValue(y)]",
+ " with x = " << x
+ << ", y = " << y
+ << "\n");
+ /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
+ goto Lah;
+ }
+ }
+ goto Default0;
+ TailCall_cDiv:
+ case cDiv:
+ switch(ByteCodePtr[0])
+ {
+ case cDup:
+ FP_TRACE_BYTECODE_OPTIMIZATION(121,"cDup cDiv", "[Value_t(0)] cMul [Value_t(1)] cAdd", "");
+ goto Lai;
+ case cImmed:
+ x = ImmedPtr[0];
+ if(x!=Value_t(0))
+ {
+ switch(ByteCodePtr[-1])
+ {
+ case cNeg:
+ FP_TRACE_BYTECODE_OPTIMIZATION(139,
+ "cNeg x[x!=Value_t(0)] cDiv",
+ "[-x] cDiv",
+ " with x = " << x << "\n");
+ /* opcode = cDiv; */ // redundant, matches cDiv @ 0
+ goto Laj;
+ case cImmed:
+ y = ImmedPtr[-1];
+ FP_TRACE_BYTECODE_OPTIMIZATION(73,
+ "y x[x!=Value_t(0)] cDiv",
+ "[y/x]",
+ " with x = " << x
+ << ", y = " << y
+ << "\n");
+ /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
+ goto Lak;
+ }
+ }
+ if(x==Value_t(1))
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(72,
+ "x[x==Value_t(1)] cDiv",
+ "",
+ " with x = " << x << "\n");
+ goto Lag;
+ }
+ break;
+ }
+ goto Default0;
+ TailCall_cEqual:
+ case cEqual:
+ if(ByteCodePtr[0] == cImmed)
+ {
+ x = ImmedPtr[0];
+ if(x==Value_t(1))
+ {
+ A = ByteCodePtr[-1];
+ if(IsLogicalOpcode(A))
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(272,
+ "A[IsLogicalOpcode(A)] x[x==Value_t(1)] cEqual",
+ "A",
+ " with x = " << x
+ << ", A = " << FP_TRACE_OPCODENAME(A)
+ << "\n");
+ /* ByteCodePtr[-1] = A; */ // redundant, matches A @ 2
+ goto Lag;
+ }
+ }
+ if(ByteCodePtr[-1] == cImmed)
+ {
+ y = ImmedPtr[-1];
+ FP_TRACE_BYTECODE_OPTIMIZATION(129,
+ "y x cEqual",
+ "[fp_equal(y,x)]",
+ " with x = " << x
+ << ", y = " << y
+ << "\n");
+ /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
+ goto Lal;
+ }
+ if(x==Value_t(0))
+ {
+ switch(ByteCodePtr[-1])
+ {
+ case cAbs:
+ FP_TRACE_BYTECODE_OPTIMIZATION(208,
+ "cAbs x[x==Value_t(0)] cEqual",
+ "[x] cEqual",
+ " with x = " << x << "\n");
+ /* ImmedPtr[0] = x; */ // redundant, matches x @ 1
+ /* opcode = cEqual; */ // redundant, matches cEqual @ 0
+ goto Lam;
+ case cSqr:
+ FP_TRACE_BYTECODE_OPTIMIZATION(210,
+ "cSqr x[x==Value_t(0)] cEqual",
+ "[x] cEqual",
+ " with x = " << x << "\n");
+ /* ImmedPtr[0] = x; */ // redundant, matches x @ 1
+ /* opcode = cEqual; */ // redundant, matches cEqual @ 0
+ goto Lam;
+ }
+ FP_TRACE_BYTECODE_OPTIMIZATION(262,
+ "x[x==Value_t(0)] cEqual",
+ "cNot",
+ " with x = " << x << "\n");
+ goto Lan;
+ }
+ }
+ goto Default0;
+ TailCall_cGreater:
+ case cGreater:
+ if(ByteCodePtr[0] == cImmed)
+ {
+ x = ImmedPtr[0];
+ if(x==Value_t(0))
+ {
+ switch(ByteCodePtr[-1])
+ {
+ case cAbs:
+ FP_TRACE_BYTECODE_OPTIMIZATION(264,
+ "cAbs x[x==Value_t(0)] cGreater",
+ "cNotNot",
+ " with x = " << x << "\n");
+ goto Lao;
+ default:
+ A = ByteCodePtr[-1];
+ if(IsNeverNegativeValueOpcode(A))
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(268,
+ "A[IsNeverNegativeValueOpcode(A)] x[x==Value_t(0)] cGreater",
+ "A cNotNot",
+ " with x = " << x
+ << ", A = " << FP_TRACE_OPCODENAME(A)
+ << "\n");
+ /* ByteCodePtr[-1] = A; */ // redundant, matches A @ 2
+ goto Lap;
+ }
+ }
+ }
+ if(ByteCodePtr[-1] == cImmed)
+ {
+ y = ImmedPtr[-1];
+ FP_TRACE_BYTECODE_OPTIMIZATION(127,
+ "y x cGreater",
+ "[fp_less(x,y)]",
+ " with x = " << x
+ << ", y = " << y
+ << "\n");
+ /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
+ goto Lba;
+ }
+ }
+ goto Default0;
+ TailCall_cGreaterOrEq:
+ case cGreaterOrEq:
+ if(ByteCodePtr[0] == cImmed)
+ {
+ x = ImmedPtr[0];
+ if(x==Value_t(1))
+ {
+ switch(ByteCodePtr[-1])
+ {
+ case cAbs:
+ FP_TRACE_BYTECODE_OPTIMIZATION(265,
+ "cAbs x[x==Value_t(1)] cGreaterOrEq",
+ "cNotNot",
+ " with x = " << x << "\n");
+ goto Lao;
+ default:
+ A = ByteCodePtr[-1];
+ if(IsNeverNegativeValueOpcode(A))
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(269,
+ "A[IsNeverNegativeValueOpcode(A)] x[x==Value_t(1)] cGreaterOrEq",
+ "A cNotNot",
+ " with x = " << x
+ << ", A = " << FP_TRACE_OPCODENAME(A)
+ << "\n");
+ /* ByteCodePtr[-1] = A; */ // redundant, matches A @ 2
+ goto Lap;
+ }
+ }
+ }
+ if(ByteCodePtr[-1] == cImmed)
+ {
+ y = ImmedPtr[-1];
+ FP_TRACE_BYTECODE_OPTIMIZATION(128,
+ "y x cGreaterOrEq",
+ "[fp_lessOrEq(x,y)]",
+ " with x = " << x
+ << ", y = " << y
+ << "\n");
+ /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
+ goto Lbb;
+ }
+ }
+ goto Default0;
+ TailCall_cInv:
+ case cInv:
+ switch(ByteCodePtr[0])
+ {
+ case cInv:
+ FP_TRACE_BYTECODE_OPTIMIZATION(190,"cInv cInv", "", "");
+ goto Lbc;
+ case cSqrt:
+ FP_TRACE_BYTECODE_OPTIMIZATION(67,"cSqrt cInv", "cRSqrt", "");
+ goto Lbd;
+ case cImmed:
+ x = ImmedPtr[0];
+ if(x!=Value_t(0))
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(69,
+ "x[x!=Value_t(0)] cInv",
+ "[Value_t(1)/x]",
+ " with x = " << x << "\n");
+ /* ByteCodePtr[0] = cImmed; */ // redundant, matches x @ 1
+ goto Lbe;
+ }
+ break;
+ }
+ goto Default0;
+ TailCall_cLess:
+ case cLess:
+ if(ByteCodePtr[0] == cImmed)
+ {
+ x = ImmedPtr[0];
+ if(x==Value_t(1))
+ {
+ switch(ByteCodePtr[-1])
+ {
+ case cAbs:
+ FP_TRACE_BYTECODE_OPTIMIZATION(266,
+ "cAbs x[x==Value_t(1)] cLess",
+ "cNot",
+ " with x = " << x << "\n");
+ goto Lbf;
+ default:
+ A = ByteCodePtr[-1];
+ if(IsNeverNegativeValueOpcode(A))
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(270,
+ "A[IsNeverNegativeValueOpcode(A)] x[x==Value_t(1)] cLess",
+ "A cNot",
+ " with x = " << x
+ << ", A = " << FP_TRACE_OPCODENAME(A)
+ << "\n");
+ /* ByteCodePtr[-1] = A; */ // redundant, matches A @ 2
+ goto Lan;
+ }
+ }
+ }
+ if(ByteCodePtr[-1] == cImmed)
+ {
+ y = ImmedPtr[-1];
+ FP_TRACE_BYTECODE_OPTIMIZATION(125,
+ "y x cLess",
+ "[fp_less(y,x)]",
+ " with x = " << x
+ << ", y = " << y
+ << "\n");
+ /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
+ goto Lbg;
+ }
+ }
+ goto Default0;
+ TailCall_cLessOrEq:
+ case cLessOrEq:
+ if(ByteCodePtr[0] == cImmed)
+ {
+ x = ImmedPtr[0];
+ if(x==Value_t(0))
+ {
+ switch(ByteCodePtr[-1])
+ {
+ case cAbs:
+ FP_TRACE_BYTECODE_OPTIMIZATION(267,
+ "cAbs x[x==Value_t(0)] cLessOrEq",
+ "cNot",
+ " with x = " << x << "\n");
+ goto Lbf;
+ default:
+ A = ByteCodePtr[-1];
+ if(IsNeverNegativeValueOpcode(A))
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(271,
+ "A[IsNeverNegativeValueOpcode(A)] x[x==Value_t(0)] cLessOrEq",
+ "A cNot",
+ " with x = " << x
+ << ", A = " << FP_TRACE_OPCODENAME(A)
+ << "\n");
+ /* ByteCodePtr[-1] = A; */ // redundant, matches A @ 2
+ goto Lan;
+ }
+ }
+ }
+ if(ByteCodePtr[-1] == cImmed)
+ {
+ y = ImmedPtr[-1];
+ FP_TRACE_BYTECODE_OPTIMIZATION(126,
+ "y x cLessOrEq",
+ "[fp_lessOrEq(y,x)]",
+ " with x = " << x
+ << ", y = " << y
+ << "\n");
+ /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
+ goto Lbh;
+ }
+ }
+ goto Default0;
+ TailCall_cMax:
+ case cMax:
+ switch(ByteCodePtr[0])
+ {
+ case cDup:
+ FP_TRACE_BYTECODE_OPTIMIZATION(111,"cDup cMax", "", "");
+ goto Lbc;
+ case cImmed:
+ x = ImmedPtr[0];
+ if(ByteCodePtr[-1] == cImmed)
+ {
+ y = ImmedPtr[-1];
+ FP_TRACE_BYTECODE_OPTIMIZATION(82,
+ "y x cMax",
+ "[Max(x,y)]",
+ " with x = " << x
+ << ", y = " << y
+ << "\n");
+ /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
+ goto Lbi;
+ }
+ break;
+ default:
+ A = ByteCodePtr[0];
+ if(A>=VarBegin)
+ {
+ switch(ByteCodePtr[-1])
+ {
+ case cDup:
+ B = ByteCodePtr[-2];
+ if(B==A)
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(113,
+ "B[B==A] cDup A[A>=VarBegin] cMax",
+ "B cDup",
+ " with A = " << FP_TRACE_OPCODENAME(A)
+ << ", B = " << FP_TRACE_OPCODENAME(B)
+ << "\n");
+ /* ByteCodePtr[-2] = B; */ // redundant, matches B @ 3
+ /* ByteCodePtr[-1] = cDup; */ // redundant, matches cDup @ 2
+ goto Lbc;
+ }
+ break;
+ case cMax:
+ B = ByteCodePtr[-2];
+ if(B==A)
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(115,
+ "B[B==A] cMax A[A>=VarBegin] cMax",
+ "B cMax",
+ " with A = " << FP_TRACE_OPCODENAME(A)
+ << ", B = " << FP_TRACE_OPCODENAME(B)
+ << "\n");
+ /* ByteCodePtr[-2] = B; */ // redundant, matches B @ 3
+ /* ByteCodePtr[-1] = cMax; */ // redundant, matches cMax @ 2
+ goto Lbc;
+ }
+ break;
+ }
+ }
+ }
+ goto Default0;
+ TailCall_cMin:
+ case cMin:
+ switch(ByteCodePtr[0])
+ {
+ case cDup:
+ FP_TRACE_BYTECODE_OPTIMIZATION(110,"cDup cMin", "", "");
+ goto Lbc;
+ case cImmed:
+ x = ImmedPtr[0];
+ if(ByteCodePtr[-1] == cImmed)
+ {
+ y = ImmedPtr[-1];
+ FP_TRACE_BYTECODE_OPTIMIZATION(81,
+ "y x cMin",
+ "[Min(x,y)]",
+ " with x = " << x
+ << ", y = " << y
+ << "\n");
+ /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
+ goto Lbj;
+ }
+ break;
+ default:
+ A = ByteCodePtr[0];
+ if(A>=VarBegin)
+ {
+ switch(ByteCodePtr[-1])
+ {
+ case cDup:
+ B = ByteCodePtr[-2];
+ if(B==A)
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(112,
+ "B[B==A] cDup A[A>=VarBegin] cMin",
+ "B cDup",
+ " with A = " << FP_TRACE_OPCODENAME(A)
+ << ", B = " << FP_TRACE_OPCODENAME(B)
+ << "\n");
+ /* ByteCodePtr[-2] = B; */ // redundant, matches B @ 3
+ /* ByteCodePtr[-1] = cDup; */ // redundant, matches cDup @ 2
+ goto Lbc;
+ }
+ break;
+ case cMin:
+ B = ByteCodePtr[-2];
+ if(B==A)
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(114,
+ "B[B==A] cMin A[A>=VarBegin] cMin",
+ "B cMin",
+ " with A = " << FP_TRACE_OPCODENAME(A)
+ << ", B = " << FP_TRACE_OPCODENAME(B)
+ << "\n");
+ /* ByteCodePtr[-2] = B; */ // redundant, matches B @ 3
+ /* ByteCodePtr[-1] = cMin; */ // redundant, matches cMin @ 2
+ goto Lbc;
+ }
+ break;
+ }
+ }
+ }
+ goto Default0;
+ TailCall_cMod:
+ case cMod:
+ if(ByteCodePtr[0] == cImmed)
+ {
+ x = ImmedPtr[0];
+ if(x!=Value_t(0))
+ {
+ if(ByteCodePtr[-1] == cImmed)
+ {
+ y = ImmedPtr[-1];
+ FP_TRACE_BYTECODE_OPTIMIZATION(74,
+ "y x[x!=Value_t(0)] cMod",
+ "[fp_mod(y,x)]",
+ " with x = " << x
+ << ", y = " << y
+ << "\n");
+ /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
+ goto Lbk;
+ }
+ }
+ }
+ goto Default0;
+ TailCall_cMul:
+ case cMul:
+ switch(ByteCodePtr[0])
+ {
+ case cDup:
+ FP_TRACE_BYTECODE_OPTIMIZATION(338,"cDup cMul", "cSqr", "");
+ goto Lbl;
+ case cInv:
+ FP_TRACE_BYTECODE_OPTIMIZATION(195,"cInv cMul", "cDiv", "");
+ goto Lbm;
+ case cNeg:
+ A = ByteCodePtr[-1];
+ if(A>=VarBegin)
+ {
+ switch(ByteCodePtr[-2])
+ {
+ case cMul:
+ B = ByteCodePtr[-3];
+ if(B==A)
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(330,
+ "B[B==A] cMul A[A>=VarBegin] cNeg cMul",
+ "B cSqr cMul cNeg",
+ " with A = " << FP_TRACE_OPCODENAME(A)
+ << ", B = " << FP_TRACE_OPCODENAME(B)
+ << "\n");
+ /* ByteCodePtr[-3] = B; */ // redundant, matches B @ 4
+ goto Lbn;
+ }
+ goto Default1;
+ default: Default1:;
+ B = ByteCodePtr[-2];
+ if(B==A)
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(324,
+ "B[B==A] A[A>=VarBegin] cNeg cMul",
+ "B cSqr cNeg",
+ " with A = " << FP_TRACE_OPCODENAME(A)
+ << ", B = " << FP_TRACE_OPCODENAME(B)
+ << "\n");
+ /* ByteCodePtr[-2] = B; */ // redundant, matches B @ 3
+ goto Lbo;
+ }
+ }
+ }
+ goto Default2;
+ case cImmed:
+ x = ImmedPtr[0];
+ if(x==Value_t(0))
+ {
+ switch(ByteCodePtr[-1])
+ {
+ case cMul:
+ A = ByteCodePtr[-2];
+ if(A>=VarBegin)
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(94,
+ "A[A>=VarBegin] cMul x[x==Value_t(0)] cMul",
+ "[x] cMul",
+ " with x = " << x
+ << ", A = " << FP_TRACE_OPCODENAME(A)
+ << "\n");
+ /* ImmedPtr[0] = x; */ // redundant, matches x @ 1
+ /* opcode = cMul; */ // redundant, matches cMul @ 0
+ goto Lbp;
+ }
+ goto Default3;
+ default: Default3:;
+ A = ByteCodePtr[-1];
+ if(IsBinaryOpcode(A)&&!HasInvalidRangesOpcode(A))
+ {
+ switch(ByteCodePtr[-2])
+ {
+ case cImmed:
+ y = ImmedPtr[-1];
+ FP_TRACE_BYTECODE_OPTIMIZATION(93,
+ "y A[IsBinaryOpcode(A)&&!HasInvalidRangesOpcode(A)] x[x==Value_t(0)] cMul",
+ "[x] cMul",
+ " with x = " << x
+ << ", A = " << FP_TRACE_OPCODENAME(A)
+ << ", y = " << y
+ << "\n");
+ /* ByteCodePtr[-2] = cImmed; */ // redundant, matches y @ 3
+ /* opcode = cMul; */ // redundant, matches cMul @ 0
+ goto Lca;
+ default:
+ B = ByteCodePtr[-2];
+ if(IsBinaryOpcode(B)&&!HasInvalidRangesOpcode(B))
+ {
+ switch(ByteCodePtr[-3])
+ {
+ case cImmed:
+ y = ImmedPtr[-1];
+ FP_TRACE_BYTECODE_OPTIMIZATION(97,
+ "y B[IsBinaryOpcode(B)&&!HasInvalidRangesOpcode(B)] A[IsBinaryOpcode(A)&&!HasInvalidRangesOpcode(A)] x[x==Value_t(0)] cMul",
+ "A [x] cMul",
+ " with x = " << x
+ << ", A = " << FP_TRACE_OPCODENAME(A)
+ << ", B = " << FP_TRACE_OPCODENAME(B)
+ << ", y = " << y
+ << "\n");
+ /* opcode = cMul; */ // redundant, matches cMul @ 0
+ goto Lcb;
+ default:
+ C = ByteCodePtr[-3];
+ if(C>=VarBegin)
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(95,
+ "C[C>=VarBegin] B[IsBinaryOpcode(B)&&!HasInvalidRangesOpcode(B)] A[IsBinaryOpcode(A)&&!HasInvalidRangesOpcode(A)] x[x==Value_t(0)] cMul",
+ "A [x] cMul",
+ " with x = " << x
+ << ", A = " << FP_TRACE_OPCODENAME(A)
+ << ", B = " << FP_TRACE_OPCODENAME(B)
+ << ", C = " << FP_TRACE_OPCODENAME(C)
+ << "\n");
+ /* opcode = cMul; */ // redundant, matches cMul @ 0
+ goto Lcc;
+ }
+ if(IsUnaryOpcode(C)&&!HasInvalidRangesOpcode(C))
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(96,
+ "C[IsUnaryOpcode(C)&&!HasInvalidRangesOpcode(C)] B[IsBinaryOpcode(B)&&!HasInvalidRangesOpcode(B)] A[IsBinaryOpcode(A)&&!HasInvalidRangesOpcode(A)] x[x==Value_t(0)] cMul",
+ "B A [x] cMul",
+ " with x = " << x
+ << ", A = " << FP_TRACE_OPCODENAME(A)
+ << ", B = " << FP_TRACE_OPCODENAME(B)
+ << ", C = " << FP_TRACE_OPCODENAME(C)
+ << "\n");
+ /* opcode = cMul; */ // redundant, matches cMul @ 0
+ goto Lcd;
+ }
+ }
+ }
+ if(B>=VarBegin)
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(91,
+ "B[B>=VarBegin] A[IsBinaryOpcode(A)&&!HasInvalidRangesOpcode(A)] x[x==Value_t(0)] cMul",
+ "[x] cMul",
+ " with x = " << x
+ << ", A = " << FP_TRACE_OPCODENAME(A)
+ << ", B = " << FP_TRACE_OPCODENAME(B)
+ << "\n");
+ /* ImmedPtr[0] = x; */ // redundant, matches x @ 1
+ /* opcode = cMul; */ // redundant, matches cMul @ 0
+ goto Lbp;
+ }
+ if(IsUnaryOpcode(B)&&!HasInvalidRangesOpcode(B))
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(92,
+ "B[IsUnaryOpcode(B)&&!HasInvalidRangesOpcode(B)] A[IsBinaryOpcode(A)&&!HasInvalidRangesOpcode(A)] x[x==Value_t(0)] cMul",
+ "A [x] cMul",
+ " with x = " << x
+ << ", A = " << FP_TRACE_OPCODENAME(A)
+ << ", B = " << FP_TRACE_OPCODENAME(B)
+ << "\n");
+ /* opcode = cMul; */ // redundant, matches cMul @ 0
+ goto Lce;
+ }
+ }
+ }
+ if(A>=VarBegin)
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(89,
+ "A[A>=VarBegin] x[x==Value_t(0)] cMul",
+ "[x]",
+ " with x = " << x
+ << ", A = " << FP_TRACE_OPCODENAME(A)
+ << "\n");
+ /* ImmedPtr[0] = x; */ // redundant, matches x @ 1
+ goto Lcf;
+ }
+ if(IsUnaryOpcode(A)&&!HasInvalidRangesOpcode(A))
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(90,
+ "A[IsUnaryOpcode(A)&&!HasInvalidRangesOpcode(A)] x[x==Value_t(0)] cMul",
+ "[x] cMul",
+ " with x = " << x
+ << ", A = " << FP_TRACE_OPCODENAME(A)
+ << "\n");
+ /* ImmedPtr[0] = x; */ // redundant, matches x @ 1
+ /* opcode = cMul; */ // redundant, matches cMul @ 0
+ goto Lcg;
+ }
+ }
+ }
+ switch(ByteCodePtr[-1])
+ {
+ case cAdd:
+ if(ByteCodePtr[-2] == cDup)
+ {
+ if(x+x==Value_t(1))
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(148,
+ "cDup[x+x==Value_t(1)] cAdd x cMul",
+ "",
+ " with x = " << x << "\n");
+ goto Lch;
+ }
+ FP_TRACE_BYTECODE_OPTIMIZATION(149,
+ "cDup cAdd x cMul",
+ "[x+x] cMul",
+ " with x = " << x << "\n");
+ /* opcode = cMul; */ // redundant, matches cMul @ 0
+ goto Lci;
+ }
+ break;
+ case cMul:
+ if(ByteCodePtr[-2] == cImmed)
+ {
+ y = ImmedPtr[-1];
+ if(y*x==Value_t(1))
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(146,
+ "y[y*x==Value_t(1)] cMul x cMul",
+ "",
+ " with x = " << x
+ << ", y = " << y
+ << "\n");
+ goto Lcj;
+ }
+ FP_TRACE_BYTECODE_OPTIMIZATION(147,
+ "y cMul x cMul",
+ "[y*x] cMul",
+ " with x = " << x
+ << ", y = " << y
+ << "\n");
+ /* ByteCodePtr[-2] = cImmed; */ // redundant, matches y @ 3
+ /* opcode = cMul; */ // redundant, matches cMul @ 0
+ goto Lck;
+ }
+ break;
+ case cNeg:
+ FP_TRACE_BYTECODE_OPTIMIZATION(136,
+ "cNeg x cMul",
+ "[-x] cMul",
+ " with x = " << x << "\n");
+ /* opcode = cMul; */ // redundant, matches cMul @ 0
+ goto Lcl;
+ case cImmed:
+ y = ImmedPtr[-1];
+ FP_TRACE_BYTECODE_OPTIMIZATION(71,
+ "y x cMul",
+ "[y*x]",
+ " with x = " << x
+ << ", y = " << y
+ << "\n");
+ /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
+ goto Lcm;
+ }
+ if(x==Value_t(1))
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(70,
+ "x[x==Value_t(1)] cMul",
+ "",
+ " with x = " << x << "\n");
+ goto Lag;
+ }
+ if(x==Value_t(2))
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(100,
+ "x[x==Value_t(2)] cMul",
+ "cDup cAdd",
+ " with x = " << x << "\n");
+ goto Lcn;
+ }
+ if(x==Value_t(-1))
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(138,
+ "x[x==Value_t(-1)] cMul",
+ "cNeg",
+ " with x = " << x << "\n");
+ goto Lco;
+ }
+ break;
+ default: Default2:;
+ A = ByteCodePtr[0];
+ if(A>=VarBegin)
+ {
+ switch(ByteCodePtr[-1])
+ {
+ case cMul:
+ switch(ByteCodePtr[-2])
+ {
+ case cNeg:
+ B = ByteCodePtr[-3];
+ if(B==A)
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(327,
+ "B[B==A] cNeg cMul A[A>=VarBegin] cMul",
+ "B cSqr cMul cNeg",
+ " with A = " << FP_TRACE_OPCODENAME(A)
+ << ", B = " << FP_TRACE_OPCODENAME(B)
+ << "\n");
+ /* ByteCodePtr[-3] = B; */ // redundant, matches B @ 4
+ goto Lbn;
+ }
+ goto Default4;
+ default: Default4:;
+ B = ByteCodePtr[-2];
+ if(B==A)
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(318,
+ "B[B==A] cMul A[A>=VarBegin] cMul",
+ "B cSqr cMul",
+ " with A = " << FP_TRACE_OPCODENAME(A)
+ << ", B = " << FP_TRACE_OPCODENAME(B)
+ << "\n");
+ /* ByteCodePtr[-2] = B; */ // redundant, matches B @ 3
+ /* opcode = cMul; */ // redundant, matches cMul @ 0
+ goto Lcp;
+ }
+ }
+ goto Default5;
+ case cNeg:
+ B = ByteCodePtr[-2];
+ if(B==A)
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(321,
+ "B[B==A] cNeg A[A>=VarBegin] cMul",
+ "B cSqr cNeg",
+ " with A = " << FP_TRACE_OPCODENAME(A)
+ << ", B = " << FP_TRACE_OPCODENAME(B)
+ << "\n");
+ /* ByteCodePtr[-2] = B; */ // redundant, matches B @ 3
+ goto Lbo;
+ }
+ goto Default5;
+ default: Default5:;
+ B = ByteCodePtr[-1];
+ if(B==A)
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(315,
+ "B[B==A] A[A>=VarBegin] cMul",
+ "B cSqr",
+ " with A = " << FP_TRACE_OPCODENAME(A)
+ << ", B = " << FP_TRACE_OPCODENAME(B)
+ << "\n");
+ /* ByteCodePtr[-1] = B; */ // redundant, matches B @ 2
+ goto Lbl;
+ }
+ }
+ }
+ if(IsUnaryOpcode(A))
+ {
+ B = ByteCodePtr[-1];
+ if(B>=VarBegin)
+ {
+ if(ByteCodePtr[-2] == cMul)
+ {
+ C = ByteCodePtr[-3];
+ if(C==A)
+ {
+ D = ByteCodePtr[-4];
+ if(D==B)
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(337,
+ "D[D==B] C[C==A] cMul B[B>=VarBegin] A[IsUnaryOpcode(A)] cMul",
+ "D C cSqr cMul",
+ " with A = " << FP_TRACE_OPCODENAME(A)
+ << ", B = " << FP_TRACE_OPCODENAME(B)
+ << ", C = " << FP_TRACE_OPCODENAME(C)
+ << ", D = " << FP_TRACE_OPCODENAME(D)
+ << "\n");
+ /* ByteCodePtr[-4] = D; */ // redundant, matches D @ 5
+ /* ByteCodePtr[-3] = C; */ // redundant, matches C @ 4
+ /* opcode = cMul; */ // redundant, matches cMul @ 0
+ goto Lda;
+ }
+ }
+ }
+ }
+ }
+ }
+ goto Default0;
+ TailCall_cNEqual:
+ case cNEqual:
+ if(ByteCodePtr[0] == cImmed)
+ {
+ x = ImmedPtr[0];
+ if(x==Value_t(1))
+ {
+ A = ByteCodePtr[-1];
+ if(IsLogicalOpcode(A))
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(273,
+ "A[IsLogicalOpcode(A)] x[x==Value_t(1)] cNEqual",
+ "A cNot",
+ " with x = " << x
+ << ", A = " << FP_TRACE_OPCODENAME(A)
+ << "\n");
+ /* ByteCodePtr[-1] = A; */ // redundant, matches A @ 2
+ goto Lan;
+ }
+ }
+ if(ByteCodePtr[-1] == cImmed)
+ {
+ y = ImmedPtr[-1];
+ FP_TRACE_BYTECODE_OPTIMIZATION(130,
+ "y x cNEqual",
+ "[fp_nequal(y,x)]",
+ " with x = " << x
+ << ", y = " << y
+ << "\n");
+ /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
+ goto Ldb;
+ }
+ if(x==Value_t(0))
+ {
+ switch(ByteCodePtr[-1])
+ {
+ case cAbs:
+ FP_TRACE_BYTECODE_OPTIMIZATION(209,
+ "cAbs x[x==Value_t(0)] cNEqual",
+ "[x] cNEqual",
+ " with x = " << x << "\n");
+ /* ImmedPtr[0] = x; */ // redundant, matches x @ 1
+ /* opcode = cNEqual; */ // redundant, matches cNEqual @ 0
+ goto Ldc;
+ case cSqr:
+ FP_TRACE_BYTECODE_OPTIMIZATION(211,
+ "cSqr x[x==Value_t(0)] cNEqual",
+ "[x] cNEqual",
+ " with x = " << x << "\n");
+ /* ImmedPtr[0] = x; */ // redundant, matches x @ 1
+ /* opcode = cNEqual; */ // redundant, matches cNEqual @ 0
+ goto Ldc;
+ }
+ FP_TRACE_BYTECODE_OPTIMIZATION(263,
+ "x[x==Value_t(0)] cNEqual",
+ "cNotNot",
+ " with x = " << x << "\n");
+ goto Lap;
+ }
+ }
+ goto Default0;
+ TailCall_cNeg:
+ case cNeg:
+ switch(ByteCodePtr[0])
+ {
+ case cMul:
+ if(ByteCodePtr[-1] == cImmed)
+ {
+ x = ImmedPtr[0];
+ FP_TRACE_BYTECODE_OPTIMIZATION(137,
+ "x cMul cNeg",
+ "[-x] cMul",
+ " with x = " << x << "\n");
+ /* ByteCodePtr[-1] = cImmed; */ // redundant, matches x @ 2
+ goto Ldd;
+ }
+ break;
+ case cNeg:
+ FP_TRACE_BYTECODE_OPTIMIZATION(191,"cNeg cNeg", "", "");
+ goto Lbc;
+ case cImmed:
+ x = ImmedPtr[0];
+ FP_TRACE_BYTECODE_OPTIMIZATION(68,
+ "x cNeg",
+ "[-x]",
+ " with x = " << x << "\n");
+ /* ByteCodePtr[0] = cImmed; */ // redundant, matches x @ 1
+ goto Lde;
+ }
+ goto Default0;
+ TailCall_cNot:
+ case cNot:
+ switch(ByteCodePtr[0])
+ {
+ case cAbs:
+ FP_TRACE_BYTECODE_OPTIMIZATION(235,"cAbs cNot", "cNot", "");
+ /* opcode = cNot; */ // redundant, matches cNot @ 0
+ goto Ldf;
+ case cAbsNot:
+ A = ByteCodePtr[-1];
+ if(IsLogicalOpcode(A))
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(240,
+ "A[IsLogicalOpcode(A)] cAbsNot cNot",
+ "A",
+ " with A = " << FP_TRACE_OPCODENAME(A) << "\n");
+ /* ByteCodePtr[-1] = A; */ // redundant, matches A @ 2
+ goto Lbc;
+ }
+ if(A!=cImmed)
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(241,
+ "A[A!=cImmed] cAbsNot cNot",
+ "A cAbsNotNot",
+ " with A = " << FP_TRACE_OPCODENAME(A) << "\n");
+ /* ByteCodePtr[-1] = A; */ // redundant, matches A @ 2
+ goto Ldg;
+ }
+ goto Default6;
+ case cAbsNotNot:
+ FP_TRACE_BYTECODE_OPTIMIZATION(238,"cAbsNotNot cNot", "cAbsNot", "");
+ goto Ldh;
+ case cEqual:
+ FP_TRACE_BYTECODE_OPTIMIZATION(205,"cEqual cNot", "cNEqual", "");
+ goto Ldi;
+ case cGreater:
+ FP_TRACE_BYTECODE_OPTIMIZATION(203,"cGreater cNot", "cLessOrEq", "");
+ goto Ldj;
+ case cGreaterOrEq:
+ FP_TRACE_BYTECODE_OPTIMIZATION(204,"cGreaterOrEq cNot", "cLess", "");
+ goto Ldk;
+ case cLess:
+ FP_TRACE_BYTECODE_OPTIMIZATION(201,"cLess cNot", "cGreaterOrEq", "");
+ goto Ldl;
+ case cLessOrEq:
+ FP_TRACE_BYTECODE_OPTIMIZATION(202,"cLessOrEq cNot", "cGreater", "");
+ goto Ldm;
+ case cNEqual:
+ FP_TRACE_BYTECODE_OPTIMIZATION(206,"cNEqual cNot", "cEqual", "");
+ goto Ldn;
+ case cNeg:
+ FP_TRACE_BYTECODE_OPTIMIZATION(234,"cNeg cNot", "cNot", "");
+ /* opcode = cNot; */ // redundant, matches cNot @ 0
+ goto Ldf;
+ case cNot:
+ FP_TRACE_BYTECODE_OPTIMIZATION(236,"cNot cNot", "cNotNot", "");
+ goto Ldo;
+ case cNotNot:
+ FP_TRACE_BYTECODE_OPTIMIZATION(237,"cNotNot cNot", "cNot", "");
+ /* opcode = cNot; */ // redundant, matches cNot @ 0
+ goto Ldf;
+ case cImmed:
+ x = ImmedPtr[0];
+ FP_TRACE_BYTECODE_OPTIMIZATION(85,
+ "x cNot",
+ "[!truthValue(x)]",
+ " with x = " << x << "\n");
+ /* ByteCodePtr[0] = cImmed; */ // redundant, matches x @ 1
+ goto Ldp;
+ default: Default6:;
+ A = ByteCodePtr[0];
+ if(IsNeverNegativeValueOpcode(A))
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(242,
+ "A[IsNeverNegativeValueOpcode(A)] cNot",
+ "A cAbsNot",
+ " with A = " << FP_TRACE_OPCODENAME(A) << "\n");
+ /* ByteCodePtr[0] = A; */ // redundant, matches A @ 1
+ goto Lea;
+ }
+ }
+ goto Default0;
+ TailCall_cOr:
+ case cOr:
+ if(ByteCodePtr[0] == cImmed)
+ {
+ x = ImmedPtr[0];
+ if(ByteCodePtr[-1] == cImmed)
+ {
+ y = ImmedPtr[-1];
+ FP_TRACE_BYTECODE_OPTIMIZATION(132,
+ "y x cOr",
+ "[truthValue(x)||truthValue(y)]",
+ " with x = " << x
+ << ", y = " << y
+ << "\n");
+ /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
+ goto Leb;
+ }
+ }
+ goto Default0;
+ TailCall_cSqr:
+ case cSqr:
+ switch(ByteCodePtr[0])
+ {
+ case cAbs:
+ FP_TRACE_BYTECODE_OPTIMIZATION(333,"cAbs cSqr", "cSqr", "");
+ /* opcode = cSqr; */ // redundant, matches cSqr @ 0
+ goto Lec;
+ case cNeg:
+ FP_TRACE_BYTECODE_OPTIMIZATION(332,"cNeg cSqr", "cSqr", "");
+ /* opcode = cSqr; */ // redundant, matches cSqr @ 0
+ goto Lec;
+ }
+ goto Default0;
+ TailCall_cSub:
+ case cSub:
+ switch(ByteCodePtr[0])
+ {
+ case cNeg:
+ FP_TRACE_BYTECODE_OPTIMIZATION(197,"cNeg cSub", "cAdd", "");
+ goto Led;
+ case cImmed:
+ x = ImmedPtr[0];
+ if(x==Value_t(0))
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(77,
+ "x[x==Value_t(0)] cSub",
+ "",
+ " with x = " << x << "\n");
+ goto Lag;
+ }
+ if(ByteCodePtr[-1] == cImmed)
+ {
+ y = ImmedPtr[-1];
+ FP_TRACE_BYTECODE_OPTIMIZATION(78,
+ "y x cSub",
+ "[y-x]",
+ " with x = " << x
+ << ", y = " << y
+ << "\n");
+ /* ByteCodePtr[-1] = cImmed; */ // redundant, matches y @ 2
+ goto Lee;
+ }
+ FP_TRACE_BYTECODE_OPTIMIZATION(160,
+ "x cSub",
+ "[-x] cAdd",
+ " with x = " << x << "\n");
+ /* ByteCodePtr[0] = cImmed; */ // redundant, matches x @ 1
+ goto Lef;
+ }
+ goto Default0;
+ default: Default0:;
+ A = opcode;
+ if(IsComparisonOpcode(A))
+ {
+ if(ByteCodePtr[0] == cImmed)
+ {
+ x = ImmedPtr[0];
+ switch(ByteCodePtr[-1])
+ {
+ case cAdd:
+ if(ByteCodePtr[-2] == cImmed)
+ {
+ y = ImmedPtr[-1];
+ FP_TRACE_BYTECODE_OPTIMIZATION(213,
+ "y cAdd x A[IsComparisonOpcode(A)]",
+ "[x-y] A",
+ " with A = " << FP_TRACE_OPCODENAME(A)
+ << ", x = " << x
+ << ", y = " << y
+ << "\n");
+ /* ByteCodePtr[-2] = cImmed; */ // redundant, matches y @ 3
+ goto Leg;
+ }
+ break;
+ case cNeg:
+ FP_TRACE_BYTECODE_OPTIMIZATION(214,
+ "cNeg x A[IsComparisonOpcode(A)]",
+ "[-x] {OppositeComparisonOpcode(A)}",
+ " with A = " << FP_TRACE_OPCODENAME(A)
+ << ", x = " << x
+ << "\n");
+ goto Leh;
+ }
+ }
+ }
+ if(A>=VarBegin)
+ {
+ B = ByteCodePtr[0];
+ if(B==A)
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(335,
+ "B[B==A] A[A>=VarBegin]",
+ "B cDup",
+ " with A = " << FP_TRACE_OPCODENAME(A)
+ << ", B = " << FP_TRACE_OPCODENAME(B)
+ << "\n");
+ /* ByteCodePtr[0] = B; */ // redundant, matches B @ 1
+ goto Lei;
+ }
+ }
+ if(IsUnaryOpcode(A))
+ {
+ B = ByteCodePtr[0];
+ if(B>=VarBegin)
+ {
+ C = ByteCodePtr[-1];
+ if(C==A)
+ {
+ D = ByteCodePtr[-2];
+ if(D==B)
+ {
+ FP_TRACE_BYTECODE_OPTIMIZATION(336,
+ "D[D==B] C[C==A] B[B>=VarBegin] A[IsUnaryOpcode(A)]",
+ "D C cDup",
+ " with A = " << FP_TRACE_OPCODENAME(A)
+ << ", B = " << FP_TRACE_OPCODENAME(B)
+ << ", C = " << FP_TRACE_OPCODENAME(C)
+ << ", D = " << FP_TRACE_OPCODENAME(D)
+ << "\n");
+ /* ByteCodePtr[-2] = D; */ // redundant, matches D @ 3
+ /* ByteCodePtr[-1] = C; */ // redundant, matches C @ 2
+ goto Lej;
+ }
+ }
+ }
+ }
+ }
+ goto Lek;
+Laa: ByteCodePtr -= 1;
+ data->ByteCode.pop_back();
+ goto TailCall_cAbs;
+Lab: ImmedPtr[0] = fp_abs(x); return;
+Lac: data->Immed.push_back(Value_t(4));
+ ByteCodePtr[-2] = cImmed;
+ ByteCodePtr -= 2;
+ data->ByteCode.pop_back();
+ data->ByteCode.pop_back();
+ opcode = cMul;
+Lel: FP_ReDefinePointers();
+Lem: goto TailCall_cMul;
Lad: ByteCodePtr -= 1;
data->ByteCode.pop_back();
- opcode = cDiv;
-Ldb: goto TailCall_cDiv;
-Lae: ByteCodePtr[-1] = cImmed; goto Lab;
-Laf: ImmedPtr[0] = -x;
+ opcode = cSub;
+ goto TailCall_cSub;
+Lae: ImmedPtr[-1] = y+x;
+ data->Immed.pop_back();
+ data->ByteCode.pop_back();
+ data->ByteCode.pop_back();
+Len: FP_ReDefinePointers();
+Leo: goto TailCall_cAdd;
+Laf: ImmedPtr[-1] = y+x;
+Lag: data->Immed.pop_back();
+Lbc: data->ByteCode.pop_back(); return;
+Lah: ImmedPtr[-1] = truthValue(x)&&truthValue(y); goto Lag;
+Lai: data->Immed.push_back(Value_t(0));
+ ByteCodePtr[0] = cImmed;
+ AddFunctionOpcode(cMul);
+ data->Immed.push_back(Value_t(1));
+ data->ByteCode.push_back(cImmed);
+ opcode = cAdd; goto Len;
+Laj: ImmedPtr[0] = -x;
ByteCodePtr[-1] = cImmed;
ByteCodePtr -= 1;
data->ByteCode.pop_back();
-Ldc: goto TailCall_cMul;
-Lag: ImmedPtr[-1] = y*x;
-Lah: data->Immed.pop_back(); goto Lab;
-Lai: ByteCodePtr[0] = cDup;
- ImmedPtr -= 1;
- data->Immed.pop_back();
-Ldd: opcode = cAdd;
- goto TailCall_cAdd;
-Laj: data->Immed.pop_back();
+Lep: goto TailCall_cDiv;
+Lak: ImmedPtr[-1] = y/x; goto Lag;
+Lal: ImmedPtr[-1] = fp_equal(y,x); goto Lag;
+Lam: ByteCodePtr[-1] = cImmed;
+ ByteCodePtr -= 1;
data->ByteCode.pop_back();
- opcode = cNeg;
+Lfa: goto TailCall_cEqual;
+Lan: data->Immed.pop_back();
+Lfb: data->ByteCode.pop_back();
+ opcode = cNot;
FP_ReDefinePointers();
+Lfc: goto TailCall_cNot;
+Lao: data->Immed.pop_back();
+ data->ByteCode.pop_back();
+Ldo: data->ByteCode.pop_back();
+ AddFunctionOpcode(cNotNot); return;
+Lap: data->Immed.pop_back(); goto Ldo;
+Lba: ImmedPtr[-1] = fp_less(x,y); goto Lag;
+Lbb: ImmedPtr[-1] = fp_lessOrEq(x,y); goto Lag;
+Lbd: data->ByteCode.pop_back();
+ AddFunctionOpcode(cRSqrt); return;
+Lbe: ImmedPtr[0] = Value_t(1)/x; return;
+Lbf: data->Immed.pop_back();
+ data->ByteCode.pop_back(); goto Lfb;
+Lbg: ImmedPtr[-1] = fp_less(y,x); goto Lag;
+Lbh: ImmedPtr[-1] = fp_lessOrEq(y,x); goto Lag;
+Lbi: ImmedPtr[-1] = Max(x,y); goto Lag;
+Lbj: ImmedPtr[-1] = Min(x,y); goto Lag;
+Lbk: ImmedPtr[-1] = fp_mod(y,x); goto Lag;
+Lbl: ByteCodePtr -= 1;
+ data->ByteCode.pop_back();
+ opcode = cSqr;
+Lfd: goto TailCall_cSqr;
+Lbm: ByteCodePtr -= 1;
+ data->ByteCode.pop_back();
+ opcode = cDiv; goto Lep;
+Lbn: data->ByteCode.pop_back();
+ data->ByteCode.pop_back();
+ data->ByteCode.pop_back();
+ AddFunctionOpcode(cSqr);
+ AddFunctionOpcode(cMul);
+Lfe: opcode = cNeg;
+ FP_ReDefinePointers();
goto TailCall_cNeg;
-Lak: ImmedPtr[-1] = y/x; goto Lah;
-Lal: ImmedPtr[0] = -x;
- ByteCodePtr[-1] = cImmed;
- ByteCodePtr -= 1;
- data->ByteCode.pop_back(); goto Ldb;
-Lam: ImmedPtr[-1] = fp_mod(y,x); goto Lah;
-Lan: data->Immed.push_back(4);
- ByteCodePtr[-2] = cImmed;
+Lbo: data->ByteCode.pop_back();
+ data->ByteCode.pop_back();
+ AddFunctionOpcode(cSqr); goto Lfe;
+Lbp: ByteCodePtr[-2] = cImmed;
ByteCodePtr -= 2;
data->ByteCode.pop_back();
+Lff: data->ByteCode.pop_back(); goto Lem;
+Lca: ImmedPtr[-1] = x;
+Lfg: data->Immed.pop_back();
data->ByteCode.pop_back();
- opcode = cMul;
- FP_ReDefinePointers(); goto Ldc;
-Lba: ByteCodePtr -= 1;
+ data->ByteCode.pop_back(); goto Lel;
+Lcb: data->Immed.pop_back();
+Lcc: data->Immed.pop_back();
data->ByteCode.pop_back();
- opcode = cSub;
- goto TailCall_cSub;
-Lbb: ImmedPtr[-1] = y+x; goto Lah;
-Lbc: ImmedPtr[-1] = y-x; goto Lah;
-Lbd: ByteCodePtr -= 1;
- data->ByteCode.pop_back(); goto Ldd;
-Lbe: ImmedPtr[-1] = Min(x,y); goto Lah;
-Lbf: ImmedPtr[-1] = Max(x,y); goto Lah;
-Lbg: ByteCodePtr -= 1;
+Lfh: data->ByteCode.pop_back();
data->ByteCode.pop_back();
- opcode = cGreaterOrEq;
- goto TailCall_cGreaterOrEq;
-Lbh: ByteCodePtr -= 1;
data->ByteCode.pop_back();
- opcode = cGreater;
- goto TailCall_cGreater;
-Lbi: ByteCodePtr -= 1;
+Lfi: AddFunctionOpcode(A);
+ data->Immed.push_back(x);
+ data->ByteCode.push_back(cImmed); goto Lel;
+Lcd: data->Immed.pop_back();
data->ByteCode.pop_back();
+ data->ByteCode.pop_back();
+ data->ByteCode.pop_back();
+ data->ByteCode.pop_back();
+ AddFunctionOpcode(B); goto Lfi;
+Lce: data->Immed.pop_back(); goto Lfh;
+Lcf: ByteCodePtr[-1] = cImmed; goto Lbc;
+Lcg: ByteCodePtr[-1] = cImmed;
+ ByteCodePtr -= 1; goto Lff;
+Lch: data->Immed.pop_back();
+ data->ByteCode.pop_back();
+ data->ByteCode.pop_back(); goto Lbc;
+Lci: ImmedPtr[0] = x+x; goto Lbp;
+Lcj: data->Immed.pop_back(); goto Lch;
+Lck: ImmedPtr[-1] = y*x; goto Lfg;
+Lcl: ImmedPtr[0] = -x; goto Lcg;
+Lcm: ImmedPtr[-1] = y*x; goto Lag;
+Lcn: ByteCodePtr[0] = cDup;
+ ImmedPtr -= 1;
+ data->Immed.pop_back();
+Lfj: opcode = cAdd; goto Leo;
+Lco: data->Immed.pop_back();
+ data->ByteCode.pop_back(); goto Lfe;
+Lcp: data->ByteCode.pop_back();
+ data->ByteCode.pop_back();
+ AddFunctionOpcode(cSqr); goto Lel;
+Lda: data->ByteCode.pop_back(); goto Lcp;
+Ldb: ImmedPtr[-1] = fp_nequal(y,x); goto Lag;
+Ldc: ByteCodePtr[-1] = cImmed;
+ ByteCodePtr -= 1;
+ data->ByteCode.pop_back();
+Lfk: goto TailCall_cNEqual;
+Ldd: ImmedPtr[0] = -x;
+ ByteCodePtr -= 1;
+ data->ByteCode.pop_back();
+ opcode = cMul; goto Lem;
+Lde: ImmedPtr[0] = -x; return;
+Ldf: ByteCodePtr -= 1;
+ data->ByteCode.pop_back(); goto Lfc;
+Ldg: data->ByteCode.pop_back();
+ AddFunctionOpcode(cAbsNotNot); return;
+Ldh: data->ByteCode.pop_back();
+Lea: AddFunctionOpcode(cAbsNot); return;
+Ldi: ByteCodePtr -= 1;
+ data->ByteCode.pop_back();
+ opcode = cNEqual; goto Lfk;
+Ldj: ByteCodePtr -= 1;
+ data->ByteCode.pop_back();
opcode = cLessOrEq;
goto TailCall_cLessOrEq;
-Lbj: ByteCodePtr -= 1;
+Ldk: ByteCodePtr -= 1;
data->ByteCode.pop_back();
opcode = cLess;
goto TailCall_cLess;
-Lbk: ByteCodePtr -= 1;
+Ldl: ByteCodePtr -= 1;
data->ByteCode.pop_back();
- opcode = cNEqual;
- goto TailCall_cNEqual;
-Lbl: ByteCodePtr -= 1;
+ opcode = cGreaterOrEq;
+ goto TailCall_cGreaterOrEq;
+Ldm: ByteCodePtr -= 1;
data->ByteCode.pop_back();
- opcode = cEqual;
- goto TailCall_cEqual;
-Lbm: ByteCodePtr -= 1;
+ opcode = cGreater;
+ goto TailCall_cGreater;
+Ldn: ByteCodePtr -= 1;
data->ByteCode.pop_back();
- goto TailCall_cNot;
-Lbn: ByteCodePtr[0] = cNotNot; return;
-Lca: ByteCodePtr[0] = cAbsNot; return;
-Lcb: ByteCodePtr[0] = cAbsNotNot; return;
-Lcc: ImmedPtr[0] = !truthValue(x); return;
-Lcd...
[truncated message content] |