From dd7595a3475407a7fa96a97393bae8c5220e8762 Mon Sep 17 00:00:00 2001 From: David Walter Seikel Date: Wed, 4 Jan 2012 18:41:13 +1000 Subject: Add the base Enlightenment Foundation Libraries - eina, eet, evas, ecore, embryo, and edje. Note that embryo wont be used, but I'm not sure yet if you can build edje without it. --- libraries/embryo/src/bin/embryo_cc_sc7.scp | 1473 ++++++++++++++++++++++++++++ 1 file changed, 1473 insertions(+) create mode 100644 libraries/embryo/src/bin/embryo_cc_sc7.scp (limited to 'libraries/embryo/src/bin/embryo_cc_sc7.scp') diff --git a/libraries/embryo/src/bin/embryo_cc_sc7.scp b/libraries/embryo/src/bin/embryo_cc_sc7.scp new file mode 100644 index 0000000..15c80ac --- /dev/null +++ b/libraries/embryo/src/bin/embryo_cc_sc7.scp @@ -0,0 +1,1473 @@ +/* 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: embryo_cc_sc7.scp 35497 2008-08-17 07:44:18Z raster $ + */ + +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} +}; -- cgit v1.1