UNLOZE/sourcemod
10
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
13e8cf9ed8
sourcemod/sourcepawn/compiler/sc7.scp
Scott Ehlert 251cced1f8 Spring Cleaning, Part Ichi (1) 
Various minor things done to project files
Updated sample extension project file and updated makefile to the new unified version (more changes likely on the way)
Updated regex project file and makefile

--HG--
extra : convert_revision : svn%3A39bc706e-5318-0410-9160-8a85361fbb7c/trunk%401971
2008-03-30 07:00:22 +00:00

2023 lines
52 KiB
Plaintext
Raw Blame History

/* Pawn compiler - Peephole optimizer "sequences" strings (plain
* and compressed formats)
*
* Copyright (c) ITB CompuPhase, 2000-2006
*
* This software is provided "as-is", without any express or implied warranty.
* In no event will the authors be held liable for any damages arising from
* the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software in
* a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*
* Version: $Id$
*/
SC_FUNC int strexpand(char *dest, unsigned char *source, int maxlen, unsigned char pairtable[128][2]);
#define SCPACK_TERMINATOR , /* end each section with a comma */
#define SCPACK_TABLE sequences_table
/*-*SCPACK start of pair table, do not change or remove this line */
unsigned char sequences_table[][2] = {
{49,33}, {37,128}, {32,129}, {32,37}, {114,105}, {112,132}, {46,133}, {97,100}, {46,97}, {136,108}, {137,116}, {115,104}, {111,135}, {117,139}, {112,141}, {108,140},
{131,50}, {144,33}, {46,115}, {138,33}, {59,36}, {134,130}, {143,146}, {115,116}, {134,145}, {110,151}, {111,153}, {99,154}, {112,147}, {135,100}, {134,33}, {114,33},
{111,156}, {112,160}, {46,99}, {138,130}, {142,158}, {131,51}, {150,152}, {112,33}, {120,167}, {101,168}, {148,169}, {97,159}, {112,171}, {148,172}, {165,33}, {173,142},
{122,101}, {176,114}, {101,113}, {110,100}, {149,164}, {157,114}, {33,161}, {131,49}, {103,33}, {157,33}, {104,184}, {99,186}, {120,187}, {98,111}, {118,101}, {111,190},
{109,191}, {130,170}, {131,52}, {106,177}, {138,145}, {180,166}, {192,147}, {108,162}, {163,166}, {143,149}, {115,174}, {117,179}, {139,199}, {203,202}, {189,205}, {105,100},
{115,103}, {115,108}, {207,120}, {195,130}, {46,135}, {178,33}, {212,114}, {204,134}, {155,149}, {142,162}, {183,145}, {150,149}, {143,152}, {194,33}, {130,175}, {97,179},
{177,111}, {182,185}, {143,46}, {183,144}, {155,152}, {145,175}, {114,101}, {230,102}, {108,231}, {101,115}, {233,115}, {114,116}, {142,147}, {105,33}, {155,163}, {178,130},
{215,32}, {240,50}, {143,196}, {155,197}, {181,197}, {181,200}, {108,210}, {46,98}, {241,225}, {208,235}, {209,234}, {224,158}, {143,163}, {150,163}, {155,200}
};
/*-*SCPACK end of pair table, do not change or remove this line */
#define seqsize(o,p) (opcodes(o)+opargs(p))
typedef struct {
char *find;
char *replace;
int savesize; /* number of bytes saved (in bytecode) */
} SEQUENCE;
static SEQUENCE sequences_cmp[] = {
/* A very common sequence in four varieties
* load.s.pri n1 load.s.pri n2
* push.pri load.s.alt n1
* load.s.pri n2 -
* pop.alt -
* --------------------------------------
* load.pri n1 load.s.pri n2
* push.pri load.alt n1
* load.s.pri n2 -
* pop.alt -
* --------------------------------------
* load.s.pri n1 load.pri n2
* push.pri load.s.alt n1
* load.pri n2 -
* pop.alt -
* --------------------------------------
* load.pri n1 load.pri n2
* push.pri load.alt n1
* load.pri n2 -
* pop.alt -
*/
{
#ifdef SCPACK
"load.s.pri %1!push.pri!load.s.pri %2!pop.alt!",
"load.s.pri %2!load.s.alt %1!",
#else
"\226\305\241",
"\246\375",
#endif
seqsize(4,2) - seqsize(2,2)
},
{
#ifdef SCPACK
"load.pri %1!push.pri!load.s.pri %2!pop.alt!",
"load.s.pri %2!load.alt %1!",
#else
"\217\305\241",
"\246\374",
#endif
seqsize(4,2) - seqsize(2,2)
},
{
#ifdef SCPACK
"load.s.pri %1!push.pri!load.pri %2!pop.alt!",
"load.pri %2!load.s.alt %1!",
#else
"\226\264\334\241",
"\334\375",
#endif
seqsize(4,2) - seqsize(2,2)
},
{
#ifdef SCPACK
"load.pri %1!push.pri!load.pri %2!pop.alt!",
"load.pri %2!load.alt %1!",
#else
"\217\264\334\241",
"\334\374",
#endif
seqsize(4,2) - seqsize(2,2)
},
/* (#1#) The above also occurs with "addr.pri" (array
* indexing) as the first line; so that adds 2 cases.
*/
{
#ifdef SCPACK
"addr.pri %1!push.pri!load.s.pri %2!pop.alt!",
"addr.alt %1!load.s.pri %2!",
#else
"\364\241",
"\365",
#endif
seqsize(4,2) - seqsize(2,2)
},
{
#ifdef SCPACK
"addr.pri %1!push.pri!load.pri %2!pop.alt!",
"addr.alt %1!load.pri %2!",
#else
"\265\264\334\241",
"\265\243\334",
#endif
seqsize(4,2) - seqsize(2,2)
},
/* And the same sequence with const.pri as either the first
* or the second load instruction: four more cases.
*/
{
#ifdef SCPACK
"const.pri %1!push.pri!load.s.pri %2!pop.alt!",
"load.s.pri %2!const.alt %1!",
#else
"\363\241",
"\246\356",
#endif
seqsize(4,2) - seqsize(2,2)
},
{
#ifdef SCPACK
"const.pri %1!push.pri!load.pri %2!pop.alt!",
"load.pri %2!const.alt %1!",
#else
"\233\264\334\241",
"\334\356",
#endif
seqsize(4,2) - seqsize(2,2)
},
{
#ifdef SCPACK
"load.s.pri %1!push.pri!const.pri %2!pop.alt!",
"const.pri %2!load.s.alt %1!",
#else
"\226\264\344\241",
"\344\375",
#endif
seqsize(4,2) - seqsize(2,2)
},
{
#ifdef SCPACK
"load.pri %1!push.pri!const.pri %2!pop.alt!",
"const.pri %2!load.alt %1!",
#else
"\217\264\344\241",
"\344\374",
#endif
seqsize(4,2) - seqsize(2,2)
},
/* The same as above, but now with "addr.pri" (array
* indexing) on the first line and const.pri on
* the second.
*/
{
#ifdef SCPACK
"addr.pri %1!push.pri!const.pri %2!pop.alt!",
"addr.alt %1!const.pri %2!",
#else
"\265\264\344\241",
"\265\243\344",
#endif
seqsize(4,2) - seqsize(2,2)
},
{
#ifdef SCPACK
"addr.pri %1!push.pri!zero.pri!pop.alt!",
"addr.alt %1!zero.pri!",
#else
"\265\264\373\241",
"\265\243\373",
#endif
seqsize(4,1) - seqsize(2,1)
},
/* ??? add references */
/* Chained relational operators can contain sequences like:
* move.pri load.s.pri n1
* push.pri -
* load.s.pri n1 -
* pop.alt -
* The above also accurs for "load.pri" and for "const.pri",
* so add another two cases.
*/
{
#ifdef SCPACK
"move.pri!push.pri!load.s.pri %1!pop.alt!",
"load.s.pri %1!",
#else
"\300\236\244\333\241",
"\333",
#endif
seqsize(4,1) - seqsize(1,1)
},
{
#ifdef SCPACK
"move.pri!push.pri!load.pri %1!pop.alt!",
"load.pri %1!",
#else
"\300\236\244\311\241",
"\311",
#endif
seqsize(4,1) - seqsize(1,1)
},
{
#ifdef SCPACK
"move.pri!push.pri!const.pri %1!pop.alt!",
"const.pri %1!",
#else
"\300\236\244\330\241",
"\330",
#endif
seqsize(4,1) - seqsize(1,1)
},
/* More optimizations for chained relational operators; the
* continuation sequences can be simplified if they turn out
* to be termination sequences:
* xchg sless also for sless, sgeq and sleq
* sgrtr pop.alt
* swap.alt and
* and ;$exp
* pop.alt -
* ;$exp -
* --------------------------------------
* xchg sless also for sless, sgeq and sleq
* sgrtr pop.alt
* swap.alt and
* and jzer n1
* pop.alt -
* jzer n1 -
* --------------------------------------
* xchg jsgeq n1 also for sless, sgeq and sleq
* sgrtr ;$exp (occurs for non-chained comparisons)
* jzer n1 -
* ;$exp -
* --------------------------------------
* xchg sless also for sless, sgeq and sleq
* sgrtr ;$exp (occurs for non-chained comparisons)
* ;$exp -
*/
{
#ifdef SCPACK
"xchg!sgrtr!swap.alt!and!pop.alt!;$exp!",
"sless!pop.alt!and!;$exp!",
#else
"\274\371\237swa\234\337\266\252",
"\372\266\337!\252",
#endif
seqsize(5,0) - seqsize(3,0)
},
{
#ifdef SCPACK
"xchg!sless!swap.alt!and!pop.alt!;$exp!",
"sgrtr!pop.alt!and!;$exp!",
#else
"\274\372!swa\234\337\266\252",
"\371\237\241\337!\252",
#endif
seqsize(5,0) - seqsize(3,0)
},
{
#ifdef SCPACK
"xchg!sgeq!swap.alt!and!pop.alt!;$exp!",
"sleq!pop.alt!and!;$exp!",
#else
"\274\320\325swa\234\337\266\252",
"\321\262\266\337!\252",
#endif
seqsize(5,0) - seqsize(3,0)
},
{
#ifdef SCPACK
"xchg!sleq!swap.alt!and!pop.alt!;$exp!",
"sgeq!pop.alt!and!;$exp!",
#else
"\274\321\325swa\234\337\266\252",
"\320\262\266\337!\252",
#endif
seqsize(5,0) - seqsize(3,0)
},
{
#ifdef SCPACK
"xchg!sgrtr!swap.alt!and!pop.alt!jzer %1!",
"sless!pop.alt!and!jzer %1!",
#else
"\274\371\237swa\234\337\266\323",
"\372\266\337!\323",
#endif
seqsize(5,0) - seqsize(3,0)
},
{
#ifdef SCPACK
"xchg!sless!swap.alt!and!pop.alt!jzer %1!",
"sgrtr!pop.alt!and!jzer %1!",
#else
"\274\372!swa\234\337\266\323",
"\371\237\241\337!\323",
#endif
seqsize(5,0) - seqsize(3,0)
},
{
#ifdef SCPACK
"xchg!sgeq!swap.alt!and!pop.alt!jzer %1!",
"sleq!pop.alt!and!jzer %1!",
#else
"\274\320\325swa\234\337\266\323",
"\321\262\266\337!\323",
#endif
seqsize(5,0) - seqsize(3,0)
},
{
#ifdef SCPACK
"xchg!sleq!swap.alt!and!pop.alt!jzer %1!",
"sgeq!pop.alt!and!jzer %1!",
#else
"\274\321\325swa\234\337\266\323",
"\320\262\266\337!\323",
#endif
seqsize(5,0) - seqsize(3,0)
},
{
#ifdef SCPACK
"xchg!sgrtr!jzer %1!;$exp!",
"jsgeq %1!;$exp!",
#else
"\274\371\237\303\301",
"j\320\262\301",
#endif
seqsize(3,1) - seqsize(1,1)
},
{
#ifdef SCPACK
"xchg!sless!jzer %1!;$exp!",
"jsleq %1!;$exp!",
#else
"\274\372!\303\301",
"j\321\262\301",
#endif
seqsize(3,1) - seqsize(1,1)
},
{
#ifdef SCPACK
"xchg!sgeq!jzer %1!;$exp!",
"jsgrtr %1!;$exp!",
#else
"\274\320\325\303\301",
"j\371r\301",
#endif
seqsize(3,1) - seqsize(1,1)
},
{
#ifdef SCPACK
"xchg!sleq!jzer %1!;$exp!",
"jsless %1!;$exp!",
#else
"\274\321\325\303\301",
"j\372\301",
#endif
seqsize(3,1) - seqsize(1,1)
},
{
#ifdef SCPACK
"xchg!sgrtr!;$exp!",
"sless!;$exp!",
#else
"\274\371\237\252",
"\372!\252",
#endif
seqsize(2,0) - seqsize(1,0)
},
{
#ifdef SCPACK
"xchg!sless!;$exp!",
"sgrtr!;$exp!",
#else
"\274\372!\252",
"\371\237\252",
#endif
seqsize(2,0) - seqsize(1,0)
},
{
#ifdef SCPACK
"xchg!sgeq!;$exp!",
"sleq!;$exp!",
#else
"\274\320\325\252",
"\321\325\252",
#endif
seqsize(2,0) - seqsize(1,0)
},
{
#ifdef SCPACK
"xchg!sleq!;$exp!",
"sgeq!;$exp!",
#else
"\274\321\325\252",
"\320\325\252",
#endif
seqsize(2,0) - seqsize(1,0)
},
/* The entry to chained operators is also opt to optimization
* load.s.pri n1 load.s.pri n2
* load.s.alt n2 load.s.alt n1
* xchg -
* --------------------------------------
* load.s.pri n1 load.pri n2
* load.alt n2 load.s.alt n1
* xchg -
* --------------------------------------
* load.s.pri n1 const.pri n2
* const.alt n2 load.s.alt n1
* xchg -
* --------------------------------------
* and all permutations...
*/
{
#ifdef SCPACK
"load.s.pri %1!load.s.alt %2!xchg!",
"load.s.pri %2!load.s.alt %1!",
#else
"\333\226\304\274",
"\246\375",
#endif
seqsize(3,2) - seqsize(2,2)
},
{
#ifdef SCPACK
"load.s.pri %1!load.alt %2!xchg!",
"load.pri %2!load.s.alt %1!",
#else
"\333\362\274",
"\334\375",
#endif
seqsize(3,2) - seqsize(2,2)
},
{
#ifdef SCPACK
"load.s.pri %1!const.alt %2!xchg!",
"const.pri %2!load.s.alt %1!",
#else
"\333\233\304\274",
"\344\375",
#endif
seqsize(3,2) - seqsize(2,2)
},
{
#ifdef SCPACK
"load.pri %1!load.s.alt %2!xchg!",
"load.s.pri %2!load.alt %1!",
#else
"\311\226\304\274",
"\246\374",
#endif
seqsize(3,2) - seqsize(2,2)
},
{
#ifdef SCPACK
"load.pri %1!load.alt %2!xchg!",
"load.pri %2!load.alt %1!",
#else
"\311\362\274",
"\334\374",
#endif
seqsize(3,2) - seqsize(2,2)
},
{
#ifdef SCPACK
"load.pri %1!const.alt %2!xchg!",
"const.pri %2!load.alt %1!",
#else
"\311\233\304\274",
"\344\374",
#endif
seqsize(3,2) - seqsize(2,2)
},
{
#ifdef SCPACK
"const.pri %1!load.s.alt %2!xchg!",
"load.s.pri %2!const.alt %1!",
#else
"\330\226\304\274",
"\246\356",
#endif
seqsize(3,2) - seqsize(2,2)
},
{
#ifdef SCPACK
"const.pri %1!load.alt %2!xchg!",
"load.pri %2!const.alt %1!",
#else
"\330\362\274",
"\334\356",
#endif
seqsize(3,2) - seqsize(2,2)
},
/* some sequences where PRI is moved to ALT can be optimized
* further when considering what follows
* move.alt const.alt n1
* const.pri %1 -
* xchg -
* (also for load.s.pri and load.pri)
* --------------------------------------
* lref.pri %1 lref.alt %1
* move.alt [load.pri %2]
* [load.pri %2] -
* (where [load.pri %2] may also be another operatrion loading PRI)
*/
{
#ifdef SCPACK
"move.alt!const.pri %1!xchg!",
"const.alt %1!",
#else
"\306\330\274",
"\356",
#endif
seqsize(3,1) - seqsize(1,1)
},
{
#ifdef SCPACK
"move.alt!load.pri %1!xchg!",
"load.alt %1!",
#else
"\306\311\274",
"\374",
#endif
seqsize(3,1) - seqsize(1,1)
},
{
#ifdef SCPACK
"move.alt!load.s.pri %1!xchg!",
"load.s.alt %1!",
#else
"\306\333\274",
"\375",
#endif
seqsize(3,1) - seqsize(1,1)
},
/* ----- */
{
#ifdef SCPACK
"lref.pri %1!move.alt!load.pri %2!",
"lref.alt %1!load.pri %2!",
#else
"\350\225\306\334",
"\350\243\334",
#endif
seqsize(3,2) - seqsize(2,2)
},
{
#ifdef SCPACK
"lref.pri %1!move.alt!load.s.pri %2!",
"lref.alt %1!load.s.pri %2!",
#else
"\350\225\306\246",
"\350\310",
#endif
seqsize(3,2) - seqsize(2,2)
},
{
#ifdef SCPACK
"lref.pri %1!move.alt!const.pri %2!",
"lref.alt %1!const.pri %2!",
#else
"\350\225\306\344",
"\350\243\344",
#endif
seqsize(3,2) - seqsize(2,2)
},
{
#ifdef SCPACK
"lref.s.pri %1!move.alt!load.pri %2!",
"lref.s.alt %1!load.pri %2!",
#else
"\350\222\225\306\334",
"\350\222\243\334",
#endif
seqsize(3,2) - seqsize(2,2)
},
{
#ifdef SCPACK
"lref.s.pri %1!move.alt!load.s.pri %2!",
"lref.s.alt %1!load.s.pri %2!",
#else
"\350\222\225\306\246",
"\350\222\310",
#endif
seqsize(3,2) - seqsize(2,2)
},
{
#ifdef SCPACK
"lref.s.pri %1!move.alt!const.pri %2!",
"lref.s.alt %1!const.pri %2!",
#else
"\350\222\225\306\344",
"\350\222\243\344",
#endif
seqsize(3,2) - seqsize(2,2)
},
/* Array indexing can merit from special instructions.
* Simple indexed array lookup can be optimized quite
* a bit.
* addr.pri n1 addr.alt n1
* push.pri load.s.pri n2
* load.s.pri n2 bounds n3
* bounds n3 lidx.b n4
* shl.c.pri n4 -
* pop.alt -
* add -
* load.i -
*
* And to prepare for storing a value in an array
* addr.pri n1 addr.alt n1
* push.pri load.s.pri n2
* load.s.pri n2 bounds n3
* bounds n3 idxaddr.b n4
* shl.c.pri n4 -
* pop.alt -
* add -
*
* Notes (additional cases):
* 1. instruction addr.pri can also be const.pri (for
* global arrays)
* 2. the bounds instruction can be absent
* 3. when "n4" (the shift value) is the 2 (with 32-bit cells), use the
* even more optimal instructions LIDX and IDDXADDR
*
* If the array index is more complex, one can only optimize
* the last four instructions:
* shl.c.pri n1 pop.alt
* pop.alt lidx.b n1
* add -
* loadi -
* --------------------------------------
* shl.c.pri n1 pop.alt
* pop.alt idxaddr.b n1
* add -
*/
#if !defined BIT16
/* loading from array, "cell" shifted */
{
#ifdef SCPACK
"addr.pri %1!push.pri!load.s.pri %2!bounds %3!shl.c.pri 2!pop.alt!add!load.i!",
"addr.alt %1!load.s.pri %2!bounds %3!lidx!",
#else
"\364\316\370\342\355",
"\365\316\366!",
#endif
seqsize(8,4) - seqsize(4,3)
},
{
#ifdef SCPACK
"const.pri %1!push.pri!load.s.pri %2!bounds %3!shl.c.pri 2!pop.alt!add!load.i!",
"const.alt %1!load.s.pri %2!bounds %3!lidx!",
#else
"\363\316\370\342\355",
"\376\316\366!",
#endif
seqsize(8,4) - seqsize(4,3)
},
{
#ifdef SCPACK
"addr.pri %1!push.pri!load.s.pri %2!shl.c.pri 2!pop.alt!add!load.i!",
"addr.alt %1!load.s.pri %2!lidx!",
#else
"\364\370\342\355",
"\365\366!",
#endif
seqsize(7,3) - seqsize(3,2)
},
{
#ifdef SCPACK
"const.pri %1!push.pri!load.s.pri %2!shl.c.pri 2!pop.alt!add!load.i!",
"const.alt %1!load.s.pri %2!lidx!",
#else
"\363\370\342\355",
"\376\366!",
#endif
seqsize(7,3) - seqsize(3,2)
},
#endif
/* loading from array, not "cell" shifted */
{
#ifdef SCPACK
"addr.pri %1!push.pri!load.s.pri %2!bounds %3!shl.c.pri %4!pop.alt!add!load.i!",
"addr.alt %1!load.s.pri %2!bounds %3!lidx.b %4!",
#else
"\364\316\327\302\341\342\355",
"\365\316\366\367\335",
#endif
seqsize(8,4) - seqsize(4,4)
},
{
#ifdef SCPACK
"const.pri %1!push.pri!load.s.pri %2!bounds %3!shl.c.pri %4!pop.alt!add!load.i!",
"const.alt %1!load.s.pri %2!bounds %3!lidx.b %4!",
#else
"\363\316\327\302\341\342\355",
"\376\316\366\367\335",
#endif
seqsize(8,4) - seqsize(4,4)
},
{
#ifdef SCPACK
"addr.pri %1!push.pri!load.s.pri %2!shl.c.pri %3!pop.alt!add!load.i!",
"addr.alt %1!load.s.pri %2!lidx.b %3!",
#else
"\364\327\256\241\271\342\355",
"\365\366\367\256",
#endif
seqsize(7,3) - seqsize(3,3)
},
{
#ifdef SCPACK
"const.pri %1!push.pri!load.s.pri %2!shl.c.pri %3!pop.alt!add!load.i!",
"const.alt %1!load.s.pri %2!lidx.b %3!",
#else
"\363\327\256\241\271\342\355",
"\376\366\367\256",
#endif
seqsize(7,3) - seqsize(3,3)
},
#if !defined BIT16
/* array index calculation for storing a value, "cell" aligned */
{
#ifdef SCPACK
"addr.pri %1!push.pri!load.s.pri %2!bounds %3!shl.c.pri 2!pop.alt!add!",
"addr.alt %1!load.s.pri %2!bounds %3!idxaddr!",
#else
"\364\316\370",
"\365\316\322\235\237",
#endif
seqsize(7,4) - seqsize(4,3)
},
{
#ifdef SCPACK
"const.pri %1!push.pri!load.s.pri %2!bounds %3!shl.c.pri 2!pop.alt!add!",
"const.alt %1!load.s.pri %2!bounds %3!idxaddr!",
#else
"\363\316\370",
"\376\316\322\235\237",
#endif
seqsize(7,4) - seqsize(4,3)
},
{
#ifdef SCPACK
"addr.pri %1!push.pri!load.s.pri %2!shl.c.pri 2!pop.alt!add!",
"addr.alt %1!load.s.pri %2!idxaddr!",
#else
"\364\370",
"\365\322\235\237",
#endif
seqsize(6,3) - seqsize(3,2)
},
{
#ifdef SCPACK
"const.pri %1!push.pri!load.s.pri %2!shl.c.pri 2!pop.alt!add!",
"const.alt %1!load.s.pri %2!idxaddr!",
#else
"\363\370",
"\376\322\235\237",
#endif
seqsize(6,3) - seqsize(3,2)
},
#endif
/* array index calculation for storing a value, not "cell" packed */
{
#ifdef SCPACK
"addr.pri %1!push.pri!load.s.pri %2!bounds %3!shl.c.pri %4!pop.alt!add!",
"addr.alt %1!load.s.pri %2!bounds %3!idxaddr.b %4!",
#else
"\364\316\327\302\341",
"\365\316\322\265\367\335",
#endif
seqsize(7,4) - seqsize(4,4)
},
{
#ifdef SCPACK
"const.pri %1!push.pri!load.s.pri %2!bounds %3!shl.c.pri %4!pop.alt!add!",
"const.alt %1!load.s.pri %2!bounds %3!idxaddr.b %4!",
#else
"\363\316\327\302\341",
"\376\316\322\265\367\335",
#endif
seqsize(7,4) - seqsize(4,4)
},
{
#ifdef SCPACK
"addr.pri %1!push.pri!load.s.pri %2!shl.c.pri %3!pop.alt!add!",
"addr.alt %1!load.s.pri %2!idxaddr.b %3!",
#else
"\364\327\256\241\271",
"\365\322\265\367\256",
#endif
seqsize(6,3) - seqsize(3,3)
},
{
#ifdef SCPACK
"const.pri %1!push.pri!load.s.pri %2!shl.c.pri %3!pop.alt!add!",
"const.alt %1!load.s.pri %2!idxaddr.b %3!",
#else
"\363\327\256\241\271",
"\376\322\265\367\256",
#endif
seqsize(6,3) - seqsize(3,3)
},
#if !defined BIT16
/* the shorter array indexing sequences, see above for comments */
{
#ifdef SCPACK
"shl.c.pri 2!pop.alt!add!loadi!",
"pop.alt!lidx!",
#else
"\370\217\355",
"\241\366!",
#endif
seqsize(4,1) - seqsize(2,0)
},
{
#ifdef SCPACK
"shl.c.pri 2!pop.alt!add!",
"pop.alt!idxaddr!",
#else
"\370",
"\241\322\235\237",
#endif
seqsize(3,1) - seqsize(2,0)
},
#endif
{
#ifdef SCPACK
"shl.c.pri %1!pop.alt!add!loadi!",
"pop.alt!lidx.b %1!",
#else
"\314\225\241\271\217\355",
"\241\366\367\202",
#endif
seqsize(4,1) - seqsize(2,1)
},
{
#ifdef SCPACK
"shl.c.pri %1!pop.alt!add!",
"pop.alt!idxaddr.b %1!",
#else
"\314\225\241\271",
"\241\322\265\367\202",
#endif
seqsize(3,1) - seqsize(2,1)
},
/* For packed arrays, there is another case (packed arrays
* do not take advantage of the LIDX or IDXADDR instructions).
* addr.pri n1 addr.alt n1
* push.pri load.s.pri n2
* load.s.pri n2 bounds n3
* bounds n3 -
* pop.alt -
*
* Notes (additional cases):
* 1. instruction addr.pri can also be const.pri (for
* global arrays)
* 2. the bounds instruction can be absent, but that
* case is already handled (see #1#)
*/
{
#ifdef SCPACK
"addr.pri %1!push.pri!load.s.pri %2!bounds %3!pop.alt!",
"addr.alt %1!load.s.pri %2!bounds %3!",
#else
"\364\316\241",
"\365\316",
#endif
seqsize(5,3) - seqsize(3,3)
},
{
#ifdef SCPACK
"const.pri %1!push.pri!load.s.pri %2!bounds %3!pop.alt!",
"const.alt %1!load.s.pri %2!bounds %3!",
#else
"\363\316\241",
"\376\316",
#endif
seqsize(5,3) - seqsize(3,3)
},
/* Declaration of simple variables often follows the sequence:
* ;$lcl <name> <stk> ;$lcl <name> <stk>
* stack -4 push.c <constval>
* const.pri <constval> ;$exp
* stor.s.pri <stk> -
* ;$exp -
*/
{
#ifdef SCPACK
";$lcl %1 %2!stack -4!const.pri %3!stor.s.pri %2!;$exp!",
";$lcl %1 %2!push.c %3!;$exp!",
#else
"\224lcl\332\227ack -4!\233\206\256\227or\222\230\252",
"\224lcl\332\331\256\252",
#endif
seqsize(3,3) - seqsize(1,1)
},
{
#ifdef SCPACK
";$lcl %1 %2!stack -4!zero.pri!stor.s.pri %2!;$exp!",
";$lcl %1 %2!push.c 0!;$exp!",
#else
"\224lcl\332\227ack -4!\373\227or\222\230\252",
"\224lcl\332\331 0!\252",
#endif
seqsize(3,2) - seqsize(1,1)
},
/* During a calculation, the intermediate result must sometimes
* be moved from PRI to ALT, like in:
* push.pri move.alt
* load.s.pri n1 load.s.pri n1
* pop.alt -
*
* The above also accurs for "load.pri" and for "const.pri",
* so add another two cases.
*/
{
#ifdef SCPACK
"push.pri!load.s.pri %1!pop.alt!",
"move.alt!load.s.pri %1!",
#else
"\244\333\241",
"\306\333",
#endif
seqsize(3,1) - seqsize(2,1)
},
{
#ifdef SCPACK
"push.pri!load.pri %1!pop.alt!",
"move.alt!load.pri %1!",
#else
"\244\311\241",
"\306\311",
#endif
seqsize(3,1) - seqsize(2,1)
},
{
#ifdef SCPACK
"push.pri!const.pri %1!pop.alt!",
"move.alt!const.pri %1!",
#else
"\244\330\241",
"\306\330",
#endif
seqsize(3,1) - seqsize(2,1)
},
{
#ifdef SCPACK
"push.pri!zero.pri!pop.alt!",
"move.alt!zero.pri!",
#else
"\244\373\241",
"\306\373",
#endif
seqsize(3,0) - seqsize(2,0)
},
/* saving PRI and then loading from its address
* occurs when indexing a multi-dimensional array
*/
{
#ifdef SCPACK
"push.pri!load.i!pop.alt!",
"move.alt!load.i!",
#else
"\244\342i\266",
"\306\342\355",
#endif
seqsize(3,0) - seqsize(2,0)
},
/* An even simpler PUSH/POP optimization (occurs in
* switch statements):
* push.pri move.alt
* pop.alt -
*/
{
#ifdef SCPACK
"push.pri!pop.alt!",
"move.alt!",
#else
"\244\241",
"\306",
#endif
seqsize(2,0) - seqsize(1,0)
},
/* Some simple arithmetic sequences
*/
{
#ifdef SCPACK
"move.alt!load.s.pri %1!add!",
"load.s.alt %1!add!",
#else
"\306\333\271",
"\375\271",
#endif
seqsize(3,1) - seqsize(2,1)
},
{
#ifdef SCPACK
"move.alt!load.pri %1!add!",
"load.alt %1!add!",
#else
"\306\311\271",
"\374\271",
#endif
seqsize(3,1) - seqsize(2,1)
},
{
#ifdef SCPACK
"move.alt!const.pri %1!add!",
"const.alt %1!add!",
#else
"\306\330\271",
"\356\271",
#endif
seqsize(3,1) - seqsize(2,1)
},
{
#ifdef SCPACK
"move.alt!load.s.pri %1!sub.alt!",
"load.s.alt %1!sub!",
#else
"\306\333sub\223",
"\375sub!",
#endif
seqsize(3,1) - seqsize(2,1)
},
{
#ifdef SCPACK
"move.alt!load.pri %1!sub.alt!",
"load.alt %1!sub!",
#else
"\306\311sub\223",
"\374sub!",
#endif
seqsize(3,1) - seqsize(2,1)
},
{
#ifdef SCPACK
"move.alt!const.pri %1!sub.alt!",
"const.alt %1!sub!",
#else
"\306\330sub\223",
"\356sub!",
#endif
seqsize(3,1) - seqsize(2,1)
},
/* User-defined operators first load the operands into registers and
* then have them pushed onto the stack. This can give rise to sequences
* like:
* const.pri n1 push.c n1
* const.alt n2 push.c n2
* push.pri -
* push.alt -
* A similar sequence occurs with the two PUSH.pri/alt instructions inverted.
* The first, second, or both CONST.pri/alt instructions can also be
* LOAD.pri/alt.
* This gives 2 x 4 cases.
*/
{
#ifdef SCPACK
"const.pri %1!const.alt %2!push.pri!push.alt!",
"push.c %1!push.c %2!",
#else
"\330\233\304\244\354",
"\331\202\331\221",
#endif
seqsize(4,2) - seqsize(2,2)
},
{
#ifdef SCPACK
"const.pri %1!const.alt %2!push.alt!push.pri!",
"push.c %2!push.c %1!",
#else
"\330\233\304\354\244",
"\331\221\331\202",
#endif
seqsize(4,2) - seqsize(2,2)
},
{
#ifdef SCPACK
"const.pri %1!load.alt %2!push.pri!push.alt!",
"push.c %1!push %2!",
#else
"\330\362\244\354",
"\331\202\216\221",
#endif
seqsize(4,2) - seqsize(2,2)
},
{
#ifdef SCPACK
"const.pri %1!load.alt %2!push.alt!push.pri!",
"push %2!push.c %1!",
#else
"\330\362\354\244",
"\216\221\331\202",
#endif
seqsize(4,2) - seqsize(2,2)
},
{
#ifdef SCPACK
"load.pri %1!const.alt %2!push.pri!push.alt!",
"push %1!push.c %2!",
#else
"\311\233\304\244\354",
"\216\202\331\221",
#endif
seqsize(4,2) - seqsize(2,2)
},
{
#ifdef SCPACK
"load.pri %1!const.alt %2!push.alt!push.pri!",
"push.c %2!push %1!",
#else
"\311\233\304\354\244",
"\331\221\216\202",
#endif
seqsize(4,2) - seqsize(2,2)
},
{
#ifdef SCPACK
"load.pri %1!load.alt %2!push.pri!push.alt!",
"push %1!push %2!",
#else
"\311\362\244\354",
"\216\202\216\221",
#endif
seqsize(4,2) - seqsize(2,2)
},
{
#ifdef SCPACK
"load.pri %1!load.alt %2!push.alt!push.pri!",
"push %2!push %1!",
#else
"\311\362\354\244",
"\216\221\216\202",
#endif
seqsize(4,2) - seqsize(2,2)
},
/* Function calls (parameters are passed on the stack)
* load.s.pri n1 push.s n1
* push.pri -
* --------------------------------------
* load.pri n1 push n1
* push.pri -
* --------------------------------------
* const.pri n1 push.c n1
* push.pri -
* --------------------------------------
* zero.pri push.c 0
* push.pri -
* --------------------------------------
* addr.pri n1 push.adr n1
* push.pri -
*
* However, PRI must not be needed after this instruction
* if this shortcut is used. Check for the ;$par comment.
*/
{
#ifdef SCPACK
"load.s.pri %1!push.pri!;$par!",
"push.s %1!;$par!",
#else
"\226\264\255",
"\216\222\202\255",
#endif
seqsize(2,1) - seqsize(1,1)
},
{
#ifdef SCPACK
"load.pri %1!push.pri!;$par!",
"push %1!;$par!",
#else
"\217\264\255",
"\216\202\255",
#endif
seqsize(2,1) - seqsize(1,1)
},
{
#ifdef SCPACK
"const.pri %1!push.pri!;$par!",
"push.c %1!;$par!",
#else
"\233\264\255",
"\331\202\255",
#endif
seqsize(2,1) - seqsize(1,1)
},
{
#ifdef SCPACK
"zero.pri!push.pri!;$par!",
"push.c 0!;$par!",
#else
"\373\244\255",
"\331 0!\255",
#endif
seqsize(2,0) - seqsize(1,1)
},
{
#ifdef SCPACK
"addr.pri %1!push.pri!;$par!",
"push.adr %1!;$par!",
#else
"\265\264\255",
"\216\326\202\255",
#endif
seqsize(2,1) - seqsize(1,1)
},
/* References with a default value generate new cells on the heap
* dynamically. That code often ends with:
* move.pri push.alt
* push.pri -
*/
{
#ifdef SCPACK
"move.pri!push.pri!",
"push.alt!",
#else
"\300\236\244",
"\354",
#endif
seqsize(2,0) - seqsize(1,0)
},
/* Simple arithmetic operations on constants. Noteworthy is the
* subtraction of a constant, since it is converted to the addition
* of the inverse value.
* const.alt n1 add.c n1
* add -
* --------------------------------------
* const.alt n1 add.c -n1
* sub -
* --------------------------------------
* const.alt n1 smul.c n1
* smul -
* --------------------------------------
* const.alt n1 eq.c.pri n1
* eq -
*/
{
#ifdef SCPACK
"const.alt %1!add!",
"add.c %1!",
#else
"\356\271",
"\235\242\202",
#endif
seqsize(2,1) - seqsize(1,1)
},
{
#ifdef SCPACK
"const.alt %1!sub!",
"add.c -%1!",
#else
"\356sub!",
"\235\242 -\201",
#endif
seqsize(2,1) - seqsize(1,1)
},
{
#ifdef SCPACK
"const.alt %1!smul!",
"smul.c %1!",
#else
"\356smul!",
"smu\307\202",
#endif
seqsize(2,1) - seqsize(1,1)
},
{
#ifdef SCPACK
"const.alt %1!eq!",
"eq.c.pri %1!",
#else
"\356\325",
"\262\242\225",
#endif
seqsize(2,1) - seqsize(1,1)
},
/* Some operations use the alternative subtraction operation --these
* can also be optimized.
* const.pri n1 load.s.pri n2
* load.s.alt n2 add.c -n1
* sub.alt -
* --------------------------------------
* const.pri n1 load.pri n2
* load.alt n2 add.c -n1
* sub.alt -
*/
{
#ifdef SCPACK
"const.pri %1!load.s.alt %2!sub.alt!",
"load.s.pri %2!add.c -%1!",
#else
"\330\226\304sub\223",
"\246\235\242 -\201",
#endif
seqsize(3,2) - seqsize(2,2)
},
{
#ifdef SCPACK
"const.pri %1!load.alt %2!sub.alt!",
"load.pri %2!add.c -%1!",
#else
"\330\362sub\223",
"\334\235\242 -\201",
#endif
seqsize(3,2) - seqsize(2,2)
},
/* With arrays indexed with constants that come from enumerations, it happens
* multiple add.c opcodes follow in sequence.
* add.c n1 add.c n1+n2
* add.c n2 -
*/
{
#ifdef SCPACK
"add.c %1!add.c %2!",
"add.c %1+%2!",
#else
"\235\242\202\235\242\221",
"\235\242\267+%2!",
#endif
seqsize(2,2) - seqsize(1,1)
},
/* Compare and jump
* eq jneq n1
* jzer n1 -
* --------------------------------------
* eq jeq n1
* jnz n1 -
* --------------------------------------
* neq jeq n1
* jzer n1 -
* --------------------------------------
* neq jneq n1
* jnz n1 -
* Compares followed by jzer occur much more
* often than compares followed with jnz. So we
* take the easy route here.
* less jgeq n1
* jzer n1 -
* --------------------------------------
* leq jgrtr n1
* jzer n1 -
* --------------------------------------
* grtr jleq n1
* jzer n1 -
* --------------------------------------
* geq jless n1
* jzer n1 -
* --------------------------------------
* sless jsgeq n1
* jzer n1 -
* --------------------------------------
* sleq jsgrtr n1
* jzer n1 -
* --------------------------------------
* sgrtr jsleq n1
* jzer n1 -
* --------------------------------------
* sgeq jsless n1
* jzer n1 -
*/
{
#ifdef SCPACK
"eq!jzer %1!",
"jneq %1!",
#else
"\325\323",
"jn\357",
#endif
seqsize(2,1) - seqsize(1,1)
},
{
#ifdef SCPACK
"eq!jnz %1!",
"jeq %1!",
#else
"\325jnz\202",
"j\357",
#endif
seqsize(2,1) - seqsize(1,1)
},
{
#ifdef SCPACK
"neq!jzer %1!",
"jeq %1!",
#else
"n\325\323",
"j\357",
#endif
seqsize(2,1) - seqsize(1,1)
},
{
#ifdef SCPACK
"neq!jnz %1!",
"jneq %1!",
#else
"n\325jnz\202",
"jn\357",
#endif
seqsize(2,1) - seqsize(1,1)
},
{
#ifdef SCPACK
"less!jzer %1!",
"jgeq %1!",
#else
"l\352!\323",
"jg\357",
#endif
seqsize(2,1) - seqsize(1,1)
},
{
#ifdef SCPACK
"leq!jzer %1!",
"jgrtr %1!",
#else
"l\325\323",
"jg\353r\202",
#endif
seqsize(2,1) - seqsize(1,1)
},
{
#ifdef SCPACK
"grtr!jzer %1!",
"jleq %1!",
#else
"g\353\237\323",
"jl\357",
#endif
seqsize(2,1) - seqsize(1,1)
},
{
#ifdef SCPACK
"geq!jzer %1!",
"jless %1!",
#else
"g\325\323",
"jl\352\202",
#endif
seqsize(2,1) - seqsize(1,1)
},
{
#ifdef SCPACK
"sless!jzer %1!",
"jsgeq %1!",
#else
"\372!\323",
"j\320\357",
#endif
seqsize(2,1) - seqsize(1,1)
},
{
#ifdef SCPACK
"sleq!jzer %1!",
"jsgrtr %1!",
#else
"\321\325\323",
"j\371r\202",
#endif
seqsize(2,1) - seqsize(1,1)
},
{
#ifdef SCPACK
"sgrtr!jzer %1!",
"jsleq %1!",
#else
"\371\237\323",
"j\321\357",
#endif
seqsize(2,1) - seqsize(1,1)
},
{
#ifdef SCPACK
"sgeq!jzer %1!",
"jsless %1!",
#else
"\320\325\323",
"j\372\202",
#endif
seqsize(2,1) - seqsize(1,1)
},
/* Test for zero (common case, especially for strings)
* E.g. the test expression of: "for (i=0; str{i}!=0; ++i)"
*
* zero.alt jzer n1
* jeq n1 -
* --------------------------------------
* zero.alt jnz n1
* jneq n1 -
*/
{
#ifdef SCPACK
"zero.alt!jeq %1!",
"jzer %1!",
#else
"\340\223j\357",
"\323",
#endif
seqsize(2,1) - seqsize(1,1)
},
{
#ifdef SCPACK
"zero.alt!jneq %1!",
"jnz %1!",
#else
"\340\223jn\357",
"jnz\202",
#endif
seqsize(2,1) - seqsize(1,1)
},
/* Incrementing and decrementing leaves a value in
* in PRI which may not be used (for example, as the
* third expression in a "for" loop).
* inc n1 inc n1 ; ++n
* load.pri n1 ;$exp
* ;$exp -
* --------------------------------------
* load.pri n1 inc n1 ; n++, e.g. "for (n=0; n<10; n++)"
* inc n1 ;$exp
* ;$exp -
* Plus the varieties for stack relative increments
* and decrements.
*/
{
#ifdef SCPACK
"inc %1!load.pri %1!;$exp!",
"inc %1!;$exp!",
#else
"inc\202\311\252",
"inc\301",
#endif
seqsize(2,2) - seqsize(1,1)
},
{
#ifdef SCPACK
"load.pri %1!inc %1!;$exp!",
"inc %1!;$exp!",
#else
"\311inc\301",
"inc\301",
#endif
seqsize(2,2) - seqsize(1,1)
},
{
#ifdef SCPACK
"inc.s %1!load.s.pri %1!;$exp!",
"inc.s %1!;$exp!",
#else
"inc\222\202\333\252",
"inc\222\301",
#endif
seqsize(2,2) - seqsize(1,1)
},
{
#ifdef SCPACK
"load.s.pri %1!inc.s %1!;$exp!",
"inc.s %1!;$exp!",
#else
"\333inc\222\301",
"inc\222\301",
#endif
seqsize(2,2) - seqsize(1,1)
},
{
#ifdef SCPACK
"dec %1!load.pri %1!;$exp!",
"dec %1!;$exp!",
#else
"dec\202\311\252",
"dec\301",
#endif
seqsize(2,2) - seqsize(1,1)
},
{
#ifdef SCPACK
"load.pri %1!dec %1!;$exp!",
"dec %1!;$exp!",
#else
"\311dec\301",
"dec\301",
#endif
seqsize(2,2) - seqsize(1,1)
},
{
#ifdef SCPACK
"dec.s %1!load.s.pri %1!;$exp!",
"dec.s %1!;$exp!",
#else
"dec\222\202\333\252",
"dec\222\301",
#endif
seqsize(2,2) - seqsize(1,1)
},
{
#ifdef SCPACK
"load.s.pri %1!dec.s %1!;$exp!",
"dec.s %1!;$exp!",
#else
"\333dec\222\301",
"dec\222\301",
#endif
seqsize(2,2) - seqsize(1,1)
},
/* ??? the same (increments and decrements) for references */
/* Loading the constant zero has a special opcode.
* When storing zero in memory, the value of PRI must not be later on.
* const.pri 0 zero n1
* stor.pri n1 ;$exp
* ;$exp -
* --------------------------------------
* const.pri 0 zero.s n1
* stor.s.pri n1 ;$exp
* ;$exp -
* --------------------------------------
* zero.pri zero n1
* stor.pri n1 ;$exp
* ;$exp -
* --------------------------------------
* zero.pri zero.s n1
* stor.s.pri n1 ;$exp
* ;$exp -
* --------------------------------------
* const.pri 0 zero.pri
* --------------------------------------
* const.alt 0 zero.alt
* The last two alternatives save more memory than they save
* time, but anyway...
*/
{
#ifdef SCPACK
"const.pri 0!stor.pri %1!;$exp!",
"zero %1!;$exp!",
#else
"\233\206 0!\227or\225\252",
"\340\301",
#endif
seqsize(2,2) - seqsize(1,1)
},
{
#ifdef SCPACK
"const.pri 0!stor.s.pri %1!;$exp!",
"zero.s %1!;$exp!",
#else
"\233\206 0!\227or\222\225\252",
"\340\222\301",
#endif
seqsize(2,2) - seqsize(1,1)
},
{
#ifdef SCPACK
"zero.pri!stor.pri %1!;$exp!",
"zero %1!;$exp!",
#else
"\373\227or\225\252",
"\340\301",
#endif
seqsize(2,1) - seqsize(1,1)
},
{
#ifdef SCPACK
"zero.pri!stor.s.pri %1!;$exp!",
"zero.s %1!;$exp!",
#else
"\373\227or\222\225\252",
"\340\222\301",
#endif
seqsize(2,1) - seqsize(1,1)
},
{
#ifdef SCPACK
"const.pri 0!",
"zero.pri!",
#else
"\233\206 0!",
"\373",
#endif
seqsize(1,1) - seqsize(1,0)
},
{
#ifdef SCPACK
"const.alt 0!",
"zero.alt!",
#else
"\233\212 0!",
"\340\223",
#endif
seqsize(1,1) - seqsize(1,0)
},
/* ------------------ */
/* Macro instructions */
/* ------------------ */
{ "", "", 0 }, /* separator, so optimizer can stop before generating macro opcodes */
/* optimizing the calling of native functions (which always have a parameter
* count pushed before, and the stack pointer restored afterwards
*/
{
#ifdef SCPACK
"push.c %1!sysreq.c %2!stack %3!", //note: %3 == %1 + 4
"sysreq.n %2 %1!",
#else
"\331\202sysr\262\242\221\227ack\256",
"sysr\262.n\220\202",
#endif
seqsize(3,3) - seqsize(1,2)
},
/* ----- */
/* Functions with many parameters with the same "type" have sequences like:
* push.c n1 push3.c n1 n2 n3
* ;$par ;$par
* push.c n2 -
* ;$par -
* push.c n3 -
* ;$par -
* etc. etc.
*
* Similar sequences occur with PUSH, PUSH.s and PUSHADDR
*/
{
#ifdef SCPACK
"push.c %1!;$par!push.c %2!;$par!push.c %3!;$par!push.c %4!;$par!push.c %5!",
"push5.c %1 %2 %3 %4 %5!",
#else
"\331\336\242\345\242\256\257\242\335\257\242\2035!",
"\2165\242\343\245\302\2035!",
#endif
seqsize(5,5) - seqsize(1,5)
},
{
#ifdef SCPACK
"push.c %1!;$par!push.c %2!;$par!push.c %3!;$par!push.c %4!",
"push4.c %1 %2 %3 %4!",
#else
"\331\336\242\345\242\256\257\242\335",
"\2164\242\343\245\335",
#endif
seqsize(4,4) - seqsize(1,4)
},
{
#ifdef SCPACK
"push.c %1!;$par!push.c %2!;$par!push.c %3!",
"push3.c %1 %2 %3!",
#else
"\331\336\242\345\242\256",
"\2163\242\343\256",
#endif
seqsize(3,3) - seqsize(1,3)
},
{
#ifdef SCPACK
"push.c %1!;$par!push.c %2!",
"push2.c %1 %2!",
#else
"\331\336\242\221",
"\2162\242\332",
#endif
seqsize(2,2) - seqsize(1,2)
},
/* ----- */
{
#ifdef SCPACK
"push %1!;$par!push %2!;$par!push %3!;$par!push %4!;$par!push %5!",
"push5 %1 %2 %3 %4 %5!",
#else
"\216\336\345\256\257\335\257\2035!",
"\2165\343\245\302\2035!",
#endif
seqsize(5,5) - seqsize(1,5)
},
{
#ifdef SCPACK
"push %1!;$par!push %2!;$par!push %3!;$par!push %4!",
"push4 %1 %2 %3 %4!",
#else
"\216\336\345\256\257\335",
"\2164\343\245\335",
#endif
seqsize(4,4) - seqsize(1,4)
},
{
#ifdef SCPACK
"push %1!;$par!push %2!;$par!push %3!",
"push3 %1 %2 %3!",
#else
"\216\336\345\256",
"\2163\343\256",
#endif
seqsize(3,3) - seqsize(1,3)
},
{
#ifdef SCPACK
"push %1!;$par!push %2!",
"push2 %1 %2!",
#else
"\216\336\221",
"\2162\332",
#endif
seqsize(2,2) - seqsize(1,2)
},
/* ----- */
{
#ifdef SCPACK
"push.s %1!;$par!push.s %2!;$par!push.s %3!;$par!push.s %4!;$par!push.s %5!",
"push5.s %1 %2 %3 %4 %5!",
#else
"\216\222\336\222\345\222\256\257\222\335\257\222\2035!",
"\2165\222\343\245\302\2035!",
#endif
seqsize(5,5) - seqsize(1,5)
},
{
#ifdef SCPACK
"push.s %1!;$par!push.s %2!;$par!push.s %3!;$par!push.s %4!",
"push4.s %1 %2 %3 %4!",
#else
"\216\222\336\222\345\222\256\257\222\335",
"\2164\222\343\245\335",
#endif
seqsize(4,4) - seqsize(1,4)
},
{
#ifdef SCPACK
"push.s %1!;$par!push.s %2!;$par!push.s %3!",
"push3.s %1 %2 %3!",
#else
"\216\222\336\222\345\222\256",
"\2163\222\343\256",
#endif
seqsize(3,3) - seqsize(1,3)
},
{
#ifdef SCPACK
"push.s %1!;$par!push.s %2!",
"push2.s %1 %2!",
#else
"\216\222\336\222\221",
"\2162\222\332",
#endif
seqsize(2,2) - seqsize(1,2)
},
/* ----- */
{
#ifdef SCPACK
"push.adr %1!;$par!push.adr %2!;$par!push.adr %3!;$par!push.adr %4!;$par!push.adr %5!",
"push5.adr %1 %2 %3 %4 %5!",
#else
"\216\326\336\326\345\326\256\257\326\335\257\326\2035!",
"\2165\326\343\245\302\2035!",
#endif
seqsize(5,5) - seqsize(1,5)
},
{
#ifdef SCPACK
"push.adr %1!;$par!push.adr %2!;$par!push.adr %3!;$par!push.adr %4!",
"push4.adr %1 %2 %3 %4!",
#else
"\216\326\336\326\345\326\256\257\326\335",
"\2164\326\343\245\335",
#endif
seqsize(4,4) - seqsize(1,4)
},
{
#ifdef SCPACK
"push.adr %1!;$par!push.adr %2!;$par!push.adr %3!",
"push3.adr %1 %2 %3!",
#else
"\216\326\336\326\345\326\256",
"\2163\326\343\256",
#endif
seqsize(3,3) - seqsize(1,3)
},
{
#ifdef SCPACK
"push.adr %1!;$par!push.adr %2!",
"push2.adr %1 %2!",
#else
"\216\326\336\326\221",
"\2162\326\332",
#endif
seqsize(2,2) - seqsize(1,2)
},
/* Loading two registers at a time
* load.pri n1 load.both n1 n2
* load.alt n2 -
* --------------------------------------
* load.alt n2 load.both n1 n2
* load.pri n1 -
* --------------------------------------
* load.s.pri n1 load.s.both n1 n2
* load.s.alt n2 -
* --------------------------------------
* load.s.alt n2 load.s.both n1 n2
* load.s.pri n1 -
*/
{
#ifdef SCPACK
"load.pri %1!load.alt %2!",
"load.both %1 %2!",
#else
"\311\362",
"\342\275th\332",
#endif
seqsize(2,2) - seqsize(1,2)
},
{
#ifdef SCPACK
"load.alt %2!load.pri %1!",
"load.both %1 %2!",
#else
"\362\311",
"\342\275th\332",
#endif
seqsize(2,2) - seqsize(1,2)
},
{
#ifdef SCPACK
"load.s.pri %1!load.s.alt %2!",
"load.s.both %1 %2!",
#else
"\333\226\304",
"\226.\275th\332",
#endif
seqsize(2,2) - seqsize(1,2)
},
{
#ifdef SCPACK
"load.s.alt %2!load.s.pri %1!",
"load.s.both %1 %2!",
#else
"\226\304\333",
"\226.\275th\332",
#endif
seqsize(2,2) - seqsize(1,2)
},
/* Loading two registers and then pushing them occurs with user operators
* load.both n1 n2 push2 n1 n2
* push.pri -
* push.alt -
* --------------------------------------
* load.s.both n1 n2 push2.s n1 n2
* push.pri -
* push.alt -
*/
{
#ifdef SCPACK
"load.both %1 %2!push.pri!push.alt!",
"push2 %1 %2!",
#else
"\342\275th\332\244\354",
"\2162\332",
#endif
seqsize(3,2) - seqsize(1,2)
},
{
#ifdef SCPACK
"load.s.both %1 %2!push.pri!push.alt!",
"push2.s %1 %2!",
#else
"\226.\275th\332\244\354",
"\2162\222\332",
#endif
seqsize(3,2) - seqsize(1,2)
},
/* Load a constant in a variable
* const.pri n1 const n2 n1
* stor.pri n2 -
* --------------------------------------
* const.pri n1 const.s n2 n1
* stor.s.pri n2 -
*/
{
#ifdef SCPACK
"const.pri %1!stor.pri %2!",
"const %2 %1!",
#else
"\330\227or\230",
"\233\220\202",
#endif
seqsize(2,2) - seqsize(1,2)
},
{
#ifdef SCPACK
"const.pri %1!stor.s.pri %2!",
"const.s %2 %1!",
#else
"\330\227or\222\230",
"\233\222\220\202",
#endif
seqsize(2,2) - seqsize(1,2)
},
/* ----- */
{ NULL, NULL, 0 }
};
Reference in New Issue View Git Blame Copy Permalink