source: mainline/uspace/app/pcc/arch/i386/table.c@ 9749e47

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 9749e47 was a7de7182, checked in by Jiří Zárevúcky <zarevucky.jiri@…>, 14 years ago

Added pcc source tree (contents of pcc-1.0.0.tgz)
  • Property mode set to 100644
File size: 31.1 KB
Line 
1/* $Id: table.c,v 1.128 2011/01/29 09:55:29 ragge Exp $ */
2/*
3 * Copyright (c) 2003 Anders Magnusson (ragge@ludd.luth.se).
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29
30# include "pass2.h"
31
32# define TLL TLONGLONG|TULONGLONG
33# define ANYSIGNED TINT|TLONG|TSHORT|TCHAR
34# define ANYUSIGNED TUNSIGNED|TULONG|TUSHORT|TUCHAR
35# define ANYFIXED ANYSIGNED|ANYUSIGNED
36# define TUWORD TUNSIGNED|TULONG
37# define TSWORD TINT|TLONG
38# define TWORD TUWORD|TSWORD
39#define SHINT SAREG /* short and int */
40#define ININT INAREG
41#define SHCH SBREG /* shape for char */
42#define INCH INBREG
43#define SHLL SCREG /* shape for long long */
44#define INLL INCREG
45#define SHFL SDREG /* shape for float/double */
46#define INFL INDREG /* shape for float/double */
47
48struct optab table[] = {
49/* First entry must be an empty entry */
50{ -1, FOREFF, SANY, TANY, SANY, TANY, 0, 0, "", },
51
52/* PCONVs are usually not necessary */
53{ PCONV, INAREG,
54 SAREG, TWORD|TPOINT,
55 SAREG, TWORD|TPOINT,
56 0, RLEFT,
57 "", },
58
59/*
60 * A bunch conversions of integral<->integral types
61 * There are lots of them, first in table conversions to itself
62 * and then conversions from each type to the others.
63 */
64
65/* itself to itself, including pointers */
66
67/* convert (u)char to (u)char. */
68{ SCONV, INCH,
69 SHCH, TCHAR|TUCHAR,
70 SHCH, TCHAR|TUCHAR,
71 0, RLEFT,
72 "", },
73
74/* convert pointers to int. */
75{ SCONV, ININT,
76 SHINT, TPOINT|TWORD,
77 SANY, TWORD,
78 0, RLEFT,
79 "", },
80
81/* convert (u)longlong to (u)longlong. */
82{ SCONV, INLL,
83 SHLL, TLL,
84 SHLL, TLL,
85 0, RLEFT,
86 "", },
87
88/* convert between float/double/long double. */
89{ SCONV, INFL,
90 SHFL, TLDOUBLE|TDOUBLE|TFLOAT,
91 SHFL, TLDOUBLE|TDOUBLE|TFLOAT,
92 0, RLEFT,
93 "ZI", },
94
95/* convert pointers to pointers. */
96{ SCONV, ININT,
97 SHINT, TPOINT,
98 SANY, TPOINT,
99 0, RLEFT,
100 "", },
101
102/* char to something */
103
104/* convert char to (unsigned) short. */
105{ SCONV, ININT,
106 SBREG|SOREG|SNAME, TCHAR,
107 SAREG, TSHORT|TUSHORT,
108 NASL|NAREG, RESC1,
109 " movsbw AL,A1\n", },
110
111/* convert unsigned char to (u)short. */
112{ SCONV, ININT,
113 SHCH|SOREG|SNAME, TUCHAR,
114 SAREG, TSHORT|TUSHORT,
115 NASL|NAREG, RESC1,
116 " movzbw AL,A1\n", },
117
118/* convert signed char to int (or pointer). */
119{ SCONV, ININT,
120 SHCH|SOREG|SNAME, TCHAR,
121 SAREG, TWORD|TPOINT,
122 NASL|NAREG, RESC1,
123 " movsbl AL,A1\n", },
124
125/* convert unsigned char to (u)int. */
126{ SCONV, ININT,
127 SHCH|SOREG|SNAME, TUCHAR,
128 SAREG, TWORD,
129 NASL|NAREG, RESC1,
130 " movzbl AL,A1\n", },
131
132/* convert char to (u)long long */
133{ SCONV, INLL,
134 SHCH|SOREG|SNAME, TCHAR,
135 SANY, TLL,
136 NSPECIAL|NCREG|NCSL, RESC1,
137 " movsbl AL,%eax\n cltd\n", },
138
139/* convert unsigned char to (u)long long */
140{ SCONV, INLL,
141 SHCH|SOREG|SNAME, TUCHAR,
142 SANY, TLL,
143 NCREG|NCSL, RESC1,
144 " movzbl AL,A1\n xorl U1,U1\n", },
145
146/* convert char (in register) to double XXX - use NTEMP */
147{ SCONV, INFL,
148 SHCH|SOREG|SNAME, TCHAR,
149 SHFL, TLDOUBLE|TDOUBLE|TFLOAT,
150 NAREG|NASL|NDREG, RESC2,
151 " movsbl AL,A1\n pushl A1\n"
152 " fildl (%esp)\n addl $4,%esp\n", },
153
154/* convert (u)char (in register) to double XXX - use NTEMP */
155{ SCONV, INFL,
156 SHCH|SOREG|SNAME, TUCHAR,
157 SHFL, TLDOUBLE|TDOUBLE|TFLOAT,
158 NAREG|NASL|NDREG, RESC2,
159 " movzbl AL,A1\n pushl A1\n"
160 " fildl (%esp)\n addl $4,%esp\n", },
161
162/* short to something */
163
164/* convert short (in memory) to char */
165{ SCONV, INCH,
166 SNAME|SOREG, TSHORT|TUSHORT,
167 SHCH, TCHAR|TUCHAR,
168 NBREG|NBSL, RESC1,
169 " movb AL,A1\n", },
170
171/* convert short (in reg) to char. */
172{ SCONV, INCH,
173 SAREG|SNAME|SOREG, TSHORT|TUSHORT,
174 SHCH, TCHAR|TUCHAR,
175 NSPECIAL|NBREG|NBSL, RESC1,
176 "ZM", },
177
178/* convert short to (u)int. */
179{ SCONV, ININT,
180 SAREG|SOREG|SNAME, TSHORT,
181 SAREG, TWORD,
182 NASL|NAREG, RESC1,
183 " movswl AL,A1\n", },
184
185/* convert unsigned short to (u)int. */
186{ SCONV, ININT,
187 SAREG|SOREG|SNAME, TUSHORT,
188 SAREG, TWORD,
189 NASL|NAREG, RESC1,
190 " movzwl AL,A1\n", },
191
192/* convert short to (u)long long */
193{ SCONV, INLL,
194 SAREG|SOREG|SNAME, TSHORT,
195 SHLL, TLL,
196 NSPECIAL|NCREG|NCSL, RESC1,
197 " movswl AL,%eax\n cltd\n", },
198
199/* convert unsigned short to (u)long long */
200{ SCONV, INLL,
201 SAREG|SOREG|SNAME, TUSHORT,
202 SHLL, TLL,
203 NCREG|NCSL, RESC1,
204 " movzwl AL,A1\n xorl U1,U1\n", },
205
206/* convert short (in memory) to float/double */
207{ SCONV, INFL,
208 SOREG|SNAME, TSHORT,
209 SDREG, TLDOUBLE|TDOUBLE|TFLOAT,
210 NDREG, RESC1,
211 " fild AL\n", },
212
213/* convert short (in register) to float/double */
214{ SCONV, INFL,
215 SAREG, TSHORT,
216 SDREG, TLDOUBLE|TDOUBLE|TFLOAT,
217 NTEMP|NDREG, RESC1,
218 " pushw AL\n fild (%esp)\n addl $2,%esp\n", },
219
220/* convert unsigned short to double XXX - use NTEMP */
221{ SCONV, INFL,
222 SAREG|SOREG|SNAME, TUSHORT,
223 SHFL, TLDOUBLE|TDOUBLE|TFLOAT,
224 NAREG|NASL|NDREG|NTEMP, RESC2,
225 " movzwl AL,A1\n pushl A1\n"
226 " fildl (%esp)\n addl $4,%esp\n", },
227
228/* int to something */
229
230/* convert int to char. This is done when register is loaded */
231{ SCONV, INCH,
232 SAREG, TWORD|TPOINT,
233 SANY, TCHAR|TUCHAR,
234 NSPECIAL|NBREG|NBSL, RESC1,
235 "ZM", },
236
237/* convert int to short. Nothing to do */
238{ SCONV, INAREG,
239 SAREG, TWORD,
240 SANY, TSHORT|TUSHORT,
241 0, RLEFT,
242 "", },
243
244/* convert signed int to (u)long long */
245{ SCONV, INLL,
246 SHINT, TSWORD,
247 SHLL, TLL,
248 NSPECIAL|NCREG|NCSL, RESC1,
249 " cltd\n", },
250
251/* convert unsigned int to (u)long long */
252{ SCONV, INLL,
253 SHINT|SOREG|SNAME, TUWORD|TPOINT,
254 SHLL, TLL,
255 NCSL|NCREG, RESC1,
256 " movl AL,A1\n xorl U1,U1\n", },
257
258/* convert int (in memory) to double */
259{ SCONV, INFL,
260 SOREG|SNAME, TWORD,
261 SHFL, TLDOUBLE|TDOUBLE|TFLOAT,
262 NDREG, RESC1,
263 " fildl AL\n", },
264
265/* convert int (in register) to double */
266{ SCONV, INFL,
267 SAREG, TWORD,
268 SHFL, TLDOUBLE|TDOUBLE|TFLOAT,
269 NTEMP|NDREG, RESC1,
270 " pushl AL\n fildl (%esp)\n addl $4,%esp\n", },
271
272/* long long to something */
273
274/* convert (u)long long to (u)char (mem->reg) */
275{ SCONV, INCH,
276 SOREG|SNAME, TLL,
277 SANY, TCHAR|TUCHAR,
278 NBREG|NBSL, RESC1,
279 " movb AL,A1\n", },
280
281/* convert (u)long long to (u)char (reg->reg, hopefully nothing) */
282{ SCONV, INCH,
283 SHLL, TLL,
284 SANY, TCHAR|TUCHAR,
285 NBREG|NBSL, RESC1,
286 "ZS", },
287
288/* convert (u)long long to (u)short (mem->reg) */
289{ SCONV, INAREG,
290 SOREG|SNAME, TLL,
291 SAREG, TSHORT|TUSHORT,
292 NAREG|NASL, RESC1,
293 " movw AL,A1\n", },
294
295/* convert (u)long long to (u)short (reg->reg, hopefully nothing) */
296{ SCONV, INAREG,
297 SHLL|SOREG|SNAME, TLL,
298 SAREG, TSHORT|TUSHORT,
299 NAREG|NASL, RESC1,
300 "ZS", },
301
302/* convert long long to int (mem->reg) */
303{ SCONV, INAREG,
304 SOREG|SNAME, TLL,
305 SAREG, TWORD|TPOINT,
306 NAREG|NASL, RESC1,
307 " movl AL,A1\n", },
308
309/* convert long long to int (reg->reg, hopefully nothing) */
310{ SCONV, INAREG,
311 SHLL|SOREG|SNAME, TLL,
312 SAREG, TWORD|TPOINT,
313 NAREG|NASL, RESC1,
314 "ZS", },
315
316/* convert long long (in memory) to floating */
317{ SCONV, INFL,
318 SOREG|SNAME, TLONGLONG,
319 SHFL, TLDOUBLE|TDOUBLE|TFLOAT,
320 NDREG, RESC1,
321 " fildq AL\n", },
322
323/* convert long long (in register) to floating */
324{ SCONV, INFL,
325 SHLL, TLONGLONG,
326 SHFL, TLDOUBLE|TDOUBLE|TFLOAT,
327 NTEMP|NDREG, RESC1,
328 " pushl UL\n pushl AL\n"
329 " fildq (%esp)\n addl $8,%esp\n", },
330
331/* convert unsigned long long to floating */
332{ SCONV, INFL,
333 SCREG, TULONGLONG,
334 SDREG, TLDOUBLE|TDOUBLE|TFLOAT,
335 NDREG, RESC1,
336 "ZJ", },
337
338/* float to something */
339
340#if 0 /* go via int by adding an extra sconv in clocal() */
341/* convert float/double to (u) char. XXX should use NTEMP here */
342{ SCONV, INCH,
343 SHFL, TLDOUBLE|TDOUBLE|TFLOAT,
344 SHCH, TWORD|TSHORT|TUSHORT|TCHAR|TUCHAR,
345 NBREG, RESC1,
346 " subl $4,%esp\n fistpl (%esp)\n popl A1\n", },
347
348/* convert float/double to (u) int/short/char. XXX should use NTEMP here */
349{ SCONV, INCH,
350 SHFL, TLDOUBLE|TDOUBLE|TFLOAT,
351 SHCH, TWORD|TSHORT|TUSHORT|TCHAR|TUCHAR,
352 NCREG, RESC1,
353 " subl $4,%esp\n fistpl (%esp)\n popl A1\n", },
354#endif
355
356/* convert float/double to (u)int. XXX should use NTEMP here */
357{ SCONV, INAREG,
358 SHFL, TLDOUBLE|TDOUBLE|TFLOAT,
359 SAREG, TWORD,
360 NAREG, RESC1,
361#ifdef notdef /* Must round down and nothing else */
362 " subl $4,%esp\n fistpl (%esp)\n popl A1\n", },
363#else
364 " subl $12,%esp\n"
365 " fnstcw (%esp)\n"
366 " fnstcw 4(%esp)\n"
367 " movb $12,1(%esp)\n"
368 " fldcw (%esp)\n"
369 " fistpl 8(%esp)\n"
370 " movl 8(%esp),A1\n"
371 " fldcw 4(%esp)\n"
372 " addl $12,%esp\n", },
373#endif
374
375/* convert float/double (in register) to (unsigned) long long */
376/* XXX - unsigned is not handled correct */
377{ SCONV, INLL,
378 SHFL, TLDOUBLE|TDOUBLE|TFLOAT,
379 SHLL, TLONGLONG|TULONGLONG,
380 NCREG, RESC1,
381#ifdef notdef /* Must round down and nothing else */
382 " subl $8,%esp\n fistpq (%esp)\n"
383 " popl A1\n popl U1\n", },
384#else
385 " subl $16,%esp\n"
386 " fnstcw (%esp)\n"
387 " fnstcw 4(%esp)\n"
388 " movb $12,1(%esp)\n"
389 " fldcw (%esp)\n"
390 " fistpq 8(%esp)\n"
391 " movl 8(%esp),A1\n"
392 " movl 12(%esp),U1\n"
393 " fldcw 4(%esp)\n"
394 " addl $16,%esp\n", },
395#endif
396
397/* slut sconv */
398
399/*
400 * Subroutine calls.
401 */
402
403{ UCALL, FOREFF,
404 SCON, TANY,
405 SANY, TANY,
406 0, 0,
407 " call CL\nZC", },
408
409{ CALL, FOREFF,
410 SCON, TANY,
411 SANY, TANY,
412 0, 0,
413 " call CL\nZC", },
414
415{ UCALL, FOREFF,
416 SCON, TANY,
417 SAREG, TWORD|TPOINT,
418 0, 0,
419 " call CL\nZC", },
420
421{ CALL, INAREG,
422 SCON, TANY,
423 SAREG, TSHORT|TUSHORT|TWORD|TPOINT,
424 NAREG|NASL, RESC1, /* should be 0 */
425 " call CL\nZC", },
426
427{ UCALL, INAREG,
428 SCON, TANY,
429 SAREG, TSHORT|TUSHORT|TWORD|TPOINT,
430 NAREG|NASL, RESC1, /* should be 0 */
431 " call CL\nZC", },
432
433{ CALL, INBREG,
434 SCON, TANY,
435 SBREG, TCHAR|TUCHAR,
436 NBREG, RESC1, /* should be 0 */
437 " call CL\nZC", },
438
439{ UCALL, INBREG,
440 SCON, TANY,
441 SBREG, TCHAR|TUCHAR,
442 NBREG, RESC1, /* should be 0 */
443 " call CL\nZC", },
444
445{ CALL, INCREG,
446 SCON, TANY,
447 SCREG, TANY,
448 NCREG|NCSL, RESC1, /* should be 0 */
449 " call CL\nZC", },
450
451{ UCALL, INCREG,
452 SCON, TANY,
453 SCREG, TANY,
454 NCREG|NCSL, RESC1, /* should be 0 */
455 " call CL\nZC", },
456
457{ CALL, INDREG,
458 SCON, TANY,
459 SDREG, TANY,
460 NDREG|NDSL, RESC1, /* should be 0 */
461 " call CL\nZC", },
462
463{ UCALL, INDREG,
464 SCON, TANY,
465 SDREG, TANY,
466 NDREG|NDSL, RESC1, /* should be 0 */
467 " call CL\nZC", },
468
469{ CALL, FOREFF,
470 SAREG, TANY,
471 SANY, TANY,
472 0, 0,
473 " call *AL\nZC", },
474
475{ UCALL, FOREFF,
476 SAREG, TANY,
477 SANY, TANY,
478 0, 0,
479 " call *AL\nZC", },
480
481{ CALL, INAREG,
482 SAREG, TANY,
483 SANY, TANY,
484 NAREG|NASL, RESC1, /* should be 0 */
485 " call *AL\nZC", },
486
487{ UCALL, INAREG,
488 SAREG, TANY,
489 SANY, TANY,
490 NAREG|NASL, RESC1, /* should be 0 */
491 " call *AL\nZC", },
492
493{ CALL, INBREG,
494 SAREG, TANY,
495 SANY, TANY,
496 NBREG|NBSL, RESC1, /* should be 0 */
497 " call *AL\nZC", },
498
499{ UCALL, INBREG,
500 SAREG, TANY,
501 SANY, TANY,
502 NBREG|NBSL, RESC1, /* should be 0 */
503 " call *AL\nZC", },
504
505{ CALL, INCREG,
506 SAREG, TANY,
507 SANY, TANY,
508 NCREG|NCSL, RESC1, /* should be 0 */
509 " call *AL\nZC", },
510
511{ UCALL, INCREG,
512 SAREG, TANY,
513 SANY, TANY,
514 NCREG|NCSL, RESC1, /* should be 0 */
515 " call *AL\nZC", },
516
517{ CALL, INDREG,
518 SAREG, TANY,
519 SANY, TANY,
520 NDREG|NDSL, RESC1, /* should be 0 */
521 " call *AL\nZC", },
522
523{ UCALL, INDREG,
524 SAREG, TANY,
525 SANY, TANY,
526 NDREG|NDSL, RESC1, /* should be 0 */
527 " call *AL\nZC", },
528
529/* struct return */
530{ USTCALL, FOREFF,
531 SCON, TANY,
532 SANY, TANY,
533 NAREG|NASL, 0,
534 "ZP call CL\nZC", },
535
536{ USTCALL, INAREG,
537 SCON, TANY,
538 SANY, TANY,
539 NAREG|NASL, RESC1, /* should be 0 */
540 "ZP call CL\nZC", },
541
542{ USTCALL, INAREG,
543 SNAME|SAREG, TANY,
544 SANY, TANY,
545 NAREG|NASL, RESC1, /* should be 0 */
546 "ZP call *AL\nZC", },
547
548{ STCALL, FOREFF,
549 SCON, TANY,
550 SANY, TANY,
551 NAREG|NASL, 0,
552 "ZP call CL\nZC", },
553
554{ STCALL, INAREG,
555 SCON, TANY,
556 SANY, TANY,
557 NAREG|NASL, RESC1, /* should be 0 */
558 "ZP call CL\nZC", },
559
560{ STCALL, INAREG,
561 SNAME|SAREG, TANY,
562 SANY, TANY,
563 NAREG|NASL, RESC1, /* should be 0 */
564 "ZP call *AL\nZC", },
565
566/*
567 * The next rules handle all binop-style operators.
568 */
569/* Special treatment for long long */
570{ PLUS, INLL|FOREFF,
571 SHLL, TLL,
572 SHLL|SNAME|SOREG, TLL,
573 0, RLEFT,
574 " addl AR,AL\n adcl UR,UL\n", },
575
576{ PLUS, INLL|FOREFF,
577 SHLL|SNAME|SOREG, TLL,
578 SHLL|SCON, TLL,
579 0, RLEFT,
580 " addl AR,AL\n adcl UR,UL\n", },
581
582/* Special treatment for long long XXX - fix commutative check */
583{ PLUS, INLL|FOREFF,
584 SHLL|SNAME|SOREG, TLL,
585 SHLL, TLL,
586 0, RRIGHT,
587 " addl AL,AR\n adcl UL,UR\n", },
588
589{ PLUS, INFL,
590 SHFL, TDOUBLE,
591 SNAME|SOREG, TDOUBLE,
592 0, RLEFT,
593 " faddl AR\n", },
594
595{ PLUS, INFL|FOREFF,
596 SHFL, TLDOUBLE|TDOUBLE|TFLOAT,
597 SHFL, TLDOUBLE|TDOUBLE|TFLOAT,
598 0, RLEFT,
599 " faddp\n", },
600
601{ PLUS, INAREG|FOREFF,
602 SAREG|SNAME|SOREG, TWORD|TPOINT,
603 SONE, TANY,
604 0, RLEFT,
605 " incl AL\n", },
606
607{ PLUS, INAREG|FOREFF,
608 SAREG|SNAME|SOREG, TSHORT|TUSHORT,
609 SONE, TANY,
610 0, RLEFT,
611 " incw AL\n", },
612
613{ PLUS, INCH|FOREFF,
614 SHCH|SNAME|SOREG, TCHAR|TUCHAR,
615 SONE, TANY,
616 0, RLEFT,
617 " incb AL\n", },
618
619{ PLUS, INAREG,
620 SAREG, TWORD,
621 SAREG, TWORD,
622 NAREG|NASL|NASR, RESC1,
623 " leal (AL,AR),A1\n", },
624
625{ MINUS, INAREG|FOREFF,
626 SAREG|SNAME|SOREG, TWORD|TPOINT,
627 SONE, TANY,
628 0, RLEFT,
629 " decl AL\n", },
630
631{ MINUS, INAREG|FOREFF,
632 SAREG|SNAME|SOREG, TSHORT|TUSHORT,
633 SONE, TANY,
634 0, RLEFT,
635 " decw AL\n", },
636
637{ MINUS, INCH|FOREFF,
638 SHCH|SNAME|SOREG, TCHAR|TUCHAR,
639 SONE, TANY,
640 0, RLEFT,
641 " decb AL\n", },
642
643/* address as register offset, negative */
644{ MINUS, INLL|FOREFF,
645 SHLL, TLL,
646 SHLL|SNAME|SOREG, TLL,
647 0, RLEFT,
648 " subl AR,AL\n sbbl UR,UL\n", },
649
650{ MINUS, INLL|FOREFF,
651 SHLL|SNAME|SOREG, TLL,
652 SHLL|SCON, TLL,
653 0, RLEFT,
654 " subl AR,AL\n sbbl UR,UL\n", },
655
656{ MINUS, INFL,
657 SHFL, TDOUBLE,
658 SNAME|SOREG, TDOUBLE,
659 0, RLEFT,
660 " fsubl AR\n", },
661
662{ MINUS, INFL|FOREFF,
663 SHFL, TLDOUBLE|TDOUBLE|TFLOAT,
664 SHFL, TLDOUBLE|TDOUBLE|TFLOAT,
665 0, RLEFT,
666 " fsubZAp\n", },
667
668/* Simple r/m->reg ops */
669/* m/r |= r */
670{ OPSIMP, INAREG|FOREFF|FORCC,
671 SAREG|SNAME|SOREG, TWORD|TPOINT,
672 SAREG, TWORD|TPOINT,
673 0, RLEFT|RESCC,
674 " Ol AR,AL\n", },
675
676/* r |= r/m */
677{ OPSIMP, INAREG|FOREFF|FORCC,
678 SAREG, TWORD|TPOINT,
679 SAREG|SNAME|SOREG, TWORD|TPOINT,
680 0, RLEFT|RESCC,
681 " Ol AR,AL\n", },
682
683/* m/r |= r */
684{ OPSIMP, INAREG|FOREFF|FORCC,
685 SHINT|SNAME|SOREG, TSHORT|TUSHORT,
686 SHINT, TSHORT|TUSHORT,
687 0, RLEFT|RESCC,
688 " Ow AR,AL\n", },
689
690/* r |= r/m */
691{ OPSIMP, INAREG|FOREFF|FORCC,
692 SHINT, TSHORT|TUSHORT,
693 SHINT|SNAME|SOREG, TSHORT|TUSHORT,
694 0, RLEFT|RESCC,
695 " Ow AR,AL\n", },
696
697/* m/r |= r */
698{ OPSIMP, INCH|FOREFF|FORCC,
699 SHCH, TCHAR|TUCHAR,
700 SHCH|SNAME|SOREG, TCHAR|TUCHAR,
701 0, RLEFT|RESCC,
702 " Ob AR,AL\n", },
703
704/* r |= r/m */
705{ OPSIMP, INCH|FOREFF|FORCC,
706 SHCH, TCHAR|TUCHAR,
707 SHCH|SNAME|SOREG, TCHAR|TUCHAR,
708 0, RLEFT|RESCC,
709 " Ob AR,AL\n", },
710
711/* m/r |= const */
712{ OPSIMP, INAREG|FOREFF|FORCC,
713 SAREG|SNAME|SOREG, TWORD|TPOINT,
714 SCON, TWORD|TPOINT,
715 0, RLEFT|RESCC,
716 " Ol AR,AL\n", },
717
718{ OPSIMP, INAREG|FOREFF|FORCC,
719 SHINT|SNAME|SOREG, TSHORT|TUSHORT,
720 SCON, TANY,
721 0, RLEFT|RESCC,
722 " Ow AR,AL\n", },
723
724{ OPSIMP, INCH|FOREFF|FORCC,
725 SHCH|SNAME|SOREG, TCHAR|TUCHAR,
726 SCON, TANY,
727 0, RLEFT|RESCC,
728 " Ob AR,AL\n", },
729
730/* r |= r/m */
731{ OPSIMP, INLL|FOREFF,
732 SHLL, TLL,
733 SHLL|SNAME|SOREG, TLL,
734 0, RLEFT,
735 " Ol AR,AL\n Ol UR,UL\n", },
736
737/* m/r |= r/const */
738{ OPSIMP, INLL|FOREFF,
739 SHLL|SNAME|SOREG, TLL,
740 SHLL|SCON, TLL,
741 0, RLEFT,
742 " Ol AR,AL\n Ol UR,UL\n", },
743
744/* Try use-reg instructions first */
745{ PLUS, INAREG,
746 SAREG, TWORD|TPOINT,
747 SCON, TANY,
748 NAREG|NASL, RESC1,
749 " leal CR(AL),A1\n", },
750
751{ MINUS, INAREG,
752 SAREG, TWORD|TPOINT,
753 SPCON, TANY,
754 NAREG|NASL, RESC1,
755 " leal -CR(AL),A1\n", },
756
757
758/*
759 * The next rules handle all shift operators.
760 */
761/* (u)longlong left shift is emulated */
762{ LS, INCREG,
763 SCREG, TLL,
764 SHCH, TCHAR|TUCHAR,
765 NSPECIAL, RLEFT,
766 "ZO", },
767
768/* r/m <<= r */
769{ LS, INAREG|FOREFF,
770 SAREG|SNAME|SOREG, TWORD,
771 SHCH, TCHAR|TUCHAR,
772 NSPECIAL, RLEFT,
773 " sall AR,AL\n", },
774
775/* r/m <<= const */
776{ LS, INAREG|FOREFF,
777 SAREG|SNAME|SOREG, TWORD,
778 SCON, TANY,
779 0, RLEFT,
780 " sall AR,AL\n", },
781
782/* r/m <<= r */
783{ LS, INAREG|FOREFF,
784 SAREG|SNAME|SOREG, TSHORT|TUSHORT,
785 SHCH, TCHAR|TUCHAR,
786 NSPECIAL, RLEFT,
787 " shlw AR,AL\n", },
788
789/* r/m <<= const */
790{ LS, INAREG|FOREFF,
791 SAREG|SNAME|SOREG, TSHORT|TUSHORT,
792 SCON, TANY,
793 0, RLEFT,
794 " shlw AR,AL\n", },
795
796{ LS, INCH|FOREFF,
797 SHCH|SNAME|SOREG, TCHAR|TUCHAR,
798 SHCH, TCHAR|TUCHAR,
799 NSPECIAL, RLEFT,
800 " salb AR,AL\n", },
801
802{ LS, INCH|FOREFF,
803 SHCH|SNAME|SOREG, TCHAR|TUCHAR,
804 SCON, TANY,
805 0, RLEFT,
806 " salb AR,AL\n", },
807
808/* (u)longlong right shift is emulated */
809{ RS, INCREG,
810 SCREG, TLL,
811 SHCH, TCHAR|TUCHAR,
812 NSPECIAL, RLEFT,
813 "ZO", },
814
815{ RS, INAREG|FOREFF,
816 SAREG|SNAME|SOREG, TSWORD,
817 SHCH, TCHAR|TUCHAR,
818 NSPECIAL, RLEFT,
819 " sarl AR,AL\n", },
820
821{ RS, INAREG|FOREFF,
822 SAREG|SNAME|SOREG, TSWORD,
823 SCON, TANY,
824 0, RLEFT,
825 " sarl AR,AL\n", },
826
827{ RS, INAREG|FOREFF,
828 SAREG|SNAME|SOREG, TUWORD,
829 SHCH, TCHAR|TUCHAR,
830 NSPECIAL, RLEFT,
831 " shrl AR,AL\n", },
832
833{ RS, INAREG|FOREFF,
834 SAREG|SNAME|SOREG, TUWORD,
835 SCON, TANY,
836 0, RLEFT,
837 " shrl AR,AL\n", },
838
839{ RS, INAREG|FOREFF,
840 SAREG|SNAME|SOREG, TSHORT,
841 SHCH, TCHAR|TUCHAR,
842 NSPECIAL, RLEFT,
843 " sarw AR,AL\n", },
844
845{ RS, INAREG|FOREFF,
846 SAREG|SNAME|SOREG, TSHORT,
847 SCON, TANY,
848 0, RLEFT,
849 " sarw AR,AL\n", },
850
851{ RS, INAREG|FOREFF,
852 SAREG|SNAME|SOREG, TUSHORT,
853 SHCH, TCHAR|TUCHAR,
854 NSPECIAL, RLEFT,
855 " shrw AR,AL\n", },
856
857{ RS, INAREG|FOREFF,
858 SAREG|SNAME|SOREG, TUSHORT,
859 SCON, TANY,
860 0, RLEFT,
861 " shrw AR,AL\n", },
862
863{ RS, INCH|FOREFF,
864 SHCH|SNAME|SOREG, TCHAR,
865 SHCH, TCHAR|TUCHAR,
866 NSPECIAL, RLEFT,
867 " sarb AR,AL\n", },
868
869{ RS, INCH|FOREFF,
870 SHCH|SNAME|SOREG, TCHAR,
871 SCON, TANY,
872 0, RLEFT,
873 " sarb AR,AL\n", },
874
875{ RS, INCH|FOREFF,
876 SHCH|SNAME|SOREG, TUCHAR,
877 SHCH, TCHAR|TUCHAR,
878 NSPECIAL, RLEFT,
879 " shrb AR,AL\n", },
880
881{ RS, INCH|FOREFF,
882 SHCH|SNAME|SOREG, TUCHAR,
883 SCON, TANY,
884 0, RLEFT,
885 " shrb AR,AL\n", },
886
887/*
888 * The next rules takes care of assignments. "=".
889 */
890{ ASSIGN, FORCC|FOREFF|INLL,
891 SHLL, TLL,
892 SMIXOR, TANY,
893 0, RDEST,
894 " xorl AL,AL\n xorl UL,UL\n", },
895
896{ ASSIGN, FORCC|FOREFF|INLL,
897 SHLL, TLL,
898 SMILWXOR, TANY,
899 0, RDEST,
900 " xorl AL,AL\n movl UR,UL\n", },
901
902{ ASSIGN, FORCC|FOREFF|INLL,
903 SHLL, TLL,
904 SMIHWXOR, TANY,
905 0, RDEST,
906 " movl AR,AL\n xorl UL,UL\n", },
907
908{ ASSIGN, FOREFF|INLL,
909 SHLL, TLL,
910 SCON, TANY,
911 0, RDEST,
912 " movl AR,AL\n movl UR,UL\n", },
913
914{ ASSIGN, FOREFF,
915 SHLL|SNAME|SOREG, TLL,
916 SCON, TANY,
917 0, 0,
918 " movl AR,AL\n movl UR,UL\n", },
919
920{ ASSIGN, FORCC|FOREFF|INAREG,
921 SAREG, TWORD|TPOINT,
922 SMIXOR, TANY,
923 0, RDEST,
924 " xorl AL,AL\n", },
925
926{ ASSIGN, FOREFF,
927 SAREG|SNAME|SOREG, TWORD|TPOINT,
928 SCON, TANY,
929 0, 0,
930 " movl AR,AL\n", },
931
932{ ASSIGN, FOREFF|INAREG,
933 SAREG, TWORD|TPOINT,
934 SCON, TANY,
935 0, RDEST,
936 " movl AR,AL\n", },
937
938{ ASSIGN, FORCC|FOREFF|INAREG,
939 SAREG, TSHORT|TUSHORT,
940 SMIXOR, TANY,
941 0, RDEST,
942 " xorw AL,AL\n", },
943
944{ ASSIGN, FOREFF,
945 SAREG|SNAME|SOREG, TSHORT|TUSHORT,
946 SCON, TANY,
947 0, 0,
948 " movw AR,AL\n", },
949
950{ ASSIGN, FOREFF|INAREG,
951 SAREG, TSHORT|TUSHORT,
952 SCON, TANY,
953 0, RDEST,
954 " movw AR,AL\n", },
955
956{ ASSIGN, FOREFF,
957 SHCH|SNAME|SOREG, TCHAR|TUCHAR,
958 SCON, TANY,
959 0, 0,
960 " movb AR,AL\n", },
961
962{ ASSIGN, FOREFF|INCH,
963 SHCH, TCHAR|TUCHAR,
964 SCON, TANY,
965 0, RDEST,
966 " movb AR,AL\n", },
967
968{ ASSIGN, FOREFF|INLL,
969 SNAME|SOREG, TLL,
970 SHLL, TLL,
971 0, RDEST,
972 " movl AR,AL\n movl UR,UL\n", },
973
974{ ASSIGN, FOREFF|INLL,
975 SHLL, TLL,
976 SHLL, TLL,
977 0, RDEST,
978 "ZH", },
979
980{ ASSIGN, FOREFF|INAREG,
981 SAREG|SNAME|SOREG, TWORD|TPOINT,
982 SAREG, TWORD|TPOINT,
983 0, RDEST,
984 " movl AR,AL\n", },
985
986{ ASSIGN, FOREFF|INAREG,
987 SAREG, TWORD|TPOINT,
988 SAREG|SNAME|SOREG, TWORD|TPOINT,
989 0, RDEST,
990 " movl AR,AL\n", },
991
992{ ASSIGN, FOREFF|INAREG,
993 SAREG|SNAME|SOREG, TSHORT|TUSHORT,
994 SAREG, TSHORT|TUSHORT,
995 0, RDEST,
996 " movw AR,AL\n", },
997
998{ ASSIGN, FOREFF|INCH,
999 SHCH|SNAME|SOREG, TCHAR|TUCHAR,
1000 SHCH, TCHAR|TUCHAR|TWORD,
1001 0, RDEST,
1002 " movb AR,AL\n", },
1003
1004{ ASSIGN, FOREFF|INBREG,
1005 SFLD, TCHAR|TUCHAR,
1006 SBREG|SCON, TCHAR|TUCHAR,
1007 NAREG|NBREG, RDEST,
1008 " movb AR,A2\n"
1009 " movzbl A2,A1\n"
1010 " andl $N,AL\n"
1011 " sall $H,A1\n"
1012 " andl $M,A1\n"
1013 " orl A1,AL\n"
1014 "F movb AR,AD\n"
1015 "FZE", },
1016
1017{ ASSIGN, FOREFF|INAREG,
1018 SFLD, TSHORT|TUSHORT,
1019 SAREG|SCON, TSHORT|TUSHORT,
1020 NAREG, RDEST,
1021 " movw AR,A1\n"
1022 " movzwl A1,ZN\n"
1023 " andl $N,AL\n"
1024 " sall $H,ZN\n"
1025 " andl $M,ZN\n"
1026 " orl ZN,AL\n"
1027 "F movw AR,AD\n"
1028 "FZE", },
1029
1030{ ASSIGN, FOREFF|INAREG,
1031 SFLD, TWORD,
1032 SAREG|SNAME|SOREG|SCON, TWORD,
1033 NAREG, RDEST,
1034 " movl AR,A1\n"
1035 " andl $N,AL\n"
1036 " sall $H,A1\n"
1037 " andl $M,A1\n"
1038 " orl A1,AL\n"
1039 "ZB"
1040 "F movl AR,AD\n"
1041 "FZE", },
1042
1043
1044{ ASSIGN, FOREFF|INCREG,
1045 SFLD, TLL,
1046 SCREG, TLL,
1047 NCREG, RDEST,
1048 "ZL", },
1049
1050
1051{ ASSIGN, INDREG|FOREFF,
1052 SHFL, TFLOAT|TDOUBLE|TLDOUBLE,
1053 SHFL, TFLOAT|TDOUBLE|TLDOUBLE,
1054 0, RDEST,
1055 "", }, /* This will always be in the correct register */
1056
1057/* order of table entries is very important here! */
1058{ ASSIGN, INFL,
1059 SNAME|SOREG, TLDOUBLE,
1060 SHFL, TFLOAT|TDOUBLE|TLDOUBLE,
1061 0, RDEST,
1062 " fstpt AL\n fldt AL\n", }, /* XXX */
1063
1064{ ASSIGN, FOREFF,
1065 SNAME|SOREG, TLDOUBLE,
1066 SHFL, TFLOAT|TDOUBLE|TLDOUBLE,
1067 0, 0,
1068 " fstpt AL\n", },
1069
1070{ ASSIGN, INFL,
1071 SNAME|SOREG, TDOUBLE,
1072 SHFL, TFLOAT|TDOUBLE|TLDOUBLE,
1073 0, RDEST,
1074 " fstl AL\n", },
1075
1076{ ASSIGN, FOREFF,
1077 SNAME|SOREG, TDOUBLE,
1078 SHFL, TFLOAT|TDOUBLE|TLDOUBLE,
1079 0, 0,
1080 " fstpl AL\n", },
1081
1082{ ASSIGN, INFL,
1083 SNAME|SOREG, TFLOAT,
1084 SHFL, TFLOAT|TDOUBLE|TLDOUBLE,
1085 0, RDEST,
1086 " fsts AL\n", },
1087
1088{ ASSIGN, FOREFF,
1089 SNAME|SOREG, TFLOAT,
1090 SHFL, TFLOAT|TDOUBLE|TLDOUBLE,
1091 0, 0,
1092 " fstps AL\n", },
1093/* end very important order */
1094
1095{ ASSIGN, INFL|FOREFF,
1096 SHFL, TLDOUBLE,
1097 SHFL|SOREG|SNAME, TLDOUBLE,
1098 0, RDEST,
1099 " fldt AR\n", },
1100
1101{ ASSIGN, INFL|FOREFF,
1102 SHFL, TDOUBLE,
1103 SHFL|SOREG|SNAME, TDOUBLE,
1104 0, RDEST,
1105 " fldl AR\n", },
1106
1107{ ASSIGN, INFL|FOREFF,
1108 SHFL, TFLOAT,
1109 SHFL|SOREG|SNAME, TFLOAT,
1110 0, RDEST,
1111 " flds AR\n", },
1112
1113/* Do not generate memcpy if return from funcall */
1114#if 0
1115{ STASG, INAREG|FOREFF,
1116 SOREG|SNAME|SAREG, TPTRTO|TSTRUCT,
1117 SFUNCALL, TPTRTO|TSTRUCT,
1118 0, RRIGHT,
1119 "", },
1120#endif
1121
1122{ STASG, INAREG|FOREFF,
1123 SOREG|SNAME, TANY,
1124 SAREG, TPTRTO|TANY,
1125 NSPECIAL, RDEST,
1126 "ZQ", },
1127
1128/*
1129 * DIV/MOD/MUL
1130 */
1131/* long long div is emulated */
1132{ DIV, INCREG,
1133 SCREG|SNAME|SOREG|SCON, TLL,
1134 SCREG|SNAME|SOREG|SCON, TLL,
1135 NSPECIAL|NCREG|NCSL|NCSR, RESC1,
1136 "ZO", },
1137
1138{ DIV, INAREG,
1139 SAREG, TSWORD,
1140 SAREG|SNAME|SOREG, TWORD,
1141 NSPECIAL, RDEST,
1142 " cltd\n idivl AR\n", },
1143
1144{ DIV, INAREG,
1145 SAREG, TUWORD|TPOINT,
1146 SAREG|SNAME|SOREG, TUWORD|TPOINT,
1147 NSPECIAL, RDEST,
1148 " xorl %edx,%edx\n divl AR\n", },
1149
1150{ DIV, INAREG,
1151 SAREG, TUSHORT,
1152 SAREG|SNAME|SOREG, TUSHORT,
1153 NSPECIAL, RDEST,
1154 " xorl %edx,%edx\n divw AR\n", },
1155
1156{ DIV, INCH,
1157 SHCH, TUCHAR,
1158 SHCH|SNAME|SOREG, TUCHAR,
1159 NSPECIAL, RDEST,
1160 " xorb %ah,%ah\n divb AR\n", },
1161
1162{ DIV, INFL,
1163 SHFL, TDOUBLE,
1164 SNAME|SOREG, TDOUBLE,
1165 0, RLEFT,
1166 " fdivl AR\n", },
1167
1168{ DIV, INFL,
1169 SHFL, TLDOUBLE|TDOUBLE|TFLOAT,
1170 SHFL, TLDOUBLE|TDOUBLE|TFLOAT,
1171 0, RLEFT,
1172 " fdivZAp\n", },
1173
1174/* (u)longlong mod is emulated */
1175{ MOD, INCREG,
1176 SCREG|SNAME|SOREG|SCON, TLL,
1177 SCREG|SNAME|SOREG|SCON, TLL,
1178 NSPECIAL|NCREG|NCSL|NCSR, RESC1,
1179 "ZO", },
1180
1181{ MOD, INAREG,
1182 SAREG, TSWORD,
1183 SAREG|SNAME|SOREG, TSWORD,
1184 NAREG|NSPECIAL, RESC1,
1185 " cltd\n idivl AR\n", },
1186
1187{ MOD, INAREG,
1188 SAREG, TWORD|TPOINT,
1189 SAREG|SNAME|SOREG, TUWORD|TPOINT,
1190 NAREG|NSPECIAL, RESC1,
1191 " xorl %edx,%edx\n divl AR\n", },
1192
1193{ MOD, INAREG,
1194 SAREG, TUSHORT,
1195 SAREG|SNAME|SOREG, TUSHORT,
1196 NAREG|NSPECIAL, RESC1,
1197 " xorl %edx,%edx\n divw AR\n", },
1198
1199{ MOD, INCH,
1200 SHCH, TUCHAR,
1201 SHCH|SNAME|SOREG, TUCHAR,
1202 NBREG|NSPECIAL, RESC1,
1203 " xorb %ah,%ah\n divb AR\n", },
1204
1205/* (u)longlong mul is emulated */
1206{ MUL, INCREG,
1207 SCREG, TLL,
1208 SCREG, TLL,
1209 NSPECIAL, RLEFT,
1210 "ZO", },
1211
1212{ MUL, INAREG,
1213 SAREG, TWORD|TPOINT,
1214 SAREG|SNAME|SOREG|SCON, TWORD|TPOINT,
1215 0, RLEFT,
1216 " imull AR,AL\n", },
1217
1218{ MUL, INAREG,
1219 SAREG, TSHORT|TUSHORT,
1220 SAREG|SNAME|SOREG, TSHORT|TUSHORT,
1221 0, RLEFT,
1222 " imulw AR,AL\n", },
1223
1224{ MUL, INCH,
1225 SHCH, TCHAR|TUCHAR,
1226 SHCH|SNAME|SOREG, TCHAR|TUCHAR,
1227 NSPECIAL, RDEST,
1228 " imulb AR\n", },
1229
1230{ MUL, INFL,
1231 SHFL, TDOUBLE,
1232 SNAME|SOREG, TDOUBLE,
1233 0, RLEFT,
1234 " fmull AR\n", },
1235
1236{ MUL, INFL,
1237 SHFL, TLDOUBLE|TDOUBLE|TFLOAT,
1238 SHFL, TLDOUBLE|TDOUBLE|TFLOAT,
1239 0, RLEFT,
1240 " fmulp\n", },
1241
1242/*
1243 * Indirection operators.
1244 */
1245{ UMUL, INLL,
1246 SANY, TANY,
1247 SOREG, TLL,
1248 NCREG, RESC1,
1249 " movl UL,U1\n movl AL,A1\n", },
1250
1251{ UMUL, INAREG,
1252 SANY, TPOINT|TWORD,
1253 SOREG, TPOINT|TWORD,
1254 NAREG|NASL, RESC1,
1255 " movl AL,A1\n", },
1256
1257{ UMUL, INCH,
1258 SANY, TANY,
1259 SOREG, TCHAR|TUCHAR,
1260 NBREG|NBSL, RESC1,
1261 " movb AL,A1\n", },
1262
1263{ UMUL, INAREG,
1264 SANY, TANY,
1265 SOREG, TSHORT|TUSHORT,
1266 NAREG|NASL, RESC1,
1267 " movw AL,A1\n", },
1268
1269{ UMUL, INFL,
1270 SANY, TANY,
1271 SOREG, TLDOUBLE,
1272 NDREG|NDSL, RESC1,
1273 " fldt AL\n", },
1274
1275{ UMUL, INFL,
1276 SANY, TANY,
1277 SOREG, TDOUBLE,
1278 NDREG|NDSL, RESC1,
1279 " fldl AL\n", },
1280
1281{ UMUL, INFL,
1282 SANY, TANY,
1283 SOREG, TFLOAT,
1284 NDREG|NDSL, RESC1,
1285 " flds AL\n", },
1286
1287/*
1288 * Logical/branching operators
1289 */
1290
1291/* Comparisions, take care of everything */
1292{ OPLOG, FORCC,
1293 SHLL|SOREG|SNAME, TLL,
1294 SHLL, TLL,
1295 0, 0,
1296 "ZD", },
1297
1298{ OPLOG, FORCC,
1299 SAREG|SOREG|SNAME, TWORD|TPOINT,
1300 SCON|SAREG, TWORD|TPOINT,
1301 0, RESCC,
1302 " cmpl AR,AL\n", },
1303
1304{ OPLOG, FORCC,
1305 SCON|SAREG, TWORD|TPOINT,
1306 SAREG|SOREG|SNAME, TWORD|TPOINT,
1307 0, RESCC,
1308 " cmpl AR,AL\n", },
1309
1310{ OPLOG, FORCC,
1311 SAREG|SOREG|SNAME, TSHORT|TUSHORT,
1312 SCON|SAREG, TANY,
1313 0, RESCC,
1314 " cmpw AR,AL\n", },
1315
1316{ OPLOG, FORCC,
1317 SBREG|SOREG|SNAME, TCHAR|TUCHAR,
1318 SCON|SBREG, TANY,
1319 0, RESCC,
1320 " cmpb AR,AL\n", },
1321
1322{ OPLOG, FORCC,
1323 SDREG, TLDOUBLE|TDOUBLE|TFLOAT,
1324 SDREG, TLDOUBLE|TDOUBLE|TFLOAT,
1325 0, RNOP,
1326 "ZG", },
1327
1328{ OPLOG, FORCC,
1329 SANY, TANY,
1330 SANY, TANY,
1331 REWRITE, 0,
1332 "diediedie!", },
1333
1334/* AND/OR/ER/NOT */
1335{ AND, INAREG|FOREFF,
1336 SAREG|SOREG|SNAME, TWORD,
1337 SCON|SAREG, TWORD,
1338 0, RLEFT,
1339 " andl AR,AL\n", },
1340
1341{ AND, INCREG|FOREFF,
1342 SCREG, TLL,
1343 SCREG|SOREG|SNAME, TLL,
1344 0, RLEFT,
1345 " andl AR,AL\n andl UR,UL\n", },
1346
1347{ AND, INAREG|FOREFF,
1348 SAREG, TWORD,
1349 SAREG|SOREG|SNAME, TWORD,
1350 0, RLEFT,
1351 " andl AR,AL\n", },
1352
1353{ AND, INAREG|FOREFF,
1354 SAREG|SOREG|SNAME, TSHORT|TUSHORT,
1355 SCON|SAREG, TSHORT|TUSHORT,
1356 0, RLEFT,
1357 " andw AR,AL\n", },
1358
1359{ AND, INAREG|FOREFF,
1360 SAREG, TSHORT|TUSHORT,
1361 SAREG|SOREG|SNAME, TSHORT|TUSHORT,
1362 0, RLEFT,
1363 " andw AR,AL\n", },
1364
1365{ AND, INBREG|FOREFF,
1366 SBREG|SOREG|SNAME, TCHAR|TUCHAR,
1367 SCON|SBREG, TCHAR|TUCHAR,
1368 0, RLEFT,
1369 " andb AR,AL\n", },
1370
1371{ AND, INBREG|FOREFF,
1372 SBREG, TCHAR|TUCHAR,
1373 SBREG|SOREG|SNAME, TCHAR|TUCHAR,
1374 0, RLEFT,
1375 " andb AR,AL\n", },
1376/* AND/OR/ER/NOT */
1377
1378/*
1379 * Jumps.
1380 */
1381{ GOTO, FOREFF,
1382 SCON, TANY,
1383 SANY, TANY,
1384 0, RNOP,
1385 " jmp LL\n", },
1386
1387#if defined(GCC_COMPAT) || defined(LANG_F77)
1388{ GOTO, FOREFF,
1389 SAREG, TANY,
1390 SANY, TANY,
1391 0, RNOP,
1392 " jmp *AL\n", },
1393#endif
1394
1395/*
1396 * Convert LTYPE to reg.
1397 */
1398{ OPLTYPE, FORCC|INLL,
1399 SCREG, TLL,
1400 SMIXOR, TANY,
1401 NCREG, RESC1,
1402 " xorl U1,U1\n xorl A1,A1\n", },
1403
1404{ OPLTYPE, FORCC|INLL,
1405 SCREG, TLL,
1406 SMILWXOR, TANY,
1407 NCREG, RESC1,
1408 " movl UL,U1\n xorl A1,A1\n", },
1409
1410{ OPLTYPE, FORCC|INLL,
1411 SCREG, TLL,
1412 SMIHWXOR, TANY,
1413 NCREG, RESC1,
1414 " xorl U1,U1\n movl AL,A1\n", },
1415
1416{ OPLTYPE, INLL,
1417 SANY, TANY,
1418 SCREG, TLL,
1419 NCREG, RESC1,
1420 "ZK", },
1421
1422{ OPLTYPE, INLL,
1423 SANY, TANY,
1424 SCON|SOREG|SNAME, TLL,
1425 NCREG, RESC1,
1426 " movl UL,U1\n movl AL,A1\n", },
1427
1428{ OPLTYPE, FORCC|INAREG,
1429 SAREG, TWORD|TPOINT,
1430 SMIXOR, TANY,
1431 NAREG|NASL, RESC1,
1432 " xorl A1,A1\n", },
1433
1434{ OPLTYPE, INAREG,
1435 SANY, TANY,
1436 SAREG|SCON|SOREG|SNAME, TWORD|TPOINT,
1437 NAREG|NASL, RESC1,
1438 " movl AL,A1\n", },
1439
1440{ OPLTYPE, INBREG,
1441 SANY, TANY,
1442 SBREG|SOREG|SNAME|SCON, TCHAR|TUCHAR,
1443 NBREG, RESC1,
1444 " movb AL,A1\n", },
1445
1446{ OPLTYPE, FORCC|INAREG,
1447 SAREG, TSHORT|TUSHORT,
1448 SMIXOR, TANY,
1449 NAREG, RESC1,
1450 " xorw A1,A1\n", },
1451
1452{ OPLTYPE, INAREG,
1453 SANY, TANY,
1454 SAREG|SOREG|SNAME|SCON, TSHORT|TUSHORT,
1455 NAREG, RESC1,
1456 " movw AL,A1\n", },
1457
1458{ OPLTYPE, INDREG,
1459 SANY, TLDOUBLE,
1460 SOREG|SNAME, TLDOUBLE,
1461 NDREG, RESC1,
1462 " fldt AL\n", },
1463
1464{ OPLTYPE, INDREG,
1465 SANY, TDOUBLE,
1466 SOREG|SNAME, TDOUBLE,
1467 NDREG, RESC1,
1468 " fldl AL\n", },
1469
1470{ OPLTYPE, INDREG,
1471 SANY, TFLOAT,
1472 SOREG|SNAME, TFLOAT,
1473 NDREG, RESC1,
1474 " flds AL\n", },
1475
1476/* Only used in ?: constructs. The stack already contains correct value */
1477{ OPLTYPE, INDREG,
1478 SANY, TFLOAT|TDOUBLE|TLDOUBLE,
1479 SDREG, TFLOAT|TDOUBLE|TLDOUBLE,
1480 NDREG, RESC1,
1481 "", },
1482
1483/*
1484 * Negate a word.
1485 */
1486
1487{ UMINUS, INCREG|FOREFF,
1488 SCREG, TLL,
1489 SCREG, TLL,
1490 0, RLEFT,
1491 " negl AL\n adcl $0,UL\n negl UL\n", },
1492
1493{ UMINUS, INAREG|FOREFF,
1494 SAREG, TWORD|TPOINT,
1495 SAREG, TWORD|TPOINT,
1496 0, RLEFT,
1497 " negl AL\n", },
1498
1499{ UMINUS, INAREG|FOREFF,
1500 SAREG, TSHORT|TUSHORT,
1501 SAREG, TSHORT|TUSHORT,
1502 0, RLEFT,
1503 " negw AL\n", },
1504
1505{ UMINUS, INBREG|FOREFF,
1506 SBREG, TCHAR|TUCHAR,
1507 SBREG, TCHAR|TUCHAR,
1508 0, RLEFT,
1509 " negb AL\n", },
1510
1511{ UMINUS, INFL|FOREFF,
1512 SHFL, TLDOUBLE|TDOUBLE|TFLOAT,
1513 SHFL, TLDOUBLE|TDOUBLE|TFLOAT,
1514 0, RLEFT,
1515 " fchs\n", },
1516
1517{ COMPL, INCREG,
1518 SCREG, TLL,
1519 SANY, TANY,
1520 0, RLEFT,
1521 " notl AL\n notl UL\n", },
1522
1523{ COMPL, INAREG,
1524 SAREG, TWORD,
1525 SANY, TANY,
1526 0, RLEFT,
1527 " notl AL\n", },
1528
1529{ COMPL, INAREG,
1530 SAREG, TSHORT|TUSHORT,
1531 SANY, TANY,
1532 0, RLEFT,
1533 " notw AL\n", },
1534
1535{ COMPL, INBREG,
1536 SBREG, TCHAR|TUCHAR,
1537 SANY, TANY,
1538 0, RLEFT,
1539 " notb AL\n", },
1540
1541/*
1542 * Arguments to functions.
1543 */
1544{ FUNARG, FOREFF,
1545 SCON|SCREG|SNAME|SOREG, TLL,
1546 SANY, TLL,
1547 0, RNULL,
1548 " pushl UL\n pushl AL\n", },
1549
1550{ FUNARG, FOREFF,
1551 SCON|SAREG|SNAME|SOREG, TWORD|TPOINT,
1552 SANY, TWORD|TPOINT,
1553 0, RNULL,
1554 " pushl AL\n", },
1555
1556{ FUNARG, FOREFF,
1557 SCON, TWORD|TSHORT|TUSHORT|TCHAR|TUCHAR,
1558 SANY, TWORD|TSHORT|TUSHORT|TCHAR|TUCHAR,
1559 0, RNULL,
1560 " pushl AL\n", },
1561
1562{ FUNARG, FOREFF,
1563 SAREG|SNAME|SOREG, TSHORT,
1564 SANY, TSHORT,
1565 NAREG, 0,
1566 " movswl AL,ZN\n pushl ZN\n", },
1567
1568{ FUNARG, FOREFF,
1569 SAREG|SNAME|SOREG, TUSHORT,
1570 SANY, TUSHORT,
1571 NAREG, 0,
1572 " movzwl AL,ZN\n pushl ZN\n", },
1573
1574{ FUNARG, FOREFF,
1575 SHCH|SNAME|SOREG, TCHAR,
1576 SANY, TCHAR,
1577 NAREG, 0,
1578 " movsbl AL,A1\n pushl A1\n", },
1579
1580{ FUNARG, FOREFF,
1581 SHCH|SNAME|SOREG, TUCHAR,
1582 SANY, TUCHAR,
1583 NAREG, 0,
1584 " movzbl AL,A1\n pushl A1\n", },
1585
1586{ FUNARG, FOREFF,
1587 SNAME|SOREG, TDOUBLE,
1588 SANY, TDOUBLE,
1589 0, 0,
1590 " pushl UL\n pushl AL\n", },
1591
1592{ FUNARG, FOREFF,
1593 SDREG, TDOUBLE,
1594 SANY, TDOUBLE,
1595 0, 0,
1596 " subl $8,%esp\n fstpl (%esp)\n", },
1597
1598{ FUNARG, FOREFF,
1599 SNAME|SOREG, TFLOAT,
1600 SANY, TFLOAT,
1601 0, 0,
1602 " pushl AL\n", },
1603
1604{ FUNARG, FOREFF,
1605 SDREG, TFLOAT,
1606 SANY, TFLOAT,
1607 0, 0,
1608 " subl $4,%esp\n fstps (%esp)\n", },
1609
1610{ FUNARG, FOREFF,
1611 SDREG, TLDOUBLE,
1612 SANY, TLDOUBLE,
1613 0, 0,
1614 " subl $12,%esp\n fstpt (%esp)\n", },
1615
1616{ STARG, FOREFF,
1617 SAREG|SOREG|SNAME|SCON, TANY,
1618 SANY, TSTRUCT,
1619 NSPECIAL|NAREG, 0,
1620 "ZF", },
1621
1622# define DF(x) FORREW,SANY,TANY,SANY,TANY,REWRITE,x,""
1623
1624{ UMUL, DF( UMUL ), },
1625
1626{ ASSIGN, DF(ASSIGN), },
1627
1628{ STASG, DF(STASG), },
1629
1630{ FLD, DF(FLD), },
1631
1632{ OPLEAF, DF(NAME), },
1633
1634/* { INIT, DF(INIT), }, */
1635
1636{ OPUNARY, DF(UMINUS), },
1637
1638{ OPANY, DF(BITYPE), },
1639
1640{ FREE, FREE, FREE, FREE, FREE, FREE, FREE, FREE, "help; I'm in trouble\n" },
1641};
1642
1643int tablesize = sizeof(table)/sizeof(table[0]);
Note: See TracBrowser for help on using the repository browser.