nacl:

	add jmp to constant pc.
	generate HLT for INT $3
	do not insert NOPs between REP/REPN and subsequent instruction.
	allow very long time for convergence.

R=ken
OCL=34879
CL=34879

diff --git a/src/cmd/8l/l.h b/src/cmd/8l/l.h
index 98d35de6241ab258148caf650be773f96a683bb9..b62d9f8fdae7182751e281ceeff38ac2ffb97254 100644 (file)
--- a/src/cmd/8l/l.h
+++ b/src/cmd/8l/l.h
@@ -201,6 +201,7 @@ enum
        Zil_rp,
        Zilo_m,
        Zjmp,
+       Zjmpcon,
        Zloop,
        Zm_o,
        Zm_r,

diff --git a/src/cmd/8l/optab.c b/src/cmd/8l/optab.c
index 14e6daa326e3be7d557d16d155a0a9d5938cf1a6..0e36599348a238b928bafb2c9dffb80e28c53adf 100644 (file)
--- a/src/cmd/8l/optab.c
+++ b/src/cmd/8l/optab.c
@@ -267,7 +267,8 @@ uchar       ycall[] =
 uchar  yjmp[] =
 {
        Ynone,  Yml,    Zo_m,   2,
-       Ynone,  Ybr,    Zjmp,   1,
+       Ynone,  Ybr,    Zjmp,   0,
+       Ynone,  Yi32,   Zjmpcon,        1,
        0
 };
 

diff --git a/src/cmd/8l/pass.c b/src/cmd/8l/pass.c
index bc3e1649fbe437dc102eec9d8cfae0ee67cabc6e..576e51bfd789698aedd94a94fbf9fb47ed7af584 100644 (file)
--- a/src/cmd/8l/pass.c
+++ b/src/cmd/8l/pass.c
@@ -464,7 +464,6 @@ dostkoff(void)
        int a, f, curframe, curbecome, maxbecome;
        Prog *pmorestack;
        Sym *symmorestack;
-       static int fsreg;
 
        pmorestack = P;
        symmorestack = lookup("sys·morestack", 0);

diff --git a/src/cmd/8l/span.c b/src/cmd/8l/span.c
index 184a37d3166e73dff7992d2dc9ad90fff2fd3b6f..7745c361cf332b4f4d500b88bdc63b7ebd108105 100644 (file)
--- a/src/cmd/8l/span.c
+++ b/src/cmd/8l/span.c
@@ -72,8 +72,9 @@ start:
                if(debug['v'])
                        Bprint(&bso, "%5.2f span %d\n", cputime(), n);
                Bflush(&bso);
-               if(n > 50) {
-                       print("span must be looping\n");
+               if(n > 500) {
+                       // TODO(rsc): figure out why nacl takes so long to converge.
+                       print("span must be looping - %d\n", textsize);
                        errorexit();
                }
                c = INITTEXT;
@@ -1045,6 +1046,12 @@ found:
        case Z_ib:
                v = vaddr(&p->to);
        case Zib_:
+               if(HEADTYPE == 8 && p->as == AINT && v == 3) {
+                       // native client disallows all INT instructions.
+                       // translate INT $3 to HLT.
+                       *andptr++ = 0xf4;
+                       break;
+               }
                *andptr++ = op;
                *andptr++ = v;
                break;
@@ -1194,6 +1201,15 @@ found:
                }
                break;
 
+       case Zjmpcon:
+               v = p->to.offset - p->pc - 5;
+               *andptr++ = o->op[z+1];
+               *andptr++ = v;
+               *andptr++ = v>>8;
+               *andptr++ = v>>16;
+               *andptr++ = v>>24;
+               break;
+
        case Zloop:
                q = p->pcond;
                if(q) {
@@ -1371,6 +1387,7 @@ asmins(Prog *p)
 {
        if(HEADTYPE == 8) {
                ulong npc;
+               static Prog *prefix;
 
                // native client
                // - pad indirect jump targets (aka ATEXT) to 32-byte boundary
@@ -1386,15 +1403,27 @@ asmins(Prog *p)
                        npc = p->pc + (andptr - and);
                        p->pc += 31 & -npc;
                }
+               if(p->as == AREP || p->as == AREPN) {
+                       // save prefix for next instruction,
+                       // so that inserted NOPs do not split (e.g.) REP / MOVSL sequence.
+                       prefix = p;
+                       andptr = and;
+                       return;
+               }
                andptr = and;
+               if(prefix)
+                       doasm(prefix);
                doasm(p);
                npc = p->pc + (andptr - and);
-               if((p->pc&~31) != ((npc-1)&~31)) {
+               if(andptr > and && (p->pc&~31) != ((npc-1)&~31)) {
                        // crossed 32-byte boundary; pad to boundary and try again
                        p->pc += 31 & -p->pc;
                        andptr = and;
+                       if(prefix)
+                               doasm(prefix);
                        doasm(p);
                }
+               prefix = nil;
        } else {
                andptr = and;
                doasm(p);