obj5.go

     1  // Derived from Inferno utils/5c/swt.c
     2  // https://bitbucket.org/inferno-os/inferno-os/src/master/utils/5c/swt.c
     3  //
     4  //	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
     5  //	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
     6  //	Portions Copyright © 1997-1999 Vita Nuova Limited
     7  //	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
     8  //	Portions Copyright © 2004,2006 Bruce Ellis
     9  //	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
    10  //	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
    11  //	Portions Copyright © 2009 The Go Authors. All rights reserved.
    12  //
    13  // Permission is hereby granted, free of charge, to any person obtaining a copy
    14  // of this software and associated documentation files (the "Software"), to deal
    15  // in the Software without restriction, including without limitation the rights
    16  // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    17  // copies of the Software, and to permit persons to whom the Software is
    18  // furnished to do so, subject to the following conditions:
    19  //
    20  // The above copyright notice and this permission notice shall be included in
    21  // all copies or substantial portions of the Software.
    22  //
    23  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    24  // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    25  // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
    26  // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    27  // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    28  // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
    29  // THE SOFTWARE.
    30  
    31  package arm
    32  
    33  import (
    34  	"cmd/internal/obj"
    35  	"cmd/internal/objabi"
    36  	"cmd/internal/sys"
    37  	"internal/abi"
    38  	"internal/buildcfg"
    39  	"log"
    40  )
    41  
    42  var progedit_tlsfallback *obj.LSym
    43  
    44  func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
    45  	p.From.Class = 0
    46  	p.To.Class = 0
    47  
    48  	c := ctxt5{ctxt: ctxt, newprog: newprog}
    49  
    50  	// Rewrite B/BL to symbol as TYPE_BRANCH.
    51  	switch p.As {
    52  	case AB, ABL, obj.ADUFFZERO, obj.ADUFFCOPY:
    53  		if p.To.Type == obj.TYPE_MEM && (p.To.Name == obj.NAME_EXTERN || p.To.Name == obj.NAME_STATIC) && p.To.Sym != nil {
    54  			p.To.Type = obj.TYPE_BRANCH
    55  		}
    56  	}
    57  
    58  	// Replace TLS register fetches on older ARM processors.
    59  	switch p.As {
    60  	// Treat MRC 15, 0, <reg>, C13, C0, 3 specially.
    61  	case AMRC:
    62  		if p.To.Offset&0xffff0fff == 0xee1d0f70 {
    63  			// Because the instruction might be rewritten to a BL which returns in R0
    64  			// the register must be zero.
    65  			if p.To.Offset&0xf000 != 0 {
    66  				ctxt.Diag("%v: TLS MRC instruction must write to R0 as it might get translated into a BL instruction", p.Line())
    67  			}
    68  
    69  			if buildcfg.GOARM.Version < 7 {
    70  				// Replace it with BL runtime.read_tls_fallback(SB) for ARM CPUs that lack the tls extension.
    71  				if progedit_tlsfallback == nil {
    72  					progedit_tlsfallback = ctxt.Lookup("runtime.read_tls_fallback")
    73  				}
    74  
    75  				// MOVW	LR, R11
    76  				p.As = AMOVW
    77  
    78  				p.From.Type = obj.TYPE_REG
    79  				p.From.Reg = REGLINK
    80  				p.To.Type = obj.TYPE_REG
    81  				p.To.Reg = REGTMP
    82  
    83  				// BL	runtime.read_tls_fallback(SB)
    84  				p = obj.Appendp(p, newprog)
    85  
    86  				p.As = ABL
    87  				p.To.Type = obj.TYPE_BRANCH
    88  				p.To.Sym = progedit_tlsfallback
    89  				p.To.Offset = 0
    90  
    91  				// MOVW	R11, LR
    92  				p = obj.Appendp(p, newprog)
    93  
    94  				p.As = AMOVW
    95  				p.From.Type = obj.TYPE_REG
    96  				p.From.Reg = REGTMP
    97  				p.To.Type = obj.TYPE_REG
    98  				p.To.Reg = REGLINK
    99  				break
   100  			}
   101  		}
   102  
   103  		// Otherwise, MRC/MCR instructions need no further treatment.
   104  		p.As = AWORD
   105  	}
   106  
   107  	// Rewrite float constants to values stored in memory.
   108  	switch p.As {
   109  	case AMOVF:
   110  		if p.From.Type == obj.TYPE_FCONST && c.chipfloat5(p.From.Val.(float64)) < 0 && (c.chipzero5(p.From.Val.(float64)) < 0 || p.Scond&C_SCOND != C_SCOND_NONE) {
   111  			f32 := float32(p.From.Val.(float64))
   112  			p.From.Type = obj.TYPE_MEM
   113  			p.From.Sym = ctxt.Float32Sym(f32)
   114  			p.From.Name = obj.NAME_EXTERN
   115  			p.From.Offset = 0
   116  		}
   117  
   118  	case AMOVD:
   119  		if p.From.Type == obj.TYPE_FCONST && c.chipfloat5(p.From.Val.(float64)) < 0 && (c.chipzero5(p.From.Val.(float64)) < 0 || p.Scond&C_SCOND != C_SCOND_NONE) {
   120  			p.From.Type = obj.TYPE_MEM
   121  			p.From.Sym = ctxt.Float64Sym(p.From.Val.(float64))
   122  			p.From.Name = obj.NAME_EXTERN
   123  			p.From.Offset = 0
   124  		}
   125  	}
   126  
   127  	if ctxt.Flag_dynlink {
   128  		c.rewriteToUseGot(p)
   129  	}
   130  }
   131  
   132  // Rewrite p, if necessary, to access global data via the global offset table.
   133  func (c *ctxt5) rewriteToUseGot(p *obj.Prog) {
   134  	if p.As == obj.ADUFFCOPY || p.As == obj.ADUFFZERO {
   135  		//     ADUFFxxx $offset
   136  		// becomes
   137  		//     MOVW runtime.duffxxx@GOT, R9
   138  		//     ADD $offset, R9
   139  		//     CALL (R9)
   140  		var sym *obj.LSym
   141  		if p.As == obj.ADUFFZERO {
   142  			sym = c.ctxt.Lookup("runtime.duffzero")
   143  		} else {
   144  			sym = c.ctxt.Lookup("runtime.duffcopy")
   145  		}
   146  		offset := p.To.Offset
   147  		p.As = AMOVW
   148  		p.From.Type = obj.TYPE_MEM
   149  		p.From.Name = obj.NAME_GOTREF
   150  		p.From.Sym = sym
   151  		p.To.Type = obj.TYPE_REG
   152  		p.To.Reg = REG_R9
   153  		p.To.Name = obj.NAME_NONE
   154  		p.To.Offset = 0
   155  		p.To.Sym = nil
   156  		p1 := obj.Appendp(p, c.newprog)
   157  		p1.As = AADD
   158  		p1.From.Type = obj.TYPE_CONST
   159  		p1.From.Offset = offset
   160  		p1.To.Type = obj.TYPE_REG
   161  		p1.To.Reg = REG_R9
   162  		p2 := obj.Appendp(p1, c.newprog)
   163  		p2.As = obj.ACALL
   164  		p2.To.Type = obj.TYPE_MEM
   165  		p2.To.Reg = REG_R9
   166  		return
   167  	}
   168  
   169  	// We only care about global data: NAME_EXTERN means a global
   170  	// symbol in the Go sense, and p.Sym.Local is true for a few
   171  	// internally defined symbols.
   172  	if p.From.Type == obj.TYPE_ADDR && p.From.Name == obj.NAME_EXTERN && !p.From.Sym.Local() {
   173  		// MOVW $sym, Rx becomes MOVW sym@GOT, Rx
   174  		// MOVW $sym+<off>, Rx becomes MOVW sym@GOT, Rx; ADD <off>, Rx
   175  		if p.As != AMOVW {
   176  			c.ctxt.Diag("do not know how to handle TYPE_ADDR in %v with -dynlink", p)
   177  		}
   178  		if p.To.Type != obj.TYPE_REG {
   179  			c.ctxt.Diag("do not know how to handle LEAQ-type insn to non-register in %v with -dynlink", p)
   180  		}
   181  		p.From.Type = obj.TYPE_MEM
   182  		p.From.Name = obj.NAME_GOTREF
   183  		if p.From.Offset != 0 {
   184  			q := obj.Appendp(p, c.newprog)
   185  			q.As = AADD
   186  			q.From.Type = obj.TYPE_CONST
   187  			q.From.Offset = p.From.Offset
   188  			q.To = p.To
   189  			p.From.Offset = 0
   190  		}
   191  	}
   192  	if p.GetFrom3() != nil && p.GetFrom3().Name == obj.NAME_EXTERN {
   193  		c.ctxt.Diag("don't know how to handle %v with -dynlink", p)
   194  	}
   195  	var source *obj.Addr
   196  	// MOVx sym, Ry becomes MOVW sym@GOT, R9; MOVx (R9), Ry
   197  	// MOVx Ry, sym becomes MOVW sym@GOT, R9; MOVx Ry, (R9)
   198  	// An addition may be inserted between the two MOVs if there is an offset.
   199  	if p.From.Name == obj.NAME_EXTERN && !p.From.Sym.Local() {
   200  		if p.To.Name == obj.NAME_EXTERN && !p.To.Sym.Local() {
   201  			c.ctxt.Diag("cannot handle NAME_EXTERN on both sides in %v with -dynlink", p)
   202  		}
   203  		source = &p.From
   204  	} else if p.To.Name == obj.NAME_EXTERN && !p.To.Sym.Local() {
   205  		source = &p.To
   206  	} else {
   207  		return
   208  	}
   209  	if p.As == obj.ATEXT || p.As == obj.AFUNCDATA || p.As == obj.ACALL || p.As == obj.ARET || p.As == obj.AJMP {
   210  		return
   211  	}
   212  	if source.Sym.Type == objabi.STLSBSS {
   213  		return
   214  	}
   215  	if source.Type != obj.TYPE_MEM {
   216  		c.ctxt.Diag("don't know how to handle %v with -dynlink", p)
   217  	}
   218  	p1 := obj.Appendp(p, c.newprog)
   219  	p2 := obj.Appendp(p1, c.newprog)
   220  
   221  	p1.As = AMOVW
   222  	p1.From.Type = obj.TYPE_MEM
   223  	p1.From.Sym = source.Sym
   224  	p1.From.Name = obj.NAME_GOTREF
   225  	p1.To.Type = obj.TYPE_REG
   226  	p1.To.Reg = REG_R9
   227  
   228  	p2.As = p.As
   229  	p2.From = p.From
   230  	p2.To = p.To
   231  	if p.From.Name == obj.NAME_EXTERN {
   232  		p2.From.Reg = REG_R9
   233  		p2.From.Name = obj.NAME_NONE
   234  		p2.From.Sym = nil
   235  	} else if p.To.Name == obj.NAME_EXTERN {
   236  		p2.To.Reg = REG_R9
   237  		p2.To.Name = obj.NAME_NONE
   238  		p2.To.Sym = nil
   239  	} else {
   240  		return
   241  	}
   242  	obj.Nopout(p)
   243  }
   244  
   245  // Prog.mark
   246  const (
   247  	FOLL  = 1 << 0
   248  	LABEL = 1 << 1
   249  	LEAF  = 1 << 2
   250  )
   251  
   252  func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
   253  	autosize := int32(0)
   254  
   255  	if cursym.Func().Text == nil || cursym.Func().Text.Link == nil {
   256  		return
   257  	}
   258  
   259  	c := ctxt5{ctxt: ctxt, cursym: cursym, newprog: newprog}
   260  
   261  	p := c.cursym.Func().Text
   262  	autoffset := int32(p.To.Offset)
   263  	if autoffset == -4 {
   264  		// Historical way to mark NOFRAME.
   265  		p.From.Sym.Set(obj.AttrNoFrame, true)
   266  		autoffset = 0
   267  	}
   268  	if autoffset < 0 || autoffset%4 != 0 {
   269  		c.ctxt.Diag("frame size %d not 0 or a positive multiple of 4", autoffset)
   270  	}
   271  	if p.From.Sym.NoFrame() {
   272  		if autoffset != 0 {
   273  			c.ctxt.Diag("NOFRAME functions must have a frame size of 0, not %d", autoffset)
   274  		}
   275  	}
   276  
   277  	cursym.Func().Locals = autoffset
   278  	cursym.Func().Args = p.To.Val.(int32)
   279  
   280  	/*
   281  	 * find leaf subroutines
   282  	 */
   283  	for p := cursym.Func().Text; p != nil; p = p.Link {
   284  		switch p.As {
   285  		case obj.ATEXT:
   286  			p.Mark |= LEAF
   287  
   288  		case ADIV, ADIVU, AMOD, AMODU:
   289  			cursym.Func().Text.Mark &^= LEAF
   290  
   291  		case ABL,
   292  			ABX,
   293  			obj.ADUFFZERO,
   294  			obj.ADUFFCOPY:
   295  			cursym.Func().Text.Mark &^= LEAF
   296  		}
   297  	}
   298  
   299  	var q2 *obj.Prog
   300  	for p := cursym.Func().Text; p != nil; p = p.Link {
   301  		o := p.As
   302  		switch o {
   303  		case obj.ATEXT:
   304  			autosize = autoffset
   305  
   306  			if p.Mark&LEAF != 0 && autosize == 0 {
   307  				// A leaf function with no locals has no frame.
   308  				p.From.Sym.Set(obj.AttrNoFrame, true)
   309  			}
   310  
   311  			if !p.From.Sym.NoFrame() {
   312  				// If there is a stack frame at all, it includes
   313  				// space to save the LR.
   314  				autosize += 4
   315  			}
   316  
   317  			if autosize == 0 && cursym.Func().Text.Mark&LEAF == 0 {
   318  				// A very few functions that do not return to their caller
   319  				// are not identified as leaves but still have no frame.
   320  				if ctxt.Debugvlog {
   321  					ctxt.Logf("save suppressed in: %s\n", cursym.Name)
   322  				}
   323  
   324  				cursym.Func().Text.Mark |= LEAF
   325  			}
   326  
   327  			// FP offsets need an updated p.To.Offset.
   328  			p.To.Offset = int64(autosize) - 4
   329  
   330  			if cursym.Func().Text.Mark&LEAF != 0 {
   331  				cursym.Set(obj.AttrLeaf, true)
   332  				if p.From.Sym.NoFrame() {
   333  					break
   334  				}
   335  			}
   336  
   337  			if !p.From.Sym.NoSplit() {
   338  				p = c.stacksplit(p, autosize) // emit split check
   339  			}
   340  
   341  			// MOVW.W		R14,$-autosize(SP)
   342  			p = obj.Appendp(p, c.newprog)
   343  
   344  			p.As = AMOVW
   345  			p.Scond |= C_WBIT
   346  			p.From.Type = obj.TYPE_REG
   347  			p.From.Reg = REGLINK
   348  			p.To.Type = obj.TYPE_MEM
   349  			p.To.Offset = int64(-autosize)
   350  			p.To.Reg = REGSP
   351  			p.Spadj = autosize
   352  
   353  		case obj.ARET:
   354  			nocache(p)
   355  			if cursym.Func().Text.Mark&LEAF != 0 {
   356  				if autosize == 0 {
   357  					p.As = AB
   358  					p.From = obj.Addr{}
   359  					if p.To.Sym != nil { // retjmp
   360  						p.To.Type = obj.TYPE_BRANCH
   361  					} else {
   362  						p.To.Type = obj.TYPE_MEM
   363  						p.To.Offset = 0
   364  						p.To.Reg = REGLINK
   365  					}
   366  
   367  					break
   368  				}
   369  			}
   370  
   371  			p.As = AMOVW
   372  			p.Scond |= C_PBIT
   373  			p.From.Type = obj.TYPE_MEM
   374  			p.From.Offset = int64(autosize)
   375  			p.From.Reg = REGSP
   376  			p.To.Type = obj.TYPE_REG
   377  			p.To.Reg = REGPC
   378  
   379  			// If there are instructions following
   380  			// this ARET, they come from a branch
   381  			// with the same stackframe, so no spadj.
   382  
   383  			if p.To.Sym != nil { // retjmp
   384  				p.To.Reg = REGLINK
   385  				q2 = obj.Appendp(p, newprog)
   386  				q2.As = AB
   387  				q2.To.Type = obj.TYPE_BRANCH
   388  				q2.To.Sym = p.To.Sym
   389  				p.To.Sym = nil
   390  				p.To.Name = obj.NAME_NONE
   391  				p = q2
   392  			}
   393  
   394  		case AADD:
   395  			if p.From.Type == obj.TYPE_CONST && p.From.Reg == 0 && p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP {
   396  				p.Spadj = int32(-p.From.Offset)
   397  			}
   398  
   399  		case ASUB:
   400  			if p.From.Type == obj.TYPE_CONST && p.From.Reg == 0 && p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP {
   401  				p.Spadj = int32(p.From.Offset)
   402  			}
   403  
   404  		case ADIV, ADIVU, AMOD, AMODU:
   405  			if cursym.Func().Text.From.Sym.NoSplit() {
   406  				ctxt.Diag("cannot divide in NOSPLIT function")
   407  			}
   408  			const debugdivmod = false
   409  			if debugdivmod {
   410  				break
   411  			}
   412  			if p.From.Type != obj.TYPE_REG {
   413  				break
   414  			}
   415  			if p.To.Type != obj.TYPE_REG {
   416  				break
   417  			}
   418  
   419  			// Make copy because we overwrite p below.
   420  			q1 := *p
   421  			if q1.Reg == REGTMP || q1.Reg == 0 && q1.To.Reg == REGTMP {
   422  				ctxt.Diag("div already using REGTMP: %v", p)
   423  			}
   424  
   425  			/* MOV m(g),REGTMP */
   426  			p.As = AMOVW
   427  			p.Pos = q1.Pos
   428  			p.From.Type = obj.TYPE_MEM
   429  			p.From.Reg = REGG
   430  			p.From.Offset = 6 * 4 // offset of g.m
   431  			p.Reg = 0
   432  			p.To.Type = obj.TYPE_REG
   433  			p.To.Reg = REGTMP
   434  
   435  			/* MOV a,m_divmod(REGTMP) */
   436  			p = obj.Appendp(p, newprog)
   437  			p.As = AMOVW
   438  			p.Pos = q1.Pos
   439  			p.From.Type = obj.TYPE_REG
   440  			p.From.Reg = q1.From.Reg
   441  			p.To.Type = obj.TYPE_MEM
   442  			p.To.Reg = REGTMP
   443  			p.To.Offset = 7 * 4 // offset of m.divmod
   444  
   445  			/* MOV b, R8 */
   446  			p = obj.Appendp(p, newprog)
   447  			p.As = AMOVW
   448  			p.Pos = q1.Pos
   449  			p.From.Type = obj.TYPE_REG
   450  			p.From.Reg = q1.Reg
   451  			if q1.Reg == 0 {
   452  				p.From.Reg = q1.To.Reg
   453  			}
   454  			p.To.Type = obj.TYPE_REG
   455  			p.To.Reg = REG_R8
   456  			p.To.Offset = 0
   457  
   458  			/* CALL appropriate */
   459  			p = obj.Appendp(p, newprog)
   460  			p.As = ABL
   461  			p.Pos = q1.Pos
   462  			p.To.Type = obj.TYPE_BRANCH
   463  			switch o {
   464  			case ADIV:
   465  				p.To.Sym = symdiv
   466  			case ADIVU:
   467  				p.To.Sym = symdivu
   468  			case AMOD:
   469  				p.To.Sym = symmod
   470  			case AMODU:
   471  				p.To.Sym = symmodu
   472  			}
   473  
   474  			/* MOV REGTMP, b */
   475  			p = obj.Appendp(p, newprog)
   476  			p.As = AMOVW
   477  			p.Pos = q1.Pos
   478  			p.From.Type = obj.TYPE_REG
   479  			p.From.Reg = REGTMP
   480  			p.From.Offset = 0
   481  			p.To.Type = obj.TYPE_REG
   482  			p.To.Reg = q1.To.Reg
   483  
   484  		case AMOVW:
   485  			if (p.Scond&C_WBIT != 0) && p.To.Type == obj.TYPE_MEM && p.To.Reg == REGSP {
   486  				p.Spadj = int32(-p.To.Offset)
   487  			}
   488  			if (p.Scond&C_PBIT != 0) && p.From.Type == obj.TYPE_MEM && p.From.Reg == REGSP && p.To.Reg != REGPC {
   489  				p.Spadj = int32(-p.From.Offset)
   490  			}
   491  			if p.From.Type == obj.TYPE_ADDR && p.From.Reg == REGSP && p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP {
   492  				p.Spadj = int32(-p.From.Offset)
   493  			}
   494  
   495  		case obj.AGETCALLERPC:
   496  			if cursym.Leaf() {
   497  				/* MOVW LR, Rd */
   498  				p.As = AMOVW
   499  				p.From.Type = obj.TYPE_REG
   500  				p.From.Reg = REGLINK
   501  			} else {
   502  				/* MOVW (RSP), Rd */
   503  				p.As = AMOVW
   504  				p.From.Type = obj.TYPE_MEM
   505  				p.From.Reg = REGSP
   506  			}
   507  		}
   508  
   509  		if p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP && p.Spadj == 0 {
   510  			f := c.cursym.Func()
   511  			if f.FuncFlag&abi.FuncFlagSPWrite == 0 {
   512  				c.cursym.Func().FuncFlag |= abi.FuncFlagSPWrite
   513  				if ctxt.Debugvlog || !ctxt.IsAsm {
   514  					ctxt.Logf("auto-SPWRITE: %s %v\n", c.cursym.Name, p)
   515  					if !ctxt.IsAsm {
   516  						ctxt.Diag("invalid auto-SPWRITE in non-assembly")
   517  						ctxt.DiagFlush()
   518  						log.Fatalf("bad SPWRITE")
   519  					}
   520  				}
   521  			}
   522  		}
   523  	}
   524  }
   525  
   526  func (c *ctxt5) stacksplit(p *obj.Prog, framesize int32) *obj.Prog {
   527  	if c.ctxt.Flag_maymorestack != "" {
   528  		// Save LR and make room for REGCTXT.
   529  		const frameSize = 8
   530  		// MOVW.W R14,$-8(SP)
   531  		p = obj.Appendp(p, c.newprog)
   532  		p.As = AMOVW
   533  		p.Scond |= C_WBIT
   534  		p.From.Type = obj.TYPE_REG
   535  		p.From.Reg = REGLINK
   536  		p.To.Type = obj.TYPE_MEM
   537  		p.To.Offset = -frameSize
   538  		p.To.Reg = REGSP
   539  		p.Spadj = frameSize
   540  
   541  		// MOVW REGCTXT, 4(SP)
   542  		p = obj.Appendp(p, c.newprog)
   543  		p.As = AMOVW
   544  		p.From.Type = obj.TYPE_REG
   545  		p.From.Reg = REGCTXT
   546  		p.To.Type = obj.TYPE_MEM
   547  		p.To.Offset = 4
   548  		p.To.Reg = REGSP
   549  
   550  		// CALL maymorestack
   551  		p = obj.Appendp(p, c.newprog)
   552  		p.As = obj.ACALL
   553  		p.To.Type = obj.TYPE_BRANCH
   554  		// See ../x86/obj6.go
   555  		p.To.Sym = c.ctxt.LookupABI(c.ctxt.Flag_maymorestack, c.cursym.ABI())
   556  
   557  		// Restore REGCTXT and LR.
   558  
   559  		// MOVW 4(SP), REGCTXT
   560  		p = obj.Appendp(p, c.newprog)
   561  		p.As = AMOVW
   562  		p.From.Type = obj.TYPE_MEM
   563  		p.From.Offset = 4
   564  		p.From.Reg = REGSP
   565  		p.To.Type = obj.TYPE_REG
   566  		p.To.Reg = REGCTXT
   567  
   568  		// MOVW.P 8(SP), R14
   569  		p.As = AMOVW
   570  		p.Scond |= C_PBIT
   571  		p.From.Type = obj.TYPE_MEM
   572  		p.From.Offset = frameSize
   573  		p.From.Reg = REGSP
   574  		p.To.Type = obj.TYPE_REG
   575  		p.To.Reg = REGLINK
   576  		p.Spadj = -frameSize
   577  	}
   578  
   579  	// Jump back to here after morestack returns.
   580  	startPred := p
   581  
   582  	// MOVW g_stackguard(g), R1
   583  	p = obj.Appendp(p, c.newprog)
   584  
   585  	p.As = AMOVW
   586  	p.From.Type = obj.TYPE_MEM
   587  	p.From.Reg = REGG
   588  	p.From.Offset = 2 * int64(c.ctxt.Arch.PtrSize) // G.stackguard0
   589  	if c.cursym.CFunc() {
   590  		p.From.Offset = 3 * int64(c.ctxt.Arch.PtrSize) // G.stackguard1
   591  	}
   592  	p.To.Type = obj.TYPE_REG
   593  	p.To.Reg = REG_R1
   594  
   595  	// Mark the stack bound check and morestack call async nonpreemptible.
   596  	// If we get preempted here, when resumed the preemption request is
   597  	// cleared, but we'll still call morestack, which will double the stack
   598  	// unnecessarily. See issue #35470.
   599  	p = c.ctxt.StartUnsafePoint(p, c.newprog)
   600  
   601  	if framesize <= abi.StackSmall {
   602  		// small stack: SP < stackguard
   603  		//	CMP	stackguard, SP
   604  		p = obj.Appendp(p, c.newprog)
   605  
   606  		p.As = ACMP
   607  		p.From.Type = obj.TYPE_REG
   608  		p.From.Reg = REG_R1
   609  		p.Reg = REGSP
   610  	} else if framesize <= abi.StackBig {
   611  		// large stack: SP-framesize < stackguard-StackSmall
   612  		//	MOVW $-(framesize-StackSmall)(SP), R2
   613  		//	CMP stackguard, R2
   614  		p = obj.Appendp(p, c.newprog)
   615  
   616  		p.As = AMOVW
   617  		p.From.Type = obj.TYPE_ADDR
   618  		p.From.Reg = REGSP
   619  		p.From.Offset = -(int64(framesize) - abi.StackSmall)
   620  		p.To.Type = obj.TYPE_REG
   621  		p.To.Reg = REG_R2
   622  
   623  		p = obj.Appendp(p, c.newprog)
   624  		p.As = ACMP
   625  		p.From.Type = obj.TYPE_REG
   626  		p.From.Reg = REG_R1
   627  		p.Reg = REG_R2
   628  	} else {
   629  		// Such a large stack we need to protect against underflow.
   630  		// The runtime guarantees SP > objabi.StackBig, but
   631  		// framesize is large enough that SP-framesize may
   632  		// underflow, causing a direct comparison with the
   633  		// stack guard to incorrectly succeed. We explicitly
   634  		// guard against underflow.
   635  		//
   636  		//	// Try subtracting from SP and check for underflow.
   637  		//	// If this underflows, it sets C to 0.
   638  		//	SUB.S $(framesize-StackSmall), SP, R2
   639  		//	// If C is 1 (unsigned >=), compare with guard.
   640  		//	CMP.HS stackguard, R2
   641  
   642  		p = obj.Appendp(p, c.newprog)
   643  		p.As = ASUB
   644  		p.Scond = C_SBIT
   645  		p.From.Type = obj.TYPE_CONST
   646  		p.From.Offset = int64(framesize) - abi.StackSmall
   647  		p.Reg = REGSP
   648  		p.To.Type = obj.TYPE_REG
   649  		p.To.Reg = REG_R2
   650  
   651  		p = obj.Appendp(p, c.newprog)
   652  		p.As = ACMP
   653  		p.Scond = C_SCOND_HS
   654  		p.From.Type = obj.TYPE_REG
   655  		p.From.Reg = REG_R1
   656  		p.Reg = REG_R2
   657  	}
   658  
   659  	// BLS call-to-morestack (C is 0 or Z is 1)
   660  	bls := obj.Appendp(p, c.newprog)
   661  	bls.As = ABLS
   662  	bls.To.Type = obj.TYPE_BRANCH
   663  
   664  	end := c.ctxt.EndUnsafePoint(bls, c.newprog, -1)
   665  
   666  	var last *obj.Prog
   667  	for last = c.cursym.Func().Text; last.Link != nil; last = last.Link {
   668  	}
   669  
   670  	// Now we are at the end of the function, but logically
   671  	// we are still in function prologue. We need to fix the
   672  	// SP data and PCDATA.
   673  	spfix := obj.Appendp(last, c.newprog)
   674  	spfix.As = obj.ANOP
   675  	spfix.Spadj = -framesize
   676  
   677  	pcdata := c.ctxt.EmitEntryStackMap(c.cursym, spfix, c.newprog)
   678  	pcdata = c.ctxt.StartUnsafePoint(pcdata, c.newprog)
   679  
   680  	// MOVW	LR, R3
   681  	movw := obj.Appendp(pcdata, c.newprog)
   682  	movw.As = AMOVW
   683  	movw.From.Type = obj.TYPE_REG
   684  	movw.From.Reg = REGLINK
   685  	movw.To.Type = obj.TYPE_REG
   686  	movw.To.Reg = REG_R3
   687  
   688  	bls.To.SetTarget(movw)
   689  
   690  	// BL runtime.morestack
   691  	call := obj.Appendp(movw, c.newprog)
   692  	call.As = obj.ACALL
   693  	call.To.Type = obj.TYPE_BRANCH
   694  	morestack := "runtime.morestack"
   695  	switch {
   696  	case c.cursym.CFunc():
   697  		morestack = "runtime.morestackc"
   698  	case !c.cursym.Func().Text.From.Sym.NeedCtxt():
   699  		morestack = "runtime.morestack_noctxt"
   700  	}
   701  	call.To.Sym = c.ctxt.Lookup(morestack)
   702  
   703  	pcdata = c.ctxt.EndUnsafePoint(call, c.newprog, -1)
   704  
   705  	// B start
   706  	b := obj.Appendp(pcdata, c.newprog)
   707  	b.As = obj.AJMP
   708  	b.To.Type = obj.TYPE_BRANCH
   709  	b.To.SetTarget(startPred.Link)
   710  	b.Spadj = +framesize
   711  
   712  	return end
   713  }
   714  
   715  var unaryDst = map[obj.As]bool{
   716  	ASWI:  true,
   717  	AWORD: true,
   718  }
   719  
   720  var Linkarm = obj.LinkArch{
   721  	Arch:           sys.ArchARM,
   722  	Init:           buildop,
   723  	Preprocess:     preprocess,
   724  	Assemble:       span5,
   725  	Progedit:       progedit,
   726  	UnaryDst:       unaryDst,
   727  	DWARFRegisters: ARMDWARFRegisters,
   728  }
   729
View as plain text