code review 10271047: cmd/5l,runtime: External linking support on linux-arm

src/cmd/5l/noop.c

 // Inferno utils/5l/noop.c
 // http://code.google.com/p/inferno-os/source/browse/utils/5l/noop.c
 //
 //      Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
 //      Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
 //      Portions Copyright © 1997-1999 Vita Nuova Limited
 //      Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
 //      Portions Copyright © 2004,2006 Bruce Ellis
 //      Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
 //      Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
@@ skipping 14 matching lines @@
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
 // Code transformations.
 
 #include        "l.h"
 #include        "../ld/lib.h"
-
-// see ../../runtime/proc.c:/StackGuard
-enum
-{
-        StackBig = 4096,
-        StackSmall = 128,
-};
+#include        "../../pkg/runtime/stack.h"
 
 static  Sym*    sym_div;
 static  Sym*    sym_divu;
 static  Sym*    sym_mod;
 static  Sym*    sym_modu;
 
 static void
 linkcase(Prog *casep)
 {
         Prog *p;
 
         for(p = casep; p != P; p = p->link){
                 if(p->as == ABCASE) {
                         for(; p != P && p->as == ABCASE; p = p->link)
                                 p->pcrel = casep;
                         break;
                 }
         }
 }
 
 void
 noops(void)
 {
         Prog *p, *q, *q1, *q2;
         int o;
+        int32 arg;
         Prog *pmorestack;
         Sym *symmorestack, *tlsfallback, *gmsym;
 
         /*
          * find leaf subroutines
          * strip NOPs
          * expand RET
          * expand BECOME pseudo
          * fixup TLS
          */
@@ skipping 149 matching lines @@
                                                         cursym->name);
                                         Bflush(&bso);
                                         cursym->text->mark |= LEAF;
                                 }
                                 if(cursym->text->mark & LEAF) {
                                         cursym->leaf = 1;
                                         if(!autosize)
                                                 break;
                                 }
 ········
-                                if(p->reg & NOSPLIT) {
-                                        q1 = prg();
-                                        q1->as = AMOVW;
-                                        q1->scond |= C_WBIT;
-                                        q1->line = p->line;
-                                        q1->from.type = D_REG;
-                                        q1->from.reg = REGLINK;
-                                        q1->to.type = D_OREG;
-                                        q1->to.offset = -autosize;
-                                        q1->to.reg = REGSP;
-                                        q1->spadj = autosize;
-                                        q1->link = p->link;
-                                        p->link = q1;
-                                } else if (autosize < StackBig) {
-                                        // split stack check for small functions
-                                        // MOVW                 g_stackguard(g), R1
-                                        // CMP                  R1, $-autosize(SP)
-                                        // MOVW.LO              $autosize, R1
-                                        // MOVW.LO              $args, R2
-                                        // MOVW.LO              R14, R3
-                                        // BL.LO                        runtime.morestack(SB) // modifies LR
-                                        // MOVW.W               R14,$-autosize(SP)
- ·······
-                                        // TODO(kaib): add more trampolines
-                                        // TODO(kaib): put stackguard in register
-                                        // TODO(kaib): add support for -K and underflow detection
-
+                                if(!(p->reg & NOSPLIT)) {
                                         // MOVW                 g_stackguard(g), R1
                                         p = appendp(p);
                                         p->as = AMOVW;
                                         p->from.type = D_OREG;
                                         p->from.reg = REGG;
                                         p->to.type = D_REG;
                                         p->to.reg = 1;
 ········································
-                                        if(autosize < StackSmall) {     
-                                                // CMP                  R1, SP
+                                        if(autosize <= StackSmall) {
+                                                // small stack: SP < stackguard
+                                                //      CMP     stackguard, SP
                                                 p = appendp(p);
                                                 p->as = ACMP;
                                                 p->from.type = D_REG;
                                                 p->from.reg = 1;
                                                 p->reg = REGSP;
-                                        } else {
-                                                // MOVW         $-autosize(SP), R2
-                                                // CMP  R1, R2
+                                        } else if(autosize <= StackBig) {
+                                                // large stack: SP-framesize < stackguard-StackSmall
+                                                //      MOVW $-autosize(SP), R2
+                                                //      CMP stackguard, R2
                                                 p = appendp(p);
                                                 p->as = AMOVW;
                                                 p->from.type = D_CONST;
                                                 p->from.reg = REGSP;
                                                 p->from.offset = -autosize;
                                                 p->to.type = D_REG;
                                                 p->to.reg = 2;
 ················································
                                                 p = appendp(p);
                                                 p->as = ACMP;
                                                 p->from.type = D_REG;
                                                 p->from.reg = 1;
                                                 p->reg = 2;
+                                        } else {
+                                                // Such a large stack we need to protect against wraparound
+                                                // if SP is close to zero.
+                                                //      SP-stackguard+StackGuard < framesize + (StackGuard-StackSmall)
+                                                // The +StackGuard on both sides is required to keep the left side positive:
+                                                // SP is allowed to be slightly below stackguard. See stack.h.
+                                                //      CMP $StackPreempt, R1
+                                                //      MOVW.NE $StackGuard(SP), R2
+                                                //      SUB.NE R1, R2
+                                                //      MOVW.NE $(autosize+(StackGuard-StackSmall)), R3
+                                                //      CMP.NE R3, R2
+                                                p = appendp(p);
+                                                p->as = ACMP;
+                                                p->from.type = D_CONST;
+                                                p->from.offset = (uint32)StackPreempt;
+                                                p->reg = 1;
+
+                                                p = appendp(p);
+                                                p->as = AMOVW;
+                                                p->from.type = D_CONST;
+                                                p->from.reg = REGSP;
+                                                p->from.offset = StackGuard;
+                                                p->to.type = D_REG;
+                                                p->to.reg = 2;
+                                                p->scond = C_SCOND_NE;
+················································
+                                                p = appendp(p);
+                                                p->as = ASUB;
+                                                p->from.type = D_REG;
+                                                p->from.reg = 1;
+                                                p->to.type = D_REG;
+                                                p->to.reg = 2;
+                                                p->scond = C_SCOND_NE;
+················································
+                                                p = appendp(p);
+                                                p->as = AMOVW;
+                                                p->from.type = D_CONST;
+                                                p->from.offset = autosize + (StackGuard - StackSmall);
+                                                p->to.type = D_REG;
+                                                p->to.reg = 3;
+                                                p->scond = C_SCOND_NE;
+················································
+                                                p = appendp(p);
+                                                p->as = ACMP;
+                                                p->from.type = D_REG;
+                                                p->from.reg = 3;
+                                                p->reg = 2;
+                                                p->scond = C_SCOND_NE;
                                         }
-
-                                        // MOVW.LO              $autosize, R1
+                                        
+                                        // MOVW.LS              $autosize, R1
                                         p = appendp(p);
                                         p->as = AMOVW;
-                                        p->scond = C_SCOND_LO;
+                                        p->scond = C_SCOND_LS;
                                         p->from.type = D_CONST;
                                         p->from.offset = autosize;
                                         p->to.type = D_REG;
                                         p->to.reg = 1;
 ········
-                                        // MOVW.LO              $args, R2
+                                        // MOVW.LS              $args, R2
                                         p = appendp(p);
                                         p->as = AMOVW;
-                                        p->scond = C_SCOND_LO;
+                                        p->scond = C_SCOND_LS;
                                         p->from.type = D_CONST;
-                                        p->from.offset = (cursym->text->to.offset2 + 3) & ~3;
+                                        arg = cursym->text->to.offset2;
+                                        if(arg == 1) // special marker for known 0
+                                                arg = 0;
+                                        if(arg&3)
+                                                diag("misaligned argument size in stack split");
+                                        p->from.offset = arg;
                                         p->to.type = D_REG;
                                         p->to.reg = 2;
 ········
-                                        // MOVW.LO      R14, R3
+                                        // MOVW.LS      R14, R3
                                         p = appendp(p);
                                         p->as = AMOVW;
-                                        p->scond = C_SCOND_LO;
+                                        p->scond = C_SCOND_LS;
                                         p->from.type = D_REG;
                                         p->from.reg = REGLINK;
                                         p->to.type = D_REG;
                                         p->to.reg = 3;
 ········
-                                        // BL.LO                runtime.morestack(SB) // modifies LR
+                                        // BL.LS                runtime.morestack(SB) // modifies LR, returns with LO still asserted
                                         p = appendp(p);
                                         p->as = ABL;
-                                        p->scond = C_SCOND_LO;
+                                        p->scond = C_SCOND_LS;
                                         p->to.type = D_BRANCH;
                                         p->to.sym = symmorestack;
                                         p->cond = pmorestack;
- ·······
-                                        // MOVW.W               R14,$-autosize(SP)
+                                 ·······
+                                        // BLS  start
                                         p = appendp(p);
-                                        p->as = AMOVW;
-                                        p->scond |= C_WBIT;
-                                        p->from.type = D_REG;
-                                        p->from.reg = REGLINK;
-                                        p->to.type = D_OREG;
-                                        p->to.offset = -autosize;
-                                        p->to.reg = REGSP;
-                                        p->spadj = autosize;
-                                } else { // > StackBig
-                                        // MOVW         $autosize, R1
-                                        // MOVW         $args, R2
-                                        // MOVW         R14, R3
-                                        // BL                   runtime.morestack(SB) // modifies LR
-                                        // MOVW.W               R14,$-autosize(SP)
- ·······
-                                        // MOVW         $autosize, R1
-                                        p = appendp(p);
-                                        p->as = AMOVW;
-                                        p->from.type = D_CONST;
-                                        p->from.offset = autosize;
-                                        p->to.type = D_REG;
-                                        p->to.reg = 1;
- ·······
-                                        // MOVW         $args, R2
-                                        // also need to store the extra 4 bytes.
-                                        p = appendp(p);
-                                        p->as = AMOVW;
-                                        p->from.type = D_CONST;
-                                        p->from.offset = (cursym->text->to.offset2 + 3) & ~3;
-                                        p->to.type = D_REG;
-                                        p->to.reg = 2;
- ·······
-                                        // MOVW R14, R3
-                                        p = appendp(p);
-                                        p->as = AMOVW;
-                                        p->from.type = D_REG;
-                                        p->from.reg = REGLINK;
-                                        p->to.type = D_REG;
-                                        p->to.reg = 3;
- ·······
-                                        // BL           runtime.morestack(SB) // modifies LR
-                                        p = appendp(p);
-                                        p->as = ABL;
+                                        p->as = ABLS;
                                         p->to.type = D_BRANCH;
-                                        p->to.sym = symmorestack;
-                                        p->cond = pmorestack;
- ·······
-                                        // MOVW.W               R14,$-autosize(SP)
-                                        p = appendp(p);
-                                        p->as = AMOVW;
-                                        p->scond |= C_WBIT;
-                                        p->from.type = D_REG;
-                                        p->from.reg = REGLINK;
-                                        p->to.type = D_OREG;
-                                        p->to.offset = -autosize;
-                                        p->to.reg = REGSP;
-                                        p->spadj = autosize;
-                                }
+                                        p->cond = cursym->text->link;
+                                }
+                         ·······
+                                // MOVW.W               R14,$-autosize(SP)
+                                p = appendp(p);
+                                p->as = AMOVW;
+                                p->scond |= C_WBIT;
+                                p->from.type = D_REG;
+                                p->from.reg = REGLINK;
+                                p->to.type = D_OREG;
+                                p->to.offset = -autosize;
+                                p->to.reg = REGSP;
+                                p->spadj = autosize;
                                 break;
 ········
                         case ARET:
                                 nocache(p);
                                 if(cursym->text->mark & LEAF) {
                                         if(!autosize) {
                                                 p->as = AB;
                                                 p->from = zprg.from;
                                                 if(p->to.sym) { // retjmp
                                                         p->to.type = D_BRANCH;
@@ skipping 197 matching lines @@
         }
 }
 
 void
 nocache(Prog *p)
 {
         p->optab = 0;
         p->from.class = 0;
         p->to.class = 0;
 }