BSD 4_4 release

[unix-history] / usr / src / old / pcc / ccom.tahoe / local2.c

diff --git a/usr/src/old/pcc/ccom.tahoe/local2.c b/usr/src/old/pcc/ccom.tahoe/local2.c
index 1c19104..158d04e 100644 (file)
--- a/usr/src/old/pcc/ccom.tahoe/local2.c
+++ b/usr/src/old/pcc/ccom.tahoe/local2.c
@@ -1,6 +1,6 @@
-# ifndef lint
-static char sccsid[] = "@(#)local2.c   1.25 (Berkeley) %G%";
-# endif
+#ifndef lint
+static char sccsid[] = "@(#)local2.c   1.32 (Berkeley) 2/29/88";
+#endif

 
 # include "pass2.h"
 # include <ctype.h>
 
 # include "pass2.h"
 # include <ctype.h>


@@ -338,11 +338,16 @@ zzzcode( p, c ) register NODE *p; {
                }
 
        case 'D':       /* INCR and DECR */
                }
 
        case 'D':       /* INCR and DECR */

-               zzzcode(p->in.left, 'U');
+               if (p->in.left->in.type == FLOAT)
+                       expand(p, INAREG, "movl\tAL,A1");
+               else if (p->in.left->in.type == DOUBLE)
+                       expand(p, INAREG, "ldd\tAL\n\tstd\tA1");
+               else
+                       zzzcode(p->in.left, 'U');

                putstr("\n      ");
 
        case 'E':       /* INCR and DECR, FOREFF */
                putstr("\n      ");
 
        case 'E':       /* INCR and DECR, FOREFF */

-               if (p->in.right->tn.lval == 1)
+               if (p->in.right->in.op == ICON && p->in.right->tn.lval == 1)

                        {
                        putstr(p->in.op == INCR ? "inc" : "dec");
                        prtype(p->in.left);
                        {
                        putstr(p->in.op == INCR ? "inc" : "dec");
                        prtype(p->in.left);


@@ -350,6 +355,15 @@ zzzcode( p, c ) register NODE *p; {
                        adrput(p->in.left);
                        return;
                        }
                        adrput(p->in.left);
                        return;
                        }

+               else if (p->in.left->in.type == FLOAT || p->in.left->in.type == DOUBLE) {
+                       if (c == 'E' || p->in.left->in.type == FLOAT)
+                               expand(p, INAREG, "ldZL\tAL\n\t");
+                       if (p->in.op == INCR)
+                               expand(p, INAREG, "addZL\tAR\n\tstZL\tAL");
+                       else /* DECR */
+                               expand(p, INAREG, "subZL\tAR\n\tstZL\tAL");
+                       return;
+                       }

                putstr(p->in.op == INCR ? "add" : "sub");
                prtype(p->in.left);
                putstr("2       ");
                putstr(p->in.op == INCR ? "add" : "sub");
                prtype(p->in.left);
                putstr("2       ");


@@ -619,10 +633,21 @@ stasg(p)
                 * Can we ever get a register conflict with R1 here?
                 */
                putstr("\tmovab\t");
                 * Can we ever get a register conflict with R1 here?
                 */
                putstr("\tmovab\t");

-               adrput(l);
-               putstr(",r1\n\tmovab\t");
-               adrput(r);
-               printf(",r0\n\tmovl\t$%d,r2\n\tmovblk\n", size);
+               if(r->in.op == OREG && r->tn.rval == R1)
+               {
+                       adrput(r);
+                       printf(",r0\n\tmovab\t");
+                       adrput(l);
+                       putstr(",r1\n");
+               }
+               else
+               {
+                       adrput(l);
+                       putstr(",r1\n\tmovab\t");
+                       adrput(r);
+                       printf(",r0\n");
+               }
+               printf("\tmovl\t$%d,r2\n\tmovblk\n", size);

                rname(R2);
                break;
        }
                rname(R2);
                break;
        }


@@ -736,6 +761,8 @@ static char convtab[SZINT/SZCHAR + 1] = {
  *     ignored and the high bits of the source are copied.  (Note
  *     that zero-extension is not a problem for immediate
  *     constants.)
  *     ignored and the high bits of the source are copied.  (Note
  *     that zero-extension is not a problem for immediate
  *     constants.)

+ * Another problem -- condition codes for a conversion with a
+ *     register source reflect the source rather than the destination.

  */
 sconv(p, forcc)
        NODE *p;
  */
 sconv(p, forcc)
        NODE *p;


@@ -819,15 +846,14 @@ sconv(p, forcc)
                        adrput(dst);
                        putstr("\n\tmovab\t4(sp),sp");
                        if (forcc) {
                        adrput(dst);
                        putstr("\n\tmovab\t4(sp),sp");
                        if (forcc) {

-                               /* inverted test */
-                               putstr("\n\tcmpl\t$0,");
+                               putstr("\n\ttstl\t");

                                adrput(dst);
                        }
                        return;
                }
                genconv(ISUNSIGNED(srctype),
                        srclen, dst->in.op == REG ? SZINT/SZCHAR : dstlen,
                                adrput(dst);
                        }
                        return;
                }
                genconv(ISUNSIGNED(srctype),
                        srclen, dst->in.op == REG ? SZINT/SZCHAR : dstlen,

-                       src, dst);
+                       src, dst, forcc);

                return;
        }
 
                return;
        }
 


@@ -861,8 +887,7 @@ sconv(p, forcc)
                        adrput(dst);
                        putstr("\n\tmovab\t4(sp),sp");
                        if (forcc) {
                        adrput(dst);
                        putstr("\n\tmovab\t4(sp),sp");
                        if (forcc) {

-                               /* inverted test */
-                               putstr("\n\tcmpl\t$0,");
+                               putstr("\n\ttstl\t");

                                adrput(dst);
                        }
                        return;
                                adrput(dst);
                        }
                        return;


@@ -887,20 +912,21 @@ sconv(p, forcc)
                        tmp->tn.op = OREG;
                        tmp->tn.lval = srclen - dstlen;
                }
                        tmp->tn.op = OREG;
                        tmp->tn.lval = srclen - dstlen;
                }

-               genconv(ISUNSIGNED(dsttype), dstlen, SZINT/SZCHAR, tmp, dst);
+               genconv(ISUNSIGNED(dsttype), dstlen, SZINT/SZCHAR, tmp, dst, forcc);

                tmp->in.op = FREE;
                return;
        }
 
        genconv(neg ? -1 : ISUNSIGNED(dsttype),
                srclen, dst->in.op == REG ? SZINT/SZCHAR : dstlen,
                tmp->in.op = FREE;
                return;
        }
 
        genconv(neg ? -1 : ISUNSIGNED(dsttype),
                srclen, dst->in.op == REG ? SZINT/SZCHAR : dstlen,

-               src, dst);
+               src, dst, forcc);

 }
 
 }
 

-genconv(srcflag, srclen, dstlen, src, dst)
+genconv(srcflag, srclen, dstlen, src, dst, forcc)

        int srcflag;
        register int srclen, dstlen;
        NODE *src, *dst;
        int srcflag;
        register int srclen, dstlen;
        NODE *src, *dst;

+       int forcc;

 {
        if (srclen != dstlen) {
                if (srcflag > 0 && srclen < dstlen)
 {
        if (srclen != dstlen) {
                if (srcflag > 0 && srclen < dstlen)


@@ -917,6 +943,17 @@ genconv(srcflag, srclen, dstlen, src, dst)
        adrput(src);
        putchar(',');
        adrput(dst);
        adrput(src);
        putchar(',');
        adrput(dst);

+
+       /*
+        * This hack is made necessary by architecture problems
+        *      described above
+        */
+       if (forcc && src->in.op == REG && srclen > dstlen) {
+               putstr("\n\ttst");
+               prlen(dstlen);
+               putchar('\t');
+               adrput(dst);
+       }

 }
 
 rmove( rt, rs, t ) TWORD t; {
 }
 
 rmove( rt, rs, t ) TWORD t; {