diff options
Diffstat (limited to 'libraries/embryo/src/bin/embryo_cc_sc7.scp')
-rw-r--r-- | libraries/embryo/src/bin/embryo_cc_sc7.scp | 1473 |
1 files changed, 1473 insertions, 0 deletions
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 @@ | |||
1 | /* Small compiler - Peephole optimizer "sequences" strings (plain | ||
2 | * and compressed formats) | ||
3 | * | ||
4 | * Copyright (c) ITB CompuPhase, 2000-2003 | ||
5 | * | ||
6 | * This software is provided "as-is", without any express or implied warranty. | ||
7 | * In no event will the authors be held liable for any damages arising from | ||
8 | * the use of this software. | ||
9 | * | ||
10 | * Permission is granted to anyone to use this software for any purpose, | ||
11 | * including commercial applications, and to alter it and redistribute it | ||
12 | * freely, subject to the following restrictions: | ||
13 | * | ||
14 | * 1. The origin of this software must not be misrepresented; you must not | ||
15 | * claim that you wrote the original software. If you use this software in | ||
16 | * a product, an acknowledgment in the product documentation would be | ||
17 | * appreciated but is not required. | ||
18 | * 2. Altered source versions must be plainly marked as such, and must not be | ||
19 | * misrepresented as being the original software. | ||
20 | * 3. This notice may not be removed or altered from any source distribution. | ||
21 | * | ||
22 | * Version: $Id: embryo_cc_sc7.scp 35497 2008-08-17 07:44:18Z raster $ | ||
23 | */ | ||
24 | |||
25 | int strexpand(char *dest, unsigned char *source, int maxlen, | ||
26 | unsigned char pairtable[128][2]); | ||
27 | |||
28 | #define SCPACK_TERMINATOR , /* end each section with a comma */ | ||
29 | |||
30 | #define SCPACK_TABLE sequences_table | ||
31 | /*-*SCPACK start of pair table, do not change or remove this line */ | ||
32 | unsigned char sequences_table[][2] = { | ||
33 | {32, 37}, {114, 105}, {112, 129}, {46, 130}, {49, 33}, {128, 132}, {97, 100}, | ||
34 | {46, 97}, {135, 108}, {136, 116}, {111, 134}, {108, 138}, {50, 33}, {115, | ||
35 | 104}, | ||
36 | {128, 140}, {137, 33}, | ||
37 | {46, 115}, {117, 141}, {112, 145}, {131, 133}, {139, 144}, {112, 143}, {131, | ||
38 | 142}, | ||
39 | {115, 116}, {111, 149}, {112, 152}, {131, 33}, {134, 100}, {110, 151}, | ||
40 | {111, 156}, {99, 157}, {59, 36}, | ||
41 | {146, 154}, {148, 150}, {112, 33}, {120, 162}, {101, 163}, {159, 164}, {137, | ||
42 | 133}, | ||
43 | {46, 99}, {122, 101}, {110, 100}, {155, 114}, {101, 113}, {168, 114}, | ||
44 | {147, 160}, {51, 33}, {128, 174}, | ||
45 | {103, 33}, {133, 165}, {104, 176}, {99, 178}, {120, 179}, {171, 33}, {106, | ||
46 | 172}, | ||
47 | {173, 161}, {155, 33}, {108, 167}, {117, 169}, {115, 175}, {186, 187}, | ||
48 | {153, 184}, {141, 185}, {111, 188}, | ||
49 | {98, 191}, {105, 100}, {115, 103}, {115, 108}, {193, 120}, {182, 133}, {114, | ||
50 | 33}, | ||
51 | {166, 161}, {190, 131}, {137, 142}, {169, 33}, {97, 202}, {139, 147}, | ||
52 | {172, 111}, {158, 147}, {139, 150}, | ||
53 | {105, 33}, {101, 115}, {209, 115}, {114, 116}, {148, 147}, {171, 133}, {189, | ||
54 | 139}, | ||
55 | {32, 140}, {146, 167}, {196, 170}, {158, 183}, {170, 183}, {199, 192}, | ||
56 | {108, 196}, {97, 198}, {194, 211}, | ||
57 | {46, 208}, {195, 210}, {200, 215}, {112, 222}, {159, 227}, {46, 98}, {118, | ||
58 | 101}, | ||
59 | {111, 230}, {109, 231}, {146, 143}, {99, 144}, {158, 150}, {97, 149}, | ||
60 | {203, 153}, {52, 33}, {225, 33}, | ||
61 | {158, 166}, {194, 181}, {195, 181}, {201, 180}, {223, 198}, {153, 203}, {214, | ||
62 | 224}, | ||
63 | {100, 101}, {128, 238}, {119, 236}, {249, 237}, {105, 110}, {115, 250}, | ||
64 | {232, 143}, {205, 154} | ||
65 | }; | ||
66 | /*-*SCPACK end of pair table, do not change or remove this line */ | ||
67 | |||
68 | #define seqsize(o,p) (opcodes(o)+opargs(p)) | ||
69 | typedef struct | ||
70 | { | ||
71 | char *find; | ||
72 | char *replace; | ||
73 | int savesize; /* number of bytes saved (in bytecode) */ | ||
74 | } SEQUENCE; | ||
75 | static SEQUENCE sequences_cmp[] = { | ||
76 | /* A very common sequence in four varieties | ||
77 | * load.s.pri n1 load.s.pri n2 | ||
78 | * push.pri load.s.alt n1 | ||
79 | * load.s.pri n2 - | ||
80 | * pop.alt - | ||
81 | * -------------------------------------- | ||
82 | * load.pri n1 load.s.pri n2 | ||
83 | * push.pri load.alt n1 | ||
84 | * load.s.pri n2 - | ||
85 | * pop.alt - | ||
86 | * -------------------------------------- | ||
87 | * load.s.pri n1 load.pri n2 | ||
88 | * push.pri load.s.alt n1 | ||
89 | * load.pri n2 - | ||
90 | * pop.alt - | ||
91 | * -------------------------------------- | ||
92 | * load.pri n1 load.pri n2 | ||
93 | * push.pri load.alt n1 | ||
94 | * load.pri n2 - | ||
95 | * pop.alt - | ||
96 | */ | ||
97 | { | ||
98 | #ifdef SCPACK | ||
99 | "load.s.pri %1!push.pri!load.s.pri %2!pop.alt!", | ||
100 | "load.s.pri %2!load.s.alt %1!", | ||
101 | #else | ||
102 | "\224\267\231", | ||
103 | "\241\224\246", | ||
104 | #endif | ||
105 | seqsize(4, 2) - seqsize(2, 2)}, | ||
106 | { | ||
107 | #ifdef SCPACK | ||
108 | "load.pri %1!push.pri!load.s.pri %2!pop.alt!", | ||
109 | "load.s.pri %2!load.alt %1!", | ||
110 | #else | ||
111 | "\213\267\231", | ||
112 | "\241\213\246", | ||
113 | #endif | ||
114 | seqsize(4, 2) - seqsize(2, 2)}, | ||
115 | { | ||
116 | #ifdef SCPACK | ||
117 | "load.s.pri %1!push.pri!load.pri %2!pop.alt!", | ||
118 | "load.pri %2!load.s.alt %1!", | ||
119 | #else | ||
120 | "\224\255\317\231", | ||
121 | "\317\224\246", | ||
122 | #endif | ||
123 | seqsize(4, 2) - seqsize(2, 2)}, | ||
124 | { | ||
125 | #ifdef SCPACK | ||
126 | "load.pri %1!push.pri!load.pri %2!pop.alt!", | ||
127 | "load.pri %2!load.alt %1!", | ||
128 | #else | ||
129 | "\213\255\317\231", | ||
130 | "\317\213\246", | ||
131 | #endif | ||
132 | seqsize(4, 2) - seqsize(2, 2)}, | ||
133 | /* (#1#) The above also occurs with "addr.pri" (array | ||
134 | * indexing) as the first line; so that adds 2 cases. | ||
135 | */ | ||
136 | { | ||
137 | #ifdef SCPACK | ||
138 | "addr.pri %1!push.pri!load.s.pri %2!pop.alt!", | ||
139 | "addr.alt %1!load.s.pri %2!", | ||
140 | #else | ||
141 | "\333\231", | ||
142 | "\252\307", | ||
143 | #endif | ||
144 | seqsize(4, 2) - seqsize(2, 2)}, | ||
145 | { | ||
146 | #ifdef SCPACK | ||
147 | "addr.pri %1!push.pri!load.pri %2!pop.alt!", | ||
148 | "addr.alt %1!load.pri %2!", | ||
149 | #else | ||
150 | "\252\255\317\231", | ||
151 | "\252\246\317", | ||
152 | #endif | ||
153 | seqsize(4, 2) - seqsize(2, 2)}, | ||
154 | /* And the same sequence with const.pri as either the first | ||
155 | * or the second load instruction: four more cases. | ||
156 | */ | ||
157 | { | ||
158 | #ifdef SCPACK | ||
159 | "const.pri %1!push.pri!load.s.pri %2!pop.alt!", | ||
160 | "load.s.pri %2!const.alt %1!", | ||
161 | #else | ||
162 | "\332\231", | ||
163 | "\241\360", | ||
164 | #endif | ||
165 | seqsize(4, 2) - seqsize(2, 2)}, | ||
166 | { | ||
167 | #ifdef SCPACK | ||
168 | "const.pri %1!push.pri!load.pri %2!pop.alt!", | ||
169 | "load.pri %2!const.alt %1!", | ||
170 | #else | ||
171 | "\236\255\317\231", | ||
172 | "\317\360", | ||
173 | #endif | ||
174 | seqsize(4, 2) - seqsize(2, 2)}, | ||
175 | { | ||
176 | #ifdef SCPACK | ||
177 | "load.s.pri %1!push.pri!const.pri %2!pop.alt!", | ||
178 | "const.pri %2!load.s.alt %1!", | ||
179 | #else | ||
180 | "\224\255\353\231", | ||
181 | "\353\224\246", | ||
182 | #endif | ||
183 | seqsize(4, 2) - seqsize(2, 2)}, | ||
184 | { | ||
185 | #ifdef SCPACK | ||
186 | "load.pri %1!push.pri!const.pri %2!pop.alt!", | ||
187 | "const.pri %2!load.alt %1!", | ||
188 | #else | ||
189 | "\213\255\353\231", | ||
190 | "\353\213\246", | ||
191 | #endif | ||
192 | seqsize(4, 2) - seqsize(2, 2)}, | ||
193 | /* The same as above, but now with "addr.pri" (array | ||
194 | * indexing) on the first line and const.pri on | ||
195 | * the second. | ||
196 | */ | ||
197 | { | ||
198 | #ifdef SCPACK | ||
199 | "addr.pri %1!push.pri!const.pri %2!pop.alt!", | ||
200 | "addr.alt %1!const.pri %2!", | ||
201 | #else | ||
202 | "\252\255\353\231", | ||
203 | "\252\246\353", | ||
204 | #endif | ||
205 | seqsize(4, 2) - seqsize(2, 2)}, | ||
206 | /* ??? add references */ | ||
207 | /* Chained relational operators can contain sequences like: | ||
208 | * move.pri load.s.pri n1 | ||
209 | * push.pri - | ||
210 | * load.s.pri n1 - | ||
211 | * pop.alt - | ||
212 | * The above also accurs for "load.pri" and for "const.pri", | ||
213 | * so add another two cases. | ||
214 | */ | ||
215 | { | ||
216 | #ifdef SCPACK | ||
217 | "move.pri!push.pri!load.s.pri %1!pop.alt!", | ||
218 | "load.s.pri %1!", | ||
219 | #else | ||
220 | "\350\232\240\324\231", | ||
221 | "\324", | ||
222 | #endif | ||
223 | seqsize(4, 1) - seqsize(1, 1)}, | ||
224 | { | ||
225 | #ifdef SCPACK | ||
226 | "move.pri!push.pri!load.pri %1!pop.alt!", | ||
227 | "load.pri %1!", | ||
228 | #else | ||
229 | "\350\232\240\314\231", | ||
230 | "\314", | ||
231 | #endif | ||
232 | seqsize(4, 1) - seqsize(1, 1)}, | ||
233 | { | ||
234 | #ifdef SCPACK | ||
235 | "move.pri!push.pri!const.pri %1!pop.alt!", | ||
236 | "const.pri %1!", | ||
237 | #else | ||
238 | "\350\232\240\316\231", | ||
239 | "\316", | ||
240 | #endif | ||
241 | seqsize(4, 1) - seqsize(1, 1)}, | ||
242 | /* More optimizations for chained relational operators; the | ||
243 | * continuation sequences can be simplified if they turn out | ||
244 | * to be termination sequences: | ||
245 | * xchg sless also for sless, sgeq and sleq | ||
246 | * sgrtr pop.alt | ||
247 | * swap.alt and | ||
248 | * and ;$exp | ||
249 | * pop.alt - | ||
250 | * ;$exp - | ||
251 | * -------------------------------------- | ||
252 | * xchg sless also for sless, sgeq and sleq | ||
253 | * sgrtr pop.alt | ||
254 | * swap.alt and | ||
255 | * and jzer n1 | ||
256 | * pop.alt - | ||
257 | * jzer n1 - | ||
258 | * -------------------------------------- | ||
259 | * xchg jsgeq n1 also for sless, sgeq and sleq | ||
260 | * sgrtr ;$exp (occurs for non-chained comparisons) | ||
261 | * jzer n1 - | ||
262 | * ;$exp - | ||
263 | * -------------------------------------- | ||
264 | * xchg sless also for sless, sgeq and sleq | ||
265 | * sgrtr ;$exp (occurs for non-chained comparisons) | ||
266 | * ;$exp - | ||
267 | */ | ||
268 | { | ||
269 | #ifdef SCPACK | ||
270 | "xchg!sgrtr!swap.alt!and!pop.alt!;$exp!", | ||
271 | "sless!pop.alt!and!;$exp!", | ||
272 | #else | ||
273 | "\264\364\374\245", | ||
274 | "\357\365\245", | ||
275 | #endif | ||
276 | seqsize(5, 0) - seqsize(3, 0)}, | ||
277 | { | ||
278 | #ifdef SCPACK | ||
279 | "xchg!sless!swap.alt!and!pop.alt!;$exp!", | ||
280 | "sgrtr!pop.alt!and!;$exp!", | ||
281 | #else | ||
282 | "\264\357\374\245", | ||
283 | "\364\365\245", | ||
284 | #endif | ||
285 | seqsize(5, 0) - seqsize(3, 0)}, | ||
286 | { | ||
287 | #ifdef SCPACK | ||
288 | "xchg!sgeq!swap.alt!and!pop.alt!;$exp!", | ||
289 | "sleq!pop.alt!and!;$exp!", | ||
290 | #else | ||
291 | "\264\361\374\245", | ||
292 | "\362\365\245", | ||
293 | #endif | ||
294 | seqsize(5, 0) - seqsize(3, 0)}, | ||
295 | { | ||
296 | #ifdef SCPACK | ||
297 | "xchg!sleq!swap.alt!and!pop.alt!;$exp!", | ||
298 | "sgeq!pop.alt!and!;$exp!", | ||
299 | #else | ||
300 | "\264\362\374\245", | ||
301 | "\361\365\245", | ||
302 | #endif | ||
303 | seqsize(5, 0) - seqsize(3, 0)}, | ||
304 | { | ||
305 | #ifdef SCPACK | ||
306 | "xchg!sgrtr!swap.alt!and!pop.alt!jzer %1!", | ||
307 | "sless!pop.alt!and!jzer %1!", | ||
308 | #else | ||
309 | "\264\364\374\305", | ||
310 | "\357\365\305", | ||
311 | #endif | ||
312 | seqsize(5, 0) - seqsize(3, 0)}, | ||
313 | { | ||
314 | #ifdef SCPACK | ||
315 | "xchg!sless!swap.alt!and!pop.alt!jzer %1!", | ||
316 | "sgrtr!pop.alt!and!jzer %1!", | ||
317 | #else | ||
318 | "\264\357\374\305", | ||
319 | "\364\365\305", | ||
320 | #endif | ||
321 | seqsize(5, 0) - seqsize(3, 0)}, | ||
322 | { | ||
323 | #ifdef SCPACK | ||
324 | "xchg!sgeq!swap.alt!and!pop.alt!jzer %1!", | ||
325 | "sleq!pop.alt!and!jzer %1!", | ||
326 | #else | ||
327 | "\264\361\374\305", | ||
328 | "\362\365\305", | ||
329 | #endif | ||
330 | seqsize(5, 0) - seqsize(3, 0)}, | ||
331 | { | ||
332 | #ifdef SCPACK | ||
333 | "xchg!sleq!swap.alt!and!pop.alt!jzer %1!", | ||
334 | "sgeq!pop.alt!and!jzer %1!", | ||
335 | #else | ||
336 | "\264\362\374\305", | ||
337 | "\361\365\305", | ||
338 | #endif | ||
339 | seqsize(5, 0) - seqsize(3, 0)}, | ||
340 | { | ||
341 | #ifdef SCPACK | ||
342 | "xchg!sgrtr!jzer %1!;$exp!", | ||
343 | "jsgeq %1!;$exp!", | ||
344 | #else | ||
345 | "\264\364\266\261", | ||
346 | "j\302\253\261", | ||
347 | #endif | ||
348 | seqsize(3, 1) - seqsize(1, 1)}, | ||
349 | { | ||
350 | #ifdef SCPACK | ||
351 | "xchg!sless!jzer %1!;$exp!", | ||
352 | "jsleq %1!;$exp!", | ||
353 | #else | ||
354 | "\264\357\266\261", | ||
355 | "j\303\253\261", | ||
356 | #endif | ||
357 | seqsize(3, 1) - seqsize(1, 1)}, | ||
358 | { | ||
359 | #ifdef SCPACK | ||
360 | "xchg!sgeq!jzer %1!;$exp!", | ||
361 | "jsgrtr %1!;$exp!", | ||
362 | #else | ||
363 | "\264\361\266\261", | ||
364 | "j\337r\261", | ||
365 | #endif | ||
366 | seqsize(3, 1) - seqsize(1, 1)}, | ||
367 | { | ||
368 | #ifdef SCPACK | ||
369 | "xchg!sleq!jzer %1!;$exp!", | ||
370 | "jsless %1!;$exp!", | ||
371 | #else | ||
372 | "\264\362\266\261", | ||
373 | "j\341\261", | ||
374 | #endif | ||
375 | seqsize(3, 1) - seqsize(1, 1)}, | ||
376 | { | ||
377 | #ifdef SCPACK | ||
378 | "xchg!sgrtr!;$exp!", | ||
379 | "sless!;$exp!", | ||
380 | #else | ||
381 | "\264\364\245", | ||
382 | "\357\245", | ||
383 | #endif | ||
384 | seqsize(2, 0) - seqsize(1, 0)}, | ||
385 | { | ||
386 | #ifdef SCPACK | ||
387 | "xchg!sless!;$exp!", | ||
388 | "sgrtr!;$exp!", | ||
389 | #else | ||
390 | "\264\357\245", | ||
391 | "\364\245", | ||
392 | #endif | ||
393 | seqsize(2, 0) - seqsize(1, 0)}, | ||
394 | { | ||
395 | #ifdef SCPACK | ||
396 | "xchg!sgeq!;$exp!", | ||
397 | "sleq!;$exp!", | ||
398 | #else | ||
399 | "\264\361\245", | ||
400 | "\362\245", | ||
401 | #endif | ||
402 | seqsize(2, 0) - seqsize(1, 0)}, | ||
403 | { | ||
404 | #ifdef SCPACK | ||
405 | "xchg!sleq!;$exp!", | ||
406 | "sgeq!;$exp!", | ||
407 | #else | ||
408 | "\264\362\245", | ||
409 | "\361\245", | ||
410 | #endif | ||
411 | seqsize(2, 0) - seqsize(1, 0)}, | ||
412 | /* The entry to chained operators is also opt to optimization | ||
413 | * load.s.pri n1 load.s.pri n2 | ||
414 | * load.s.alt n2 load.s.alt n1 | ||
415 | * xchg - | ||
416 | * -------------------------------------- | ||
417 | * load.s.pri n1 load.pri n2 | ||
418 | * load.alt n2 load.s.alt n1 | ||
419 | * xchg - | ||
420 | * -------------------------------------- | ||
421 | * load.s.pri n1 const.pri n2 | ||
422 | * const.alt n2 load.s.alt n1 | ||
423 | * xchg - | ||
424 | * -------------------------------------- | ||
425 | * and all permutations... | ||
426 | */ | ||
427 | { | ||
428 | #ifdef SCPACK | ||
429 | "load.s.pri %1!load.s.alt %2!xchg!", | ||
430 | "load.s.pri %2!load.s.alt %1!", | ||
431 | #else | ||
432 | "\324\224\363", | ||
433 | "\241\224\246", | ||
434 | #endif | ||
435 | seqsize(3, 2) - seqsize(2, 2)}, | ||
436 | { | ||
437 | #ifdef SCPACK | ||
438 | "load.s.pri %1!load.alt %2!xchg!", | ||
439 | "load.pri %2!load.s.alt %1!", | ||
440 | #else | ||
441 | "\324\213\363", | ||
442 | "\317\224\246", | ||
443 | #endif | ||
444 | seqsize(3, 2) - seqsize(2, 2)}, | ||
445 | { | ||
446 | #ifdef SCPACK | ||
447 | "load.s.pri %1!const.alt %2!xchg!", | ||
448 | "const.pri %2!load.s.alt %1!", | ||
449 | #else | ||
450 | "\324\236\363", | ||
451 | "\353\224\246", | ||
452 | #endif | ||
453 | seqsize(3, 2) - seqsize(2, 2)}, | ||
454 | { | ||
455 | #ifdef SCPACK | ||
456 | "load.pri %1!load.s.alt %2!xchg!", | ||
457 | "load.s.pri %2!load.alt %1!", | ||
458 | #else | ||
459 | "\314\224\363", | ||
460 | "\241\213\246", | ||
461 | #endif | ||
462 | seqsize(3, 2) - seqsize(2, 2)}, | ||
463 | { | ||
464 | #ifdef SCPACK | ||
465 | "load.pri %1!load.alt %2!xchg!", | ||
466 | "load.pri %2!load.alt %1!", | ||
467 | #else | ||
468 | "\314\213\363", | ||
469 | "\317\213\246", | ||
470 | #endif | ||
471 | seqsize(3, 2) - seqsize(2, 2)}, | ||
472 | { | ||
473 | #ifdef SCPACK | ||
474 | "load.pri %1!const.alt %2!xchg!", | ||
475 | "const.pri %2!load.alt %1!", | ||
476 | #else | ||
477 | "\314\236\363", | ||
478 | "\353\213\246", | ||
479 | #endif | ||
480 | seqsize(3, 2) - seqsize(2, 2)}, | ||
481 | { | ||
482 | #ifdef SCPACK | ||
483 | "const.pri %1!load.s.alt %2!xchg!", | ||
484 | "load.s.pri %2!const.alt %1!", | ||
485 | #else | ||
486 | "\316\224\363", | ||
487 | "\241\360", | ||
488 | #endif | ||
489 | seqsize(3, 2) - seqsize(2, 2)}, | ||
490 | { | ||
491 | #ifdef SCPACK | ||
492 | "const.pri %1!load.alt %2!xchg!", | ||
493 | "load.pri %2!const.alt %1!", | ||
494 | #else | ||
495 | "\316\213\363", | ||
496 | "\317\360", | ||
497 | #endif | ||
498 | seqsize(3, 2) - seqsize(2, 2)}, | ||
499 | /* Array indexing can merit from special instructions. | ||
500 | * Simple indexed array lookup can be optimized quite | ||
501 | * a bit. | ||
502 | * addr.pri n1 addr.alt n1 | ||
503 | * push.pri load.s.pri n2 | ||
504 | * load.s.pri n2 bounds n3 | ||
505 | * bounds n3 lidx.b n4 | ||
506 | * shl.c.pri n4 - | ||
507 | * pop.alt - | ||
508 | * add - | ||
509 | * load.i - | ||
510 | * | ||
511 | * And to prepare for storing a value in an array | ||
512 | * addr.pri n1 addr.alt n1 | ||
513 | * push.pri load.s.pri n2 | ||
514 | * load.s.pri n2 bounds n3 | ||
515 | * bounds n3 idxaddr.b n4 | ||
516 | * shl.c.pri n4 - | ||
517 | * pop.alt - | ||
518 | * add - | ||
519 | * | ||
520 | * Notes (additional cases): | ||
521 | * 1. instruction addr.pri can also be const.pri (for | ||
522 | * global arrays) | ||
523 | * 2. the bounds instruction can be absent | ||
524 | * 3. when "n4" (the shift value) is the 2 (with 32-bit cels), use the | ||
525 | * even more optimal instructions LIDX and IDDXADDR | ||
526 | * | ||
527 | * If the array index is more complex, one can only optimize | ||
528 | * the last four instructions: | ||
529 | * shl.c.pri n1 pop.alt | ||
530 | * pop.alt lidx.b n1 | ||
531 | * add - | ||
532 | * loadi - | ||
533 | * -------------------------------------- | ||
534 | * shl.c.pri n1 pop.alt | ||
535 | * pop.alt idxaddr.b n1 | ||
536 | * add - | ||
537 | */ | ||
538 | #if !defined BIT16 | ||
539 | /* loading from array, "cell" shifted */ | ||
540 | { | ||
541 | #ifdef SCPACK | ||
542 | "addr.pri %1!push.pri!load.s.pri %2!bounds %3!shl.c.pri 2!pop.alt!add!load.i!", | ||
543 | "addr.alt %1!load.s.pri %2!bounds %3!lidx!", | ||
544 | #else | ||
545 | "\333\300\342\366", | ||
546 | "\252\334\335!", | ||
547 | #endif | ||
548 | seqsize(8, 4) - seqsize(4, 3)}, | ||
549 | { | ||
550 | #ifdef SCPACK | ||
551 | "const.pri %1!push.pri!load.s.pri %2!bounds %3!shl.c.pri 2!pop.alt!add!load.i!", | ||
552 | "const.alt %1!load.s.pri %2!bounds %3!lidx!", | ||
553 | #else | ||
554 | "\332\300\342\366", | ||
555 | "\236\334\335!", | ||
556 | #endif | ||
557 | seqsize(8, 4) - seqsize(4, 3)}, | ||
558 | { | ||
559 | #ifdef SCPACK | ||
560 | "addr.pri %1!push.pri!load.s.pri %2!shl.c.pri 2!pop.alt!add!load.i!", | ||
561 | "addr.alt %1!load.s.pri %2!lidx!", | ||
562 | #else | ||
563 | "\333\342\366", | ||
564 | "\252\307\335!", | ||
565 | #endif | ||
566 | seqsize(7, 3) - seqsize(3, 2)}, | ||
567 | { | ||
568 | #ifdef SCPACK | ||
569 | "const.pri %1!push.pri!load.s.pri %2!shl.c.pri 2!pop.alt!add!load.i!", | ||
570 | "const.alt %1!load.s.pri %2!lidx!", | ||
571 | #else | ||
572 | "\332\342\366", | ||
573 | "\236\307\335!", | ||
574 | #endif | ||
575 | seqsize(7, 3) - seqsize(3, 2)}, | ||
576 | #endif | ||
577 | /* loading from array, not "cell" shifted */ | ||
578 | { | ||
579 | #ifdef SCPACK | ||
580 | "addr.pri %1!push.pri!load.s.pri %2!bounds %3!shl.c.pri %4!pop.alt!add!load.i!", | ||
581 | "addr.alt %1!load.s.pri %2!bounds %3!lidx.b %4!", | ||
582 | #else | ||
583 | "\333\300\310\370\366", | ||
584 | "\252\334\335\345\370", | ||
585 | #endif | ||
586 | seqsize(8, 4) - seqsize(4, 4)}, | ||
587 | { | ||
588 | #ifdef SCPACK | ||
589 | "const.pri %1!push.pri!load.s.pri %2!bounds %3!shl.c.pri %4!pop.alt!add!load.i!", | ||
590 | "const.alt %1!load.s.pri %2!bounds %3!lidx.b %4!", | ||
591 | #else | ||
592 | "\332\300\310\370\366", | ||
593 | "\236\334\335\345\370", | ||
594 | #endif | ||
595 | seqsize(8, 4) - seqsize(4, 4)}, | ||
596 | { | ||
597 | #ifdef SCPACK | ||
598 | "addr.pri %1!push.pri!load.s.pri %2!shl.c.pri %3!pop.alt!add!load.i!", | ||
599 | "addr.alt %1!load.s.pri %2!lidx.b %3!", | ||
600 | #else | ||
601 | "\333\310\257\366", | ||
602 | "\252\307\335\345\257", | ||
603 | #endif | ||
604 | seqsize(7, 3) - seqsize(3, 3)}, | ||
605 | { | ||
606 | #ifdef SCPACK | ||
607 | "const.pri %1!push.pri!load.s.pri %2!shl.c.pri %3!pop.alt!add!load.i!", | ||
608 | "const.alt %1!load.s.pri %2!lidx.b %3!", | ||
609 | #else | ||
610 | "\332\310\257\366", | ||
611 | "\236\307\335\345\257", | ||
612 | #endif | ||
613 | seqsize(7, 3) - seqsize(3, 3)}, | ||
614 | #if !defined BIT16 | ||
615 | /* array index calculation for storing a value, "cell" aligned */ | ||
616 | { | ||
617 | #ifdef SCPACK | ||
618 | "addr.pri %1!push.pri!load.s.pri %2!bounds %3!shl.c.pri 2!pop.alt!add!", | ||
619 | "addr.alt %1!load.s.pri %2!bounds %3!idxaddr!", | ||
620 | #else | ||
621 | "\333\300\342\275", | ||
622 | "\252\334\331!", | ||
623 | #endif | ||
624 | seqsize(7, 4) - seqsize(4, 3)}, | ||
625 | { | ||
626 | #ifdef SCPACK | ||
627 | "const.pri %1!push.pri!load.s.pri %2!bounds %3!shl.c.pri 2!pop.alt!add!", | ||
628 | "const.alt %1!load.s.pri %2!bounds %3!idxaddr!", | ||
629 | #else | ||
630 | "\332\300\342\275", | ||
631 | "\236\334\331!", | ||
632 | #endif | ||
633 | seqsize(7, 4) - seqsize(4, 3)}, | ||
634 | { | ||
635 | #ifdef SCPACK | ||
636 | "addr.pri %1!push.pri!load.s.pri %2!shl.c.pri 2!pop.alt!add!", | ||
637 | "addr.alt %1!load.s.pri %2!idxaddr!", | ||
638 | #else | ||
639 | "\333\342\275", | ||
640 | "\252\307\331!", | ||
641 | #endif | ||
642 | seqsize(6, 3) - seqsize(3, 2)}, | ||
643 | { | ||
644 | #ifdef SCPACK | ||
645 | "const.pri %1!push.pri!load.s.pri %2!shl.c.pri 2!pop.alt!add!", | ||
646 | "const.alt %1!load.s.pri %2!idxaddr!", | ||
647 | #else | ||
648 | "\332\342\275", | ||
649 | "\236\307\331!", | ||
650 | #endif | ||
651 | seqsize(6, 3) - seqsize(3, 2)}, | ||
652 | #endif | ||
653 | /* array index calculation for storing a value, not "cell" packed */ | ||
654 | { | ||
655 | #ifdef SCPACK | ||
656 | "addr.pri %1!push.pri!load.s.pri %2!bounds %3!shl.c.pri %4!pop.alt!add!", | ||
657 | "addr.alt %1!load.s.pri %2!bounds %3!idxaddr.b %4!", | ||
658 | #else | ||
659 | "\333\300\310\370\275", | ||
660 | "\252\334\331\345\370", | ||
661 | #endif | ||
662 | seqsize(7, 4) - seqsize(4, 4)}, | ||
663 | { | ||
664 | #ifdef SCPACK | ||
665 | "const.pri %1!push.pri!load.s.pri %2!bounds %3!shl.c.pri %4!pop.alt!add!", | ||
666 | "const.alt %1!load.s.pri %2!bounds %3!idxaddr.b %4!", | ||
667 | #else | ||
668 | "\332\300\310\370\275", | ||
669 | "\236\334\331\345\370", | ||
670 | #endif | ||
671 | seqsize(7, 4) - seqsize(4, 4)}, | ||
672 | { | ||
673 | #ifdef SCPACK | ||
674 | "addr.pri %1!push.pri!load.s.pri %2!shl.c.pri %3!pop.alt!add!", | ||
675 | "addr.alt %1!load.s.pri %2!idxaddr.b %3!", | ||
676 | #else | ||
677 | "\333\310\257\275", | ||
678 | "\252\307\331\345\257", | ||
679 | #endif | ||
680 | seqsize(6, 3) - seqsize(3, 3)}, | ||
681 | { | ||
682 | #ifdef SCPACK | ||
683 | "const.pri %1!push.pri!load.s.pri %2!shl.c.pri %3!pop.alt!add!", | ||
684 | "const.alt %1!load.s.pri %2!idxaddr.b %3!", | ||
685 | #else | ||
686 | "\332\310\257\275", | ||
687 | "\236\307\331\345\257", | ||
688 | #endif | ||
689 | seqsize(6, 3) - seqsize(3, 3)}, | ||
690 | #if !defined BIT16 | ||
691 | /* the shorter array indexing sequences, see above for comments */ | ||
692 | { | ||
693 | #ifdef SCPACK | ||
694 | "shl.c.pri 2!pop.alt!add!loadi!", | ||
695 | "pop.alt!lidx!", | ||
696 | #else | ||
697 | "\342\326\320", | ||
698 | "\231\335!", | ||
699 | #endif | ||
700 | seqsize(4, 1) - seqsize(2, 0)}, | ||
701 | { | ||
702 | #ifdef SCPACK | ||
703 | "shl.c.pri 2!pop.alt!add!", | ||
704 | "pop.alt!idxaddr!", | ||
705 | #else | ||
706 | "\342\275", | ||
707 | "\231\331!", | ||
708 | #endif | ||
709 | seqsize(3, 1) - seqsize(2, 0)}, | ||
710 | #endif | ||
711 | { | ||
712 | #ifdef SCPACK | ||
713 | "shl.c.pri %1!pop.alt!add!loadi!", | ||
714 | "pop.alt!lidx.b %1!", | ||
715 | #else | ||
716 | "\276\223\326\320", | ||
717 | "\231\335\345\205", | ||
718 | #endif | ||
719 | seqsize(4, 1) - seqsize(2, 1)}, | ||
720 | { | ||
721 | #ifdef SCPACK | ||
722 | "shl.c.pri %1!pop.alt!add!", | ||
723 | "pop.alt!idxaddr.b %1!", | ||
724 | #else | ||
725 | "\276\223\275", | ||
726 | "\231\331\345\205", | ||
727 | #endif | ||
728 | seqsize(3, 1) - seqsize(2, 1)}, | ||
729 | /* For packed arrays, there is another case (packed arrays | ||
730 | * do not take advantage of the LIDX or IDXADDR instructions). | ||
731 | * addr.pri n1 addr.alt n1 | ||
732 | * push.pri load.s.pri n2 | ||
733 | * load.s.pri n2 bounds n3 | ||
734 | * bounds n3 - | ||
735 | * pop.alt - | ||
736 | * | ||
737 | * Notes (additional cases): | ||
738 | * 1. instruction addr.pri can also be const.pri (for | ||
739 | * global arrays) | ||
740 | * 2. the bounds instruction can be absent, but that | ||
741 | * case is already handled (see #1#) | ||
742 | */ | ||
743 | { | ||
744 | #ifdef SCPACK | ||
745 | "addr.pri %1!push.pri!load.s.pri %2!bounds %3!pop.alt!", | ||
746 | "addr.alt %1!load.s.pri %2!bounds %3!", | ||
747 | #else | ||
748 | "\333\300\231", | ||
749 | "\252\334", | ||
750 | #endif | ||
751 | seqsize(5, 3) - seqsize(3, 3)}, | ||
752 | { | ||
753 | #ifdef SCPACK | ||
754 | "const.pri %1!push.pri!load.s.pri %2!bounds %3!pop.alt!", | ||
755 | "const.alt %1!load.s.pri %2!bounds %3!", | ||
756 | #else | ||
757 | "\332\300\231", | ||
758 | "\236\334", | ||
759 | #endif | ||
760 | seqsize(5, 3) - seqsize(3, 3)}, | ||
761 | /* During a calculation, the intermediate result must sometimes | ||
762 | * be moved from PRI to ALT, like in: | ||
763 | * push.pri move.alt | ||
764 | * load.s.pri n1 load.s.pri n1 | ||
765 | * pop.alt - | ||
766 | * | ||
767 | * The above also accurs for "load.pri" and for "const.pri", | ||
768 | * so add another two cases. | ||
769 | */ | ||
770 | { | ||
771 | #ifdef SCPACK | ||
772 | "push.pri!load.s.pri %1!pop.alt!", | ||
773 | "move.alt!load.s.pri %1!", | ||
774 | #else | ||
775 | "\240\324\231", | ||
776 | "\375\324", | ||
777 | #endif | ||
778 | seqsize(3, 1) - seqsize(2, 1)}, | ||
779 | { | ||
780 | #ifdef SCPACK | ||
781 | "push.pri!load.pri %1!pop.alt!", | ||
782 | "move.alt!load.pri %1!", | ||
783 | #else | ||
784 | "\240\314\231", | ||
785 | "\375\314", | ||
786 | #endif | ||
787 | seqsize(3, 1) - seqsize(2, 1)}, | ||
788 | { | ||
789 | #ifdef SCPACK | ||
790 | "push.pri!const.pri %1!pop.alt!", | ||
791 | "move.alt!const.pri %1!", | ||
792 | #else | ||
793 | "\240\316\231", | ||
794 | "\375\316", | ||
795 | #endif | ||
796 | seqsize(3, 1) - seqsize(2, 1)}, | ||
797 | { | ||
798 | #ifdef SCPACK | ||
799 | "push.pri!zero.pri!pop.alt!", | ||
800 | "move.alt!zero.pri!", | ||
801 | #else | ||
802 | "\240\376\231", | ||
803 | "\375\376", | ||
804 | #endif | ||
805 | seqsize(3, 0) - seqsize(2, 0)}, | ||
806 | /* saving PRI and then loading from its address | ||
807 | * occurs when indexing a multi-dimensional array | ||
808 | */ | ||
809 | { | ||
810 | #ifdef SCPACK | ||
811 | "push.pri!load.i!pop.alt!", | ||
812 | "move.alt!load.i!", | ||
813 | #else | ||
814 | "\240\213\340\231", | ||
815 | "\375\213\340", | ||
816 | #endif | ||
817 | seqsize(3, 0) - seqsize(2, 0)}, | ||
818 | /* An even simpler PUSH/POP optimization (occurs in | ||
819 | * switch statements): | ||
820 | * push.pri move.alt | ||
821 | * pop.alt - | ||
822 | */ | ||
823 | { | ||
824 | #ifdef SCPACK | ||
825 | "push.pri!pop.alt!", | ||
826 | "move.alt!", | ||
827 | #else | ||
828 | "\240\231", | ||
829 | "\375", | ||
830 | #endif | ||
831 | seqsize(2, 0) - seqsize(1, 0)}, | ||
832 | /* And what to think of this PUSH/POP sequence, which occurs | ||
833 | * due to the support for user-defined assignment operator): | ||
834 | * push.alt - | ||
835 | * pop.alt - | ||
836 | */ | ||
837 | //??? | ||
838 | //{ | ||
839 | // #ifdef SCPACK | ||
840 | // "push.alt!pop.alt!", | ||
841 | // ";$", /* SCPACK cannot handle empty strings */ | ||
842 | // #else | ||
843 | // "\225\237", | ||
844 | // "\353", | ||
845 | // #endif | ||
846 | // seqsize(2,0) - seqsize(0,0) | ||
847 | //}, | ||
848 | /* Functions with many parameters with the same default | ||
849 | * value have sequences like: | ||
850 | * push.c n1 const.pri n1 | ||
851 | * ;$par push.r.pri n2 ; where n2 is the number of pushes | ||
852 | * push.c n1 ;$par | ||
853 | * ;$par - | ||
854 | * push.c n1 - | ||
855 | * ;$par - | ||
856 | * etc. etc. | ||
857 | * The shortest matched sequence is 3, because a sequence of two can also be | ||
858 | * optimized as two "push.c n1" instructions. | ||
859 | * => this optimization does not work, because the argument re-ordering in | ||
860 | * a function call causes each argument to be optimized individually | ||
861 | */ | ||
862 | //{ | ||
863 | // #ifdef SCPACK | ||
864 | // "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!", | ||
865 | // "const.pri %1!push.r.pri 5!;$par!", | ||
866 | // #else | ||
867 | // "\327\327\254", | ||
868 | // "\352\221.r\2745!", | ||
869 | // #endif | ||
870 | // seqsize(10,5) - seqsize(2,2) | ||
871 | //}, | ||
872 | //{ | ||
873 | // #ifdef SCPACK | ||
874 | // "const.pri %1!push.pri!;$par!const.pri %1!push.pri!;$par!const.pri %1!push.pri!;$par!const.pri %1!push.pri!;$par!", | ||
875 | // "const.pri %1!push.r.pri 4!;$par!", | ||
876 | // #else | ||
877 | // "\327\327", | ||
878 | // "\352\221.r\274\326", | ||
879 | // #endif | ||
880 | // seqsize(8,4) - seqsize(2,2) | ||
881 | //}, | ||
882 | //{ | ||
883 | // #ifdef SCPACK | ||
884 | // "const.pri %1!push.pri!;$par!const.pri %1!push.pri!;$par!const.pri %1!push.pri!;$par!", | ||
885 | // "const.pri %1!push.r.pri 3!;$par!", | ||
886 | // #else | ||
887 | // "\327\254", | ||
888 | // "\352\221.r\274\247", | ||
889 | // #endif | ||
890 | // seqsize(6,3) - seqsize(2,2) | ||
891 | //}, | ||
892 | /* User-defined operators first load the operands into registers and | ||
893 | * then have them pushed onto the stack. This can give rise to sequences | ||
894 | * like: | ||
895 | * const.pri n1 push.c n1 | ||
896 | * const.alt n2 push.c n2 | ||
897 | * push.pri - | ||
898 | * push.alt - | ||
899 | * A similar sequence occurs with the two PUSH.pri/alt instructions inverted. | ||
900 | * The first, second, or both CONST.pri/alt instructions can also be | ||
901 | * LOAD.pri/alt. | ||
902 | * This gives 2 x 4 cases. | ||
903 | */ | ||
904 | { | ||
905 | #ifdef SCPACK | ||
906 | "const.pri %1!const.alt %2!push.pri!push.alt!", | ||
907 | "push.c %1!push.c %2!", | ||
908 | #else | ||
909 | "\316\236\311\240\351", | ||
910 | "\330\205\330\216", | ||
911 | #endif | ||
912 | seqsize(4, 2) - seqsize(2, 2)}, | ||
913 | { | ||
914 | #ifdef SCPACK | ||
915 | "const.pri %1!const.alt %2!push.alt!push.pri!", | ||
916 | "push.c %2!push.c %1!", | ||
917 | #else | ||
918 | "\316\236\311\351\240", | ||
919 | "\330\216\330\205", | ||
920 | #endif | ||
921 | seqsize(4, 2) - seqsize(2, 2)}, | ||
922 | { | ||
923 | #ifdef SCPACK | ||
924 | "const.pri %1!load.alt %2!push.pri!push.alt!", | ||
925 | "push.c %1!push %2!", | ||
926 | #else | ||
927 | "\316\213\311\240\351", | ||
928 | "\330\205\222\216", | ||
929 | #endif | ||
930 | seqsize(4, 2) - seqsize(2, 2)}, | ||
931 | { | ||
932 | #ifdef SCPACK | ||
933 | "const.pri %1!load.alt %2!push.alt!push.pri!", | ||
934 | "push %2!push.c %1!", | ||
935 | #else | ||
936 | "\316\213\311\351\240", | ||
937 | "\222\216\330\205", | ||
938 | #endif | ||
939 | seqsize(4, 2) - seqsize(2, 2)}, | ||
940 | { | ||
941 | #ifdef SCPACK | ||
942 | "load.pri %1!const.alt %2!push.pri!push.alt!", | ||
943 | "push %1!push.c %2!", | ||
944 | #else | ||
945 | "\314\236\311\240\351", | ||
946 | "\222\205\330\216", | ||
947 | #endif | ||
948 | seqsize(4, 2) - seqsize(2, 2)}, | ||
949 | { | ||
950 | #ifdef SCPACK | ||
951 | "load.pri %1!const.alt %2!push.alt!push.pri!", | ||
952 | "push.c %2!push %1!", | ||
953 | #else | ||
954 | "\314\236\311\351\240", | ||
955 | "\330\216\222\205", | ||
956 | #endif | ||
957 | seqsize(4, 2) - seqsize(2, 2)}, | ||
958 | { | ||
959 | #ifdef SCPACK | ||
960 | "load.pri %1!load.alt %2!push.pri!push.alt!", | ||
961 | "push %1!push %2!", | ||
962 | #else | ||
963 | "\314\213\311\240\351", | ||
964 | "\222\205\222\216", | ||
965 | #endif | ||
966 | seqsize(4, 2) - seqsize(2, 2)}, | ||
967 | { | ||
968 | #ifdef SCPACK | ||
969 | "load.pri %1!load.alt %2!push.alt!push.pri!", | ||
970 | "push %2!push %1!", | ||
971 | #else | ||
972 | "\314\213\311\351\240", | ||
973 | "\222\216\222\205", | ||
974 | #endif | ||
975 | seqsize(4, 2) - seqsize(2, 2)}, | ||
976 | /* Function calls (parameters are passed on the stack) | ||
977 | * load.s.pri n1 push.s n1 | ||
978 | * push.pri - | ||
979 | * -------------------------------------- | ||
980 | * load.pri n1 push n1 | ||
981 | * push.pri - | ||
982 | * -------------------------------------- | ||
983 | * const.pri n1 push.c n1 | ||
984 | * push.pri - | ||
985 | * -------------------------------------- | ||
986 | * zero.pri push.c 0 | ||
987 | * push.pri - | ||
988 | * -------------------------------------- | ||
989 | * addr.pri n1 pushaddr n1 | ||
990 | * push.pri - | ||
991 | * | ||
992 | * However, PRI must not be needed after this instruction | ||
993 | * if this shortcut is used. Check for the ;$par comment. | ||
994 | */ | ||
995 | { | ||
996 | #ifdef SCPACK | ||
997 | "load.s.pri %1!push.pri!;$par!", | ||
998 | "push.s %1!;$par!", | ||
999 | #else | ||
1000 | "\224\255\344", | ||
1001 | "\222\220\205\344", | ||
1002 | #endif | ||
1003 | seqsize(2, 1) - seqsize(1, 1)}, | ||
1004 | { | ||
1005 | #ifdef SCPACK | ||
1006 | "load.pri %1!push.pri!;$par!", | ||
1007 | "push %1!;$par!", | ||
1008 | #else | ||
1009 | "\213\255\344", | ||
1010 | "\222\205\344", | ||
1011 | #endif | ||
1012 | seqsize(2, 1) - seqsize(1, 1)}, | ||
1013 | { | ||
1014 | #ifdef SCPACK | ||
1015 | "const.pri %1!push.pri!;$par!", | ||
1016 | "push.c %1!;$par!", | ||
1017 | #else | ||
1018 | "\236\255\344", | ||
1019 | "\330\205\344", | ||
1020 | #endif | ||
1021 | seqsize(2, 1) - seqsize(1, 1)}, | ||
1022 | { | ||
1023 | #ifdef SCPACK | ||
1024 | "zero.pri!push.pri!;$par!", | ||
1025 | "push.c 0!;$par!", | ||
1026 | #else | ||
1027 | "\376\240\344", | ||
1028 | "\330 0!\344", | ||
1029 | #endif | ||
1030 | seqsize(2, 0) - seqsize(1, 1)}, | ||
1031 | { | ||
1032 | #ifdef SCPACK | ||
1033 | "addr.pri %1!push.pri!;$par!", | ||
1034 | "pushaddr %1!;$par!", | ||
1035 | #else | ||
1036 | "\252\255\344", | ||
1037 | "\222\252\205\344", | ||
1038 | #endif | ||
1039 | seqsize(2, 1) - seqsize(1, 1)}, | ||
1040 | /* References with a default value generate new cells on the heap | ||
1041 | * dynamically. That code often ends with: | ||
1042 | * move.pri push.alt | ||
1043 | * push.pri - | ||
1044 | */ | ||
1045 | { | ||
1046 | #ifdef SCPACK | ||
1047 | "move.pri!push.pri!", | ||
1048 | "push.alt!", | ||
1049 | #else | ||
1050 | "\350\232\240", | ||
1051 | "\351", | ||
1052 | #endif | ||
1053 | seqsize(2, 0) - seqsize(1, 0)}, | ||
1054 | /* Simple arithmetic operations on constants. Noteworthy is the | ||
1055 | * subtraction of a constant, since it is converted to the addition | ||
1056 | * of the inverse value. | ||
1057 | * const.alt n1 add.c n1 | ||
1058 | * add - | ||
1059 | * -------------------------------------- | ||
1060 | * const.alt n1 add.c -n1 | ||
1061 | * sub - | ||
1062 | * -------------------------------------- | ||
1063 | * const.alt n1 smul.c n1 | ||
1064 | * smul - | ||
1065 | * -------------------------------------- | ||
1066 | * const.alt n1 eq.c.pri n1 | ||
1067 | * eq - | ||
1068 | */ | ||
1069 | { | ||
1070 | #ifdef SCPACK | ||
1071 | "const.alt %1!add!", | ||
1072 | "add.c %1!", | ||
1073 | #else | ||
1074 | "\360\270", | ||
1075 | "\233\247\205", | ||
1076 | #endif | ||
1077 | seqsize(2, 1) - seqsize(1, 1)}, | ||
1078 | { | ||
1079 | #ifdef SCPACK | ||
1080 | "const.alt %1!sub!", | ||
1081 | "add.c -%1!", | ||
1082 | #else | ||
1083 | "\360sub!", | ||
1084 | "\233\247 -%\204", | ||
1085 | #endif | ||
1086 | seqsize(2, 1) - seqsize(1, 1)}, | ||
1087 | { | ||
1088 | #ifdef SCPACK | ||
1089 | "const.alt %1!smul!", | ||
1090 | "smul.c %1!", | ||
1091 | #else | ||
1092 | "\360smul!", | ||
1093 | "smu\271\205", | ||
1094 | #endif | ||
1095 | seqsize(2, 1) - seqsize(1, 1)}, | ||
1096 | { | ||
1097 | #ifdef SCPACK | ||
1098 | "const.alt %1!eq!", | ||
1099 | "eq.c.pri %1!", | ||
1100 | #else | ||
1101 | "\360\265", | ||
1102 | "\253\247\223", | ||
1103 | #endif | ||
1104 | seqsize(2, 1) - seqsize(1, 1)}, | ||
1105 | /* Some operations use the alternative subtraction operation --these | ||
1106 | * can also be optimized. | ||
1107 | * const.pri n1 load.s.pri n2 | ||
1108 | * load.s.alt n2 add.c -n1 | ||
1109 | * sub.alt - | ||
1110 | * -------------------------------------- | ||
1111 | * const.pri n1 load.pri n2 | ||
1112 | * load.alt n2 add.c -n1 | ||
1113 | * sub.alt - | ||
1114 | */ | ||
1115 | { | ||
1116 | #ifdef SCPACK | ||
1117 | "const.pri %1!load.s.alt %2!sub.alt!", | ||
1118 | "load.s.pri %2!add.c -%1!", | ||
1119 | #else | ||
1120 | "\316\224\311sub\217", | ||
1121 | "\241\233\247 -%\204", | ||
1122 | #endif | ||
1123 | seqsize(3, 2) - seqsize(2, 2)}, | ||
1124 | { | ||
1125 | #ifdef SCPACK | ||
1126 | "const.pri %1!load.alt %2!sub.alt!", | ||
1127 | "load.pri %2!add.c -%1!", | ||
1128 | #else | ||
1129 | "\316\213\311sub\217", | ||
1130 | "\317\233\247 -%\204", | ||
1131 | #endif | ||
1132 | seqsize(3, 2) - seqsize(2, 2)}, | ||
1133 | /* Compare and jump | ||
1134 | * eq jneq n1 | ||
1135 | * jzer n1 - | ||
1136 | * -------------------------------------- | ||
1137 | * eq jeq n1 | ||
1138 | * jnz n1 - | ||
1139 | * -------------------------------------- | ||
1140 | * neq jeq n1 | ||
1141 | * jzer n1 - | ||
1142 | * -------------------------------------- | ||
1143 | * neq jneq n1 | ||
1144 | * jnz n1 - | ||
1145 | * Compares followed by jzer occur much more | ||
1146 | * often than compares followed with jnz. So we | ||
1147 | * take the easy route here. | ||
1148 | * less jgeq n1 | ||
1149 | * jzer n1 - | ||
1150 | * -------------------------------------- | ||
1151 | * leq jgrtr n1 | ||
1152 | * jzer n1 - | ||
1153 | * -------------------------------------- | ||
1154 | * grtr jleq n1 | ||
1155 | * jzer n1 - | ||
1156 | * -------------------------------------- | ||
1157 | * geq jless n1 | ||
1158 | * jzer n1 - | ||
1159 | * -------------------------------------- | ||
1160 | * sless jsgeq n1 | ||
1161 | * jzer n1 - | ||
1162 | * -------------------------------------- | ||
1163 | * sleq jsgrtr n1 | ||
1164 | * jzer n1 - | ||
1165 | * -------------------------------------- | ||
1166 | * sgrtr jsleq n1 | ||
1167 | * jzer n1 - | ||
1168 | * -------------------------------------- | ||
1169 | * sgeq jsless n1 | ||
1170 | * jzer n1 - | ||
1171 | */ | ||
1172 | { | ||
1173 | #ifdef SCPACK | ||
1174 | "eq!jzer %1!", | ||
1175 | "jneq %1!", | ||
1176 | #else | ||
1177 | "\265\305", | ||
1178 | "jn\325", | ||
1179 | #endif | ||
1180 | seqsize(2, 1) - seqsize(1, 1)}, | ||
1181 | { | ||
1182 | #ifdef SCPACK | ||
1183 | "eq!jnz %1!", | ||
1184 | "jeq %1!", | ||
1185 | #else | ||
1186 | "\265jnz\205", | ||
1187 | "j\325", | ||
1188 | #endif | ||
1189 | seqsize(2, 1) - seqsize(1, 1)}, | ||
1190 | { | ||
1191 | #ifdef SCPACK | ||
1192 | "neq!jzer %1!", | ||
1193 | "jeq %1!", | ||
1194 | #else | ||
1195 | "n\265\305", | ||
1196 | "j\325", | ||
1197 | #endif | ||
1198 | seqsize(2, 1) - seqsize(1, 1)}, | ||
1199 | { | ||
1200 | #ifdef SCPACK | ||
1201 | "neq!jnz %1!", | ||
1202 | "jneq %1!", | ||
1203 | #else | ||
1204 | "n\265jnz\205", | ||
1205 | "jn\325", | ||
1206 | #endif | ||
1207 | seqsize(2, 1) - seqsize(1, 1)}, | ||
1208 | { | ||
1209 | #ifdef SCPACK | ||
1210 | "less!jzer %1!", | ||
1211 | "jgeq %1!", | ||
1212 | #else | ||
1213 | "l\322!\305", | ||
1214 | "jg\325", | ||
1215 | #endif | ||
1216 | seqsize(2, 1) - seqsize(1, 1)}, | ||
1217 | { | ||
1218 | #ifdef SCPACK | ||
1219 | "leq!jzer %1!", | ||
1220 | "jgrtr %1!", | ||
1221 | #else | ||
1222 | "l\265\305", | ||
1223 | "jg\323r\205", | ||
1224 | #endif | ||
1225 | seqsize(2, 1) - seqsize(1, 1)}, | ||
1226 | { | ||
1227 | #ifdef SCPACK | ||
1228 | "grtr!jzer %1!", | ||
1229 | "jleq %1!", | ||
1230 | #else | ||
1231 | "g\323\306\305", | ||
1232 | "jl\325", | ||
1233 | #endif | ||
1234 | seqsize(2, 1) - seqsize(1, 1)}, | ||
1235 | { | ||
1236 | #ifdef SCPACK | ||
1237 | "geq!jzer %1!", | ||
1238 | "jless %1!", | ||
1239 | #else | ||
1240 | "g\265\305", | ||
1241 | "jl\322\205", | ||
1242 | #endif | ||
1243 | seqsize(2, 1) - seqsize(1, 1)}, | ||
1244 | { | ||
1245 | #ifdef SCPACK | ||
1246 | "sless!jzer %1!", | ||
1247 | "jsgeq %1!", | ||
1248 | #else | ||
1249 | "\357\305", | ||
1250 | "j\302\325", | ||
1251 | #endif | ||
1252 | seqsize(2, 1) - seqsize(1, 1)}, | ||
1253 | { | ||
1254 | #ifdef SCPACK | ||
1255 | "sleq!jzer %1!", | ||
1256 | "jsgrtr %1!", | ||
1257 | #else | ||
1258 | "\362\305", | ||
1259 | "j\337r\205", | ||
1260 | #endif | ||
1261 | seqsize(2, 1) - seqsize(1, 1)}, | ||
1262 | { | ||
1263 | #ifdef SCPACK | ||
1264 | "sgrtr!jzer %1!", | ||
1265 | "jsleq %1!", | ||
1266 | #else | ||
1267 | "\364\305", | ||
1268 | "j\303\325", | ||
1269 | #endif | ||
1270 | seqsize(2, 1) - seqsize(1, 1)}, | ||
1271 | { | ||
1272 | #ifdef SCPACK | ||
1273 | "sgeq!jzer %1!", | ||
1274 | "jsless %1!", | ||
1275 | #else | ||
1276 | "\361\305", | ||
1277 | "j\341\205", | ||
1278 | #endif | ||
1279 | seqsize(2, 1) - seqsize(1, 1)}, | ||
1280 | /* Test for zero (common case, especially for strings) | ||
1281 | * E.g. the test expression of: "for (i=0; str{i}!=0; ++i)" | ||
1282 | * | ||
1283 | * zero.alt jzer n1 | ||
1284 | * jeq n1 - | ||
1285 | * -------------------------------------- | ||
1286 | * zero.alt jnz n1 | ||
1287 | * jneq n1 - | ||
1288 | */ | ||
1289 | { | ||
1290 | #ifdef SCPACK | ||
1291 | "zero.alt!jeq %1!", | ||
1292 | "jzer %1!", | ||
1293 | #else | ||
1294 | "\315\217j\325", | ||
1295 | "\305", | ||
1296 | #endif | ||
1297 | seqsize(2, 1) - seqsize(1, 1)}, | ||
1298 | { | ||
1299 | #ifdef SCPACK | ||
1300 | "zero.alt!jneq %1!", | ||
1301 | "jnz %1!", | ||
1302 | #else | ||
1303 | "\315\217jn\325", | ||
1304 | "jnz\205", | ||
1305 | #endif | ||
1306 | seqsize(2, 1) - seqsize(1, 1)}, | ||
1307 | /* Incrementing and decrementing leaves a value in | ||
1308 | * in PRI which may not be used (for example, as the | ||
1309 | * third expression in a "for" loop). | ||
1310 | * inc n1 inc n1 ; ++n | ||
1311 | * load.pri n1 ;$exp | ||
1312 | * ;$exp - | ||
1313 | * -------------------------------------- | ||
1314 | * load.pri n1 inc n1 ; n++, e.g. "for (n=0; n<10; n++)" | ||
1315 | * inc n1 ;$exp | ||
1316 | * ;$exp - | ||
1317 | * Plus the varieties for stack relative increments | ||
1318 | * and decrements. | ||
1319 | */ | ||
1320 | { | ||
1321 | #ifdef SCPACK | ||
1322 | "inc %1!load.pri %1!;$exp!", | ||
1323 | "inc %1!;$exp!", | ||
1324 | #else | ||
1325 | "\373c\205\314\245", | ||
1326 | "\373c\261", | ||
1327 | #endif | ||
1328 | seqsize(2, 2) - seqsize(1, 1)}, | ||
1329 | { | ||
1330 | #ifdef SCPACK | ||
1331 | "load.pri %1!inc %1!;$exp!", | ||
1332 | "inc %1!;$exp!", | ||
1333 | #else | ||
1334 | "\314\373c\261", | ||
1335 | "\373c\261", | ||
1336 | #endif | ||
1337 | seqsize(2, 2) - seqsize(1, 1)}, | ||
1338 | { | ||
1339 | #ifdef SCPACK | ||
1340 | "inc.s %1!load.s.pri %1!;$exp!", | ||
1341 | "inc.s %1!;$exp!", | ||
1342 | #else | ||
1343 | "\373\352\205\324\245", | ||
1344 | "\373\352\261", | ||
1345 | #endif | ||
1346 | seqsize(2, 2) - seqsize(1, 1)}, | ||
1347 | { | ||
1348 | #ifdef SCPACK | ||
1349 | "load.s.pri %1!inc.s %1!;$exp!", | ||
1350 | "inc.s %1!;$exp!", | ||
1351 | #else | ||
1352 | "\324\373\352\261", | ||
1353 | "\373\352\261", | ||
1354 | #endif | ||
1355 | seqsize(2, 2) - seqsize(1, 1)}, | ||
1356 | { | ||
1357 | #ifdef SCPACK | ||
1358 | "dec %1!load.pri %1!;$exp!", | ||
1359 | "dec %1!;$exp!", | ||
1360 | #else | ||
1361 | "\367c\205\314\245", | ||
1362 | "\367c\261", | ||
1363 | #endif | ||
1364 | seqsize(2, 2) - seqsize(1, 1)}, | ||
1365 | { | ||
1366 | #ifdef SCPACK | ||
1367 | "load.pri %1!dec %1!;$exp!", | ||
1368 | "dec %1!;$exp!", | ||
1369 | #else | ||
1370 | "\314\367c\261", | ||
1371 | "\367c\261", | ||
1372 | #endif | ||
1373 | seqsize(2, 2) - seqsize(1, 1)}, | ||
1374 | { | ||
1375 | #ifdef SCPACK | ||
1376 | "dec.s %1!load.s.pri %1!;$exp!", | ||
1377 | "dec.s %1!;$exp!", | ||
1378 | #else | ||
1379 | "\367\352\205\324\245", | ||
1380 | "\367\352\261", | ||
1381 | #endif | ||
1382 | seqsize(2, 2) - seqsize(1, 1)}, | ||
1383 | { | ||
1384 | #ifdef SCPACK | ||
1385 | "load.s.pri %1!dec.s %1!;$exp!", | ||
1386 | "dec.s %1!;$exp!", | ||
1387 | #else | ||
1388 | "\324\367\352\261", | ||
1389 | "\367\352\261", | ||
1390 | #endif | ||
1391 | seqsize(2, 2) - seqsize(1, 1)}, | ||
1392 | /* ??? the same (increments and decrements) for references */ | ||
1393 | /* Loading the constant zero has a special opcode. | ||
1394 | * When storing zero in memory, the value of PRI must not be later on. | ||
1395 | * const.pri 0 zero n1 | ||
1396 | * stor.pri n1 ;$exp | ||
1397 | * ;$exp - | ||
1398 | * -------------------------------------- | ||
1399 | * const.pri 0 zero.s n1 | ||
1400 | * stor.s.pri n1 ;$exp | ||
1401 | * ;$exp - | ||
1402 | * -------------------------------------- | ||
1403 | * zero.pri zero n1 | ||
1404 | * stor.pri n1 ;$exp | ||
1405 | * ;$exp - | ||
1406 | * -------------------------------------- | ||
1407 | * zero.pri zero.s n1 | ||
1408 | * stor.s.pri n1 ;$exp | ||
1409 | * ;$exp - | ||
1410 | * -------------------------------------- | ||
1411 | * const.pri 0 zero.pri | ||
1412 | * -------------------------------------- | ||
1413 | * const.alt 0 zero.alt | ||
1414 | * The last two alternatives save more memory than they save | ||
1415 | * time, but anyway... | ||
1416 | */ | ||
1417 | { | ||
1418 | #ifdef SCPACK | ||
1419 | "const.pri 0!stor.pri %1!;$exp!", | ||
1420 | "zero %1!;$exp!", | ||
1421 | #else | ||
1422 | "\236\203 0!\227or\223\245", | ||
1423 | "\315\261", | ||
1424 | #endif | ||
1425 | seqsize(2, 2) - seqsize(1, 1)}, | ||
1426 | { | ||
1427 | #ifdef SCPACK | ||
1428 | "const.pri 0!stor.s.pri %1!;$exp!", | ||
1429 | "zero.s %1!;$exp!", | ||
1430 | #else | ||
1431 | "\236\203 0!\227or\220\223\245", | ||
1432 | "\315\220\261", | ||
1433 | #endif | ||
1434 | seqsize(2, 2) - seqsize(1, 1)}, | ||
1435 | { | ||
1436 | #ifdef SCPACK | ||
1437 | "zero.pri!stor.pri %1!;$exp!", | ||
1438 | "zero %1!;$exp!", | ||
1439 | #else | ||
1440 | "\376\227or\223\245", | ||
1441 | "\315\261", | ||
1442 | #endif | ||
1443 | seqsize(2, 1) - seqsize(1, 1)}, | ||
1444 | { | ||
1445 | #ifdef SCPACK | ||
1446 | "zero.pri!stor.s.pri %1!;$exp!", | ||
1447 | "zero.s %1!;$exp!", | ||
1448 | #else | ||
1449 | "\376\227or\220\223\245", | ||
1450 | "\315\220\261", | ||
1451 | #endif | ||
1452 | seqsize(2, 1) - seqsize(1, 1)}, | ||
1453 | { | ||
1454 | #ifdef SCPACK | ||
1455 | "const.pri 0!", | ||
1456 | "zero.pri!", | ||
1457 | #else | ||
1458 | "\236\203 0!", | ||
1459 | "\376", | ||
1460 | #endif | ||
1461 | seqsize(1, 1) - seqsize(1, 0)}, | ||
1462 | { | ||
1463 | #ifdef SCPACK | ||
1464 | "const.alt 0!", | ||
1465 | "zero.alt!", | ||
1466 | #else | ||
1467 | "\236\211 0!", | ||
1468 | "\315\217", | ||
1469 | #endif | ||
1470 | seqsize(1, 1) - seqsize(1, 0)}, | ||
1471 | /* ----- */ | ||
1472 | {NULL, NULL, 0} | ||
1473 | }; | ||