You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1473 lines
38 KiB
1473 lines
38 KiB
/* Small compiler - Peephole optimizer "sequences" strings (plain |
|
* and compressed formats) |
|
* |
|
* Copyright (c) ITB CompuPhase, 2000-2003 |
|
* |
|
* 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$ |
|
*/ |
|
|
|
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] = { |
|
{32, 37}, {114, 105}, {112, 129}, {46, 130}, {49, 33}, {128, 132}, {97, 100}, |
|
{46, 97}, {135, 108}, {136, 116}, {111, 134}, {108, 138}, {50, 33}, {115, |
|
104}, |
|
{128, 140}, {137, 33}, |
|
{46, 115}, {117, 141}, {112, 145}, {131, 133}, {139, 144}, {112, 143}, {131, |
|
142}, |
|
{115, 116}, {111, 149}, {112, 152}, {131, 33}, {134, 100}, {110, 151}, |
|
{111, 156}, {99, 157}, {59, 36}, |
|
{146, 154}, {148, 150}, {112, 33}, {120, 162}, {101, 163}, {159, 164}, {137, |
|
133}, |
|
{46, 99}, {122, 101}, {110, 100}, {155, 114}, {101, 113}, {168, 114}, |
|
{147, 160}, {51, 33}, {128, 174}, |
|
{103, 33}, {133, 165}, {104, 176}, {99, 178}, {120, 179}, {171, 33}, {106, |
|
172}, |
|
{173, 161}, {155, 33}, {108, 167}, {117, 169}, {115, 175}, {186, 187}, |
|
{153, 184}, {141, 185}, {111, 188}, |
|
{98, 191}, {105, 100}, {115, 103}, {115, 108}, {193, 120}, {182, 133}, {114, |
|
33}, |
|
{166, 161}, {190, 131}, {137, 142}, {169, 33}, {97, 202}, {139, 147}, |
|
{172, 111}, {158, 147}, {139, 150}, |
|
{105, 33}, {101, 115}, {209, 115}, {114, 116}, {148, 147}, {171, 133}, {189, |
|
139}, |
|
{32, 140}, {146, 167}, {196, 170}, {158, 183}, {170, 183}, {199, 192}, |
|
{108, 196}, {97, 198}, {194, 211}, |
|
{46, 208}, {195, 210}, {200, 215}, {112, 222}, {159, 227}, {46, 98}, {118, |
|
101}, |
|
{111, 230}, {109, 231}, {146, 143}, {99, 144}, {158, 150}, {97, 149}, |
|
{203, 153}, {52, 33}, {225, 33}, |
|
{158, 166}, {194, 181}, {195, 181}, {201, 180}, {223, 198}, {153, 203}, {214, |
|
224}, |
|
{100, 101}, {128, 238}, {119, 236}, {249, 237}, {105, 110}, {115, 250}, |
|
{232, 143}, {205, 154} |
|
}; |
|
/*-*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 |
|
"\224\267\231", |
|
"\241\224\246", |
|
#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 |
|
"\213\267\231", |
|
"\241\213\246", |
|
#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 |
|
"\224\255\317\231", |
|
"\317\224\246", |
|
#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 |
|
"\213\255\317\231", |
|
"\317\213\246", |
|
#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 |
|
"\333\231", |
|
"\252\307", |
|
#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 |
|
"\252\255\317\231", |
|
"\252\246\317", |
|
#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 |
|
"\332\231", |
|
"\241\360", |
|
#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 |
|
"\236\255\317\231", |
|
"\317\360", |
|
#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 |
|
"\224\255\353\231", |
|
"\353\224\246", |
|
#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 |
|
"\213\255\353\231", |
|
"\353\213\246", |
|
#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 |
|
"\252\255\353\231", |
|
"\252\246\353", |
|
#endif |
|
seqsize(4, 2) - seqsize(2, 2)}, |
|
/* ??? 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 |
|
"\350\232\240\324\231", |
|
"\324", |
|
#endif |
|
seqsize(4, 1) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"move.pri!push.pri!load.pri %1!pop.alt!", |
|
"load.pri %1!", |
|
#else |
|
"\350\232\240\314\231", |
|
"\314", |
|
#endif |
|
seqsize(4, 1) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"move.pri!push.pri!const.pri %1!pop.alt!", |
|
"const.pri %1!", |
|
#else |
|
"\350\232\240\316\231", |
|
"\316", |
|
#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 |
|
"\264\364\374\245", |
|
"\357\365\245", |
|
#endif |
|
seqsize(5, 0) - seqsize(3, 0)}, |
|
{ |
|
#ifdef SCPACK |
|
"xchg!sless!swap.alt!and!pop.alt!;$exp!", |
|
"sgrtr!pop.alt!and!;$exp!", |
|
#else |
|
"\264\357\374\245", |
|
"\364\365\245", |
|
#endif |
|
seqsize(5, 0) - seqsize(3, 0)}, |
|
{ |
|
#ifdef SCPACK |
|
"xchg!sgeq!swap.alt!and!pop.alt!;$exp!", |
|
"sleq!pop.alt!and!;$exp!", |
|
#else |
|
"\264\361\374\245", |
|
"\362\365\245", |
|
#endif |
|
seqsize(5, 0) - seqsize(3, 0)}, |
|
{ |
|
#ifdef SCPACK |
|
"xchg!sleq!swap.alt!and!pop.alt!;$exp!", |
|
"sgeq!pop.alt!and!;$exp!", |
|
#else |
|
"\264\362\374\245", |
|
"\361\365\245", |
|
#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 |
|
"\264\364\374\305", |
|
"\357\365\305", |
|
#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 |
|
"\264\357\374\305", |
|
"\364\365\305", |
|
#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 |
|
"\264\361\374\305", |
|
"\362\365\305", |
|
#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 |
|
"\264\362\374\305", |
|
"\361\365\305", |
|
#endif |
|
seqsize(5, 0) - seqsize(3, 0)}, |
|
{ |
|
#ifdef SCPACK |
|
"xchg!sgrtr!jzer %1!;$exp!", |
|
"jsgeq %1!;$exp!", |
|
#else |
|
"\264\364\266\261", |
|
"j\302\253\261", |
|
#endif |
|
seqsize(3, 1) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"xchg!sless!jzer %1!;$exp!", |
|
"jsleq %1!;$exp!", |
|
#else |
|
"\264\357\266\261", |
|
"j\303\253\261", |
|
#endif |
|
seqsize(3, 1) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"xchg!sgeq!jzer %1!;$exp!", |
|
"jsgrtr %1!;$exp!", |
|
#else |
|
"\264\361\266\261", |
|
"j\337r\261", |
|
#endif |
|
seqsize(3, 1) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"xchg!sleq!jzer %1!;$exp!", |
|
"jsless %1!;$exp!", |
|
#else |
|
"\264\362\266\261", |
|
"j\341\261", |
|
#endif |
|
seqsize(3, 1) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"xchg!sgrtr!;$exp!", |
|
"sless!;$exp!", |
|
#else |
|
"\264\364\245", |
|
"\357\245", |
|
#endif |
|
seqsize(2, 0) - seqsize(1, 0)}, |
|
{ |
|
#ifdef SCPACK |
|
"xchg!sless!;$exp!", |
|
"sgrtr!;$exp!", |
|
#else |
|
"\264\357\245", |
|
"\364\245", |
|
#endif |
|
seqsize(2, 0) - seqsize(1, 0)}, |
|
{ |
|
#ifdef SCPACK |
|
"xchg!sgeq!;$exp!", |
|
"sleq!;$exp!", |
|
#else |
|
"\264\361\245", |
|
"\362\245", |
|
#endif |
|
seqsize(2, 0) - seqsize(1, 0)}, |
|
{ |
|
#ifdef SCPACK |
|
"xchg!sleq!;$exp!", |
|
"sgeq!;$exp!", |
|
#else |
|
"\264\362\245", |
|
"\361\245", |
|
#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 |
|
"\324\224\363", |
|
"\241\224\246", |
|
#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 |
|
"\324\213\363", |
|
"\317\224\246", |
|
#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 |
|
"\324\236\363", |
|
"\353\224\246", |
|
#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 |
|
"\314\224\363", |
|
"\241\213\246", |
|
#endif |
|
seqsize(3, 2) - seqsize(2, 2)}, |
|
{ |
|
#ifdef SCPACK |
|
"load.pri %1!load.alt %2!xchg!", |
|
"load.pri %2!load.alt %1!", |
|
#else |
|
"\314\213\363", |
|
"\317\213\246", |
|
#endif |
|
seqsize(3, 2) - seqsize(2, 2)}, |
|
{ |
|
#ifdef SCPACK |
|
"load.pri %1!const.alt %2!xchg!", |
|
"const.pri %2!load.alt %1!", |
|
#else |
|
"\314\236\363", |
|
"\353\213\246", |
|
#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 |
|
"\316\224\363", |
|
"\241\360", |
|
#endif |
|
seqsize(3, 2) - seqsize(2, 2)}, |
|
{ |
|
#ifdef SCPACK |
|
"const.pri %1!load.alt %2!xchg!", |
|
"load.pri %2!const.alt %1!", |
|
#else |
|
"\316\213\363", |
|
"\317\360", |
|
#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 cels), 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 |
|
"\333\300\342\366", |
|
"\252\334\335!", |
|
#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 |
|
"\332\300\342\366", |
|
"\236\334\335!", |
|
#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 |
|
"\333\342\366", |
|
"\252\307\335!", |
|
#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 |
|
"\332\342\366", |
|
"\236\307\335!", |
|
#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 |
|
"\333\300\310\370\366", |
|
"\252\334\335\345\370", |
|
#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 |
|
"\332\300\310\370\366", |
|
"\236\334\335\345\370", |
|
#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 |
|
"\333\310\257\366", |
|
"\252\307\335\345\257", |
|
#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 |
|
"\332\310\257\366", |
|
"\236\307\335\345\257", |
|
#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 |
|
"\333\300\342\275", |
|
"\252\334\331!", |
|
#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 |
|
"\332\300\342\275", |
|
"\236\334\331!", |
|
#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 |
|
"\333\342\275", |
|
"\252\307\331!", |
|
#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 |
|
"\332\342\275", |
|
"\236\307\331!", |
|
#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 |
|
"\333\300\310\370\275", |
|
"\252\334\331\345\370", |
|
#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 |
|
"\332\300\310\370\275", |
|
"\236\334\331\345\370", |
|
#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 |
|
"\333\310\257\275", |
|
"\252\307\331\345\257", |
|
#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 |
|
"\332\310\257\275", |
|
"\236\307\331\345\257", |
|
#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 |
|
"\342\326\320", |
|
"\231\335!", |
|
#endif |
|
seqsize(4, 1) - seqsize(2, 0)}, |
|
{ |
|
#ifdef SCPACK |
|
"shl.c.pri 2!pop.alt!add!", |
|
"pop.alt!idxaddr!", |
|
#else |
|
"\342\275", |
|
"\231\331!", |
|
#endif |
|
seqsize(3, 1) - seqsize(2, 0)}, |
|
#endif |
|
{ |
|
#ifdef SCPACK |
|
"shl.c.pri %1!pop.alt!add!loadi!", |
|
"pop.alt!lidx.b %1!", |
|
#else |
|
"\276\223\326\320", |
|
"\231\335\345\205", |
|
#endif |
|
seqsize(4, 1) - seqsize(2, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"shl.c.pri %1!pop.alt!add!", |
|
"pop.alt!idxaddr.b %1!", |
|
#else |
|
"\276\223\275", |
|
"\231\331\345\205", |
|
#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 |
|
"\333\300\231", |
|
"\252\334", |
|
#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 |
|
"\332\300\231", |
|
"\236\334", |
|
#endif |
|
seqsize(5, 3) - seqsize(3, 3)}, |
|
/* 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 |
|
"\240\324\231", |
|
"\375\324", |
|
#endif |
|
seqsize(3, 1) - seqsize(2, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"push.pri!load.pri %1!pop.alt!", |
|
"move.alt!load.pri %1!", |
|
#else |
|
"\240\314\231", |
|
"\375\314", |
|
#endif |
|
seqsize(3, 1) - seqsize(2, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"push.pri!const.pri %1!pop.alt!", |
|
"move.alt!const.pri %1!", |
|
#else |
|
"\240\316\231", |
|
"\375\316", |
|
#endif |
|
seqsize(3, 1) - seqsize(2, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"push.pri!zero.pri!pop.alt!", |
|
"move.alt!zero.pri!", |
|
#else |
|
"\240\376\231", |
|
"\375\376", |
|
#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 |
|
"\240\213\340\231", |
|
"\375\213\340", |
|
#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 |
|
"\240\231", |
|
"\375", |
|
#endif |
|
seqsize(2, 0) - seqsize(1, 0)}, |
|
/* And what to think of this PUSH/POP sequence, which occurs |
|
* due to the support for user-defined assignment operator): |
|
* push.alt - |
|
* pop.alt - |
|
*/ |
|
//??? |
|
//{ |
|
// #ifdef SCPACK |
|
// "push.alt!pop.alt!", |
|
// ";$", /* SCPACK cannot handle empty strings */ |
|
// #else |
|
// "\225\237", |
|
// "\353", |
|
// #endif |
|
// seqsize(2,0) - seqsize(0,0) |
|
//}, |
|
/* Functions with many parameters with the same default |
|
* value have sequences like: |
|
* push.c n1 const.pri n1 |
|
* ;$par push.r.pri n2 ; where n2 is the number of pushes |
|
* push.c n1 ;$par |
|
* ;$par - |
|
* push.c n1 - |
|
* ;$par - |
|
* etc. etc. |
|
* The shortest matched sequence is 3, because a sequence of two can also be |
|
* optimized as two "push.c n1" instructions. |
|
* => this optimization does not work, because the argument re-ordering in |
|
* a function call causes each argument to be optimized individually |
|
*/ |
|
//{ |
|
// #ifdef SCPACK |
|
// "const.pri %1!push.pri!;$par!const.pri %1!push.pri!;$par!const.pri %1!push.pri!;$par!const.pri %1!push.pri!;$par!const.pri %1!push.pri!;$par!", |
|
// "const.pri %1!push.r.pri 5!;$par!", |
|
// #else |
|
// "\327\327\254", |
|
// "\352\221.r\2745!", |
|
// #endif |
|
// seqsize(10,5) - seqsize(2,2) |
|
//}, |
|
//{ |
|
// #ifdef SCPACK |
|
// "const.pri %1!push.pri!;$par!const.pri %1!push.pri!;$par!const.pri %1!push.pri!;$par!const.pri %1!push.pri!;$par!", |
|
// "const.pri %1!push.r.pri 4!;$par!", |
|
// #else |
|
// "\327\327", |
|
// "\352\221.r\274\326", |
|
// #endif |
|
// seqsize(8,4) - seqsize(2,2) |
|
//}, |
|
//{ |
|
// #ifdef SCPACK |
|
// "const.pri %1!push.pri!;$par!const.pri %1!push.pri!;$par!const.pri %1!push.pri!;$par!", |
|
// "const.pri %1!push.r.pri 3!;$par!", |
|
// #else |
|
// "\327\254", |
|
// "\352\221.r\274\247", |
|
// #endif |
|
// seqsize(6,3) - seqsize(2,2) |
|
//}, |
|
/* 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 |
|
"\316\236\311\240\351", |
|
"\330\205\330\216", |
|
#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 |
|
"\316\236\311\351\240", |
|
"\330\216\330\205", |
|
#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 |
|
"\316\213\311\240\351", |
|
"\330\205\222\216", |
|
#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 |
|
"\316\213\311\351\240", |
|
"\222\216\330\205", |
|
#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 |
|
"\314\236\311\240\351", |
|
"\222\205\330\216", |
|
#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 |
|
"\314\236\311\351\240", |
|
"\330\216\222\205", |
|
#endif |
|
seqsize(4, 2) - seqsize(2, 2)}, |
|
{ |
|
#ifdef SCPACK |
|
"load.pri %1!load.alt %2!push.pri!push.alt!", |
|
"push %1!push %2!", |
|
#else |
|
"\314\213\311\240\351", |
|
"\222\205\222\216", |
|
#endif |
|
seqsize(4, 2) - seqsize(2, 2)}, |
|
{ |
|
#ifdef SCPACK |
|
"load.pri %1!load.alt %2!push.alt!push.pri!", |
|
"push %2!push %1!", |
|
#else |
|
"\314\213\311\351\240", |
|
"\222\216\222\205", |
|
#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 pushaddr 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 |
|
"\224\255\344", |
|
"\222\220\205\344", |
|
#endif |
|
seqsize(2, 1) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"load.pri %1!push.pri!;$par!", |
|
"push %1!;$par!", |
|
#else |
|
"\213\255\344", |
|
"\222\205\344", |
|
#endif |
|
seqsize(2, 1) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"const.pri %1!push.pri!;$par!", |
|
"push.c %1!;$par!", |
|
#else |
|
"\236\255\344", |
|
"\330\205\344", |
|
#endif |
|
seqsize(2, 1) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"zero.pri!push.pri!;$par!", |
|
"push.c 0!;$par!", |
|
#else |
|
"\376\240\344", |
|
"\330 0!\344", |
|
#endif |
|
seqsize(2, 0) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"addr.pri %1!push.pri!;$par!", |
|
"pushaddr %1!;$par!", |
|
#else |
|
"\252\255\344", |
|
"\222\252\205\344", |
|
#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 |
|
"\350\232\240", |
|
"\351", |
|
#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 |
|
"\360\270", |
|
"\233\247\205", |
|
#endif |
|
seqsize(2, 1) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"const.alt %1!sub!", |
|
"add.c -%1!", |
|
#else |
|
"\360sub!", |
|
"\233\247 -%\204", |
|
#endif |
|
seqsize(2, 1) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"const.alt %1!smul!", |
|
"smul.c %1!", |
|
#else |
|
"\360smul!", |
|
"smu\271\205", |
|
#endif |
|
seqsize(2, 1) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"const.alt %1!eq!", |
|
"eq.c.pri %1!", |
|
#else |
|
"\360\265", |
|
"\253\247\223", |
|
#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 |
|
"\316\224\311sub\217", |
|
"\241\233\247 -%\204", |
|
#endif |
|
seqsize(3, 2) - seqsize(2, 2)}, |
|
{ |
|
#ifdef SCPACK |
|
"const.pri %1!load.alt %2!sub.alt!", |
|
"load.pri %2!add.c -%1!", |
|
#else |
|
"\316\213\311sub\217", |
|
"\317\233\247 -%\204", |
|
#endif |
|
seqsize(3, 2) - seqsize(2, 2)}, |
|
/* 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 |
|
"\265\305", |
|
"jn\325", |
|
#endif |
|
seqsize(2, 1) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"eq!jnz %1!", |
|
"jeq %1!", |
|
#else |
|
"\265jnz\205", |
|
"j\325", |
|
#endif |
|
seqsize(2, 1) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"neq!jzer %1!", |
|
"jeq %1!", |
|
#else |
|
"n\265\305", |
|
"j\325", |
|
#endif |
|
seqsize(2, 1) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"neq!jnz %1!", |
|
"jneq %1!", |
|
#else |
|
"n\265jnz\205", |
|
"jn\325", |
|
#endif |
|
seqsize(2, 1) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"less!jzer %1!", |
|
"jgeq %1!", |
|
#else |
|
"l\322!\305", |
|
"jg\325", |
|
#endif |
|
seqsize(2, 1) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"leq!jzer %1!", |
|
"jgrtr %1!", |
|
#else |
|
"l\265\305", |
|
"jg\323r\205", |
|
#endif |
|
seqsize(2, 1) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"grtr!jzer %1!", |
|
"jleq %1!", |
|
#else |
|
"g\323\306\305", |
|
"jl\325", |
|
#endif |
|
seqsize(2, 1) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"geq!jzer %1!", |
|
"jless %1!", |
|
#else |
|
"g\265\305", |
|
"jl\322\205", |
|
#endif |
|
seqsize(2, 1) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"sless!jzer %1!", |
|
"jsgeq %1!", |
|
#else |
|
"\357\305", |
|
"j\302\325", |
|
#endif |
|
seqsize(2, 1) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"sleq!jzer %1!", |
|
"jsgrtr %1!", |
|
#else |
|
"\362\305", |
|
"j\337r\205", |
|
#endif |
|
seqsize(2, 1) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"sgrtr!jzer %1!", |
|
"jsleq %1!", |
|
#else |
|
"\364\305", |
|
"j\303\325", |
|
#endif |
|
seqsize(2, 1) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"sgeq!jzer %1!", |
|
"jsless %1!", |
|
#else |
|
"\361\305", |
|
"j\341\205", |
|
#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 |
|
"\315\217j\325", |
|
"\305", |
|
#endif |
|
seqsize(2, 1) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"zero.alt!jneq %1!", |
|
"jnz %1!", |
|
#else |
|
"\315\217jn\325", |
|
"jnz\205", |
|
#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 |
|
"\373c\205\314\245", |
|
"\373c\261", |
|
#endif |
|
seqsize(2, 2) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"load.pri %1!inc %1!;$exp!", |
|
"inc %1!;$exp!", |
|
#else |
|
"\314\373c\261", |
|
"\373c\261", |
|
#endif |
|
seqsize(2, 2) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"inc.s %1!load.s.pri %1!;$exp!", |
|
"inc.s %1!;$exp!", |
|
#else |
|
"\373\352\205\324\245", |
|
"\373\352\261", |
|
#endif |
|
seqsize(2, 2) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"load.s.pri %1!inc.s %1!;$exp!", |
|
"inc.s %1!;$exp!", |
|
#else |
|
"\324\373\352\261", |
|
"\373\352\261", |
|
#endif |
|
seqsize(2, 2) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"dec %1!load.pri %1!;$exp!", |
|
"dec %1!;$exp!", |
|
#else |
|
"\367c\205\314\245", |
|
"\367c\261", |
|
#endif |
|
seqsize(2, 2) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"load.pri %1!dec %1!;$exp!", |
|
"dec %1!;$exp!", |
|
#else |
|
"\314\367c\261", |
|
"\367c\261", |
|
#endif |
|
seqsize(2, 2) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"dec.s %1!load.s.pri %1!;$exp!", |
|
"dec.s %1!;$exp!", |
|
#else |
|
"\367\352\205\324\245", |
|
"\367\352\261", |
|
#endif |
|
seqsize(2, 2) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"load.s.pri %1!dec.s %1!;$exp!", |
|
"dec.s %1!;$exp!", |
|
#else |
|
"\324\367\352\261", |
|
"\367\352\261", |
|
#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 |
|
"\236\203 0!\227or\223\245", |
|
"\315\261", |
|
#endif |
|
seqsize(2, 2) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"const.pri 0!stor.s.pri %1!;$exp!", |
|
"zero.s %1!;$exp!", |
|
#else |
|
"\236\203 0!\227or\220\223\245", |
|
"\315\220\261", |
|
#endif |
|
seqsize(2, 2) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"zero.pri!stor.pri %1!;$exp!", |
|
"zero %1!;$exp!", |
|
#else |
|
"\376\227or\223\245", |
|
"\315\261", |
|
#endif |
|
seqsize(2, 1) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"zero.pri!stor.s.pri %1!;$exp!", |
|
"zero.s %1!;$exp!", |
|
#else |
|
"\376\227or\220\223\245", |
|
"\315\220\261", |
|
#endif |
|
seqsize(2, 1) - seqsize(1, 1)}, |
|
{ |
|
#ifdef SCPACK |
|
"const.pri 0!", |
|
"zero.pri!", |
|
#else |
|
"\236\203 0!", |
|
"\376", |
|
#endif |
|
seqsize(1, 1) - seqsize(1, 0)}, |
|
{ |
|
#ifdef SCPACK |
|
"const.alt 0!", |
|
"zero.alt!", |
|
#else |
|
"\236\211 0!", |
|
"\315\217", |
|
#endif |
|
seqsize(1, 1) - seqsize(1, 0)}, |
|
/* ----- */ |
|
{NULL, NULL, 0} |
|
};
|
|
|