Source file src/cmd/internal/obj/wasm/wasmobj.go

     1  // Copyright 2018 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package wasm
     6  
     7  import (
     8  	"bytes"
     9  	"cmd/internal/obj"
    10  	"cmd/internal/objabi"
    11  	"cmd/internal/sys"
    12  	"encoding/binary"
    13  	"fmt"
    14  	"internal/abi"
    15  	"io"
    16  	"math"
    17  )
    18  
    19  var Register = map[string]int16{
    20  	"SP":    REG_SP,
    21  	"CTXT":  REG_CTXT,
    22  	"g":     REG_g,
    23  	"RET0":  REG_RET0,
    24  	"RET1":  REG_RET1,
    25  	"RET2":  REG_RET2,
    26  	"RET3":  REG_RET3,
    27  	"PAUSE": REG_PAUSE,
    28  
    29  	"R0":  REG_R0,
    30  	"R1":  REG_R1,
    31  	"R2":  REG_R2,
    32  	"R3":  REG_R3,
    33  	"R4":  REG_R4,
    34  	"R5":  REG_R5,
    35  	"R6":  REG_R6,
    36  	"R7":  REG_R7,
    37  	"R8":  REG_R8,
    38  	"R9":  REG_R9,
    39  	"R10": REG_R10,
    40  	"R11": REG_R11,
    41  	"R12": REG_R12,
    42  	"R13": REG_R13,
    43  	"R14": REG_R14,
    44  	"R15": REG_R15,
    45  
    46  	"F0":  REG_F0,
    47  	"F1":  REG_F1,
    48  	"F2":  REG_F2,
    49  	"F3":  REG_F3,
    50  	"F4":  REG_F4,
    51  	"F5":  REG_F5,
    52  	"F6":  REG_F6,
    53  	"F7":  REG_F7,
    54  	"F8":  REG_F8,
    55  	"F9":  REG_F9,
    56  	"F10": REG_F10,
    57  	"F11": REG_F11,
    58  	"F12": REG_F12,
    59  	"F13": REG_F13,
    60  	"F14": REG_F14,
    61  	"F15": REG_F15,
    62  
    63  	"F16": REG_F16,
    64  	"F17": REG_F17,
    65  	"F18": REG_F18,
    66  	"F19": REG_F19,
    67  	"F20": REG_F20,
    68  	"F21": REG_F21,
    69  	"F22": REG_F22,
    70  	"F23": REG_F23,
    71  	"F24": REG_F24,
    72  	"F25": REG_F25,
    73  	"F26": REG_F26,
    74  	"F27": REG_F27,
    75  	"F28": REG_F28,
    76  	"F29": REG_F29,
    77  	"F30": REG_F30,
    78  	"F31": REG_F31,
    79  
    80  	"PC_B": REG_PC_B,
    81  }
    82  
    83  var registerNames []string
    84  
    85  func init() {
    86  	obj.RegisterRegister(MINREG, MAXREG, rconv)
    87  	obj.RegisterOpcode(obj.ABaseWasm, Anames)
    88  
    89  	registerNames = make([]string, MAXREG-MINREG)
    90  	for name, reg := range Register {
    91  		registerNames[reg-MINREG] = name
    92  	}
    93  }
    94  
    95  func rconv(r int) string {
    96  	return registerNames[r-MINREG]
    97  }
    98  
    99  var unaryDst = map[obj.As]bool{
   100  	ASet:          true,
   101  	ATee:          true,
   102  	ACall:         true,
   103  	ACallIndirect: true,
   104  	ABr:           true,
   105  	ABrIf:         true,
   106  	ABrTable:      true,
   107  	AI32Store:     true,
   108  	AI64Store:     true,
   109  	AF32Store:     true,
   110  	AF64Store:     true,
   111  	AI32Store8:    true,
   112  	AI32Store16:   true,
   113  	AI64Store8:    true,
   114  	AI64Store16:   true,
   115  	AI64Store32:   true,
   116  	ACALLNORESUME: true,
   117  }
   118  
   119  var Linkwasm = obj.LinkArch{
   120  	Arch:       sys.ArchWasm,
   121  	Init:       instinit,
   122  	Preprocess: preprocess,
   123  	Assemble:   assemble,
   124  	UnaryDst:   unaryDst,
   125  }
   126  
   127  var (
   128  	morestack             *obj.LSym
   129  	morestackNoCtxt       *obj.LSym
   130  	sigpanic              *obj.LSym
   131  	wasm_pc_f_loop_export *obj.LSym
   132  	runtimeNotInitialized *obj.LSym
   133  )
   134  
   135  const (
   136  	/* mark flags */
   137  	WasmImport = 1 << 0
   138  )
   139  
   140  const (
   141  	// This is a special wasm module name that when used as the module name
   142  	// in //go:wasmimport will cause the generated code to pass the stack pointer
   143  	// directly to the imported function. In other words, any function that
   144  	// uses the gojs module understands the internal Go WASM ABI directly.
   145  	GojsModule = "gojs"
   146  )
   147  
   148  func instinit(ctxt *obj.Link) {
   149  	morestack = ctxt.Lookup("runtime.morestack")
   150  	morestackNoCtxt = ctxt.Lookup("runtime.morestack_noctxt")
   151  	sigpanic = ctxt.LookupABI("runtime.sigpanic", obj.ABIInternal)
   152  	wasm_pc_f_loop_export = ctxt.Lookup("wasm_pc_f_loop_export")
   153  	runtimeNotInitialized = ctxt.Lookup("runtime.notInitialized")
   154  }
   155  
   156  func preprocess(ctxt *obj.Link, s *obj.LSym, newprog obj.ProgAlloc) {
   157  	appendp := func(p *obj.Prog, as obj.As, args ...obj.Addr) *obj.Prog {
   158  		if p.As != obj.ANOP {
   159  			p2 := obj.Appendp(p, newprog)
   160  			p2.Pc = p.Pc
   161  			p = p2
   162  		}
   163  		p.As = as
   164  		switch len(args) {
   165  		case 0:
   166  			p.From = obj.Addr{}
   167  			p.To = obj.Addr{}
   168  		case 1:
   169  			if unaryDst[as] {
   170  				p.From = obj.Addr{}
   171  				p.To = args[0]
   172  			} else {
   173  				p.From = args[0]
   174  				p.To = obj.Addr{}
   175  			}
   176  		case 2:
   177  			p.From = args[0]
   178  			p.To = args[1]
   179  		default:
   180  			panic("bad args")
   181  		}
   182  		return p
   183  	}
   184  
   185  	framesize := s.Func().Text.To.Offset
   186  	if framesize < 0 {
   187  		panic("bad framesize")
   188  	}
   189  	s.Func().Args = s.Func().Text.To.Val.(int32)
   190  	s.Func().Locals = int32(framesize)
   191  
   192  	// If the function exits just to call out to a wasmimport, then
   193  	// generate the code to translate from our internal Go-stack
   194  	// based call convention to the native webassembly call convention.
   195  	if s.Func().WasmImport != nil {
   196  		genWasmImportWrapper(s, appendp)
   197  
   198  		// It should be 0 already, but we'll set it to 0 anyway just to be sure
   199  		// that the code below which adds frame expansion code to the function body
   200  		// isn't run. We don't want the frame expansion code because our function
   201  		// body is just the code to translate and call the imported function.
   202  		framesize = 0
   203  	} else if s.Func().WasmExport != nil {
   204  		genWasmExportWrapper(s, appendp)
   205  	} else if s.Func().Text.From.Sym.Wrapper() {
   206  		// if g._panic != nil && g._panic.argp == FP {
   207  		//   g._panic.argp = bottom-of-frame
   208  		// }
   209  		//
   210  		// MOVD g_panic(g), R0
   211  		// Get R0
   212  		// I64Eqz
   213  		// Not
   214  		// If
   215  		//   Get SP
   216  		//   I64ExtendI32U
   217  		//   I64Const $framesize+8
   218  		//   I64Add
   219  		//   I64Load panic_argp(R0)
   220  		//   I64Eq
   221  		//   If
   222  		//     MOVD SP, panic_argp(R0)
   223  		//   End
   224  		// End
   225  
   226  		gpanic := obj.Addr{
   227  			Type:   obj.TYPE_MEM,
   228  			Reg:    REGG,
   229  			Offset: 4 * 8, // g_panic
   230  		}
   231  
   232  		panicargp := obj.Addr{
   233  			Type:   obj.TYPE_MEM,
   234  			Reg:    REG_R0,
   235  			Offset: 0, // panic.argp
   236  		}
   237  
   238  		p := s.Func().Text
   239  		p = appendp(p, AMOVD, gpanic, regAddr(REG_R0))
   240  
   241  		p = appendp(p, AGet, regAddr(REG_R0))
   242  		p = appendp(p, AI64Eqz)
   243  		p = appendp(p, ANot)
   244  		p = appendp(p, AIf)
   245  
   246  		p = appendp(p, AGet, regAddr(REG_SP))
   247  		p = appendp(p, AI64ExtendI32U)
   248  		p = appendp(p, AI64Const, constAddr(framesize+8))
   249  		p = appendp(p, AI64Add)
   250  		p = appendp(p, AI64Load, panicargp)
   251  
   252  		p = appendp(p, AI64Eq)
   253  		p = appendp(p, AIf)
   254  		p = appendp(p, AMOVD, regAddr(REG_SP), panicargp)
   255  		p = appendp(p, AEnd)
   256  
   257  		p = appendp(p, AEnd)
   258  	}
   259  
   260  	if framesize > 0 && s.Func().WasmExport == nil { // genWasmExportWrapper has its own prologue generation
   261  		p := s.Func().Text
   262  		p = appendp(p, AGet, regAddr(REG_SP))
   263  		p = appendp(p, AI32Const, constAddr(framesize))
   264  		p = appendp(p, AI32Sub)
   265  		p = appendp(p, ASet, regAddr(REG_SP))
   266  		p.Spadj = int32(framesize)
   267  	}
   268  
   269  	// If the framesize is 0, then imply nosplit because it's a specially
   270  	// generated function.
   271  	needMoreStack := framesize > 0 && !s.Func().Text.From.Sym.NoSplit()
   272  
   273  	// If the maymorestack debug option is enabled, insert the
   274  	// call to maymorestack *before* processing resume points so
   275  	// we can construct a resume point after maymorestack for
   276  	// morestack to resume at.
   277  	var pMorestack = s.Func().Text
   278  	if needMoreStack && ctxt.Flag_maymorestack != "" {
   279  		p := pMorestack
   280  
   281  		// Save REGCTXT on the stack.
   282  		const tempFrame = 8
   283  		p = appendp(p, AGet, regAddr(REG_SP))
   284  		p = appendp(p, AI32Const, constAddr(tempFrame))
   285  		p = appendp(p, AI32Sub)
   286  		p = appendp(p, ASet, regAddr(REG_SP))
   287  		p.Spadj = tempFrame
   288  		ctxtp := obj.Addr{
   289  			Type:   obj.TYPE_MEM,
   290  			Reg:    REG_SP,
   291  			Offset: 0,
   292  		}
   293  		p = appendp(p, AMOVD, regAddr(REGCTXT), ctxtp)
   294  
   295  		// maymorestack must not itself preempt because we
   296  		// don't have full stack information, so this can be
   297  		// ACALLNORESUME.
   298  		p = appendp(p, ACALLNORESUME, constAddr(0))
   299  		// See ../x86/obj6.go
   300  		sym := ctxt.LookupABI(ctxt.Flag_maymorestack, s.ABI())
   301  		p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: sym}
   302  
   303  		// Restore REGCTXT.
   304  		p = appendp(p, AMOVD, ctxtp, regAddr(REGCTXT))
   305  		p = appendp(p, AGet, regAddr(REG_SP))
   306  		p = appendp(p, AI32Const, constAddr(tempFrame))
   307  		p = appendp(p, AI32Add)
   308  		p = appendp(p, ASet, regAddr(REG_SP))
   309  		p.Spadj = -tempFrame
   310  
   311  		// Add an explicit ARESUMEPOINT after maymorestack for
   312  		// morestack to resume at.
   313  		pMorestack = appendp(p, ARESUMEPOINT)
   314  	}
   315  
   316  	// Introduce resume points for CALL instructions
   317  	// and collect other explicit resume points.
   318  	numResumePoints := 0
   319  	explicitBlockDepth := 0
   320  	pc := int64(0) // pc is only incremented when necessary, this avoids bloat of the BrTable instruction
   321  	var tableIdxs []uint64
   322  	tablePC := int64(0)
   323  	base := ctxt.PosTable.Pos(s.Func().Text.Pos).Base()
   324  	for p := s.Func().Text; p != nil; p = p.Link {
   325  		prevBase := base
   326  		base = ctxt.PosTable.Pos(p.Pos).Base()
   327  		switch p.As {
   328  		case ABlock, ALoop, AIf:
   329  			explicitBlockDepth++
   330  
   331  		case AEnd:
   332  			if explicitBlockDepth == 0 {
   333  				panic("End without block")
   334  			}
   335  			explicitBlockDepth--
   336  
   337  		case ARESUMEPOINT:
   338  			if explicitBlockDepth != 0 {
   339  				panic("RESUME can only be used on toplevel")
   340  			}
   341  			p.As = AEnd
   342  			for tablePC <= pc {
   343  				tableIdxs = append(tableIdxs, uint64(numResumePoints))
   344  				tablePC++
   345  			}
   346  			numResumePoints++
   347  			pc++
   348  
   349  		case obj.ACALL:
   350  			if explicitBlockDepth != 0 {
   351  				panic("CALL can only be used on toplevel, try CALLNORESUME instead")
   352  			}
   353  			appendp(p, ARESUMEPOINT)
   354  		}
   355  
   356  		p.Pc = pc
   357  
   358  		// Increase pc whenever some pc-value table needs a new entry. Don't increase it
   359  		// more often to avoid bloat of the BrTable instruction.
   360  		// The "base != prevBase" condition detects inlined instructions. They are an
   361  		// implicit call, so entering and leaving this section affects the stack trace.
   362  		if p.As == ACALLNORESUME || p.As == obj.ANOP || p.As == ANop || p.Spadj != 0 || base != prevBase {
   363  			pc++
   364  			if p.To.Sym == sigpanic {
   365  				// The panic stack trace expects the PC at the call of sigpanic,
   366  				// not the next one. However, runtime.Caller subtracts 1 from the
   367  				// PC. To make both PC and PC-1 work (have the same line number),
   368  				// we advance the PC by 2 at sigpanic.
   369  				pc++
   370  			}
   371  		}
   372  	}
   373  	tableIdxs = append(tableIdxs, uint64(numResumePoints))
   374  	s.Size = pc + 1
   375  
   376  	if needMoreStack {
   377  		p := pMorestack
   378  
   379  		if framesize <= abi.StackSmall {
   380  			// small stack: SP <= stackguard
   381  			// Get SP
   382  			// Get g
   383  			// I32WrapI64
   384  			// I32Load $stackguard0
   385  			// I32GtU
   386  
   387  			p = appendp(p, AGet, regAddr(REG_SP))
   388  			p = appendp(p, AGet, regAddr(REGG))
   389  			p = appendp(p, AI32WrapI64)
   390  			p = appendp(p, AI32Load, constAddr(2*int64(ctxt.Arch.PtrSize))) // G.stackguard0
   391  			p = appendp(p, AI32LeU)
   392  		} else {
   393  			// large stack: SP-framesize <= stackguard-StackSmall
   394  			//              SP <= stackguard+(framesize-StackSmall)
   395  			// Get SP
   396  			// Get g
   397  			// I32WrapI64
   398  			// I32Load $stackguard0
   399  			// I32Const $(framesize-StackSmall)
   400  			// I32Add
   401  			// I32GtU
   402  
   403  			p = appendp(p, AGet, regAddr(REG_SP))
   404  			p = appendp(p, AGet, regAddr(REGG))
   405  			p = appendp(p, AI32WrapI64)
   406  			p = appendp(p, AI32Load, constAddr(2*int64(ctxt.Arch.PtrSize))) // G.stackguard0
   407  			p = appendp(p, AI32Const, constAddr(framesize-abi.StackSmall))
   408  			p = appendp(p, AI32Add)
   409  			p = appendp(p, AI32LeU)
   410  		}
   411  		// TODO(neelance): handle wraparound case
   412  
   413  		p = appendp(p, AIf)
   414  		// This CALL does *not* have a resume point after it
   415  		// (we already inserted all of the resume points). As
   416  		// a result, morestack will resume at the *previous*
   417  		// resume point (typically, the beginning of the
   418  		// function) and perform the morestack check again.
   419  		// This is why we don't need an explicit loop like
   420  		// other architectures.
   421  		p = appendp(p, obj.ACALL, constAddr(0))
   422  		if s.Func().Text.From.Sym.NeedCtxt() {
   423  			p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: morestack}
   424  		} else {
   425  			p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: morestackNoCtxt}
   426  		}
   427  		p = appendp(p, AEnd)
   428  	}
   429  
   430  	// record the branches targeting the entry loop and the unwind exit,
   431  	// their targets with be filled in later
   432  	var entryPointLoopBranches []*obj.Prog
   433  	var unwindExitBranches []*obj.Prog
   434  	currentDepth := 0
   435  	for p := s.Func().Text; p != nil; p = p.Link {
   436  		switch p.As {
   437  		case ABlock, ALoop, AIf:
   438  			currentDepth++
   439  		case AEnd:
   440  			currentDepth--
   441  		}
   442  
   443  		switch p.As {
   444  		case obj.AJMP:
   445  			jmp := *p
   446  			p.As = obj.ANOP
   447  
   448  			if jmp.To.Type == obj.TYPE_BRANCH {
   449  				// jump to basic block
   450  				p = appendp(p, AI32Const, constAddr(jmp.To.Val.(*obj.Prog).Pc))
   451  				p = appendp(p, ASet, regAddr(REG_PC_B)) // write next basic block to PC_B
   452  				p = appendp(p, ABr)                     // jump to beginning of entryPointLoop
   453  				entryPointLoopBranches = append(entryPointLoopBranches, p)
   454  				break
   455  			}
   456  
   457  			// low-level WebAssembly call to function
   458  			switch jmp.To.Type {
   459  			case obj.TYPE_MEM:
   460  				if !notUsePC_B[jmp.To.Sym.Name] {
   461  					// Set PC_B parameter to function entry.
   462  					p = appendp(p, AI32Const, constAddr(0))
   463  				}
   464  				p = appendp(p, ACall, jmp.To)
   465  
   466  			case obj.TYPE_NONE:
   467  				// (target PC is on stack)
   468  				p = appendp(p, AI32WrapI64)
   469  				p = appendp(p, AI32Const, constAddr(16)) // only needs PC_F bits (16-31), PC_B bits (0-15) are zero
   470  				p = appendp(p, AI32ShrU)
   471  
   472  				// Set PC_B parameter to function entry.
   473  				// We need to push this before pushing the target PC_F,
   474  				// so temporarily pop PC_F, using our REG_PC_B as a
   475  				// scratch register, and push it back after pushing 0.
   476  				p = appendp(p, ASet, regAddr(REG_PC_B))
   477  				p = appendp(p, AI32Const, constAddr(0))
   478  				p = appendp(p, AGet, regAddr(REG_PC_B))
   479  
   480  				p = appendp(p, ACallIndirect)
   481  
   482  			default:
   483  				panic("bad target for JMP")
   484  			}
   485  
   486  			p = appendp(p, AReturn)
   487  
   488  		case obj.ACALL, ACALLNORESUME:
   489  			call := *p
   490  			p.As = obj.ANOP
   491  
   492  			pcAfterCall := call.Link.Pc
   493  			if call.To.Sym == sigpanic {
   494  				pcAfterCall-- // sigpanic expects to be called without advancing the pc
   495  			}
   496  
   497  			// SP -= 8
   498  			p = appendp(p, AGet, regAddr(REG_SP))
   499  			p = appendp(p, AI32Const, constAddr(8))
   500  			p = appendp(p, AI32Sub)
   501  			p = appendp(p, ASet, regAddr(REG_SP))
   502  
   503  			// write return address to Go stack
   504  			p = appendp(p, AGet, regAddr(REG_SP))
   505  			p = appendp(p, AI64Const, obj.Addr{
   506  				Type:   obj.TYPE_ADDR,
   507  				Name:   obj.NAME_EXTERN,
   508  				Sym:    s,           // PC_F
   509  				Offset: pcAfterCall, // PC_B
   510  			})
   511  			p = appendp(p, AI64Store, constAddr(0))
   512  
   513  			// low-level WebAssembly call to function
   514  			switch call.To.Type {
   515  			case obj.TYPE_MEM:
   516  				if !notUsePC_B[call.To.Sym.Name] {
   517  					// Set PC_B parameter to function entry.
   518  					p = appendp(p, AI32Const, constAddr(0))
   519  				}
   520  				p = appendp(p, ACall, call.To)
   521  
   522  			case obj.TYPE_NONE:
   523  				// (target PC is on stack)
   524  				p = appendp(p, AI32WrapI64)
   525  				p = appendp(p, AI32Const, constAddr(16)) // only needs PC_F bits (16-31), PC_B bits (0-15) are zero
   526  				p = appendp(p, AI32ShrU)
   527  
   528  				// Set PC_B parameter to function entry.
   529  				// We need to push this before pushing the target PC_F,
   530  				// so temporarily pop PC_F, using our PC_B as a
   531  				// scratch register, and push it back after pushing 0.
   532  				p = appendp(p, ASet, regAddr(REG_PC_B))
   533  				p = appendp(p, AI32Const, constAddr(0))
   534  				p = appendp(p, AGet, regAddr(REG_PC_B))
   535  
   536  				p = appendp(p, ACallIndirect)
   537  
   538  			default:
   539  				panic("bad target for CALL")
   540  			}
   541  
   542  			// return value of call is on the top of the stack, indicating whether to unwind the WebAssembly stack
   543  			if call.As == ACALLNORESUME && call.To.Sym != sigpanic { // sigpanic unwinds the stack, but it never resumes
   544  				// trying to unwind WebAssembly stack but call has no resume point, terminate with error
   545  				p = appendp(p, AIf)
   546  				p = appendp(p, obj.AUNDEF)
   547  				p = appendp(p, AEnd)
   548  			} else {
   549  				// unwinding WebAssembly stack to switch goroutine, return 1
   550  				p = appendp(p, ABrIf)
   551  				unwindExitBranches = append(unwindExitBranches, p)
   552  			}
   553  
   554  		case obj.ARET, ARETUNWIND:
   555  			ret := *p
   556  			p.As = obj.ANOP
   557  
   558  			if framesize > 0 {
   559  				// SP += framesize
   560  				p = appendp(p, AGet, regAddr(REG_SP))
   561  				p = appendp(p, AI32Const, constAddr(framesize))
   562  				p = appendp(p, AI32Add)
   563  				p = appendp(p, ASet, regAddr(REG_SP))
   564  				// TODO(neelance): This should theoretically set Spadj, but it only works without.
   565  				// p.Spadj = int32(-framesize)
   566  			}
   567  
   568  			if ret.To.Type == obj.TYPE_MEM {
   569  				// Set PC_B parameter to function entry.
   570  				p = appendp(p, AI32Const, constAddr(0))
   571  
   572  				// low-level WebAssembly call to function
   573  				p = appendp(p, ACall, ret.To)
   574  				p = appendp(p, AReturn)
   575  				break
   576  			}
   577  
   578  			// SP += 8
   579  			p = appendp(p, AGet, regAddr(REG_SP))
   580  			p = appendp(p, AI32Const, constAddr(8))
   581  			p = appendp(p, AI32Add)
   582  			p = appendp(p, ASet, regAddr(REG_SP))
   583  
   584  			if ret.As == ARETUNWIND {
   585  				// function needs to unwind the WebAssembly stack, return 1
   586  				p = appendp(p, AI32Const, constAddr(1))
   587  				p = appendp(p, AReturn)
   588  				break
   589  			}
   590  
   591  			// not unwinding the WebAssembly stack, return 0
   592  			p = appendp(p, AI32Const, constAddr(0))
   593  			p = appendp(p, AReturn)
   594  		}
   595  	}
   596  
   597  	for p := s.Func().Text; p != nil; p = p.Link {
   598  		switch p.From.Name {
   599  		case obj.NAME_AUTO:
   600  			p.From.Offset += framesize
   601  		case obj.NAME_PARAM:
   602  			p.From.Reg = REG_SP
   603  			p.From.Offset += framesize + 8 // parameters are after the frame and the 8-byte return address
   604  		}
   605  
   606  		switch p.To.Name {
   607  		case obj.NAME_AUTO:
   608  			p.To.Offset += framesize
   609  		case obj.NAME_PARAM:
   610  			p.To.Reg = REG_SP
   611  			p.To.Offset += framesize + 8 // parameters are after the frame and the 8-byte return address
   612  		}
   613  
   614  		switch p.As {
   615  		case AGet:
   616  			if p.From.Type == obj.TYPE_ADDR {
   617  				get := *p
   618  				p.As = obj.ANOP
   619  
   620  				switch get.From.Name {
   621  				case obj.NAME_EXTERN:
   622  					p = appendp(p, AI64Const, get.From)
   623  				case obj.NAME_AUTO, obj.NAME_PARAM:
   624  					p = appendp(p, AGet, regAddr(get.From.Reg))
   625  					if get.From.Reg == REG_SP {
   626  						p = appendp(p, AI64ExtendI32U)
   627  					}
   628  					if get.From.Offset != 0 {
   629  						p = appendp(p, AI64Const, constAddr(get.From.Offset))
   630  						p = appendp(p, AI64Add)
   631  					}
   632  				default:
   633  					panic("bad Get: invalid name")
   634  				}
   635  			}
   636  
   637  		case AI32Load, AI64Load, AF32Load, AF64Load, AI32Load8S, AI32Load8U, AI32Load16S, AI32Load16U, AI64Load8S, AI64Load8U, AI64Load16S, AI64Load16U, AI64Load32S, AI64Load32U:
   638  			if p.From.Type == obj.TYPE_MEM {
   639  				as := p.As
   640  				from := p.From
   641  
   642  				p.As = AGet
   643  				p.From = regAddr(from.Reg)
   644  
   645  				if from.Reg != REG_SP {
   646  					p = appendp(p, AI32WrapI64)
   647  				}
   648  
   649  				p = appendp(p, as, constAddr(from.Offset))
   650  			}
   651  
   652  		case AMOVB, AMOVH, AMOVW, AMOVD:
   653  			mov := *p
   654  			p.As = obj.ANOP
   655  
   656  			var loadAs obj.As
   657  			var storeAs obj.As
   658  			switch mov.As {
   659  			case AMOVB:
   660  				loadAs = AI64Load8U
   661  				storeAs = AI64Store8
   662  			case AMOVH:
   663  				loadAs = AI64Load16U
   664  				storeAs = AI64Store16
   665  			case AMOVW:
   666  				loadAs = AI64Load32U
   667  				storeAs = AI64Store32
   668  			case AMOVD:
   669  				loadAs = AI64Load
   670  				storeAs = AI64Store
   671  			}
   672  
   673  			appendValue := func() {
   674  				switch mov.From.Type {
   675  				case obj.TYPE_CONST:
   676  					p = appendp(p, AI64Const, constAddr(mov.From.Offset))
   677  
   678  				case obj.TYPE_ADDR:
   679  					switch mov.From.Name {
   680  					case obj.NAME_NONE, obj.NAME_PARAM, obj.NAME_AUTO:
   681  						p = appendp(p, AGet, regAddr(mov.From.Reg))
   682  						if mov.From.Reg == REG_SP {
   683  							p = appendp(p, AI64ExtendI32U)
   684  						}
   685  						p = appendp(p, AI64Const, constAddr(mov.From.Offset))
   686  						p = appendp(p, AI64Add)
   687  					case obj.NAME_EXTERN:
   688  						p = appendp(p, AI64Const, mov.From)
   689  					default:
   690  						panic("bad name for MOV")
   691  					}
   692  
   693  				case obj.TYPE_REG:
   694  					p = appendp(p, AGet, mov.From)
   695  					if mov.From.Reg == REG_SP {
   696  						p = appendp(p, AI64ExtendI32U)
   697  					}
   698  
   699  				case obj.TYPE_MEM:
   700  					p = appendp(p, AGet, regAddr(mov.From.Reg))
   701  					if mov.From.Reg != REG_SP {
   702  						p = appendp(p, AI32WrapI64)
   703  					}
   704  					p = appendp(p, loadAs, constAddr(mov.From.Offset))
   705  
   706  				default:
   707  					panic("bad MOV type")
   708  				}
   709  			}
   710  
   711  			switch mov.To.Type {
   712  			case obj.TYPE_REG:
   713  				appendValue()
   714  				if mov.To.Reg == REG_SP {
   715  					p = appendp(p, AI32WrapI64)
   716  				}
   717  				p = appendp(p, ASet, mov.To)
   718  
   719  			case obj.TYPE_MEM:
   720  				switch mov.To.Name {
   721  				case obj.NAME_NONE, obj.NAME_PARAM:
   722  					p = appendp(p, AGet, regAddr(mov.To.Reg))
   723  					if mov.To.Reg != REG_SP {
   724  						p = appendp(p, AI32WrapI64)
   725  					}
   726  				case obj.NAME_EXTERN:
   727  					p = appendp(p, AI32Const, obj.Addr{Type: obj.TYPE_ADDR, Name: obj.NAME_EXTERN, Sym: mov.To.Sym})
   728  				default:
   729  					panic("bad MOV name")
   730  				}
   731  				appendValue()
   732  				p = appendp(p, storeAs, constAddr(mov.To.Offset))
   733  
   734  			default:
   735  				panic("bad MOV type")
   736  			}
   737  		}
   738  	}
   739  
   740  	{
   741  		p := s.Func().Text
   742  		if len(unwindExitBranches) > 0 {
   743  			p = appendp(p, ABlock) // unwindExit, used to return 1 when unwinding the stack
   744  			for _, b := range unwindExitBranches {
   745  				b.To = obj.Addr{Type: obj.TYPE_BRANCH, Val: p}
   746  			}
   747  		}
   748  		if len(entryPointLoopBranches) > 0 {
   749  			p = appendp(p, ALoop) // entryPointLoop, used to jump between basic blocks
   750  			for _, b := range entryPointLoopBranches {
   751  				b.To = obj.Addr{Type: obj.TYPE_BRANCH, Val: p}
   752  			}
   753  		}
   754  		if numResumePoints > 0 {
   755  			// Add Block instructions for resume points and BrTable to jump to selected resume point.
   756  			for i := 0; i < numResumePoints+1; i++ {
   757  				p = appendp(p, ABlock)
   758  			}
   759  			p = appendp(p, AGet, regAddr(REG_PC_B)) // read next basic block from PC_B
   760  			p = appendp(p, ABrTable, obj.Addr{Val: tableIdxs})
   761  			p = appendp(p, AEnd) // end of Block
   762  		}
   763  		for p.Link != nil {
   764  			p = p.Link // function instructions
   765  		}
   766  		if len(entryPointLoopBranches) > 0 {
   767  			p = appendp(p, AEnd) // end of entryPointLoop
   768  		}
   769  		p = appendp(p, obj.AUNDEF)
   770  		if len(unwindExitBranches) > 0 {
   771  			p = appendp(p, AEnd) // end of unwindExit
   772  			p = appendp(p, AI32Const, constAddr(1))
   773  		}
   774  	}
   775  
   776  	currentDepth = 0
   777  	blockDepths := make(map[*obj.Prog]int)
   778  	for p := s.Func().Text; p != nil; p = p.Link {
   779  		switch p.As {
   780  		case ABlock, ALoop, AIf:
   781  			currentDepth++
   782  			blockDepths[p] = currentDepth
   783  		case AEnd:
   784  			currentDepth--
   785  		}
   786  
   787  		switch p.As {
   788  		case ABr, ABrIf:
   789  			if p.To.Type == obj.TYPE_BRANCH {
   790  				blockDepth, ok := blockDepths[p.To.Val.(*obj.Prog)]
   791  				if !ok {
   792  					panic("label not at block")
   793  				}
   794  				p.To = constAddr(int64(currentDepth - blockDepth))
   795  			}
   796  		}
   797  	}
   798  }
   799  
   800  // Generate function body for wasmimport wrapper function.
   801  func genWasmImportWrapper(s *obj.LSym, appendp func(p *obj.Prog, as obj.As, args ...obj.Addr) *obj.Prog) {
   802  	wi := s.Func().WasmImport
   803  	wi.CreateAuxSym()
   804  	p := s.Func().Text
   805  	if p.Link != nil {
   806  		panic("wrapper functions for WASM imports should not have a body")
   807  	}
   808  	to := obj.Addr{
   809  		Type: obj.TYPE_MEM,
   810  		Name: obj.NAME_EXTERN,
   811  		Sym:  s,
   812  	}
   813  
   814  	// If the module that the import is for is our magic "gojs" module, then this
   815  	// indicates that the called function understands the Go stack-based call convention
   816  	// so we just pass the stack pointer to it, knowing it will read the params directly
   817  	// off the stack and push the results into memory based on the stack pointer.
   818  	if wi.Module == GojsModule {
   819  		// The called function has a signature of 'func(sp int)'. It has access to the memory
   820  		// value somewhere to be able to address the memory based on the "sp" value.
   821  
   822  		p = appendp(p, AGet, regAddr(REG_SP))
   823  		p = appendp(p, ACall, to)
   824  
   825  		p.Mark = WasmImport
   826  	} else {
   827  		if len(wi.Results) > 1 {
   828  			// TODO(evanphx) implement support for the multi-value proposal:
   829  			// https://github.com/WebAssembly/multi-value/blob/master/proposals/multi-value/Overview.md
   830  			panic("invalid results type") // impossible until multi-value proposal has landed
   831  		}
   832  		for _, f := range wi.Params {
   833  			// Each load instructions will consume the value of sp on the stack, so
   834  			// we need to read sp for each param. WASM appears to not have a stack dup instruction
   835  			// (a strange omission for a stack-based VM), if it did, we'd be using the dup here.
   836  			p = appendp(p, AGet, regAddr(REG_SP))
   837  
   838  			// Offset is the location of the param on the Go stack (ie relative to sp).
   839  			// Because of our call convention, the parameters are located an additional 8 bytes
   840  			// from sp because we store the return address as an int64 at the bottom of the stack.
   841  			// Ie the stack looks like [return_addr, param3, param2, param1, etc]
   842  
   843  			// Ergo, we add 8 to the true byte offset of the param to skip the return address.
   844  			loadOffset := f.Offset + 8
   845  
   846  			// We're reading the value from the Go stack onto the WASM stack and leaving it there
   847  			// for CALL to pick them up.
   848  			switch f.Type {
   849  			case obj.WasmI32:
   850  				p = appendp(p, AI32Load, constAddr(loadOffset))
   851  			case obj.WasmI64:
   852  				p = appendp(p, AI64Load, constAddr(loadOffset))
   853  			case obj.WasmF32:
   854  				p = appendp(p, AF32Load, constAddr(loadOffset))
   855  			case obj.WasmF64:
   856  				p = appendp(p, AF64Load, constAddr(loadOffset))
   857  			case obj.WasmPtr:
   858  				p = appendp(p, AI32Load, constAddr(loadOffset))
   859  			case obj.WasmBool:
   860  				p = appendp(p, AI32Load8U, constAddr(loadOffset))
   861  			default:
   862  				panic("bad param type")
   863  			}
   864  		}
   865  
   866  		// The call instruction is marked as being for a wasm import so that a later phase
   867  		// will generate relocation information that allows us to patch this with then
   868  		// offset of the imported function in the wasm imports.
   869  		p = appendp(p, ACall, to)
   870  		p.Mark = WasmImport
   871  
   872  		if len(wi.Results) == 1 {
   873  			f := wi.Results[0]
   874  
   875  			// Much like with the params, we need to adjust the offset we store the result value
   876  			// to by 8 bytes to account for the return address on the Go stack.
   877  			storeOffset := f.Offset + 8
   878  
   879  			// We need to push SP on the Wasm stack for the Store instruction, which needs to
   880  			// be pushed before the value (call result). So we pop the value into a register,
   881  			// push SP, and push the value back.
   882  			// We cannot get the SP onto the stack before the call, as if the host function
   883  			// calls back into Go, the Go stack may have moved.
   884  			switch f.Type {
   885  			case obj.WasmI32:
   886  				p = appendp(p, AI64ExtendI32U) // the register is 64-bit, so we have to extend
   887  				p = appendp(p, ASet, regAddr(REG_R0))
   888  				p = appendp(p, AGet, regAddr(REG_SP))
   889  				p = appendp(p, AGet, regAddr(REG_R0))
   890  				p = appendp(p, AI64Store32, constAddr(storeOffset))
   891  			case obj.WasmI64:
   892  				p = appendp(p, ASet, regAddr(REG_R0))
   893  				p = appendp(p, AGet, regAddr(REG_SP))
   894  				p = appendp(p, AGet, regAddr(REG_R0))
   895  				p = appendp(p, AI64Store, constAddr(storeOffset))
   896  			case obj.WasmF32:
   897  				p = appendp(p, ASet, regAddr(REG_F0))
   898  				p = appendp(p, AGet, regAddr(REG_SP))
   899  				p = appendp(p, AGet, regAddr(REG_F0))
   900  				p = appendp(p, AF32Store, constAddr(storeOffset))
   901  			case obj.WasmF64:
   902  				p = appendp(p, ASet, regAddr(REG_F16))
   903  				p = appendp(p, AGet, regAddr(REG_SP))
   904  				p = appendp(p, AGet, regAddr(REG_F16))
   905  				p = appendp(p, AF64Store, constAddr(storeOffset))
   906  			case obj.WasmPtr:
   907  				p = appendp(p, AI64ExtendI32U)
   908  				p = appendp(p, ASet, regAddr(REG_R0))
   909  				p = appendp(p, AGet, regAddr(REG_SP))
   910  				p = appendp(p, AGet, regAddr(REG_R0))
   911  				p = appendp(p, AI64Store, constAddr(storeOffset))
   912  			case obj.WasmBool:
   913  				p = appendp(p, AI64ExtendI32U)
   914  				p = appendp(p, ASet, regAddr(REG_R0))
   915  				p = appendp(p, AGet, regAddr(REG_SP))
   916  				p = appendp(p, AGet, regAddr(REG_R0))
   917  				p = appendp(p, AI64Store8, constAddr(storeOffset))
   918  			default:
   919  				panic("bad result type")
   920  			}
   921  		}
   922  	}
   923  
   924  	p = appendp(p, obj.ARET)
   925  }
   926  
   927  // Generate function body for wasmexport wrapper function.
   928  func genWasmExportWrapper(s *obj.LSym, appendp func(p *obj.Prog, as obj.As, args ...obj.Addr) *obj.Prog) {
   929  	we := s.Func().WasmExport
   930  	we.CreateAuxSym()
   931  	p := s.Func().Text
   932  	framesize := p.To.Offset
   933  	for p.Link != nil && p.Link.As == obj.AFUNCDATA {
   934  		p = p.Link
   935  	}
   936  	if p.Link != nil {
   937  		panic("wrapper functions for WASM export should not have a body")
   938  	}
   939  
   940  	// Detect and error out if called before runtime initialization
   941  	// SP is 0 if not initialized
   942  	p = appendp(p, AGet, regAddr(REG_SP))
   943  	p = appendp(p, AI32Eqz)
   944  	p = appendp(p, AIf)
   945  	p = appendp(p, ACall, obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: runtimeNotInitialized})
   946  	p = appendp(p, AEnd)
   947  
   948  	// Now that we've checked the SP, generate the prologue
   949  	if framesize > 0 {
   950  		p = appendp(p, AGet, regAddr(REG_SP))
   951  		p = appendp(p, AI32Const, constAddr(framesize))
   952  		p = appendp(p, AI32Sub)
   953  		p = appendp(p, ASet, regAddr(REG_SP))
   954  		p.Spadj = int32(framesize)
   955  	}
   956  
   957  	// Store args
   958  	for i, f := range we.Params {
   959  		p = appendp(p, AGet, regAddr(REG_SP))
   960  		p = appendp(p, AGet, regAddr(REG_R0+int16(i)))
   961  		switch f.Type {
   962  		case obj.WasmI32:
   963  			p = appendp(p, AI32Store, constAddr(f.Offset))
   964  		case obj.WasmI64:
   965  			p = appendp(p, AI64Store, constAddr(f.Offset))
   966  		case obj.WasmF32:
   967  			p = appendp(p, AF32Store, constAddr(f.Offset))
   968  		case obj.WasmF64:
   969  			p = appendp(p, AF64Store, constAddr(f.Offset))
   970  		case obj.WasmPtr:
   971  			p = appendp(p, AI64ExtendI32U)
   972  			p = appendp(p, AI64Store, constAddr(f.Offset))
   973  		case obj.WasmBool:
   974  			p = appendp(p, AI32Store8, constAddr(f.Offset))
   975  		default:
   976  			panic("bad param type")
   977  		}
   978  	}
   979  
   980  	// Call the Go function.
   981  	// XXX maybe use ACALL and let later phase expand? But we don't use PC_B. Maybe we should?
   982  	// Go calling convention expects we push a return PC before call.
   983  	// SP -= 8
   984  	p = appendp(p, AGet, regAddr(REG_SP))
   985  	p = appendp(p, AI32Const, constAddr(8))
   986  	p = appendp(p, AI32Sub)
   987  	p = appendp(p, ASet, regAddr(REG_SP))
   988  	// write return address to Go stack
   989  	p = appendp(p, AGet, regAddr(REG_SP))
   990  	retAddr := obj.Addr{
   991  		Type:   obj.TYPE_ADDR,
   992  		Name:   obj.NAME_EXTERN,
   993  		Sym:    s, // PC_F
   994  		Offset: 1, // PC_B=1, past the prologue, so we have the right SP delta
   995  	}
   996  	if framesize == 0 {
   997  		// Frameless function, no prologue.
   998  		retAddr.Offset = 0
   999  	}
  1000  	p = appendp(p, AI64Const, retAddr)
  1001  	p = appendp(p, AI64Store, constAddr(0))
  1002  	// Set PC_B parameter to function entry
  1003  	p = appendp(p, AI32Const, constAddr(0))
  1004  	p = appendp(p, ACall, obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: we.WrappedSym})
  1005  	// Return value is on the top of the stack, indicating whether to unwind the Wasm stack.
  1006  	// In the unwinding case, we call wasm_pc_f_loop_export to handle stack switch and rewinding,
  1007  	// until a normal return (non-unwinding) back to this function.
  1008  	p = appendp(p, AIf)
  1009  	p = appendp(p, AI32Const, retAddr)
  1010  	p = appendp(p, AI32Const, constAddr(16))
  1011  	p = appendp(p, AI32ShrU)
  1012  	p = appendp(p, ACall, obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: wasm_pc_f_loop_export})
  1013  	p = appendp(p, AEnd)
  1014  
  1015  	// Load result
  1016  	if len(we.Results) > 1 {
  1017  		panic("invalid results type")
  1018  	} else if len(we.Results) == 1 {
  1019  		p = appendp(p, AGet, regAddr(REG_SP))
  1020  		f := we.Results[0]
  1021  		switch f.Type {
  1022  		case obj.WasmI32:
  1023  			p = appendp(p, AI32Load, constAddr(f.Offset))
  1024  		case obj.WasmI64:
  1025  			p = appendp(p, AI64Load, constAddr(f.Offset))
  1026  		case obj.WasmF32:
  1027  			p = appendp(p, AF32Load, constAddr(f.Offset))
  1028  		case obj.WasmF64:
  1029  			p = appendp(p, AF64Load, constAddr(f.Offset))
  1030  		case obj.WasmPtr:
  1031  			p = appendp(p, AI32Load, constAddr(f.Offset))
  1032  		case obj.WasmBool:
  1033  			p = appendp(p, AI32Load8U, constAddr(f.Offset))
  1034  		default:
  1035  			panic("bad result type")
  1036  		}
  1037  	}
  1038  
  1039  	// Epilogue. Cannot use ARET as we don't follow Go calling convention.
  1040  	if framesize > 0 {
  1041  		// SP += framesize
  1042  		p = appendp(p, AGet, regAddr(REG_SP))
  1043  		p = appendp(p, AI32Const, constAddr(framesize))
  1044  		p = appendp(p, AI32Add)
  1045  		p = appendp(p, ASet, regAddr(REG_SP))
  1046  	}
  1047  	p = appendp(p, AReturn)
  1048  }
  1049  
  1050  func constAddr(value int64) obj.Addr {
  1051  	return obj.Addr{Type: obj.TYPE_CONST, Offset: value}
  1052  }
  1053  
  1054  func regAddr(reg int16) obj.Addr {
  1055  	return obj.Addr{Type: obj.TYPE_REG, Reg: reg}
  1056  }
  1057  
  1058  // Most of the Go functions has a single parameter (PC_B) in
  1059  // Wasm ABI. This is a list of exceptions.
  1060  var notUsePC_B = map[string]bool{
  1061  	"_rt0_wasm_js":            true,
  1062  	"_rt0_wasm_wasip1":        true,
  1063  	"_rt0_wasm_wasip1_lib":    true,
  1064  	"wasm_export_run":         true,
  1065  	"wasm_export_resume":      true,
  1066  	"wasm_export_getsp":       true,
  1067  	"wasm_pc_f_loop":          true,
  1068  	"wasm_pc_f_loop_export":   true,
  1069  	"gcWriteBarrier":          true,
  1070  	"runtime.gcWriteBarrier1": true,
  1071  	"runtime.gcWriteBarrier2": true,
  1072  	"runtime.gcWriteBarrier3": true,
  1073  	"runtime.gcWriteBarrier4": true,
  1074  	"runtime.gcWriteBarrier5": true,
  1075  	"runtime.gcWriteBarrier6": true,
  1076  	"runtime.gcWriteBarrier7": true,
  1077  	"runtime.gcWriteBarrier8": true,
  1078  	"runtime.notInitialized":  true,
  1079  	"runtime.wasmDiv":         true,
  1080  	"runtime.wasmTruncS":      true,
  1081  	"runtime.wasmTruncU":      true,
  1082  	"cmpbody":                 true,
  1083  	"memeqbody":               true,
  1084  	"memcmp":                  true,
  1085  	"memchr":                  true,
  1086  }
  1087  
  1088  func assemble(ctxt *obj.Link, s *obj.LSym, newprog obj.ProgAlloc) {
  1089  	type regVar struct {
  1090  		global bool
  1091  		index  uint64
  1092  	}
  1093  
  1094  	type varDecl struct {
  1095  		count uint64
  1096  		typ   valueType
  1097  	}
  1098  
  1099  	hasLocalSP := false
  1100  	regVars := [MAXREG - MINREG]*regVar{
  1101  		REG_SP - MINREG:    {true, 0},
  1102  		REG_CTXT - MINREG:  {true, 1},
  1103  		REG_g - MINREG:     {true, 2},
  1104  		REG_RET0 - MINREG:  {true, 3},
  1105  		REG_RET1 - MINREG:  {true, 4},
  1106  		REG_RET2 - MINREG:  {true, 5},
  1107  		REG_RET3 - MINREG:  {true, 6},
  1108  		REG_PAUSE - MINREG: {true, 7},
  1109  	}
  1110  	var varDecls []*varDecl
  1111  	useAssemblyRegMap := func() {
  1112  		for i := int16(0); i < 16; i++ {
  1113  			regVars[REG_R0+i-MINREG] = &regVar{false, uint64(i)}
  1114  		}
  1115  	}
  1116  
  1117  	// Function starts with declaration of locals: numbers and types.
  1118  	// Some functions use a special calling convention.
  1119  	switch s.Name {
  1120  	case "_rt0_wasm_js", "_rt0_wasm_wasip1", "_rt0_wasm_wasip1_lib",
  1121  		"wasm_export_run", "wasm_export_resume", "wasm_export_getsp",
  1122  		"wasm_pc_f_loop", "runtime.wasmDiv", "runtime.wasmTruncS", "runtime.wasmTruncU", "memeqbody":
  1123  		varDecls = []*varDecl{}
  1124  		useAssemblyRegMap()
  1125  	case "wasm_pc_f_loop_export":
  1126  		varDecls = []*varDecl{{count: 2, typ: i32}}
  1127  		useAssemblyRegMap()
  1128  	case "memchr", "memcmp":
  1129  		varDecls = []*varDecl{{count: 2, typ: i32}}
  1130  		useAssemblyRegMap()
  1131  	case "cmpbody":
  1132  		varDecls = []*varDecl{{count: 2, typ: i64}}
  1133  		useAssemblyRegMap()
  1134  	case "gcWriteBarrier":
  1135  		varDecls = []*varDecl{{count: 5, typ: i64}}
  1136  		useAssemblyRegMap()
  1137  	case "runtime.gcWriteBarrier1",
  1138  		"runtime.gcWriteBarrier2",
  1139  		"runtime.gcWriteBarrier3",
  1140  		"runtime.gcWriteBarrier4",
  1141  		"runtime.gcWriteBarrier5",
  1142  		"runtime.gcWriteBarrier6",
  1143  		"runtime.gcWriteBarrier7",
  1144  		"runtime.gcWriteBarrier8",
  1145  		"runtime.notInitialized":
  1146  		// no locals
  1147  		useAssemblyRegMap()
  1148  	default:
  1149  		if s.Func().WasmExport != nil {
  1150  			// no local SP, not following Go calling convention
  1151  			useAssemblyRegMap()
  1152  			break
  1153  		}
  1154  
  1155  		// Normal calling convention: PC_B as WebAssembly parameter. First local variable is local SP cache.
  1156  		regVars[REG_PC_B-MINREG] = &regVar{false, 0}
  1157  		hasLocalSP = true
  1158  
  1159  		var regUsed [MAXREG - MINREG]bool
  1160  		for p := s.Func().Text; p != nil; p = p.Link {
  1161  			if p.From.Reg != 0 {
  1162  				regUsed[p.From.Reg-MINREG] = true
  1163  			}
  1164  			if p.To.Reg != 0 {
  1165  				regUsed[p.To.Reg-MINREG] = true
  1166  			}
  1167  		}
  1168  
  1169  		regs := []int16{REG_SP}
  1170  		for reg := int16(REG_R0); reg <= REG_F31; reg++ {
  1171  			if regUsed[reg-MINREG] {
  1172  				regs = append(regs, reg)
  1173  			}
  1174  		}
  1175  
  1176  		var lastDecl *varDecl
  1177  		for i, reg := range regs {
  1178  			t := regType(reg)
  1179  			if lastDecl == nil || lastDecl.typ != t {
  1180  				lastDecl = &varDecl{
  1181  					count: 0,
  1182  					typ:   t,
  1183  				}
  1184  				varDecls = append(varDecls, lastDecl)
  1185  			}
  1186  			lastDecl.count++
  1187  			if reg != REG_SP {
  1188  				regVars[reg-MINREG] = &regVar{false, 1 + uint64(i)}
  1189  			}
  1190  		}
  1191  	}
  1192  
  1193  	w := new(bytes.Buffer)
  1194  
  1195  	writeUleb128(w, uint64(len(varDecls)))
  1196  	for _, decl := range varDecls {
  1197  		writeUleb128(w, decl.count)
  1198  		w.WriteByte(byte(decl.typ))
  1199  	}
  1200  
  1201  	if hasLocalSP {
  1202  		// Copy SP from its global variable into a local variable. Accessing a local variable is more efficient.
  1203  		updateLocalSP(w)
  1204  	}
  1205  
  1206  	for p := s.Func().Text; p != nil; p = p.Link {
  1207  		switch p.As {
  1208  		case AGet:
  1209  			if p.From.Type != obj.TYPE_REG {
  1210  				panic("bad Get: argument is not a register")
  1211  			}
  1212  			reg := p.From.Reg
  1213  			v := regVars[reg-MINREG]
  1214  			if v == nil {
  1215  				panic("bad Get: invalid register")
  1216  			}
  1217  			if reg == REG_SP && hasLocalSP {
  1218  				writeOpcode(w, ALocalGet)
  1219  				writeUleb128(w, 1) // local SP
  1220  				continue
  1221  			}
  1222  			if v.global {
  1223  				writeOpcode(w, AGlobalGet)
  1224  			} else {
  1225  				writeOpcode(w, ALocalGet)
  1226  			}
  1227  			writeUleb128(w, v.index)
  1228  			continue
  1229  
  1230  		case ASet:
  1231  			if p.To.Type != obj.TYPE_REG {
  1232  				panic("bad Set: argument is not a register")
  1233  			}
  1234  			reg := p.To.Reg
  1235  			v := regVars[reg-MINREG]
  1236  			if v == nil {
  1237  				panic("bad Set: invalid register")
  1238  			}
  1239  			if reg == REG_SP && hasLocalSP {
  1240  				writeOpcode(w, ALocalTee)
  1241  				writeUleb128(w, 1) // local SP
  1242  			}
  1243  			if v.global {
  1244  				writeOpcode(w, AGlobalSet)
  1245  			} else {
  1246  				if p.Link.As == AGet && p.Link.From.Reg == reg {
  1247  					writeOpcode(w, ALocalTee)
  1248  					p = p.Link
  1249  				} else {
  1250  					writeOpcode(w, ALocalSet)
  1251  				}
  1252  			}
  1253  			writeUleb128(w, v.index)
  1254  			continue
  1255  
  1256  		case ATee:
  1257  			if p.To.Type != obj.TYPE_REG {
  1258  				panic("bad Tee: argument is not a register")
  1259  			}
  1260  			reg := p.To.Reg
  1261  			v := regVars[reg-MINREG]
  1262  			if v == nil {
  1263  				panic("bad Tee: invalid register")
  1264  			}
  1265  			writeOpcode(w, ALocalTee)
  1266  			writeUleb128(w, v.index)
  1267  			continue
  1268  
  1269  		case ANot:
  1270  			writeOpcode(w, AI32Eqz)
  1271  			continue
  1272  
  1273  		case obj.AUNDEF:
  1274  			writeOpcode(w, AUnreachable)
  1275  			continue
  1276  
  1277  		case obj.ANOP, obj.ATEXT, obj.AFUNCDATA, obj.APCDATA:
  1278  			// ignore
  1279  			continue
  1280  		}
  1281  
  1282  		writeOpcode(w, p.As)
  1283  
  1284  		switch p.As {
  1285  		case ABlock, ALoop, AIf:
  1286  			if p.From.Offset != 0 {
  1287  				// block type, rarely used, e.g. for code compiled with emscripten
  1288  				w.WriteByte(0x80 - byte(p.From.Offset))
  1289  				continue
  1290  			}
  1291  			w.WriteByte(0x40)
  1292  
  1293  		case ABr, ABrIf:
  1294  			if p.To.Type != obj.TYPE_CONST {
  1295  				panic("bad Br/BrIf")
  1296  			}
  1297  			writeUleb128(w, uint64(p.To.Offset))
  1298  
  1299  		case ABrTable:
  1300  			idxs := p.To.Val.([]uint64)
  1301  			writeUleb128(w, uint64(len(idxs)-1))
  1302  			for _, idx := range idxs {
  1303  				writeUleb128(w, idx)
  1304  			}
  1305  
  1306  		case ACall:
  1307  			switch p.To.Type {
  1308  			case obj.TYPE_CONST:
  1309  				writeUleb128(w, uint64(p.To.Offset))
  1310  
  1311  			case obj.TYPE_MEM:
  1312  				if p.To.Name != obj.NAME_EXTERN && p.To.Name != obj.NAME_STATIC {
  1313  					fmt.Println(p.To)
  1314  					panic("bad name for Call")
  1315  				}
  1316  				typ := objabi.R_CALL
  1317  				if p.Mark&WasmImport != 0 {
  1318  					typ = objabi.R_WASMIMPORT
  1319  				}
  1320  				s.AddRel(ctxt, obj.Reloc{
  1321  					Type: typ,
  1322  					Off:  int32(w.Len()),
  1323  					Siz:  1, // actually variable sized
  1324  					Sym:  p.To.Sym,
  1325  				})
  1326  				if hasLocalSP {
  1327  					// The stack may have moved, which changes SP. Update the local SP variable.
  1328  					updateLocalSP(w)
  1329  				}
  1330  
  1331  			default:
  1332  				panic("bad type for Call")
  1333  			}
  1334  
  1335  		case ACallIndirect:
  1336  			writeUleb128(w, uint64(p.To.Offset))
  1337  			w.WriteByte(0x00) // reserved value
  1338  			if hasLocalSP {
  1339  				// The stack may have moved, which changes SP. Update the local SP variable.
  1340  				updateLocalSP(w)
  1341  			}
  1342  
  1343  		case AI32Const, AI64Const:
  1344  			if p.From.Name == obj.NAME_EXTERN {
  1345  				s.AddRel(ctxt, obj.Reloc{
  1346  					Type: objabi.R_ADDR,
  1347  					Off:  int32(w.Len()),
  1348  					Siz:  1, // actually variable sized
  1349  					Sym:  p.From.Sym,
  1350  					Add:  p.From.Offset,
  1351  				})
  1352  				break
  1353  			}
  1354  			writeSleb128(w, p.From.Offset)
  1355  
  1356  		case AF32Const:
  1357  			b := make([]byte, 4)
  1358  			binary.LittleEndian.PutUint32(b, math.Float32bits(float32(p.From.Val.(float64))))
  1359  			w.Write(b)
  1360  
  1361  		case AF64Const:
  1362  			b := make([]byte, 8)
  1363  			binary.LittleEndian.PutUint64(b, math.Float64bits(p.From.Val.(float64)))
  1364  			w.Write(b)
  1365  
  1366  		case AI32Load, AI64Load, AF32Load, AF64Load, AI32Load8S, AI32Load8U, AI32Load16S, AI32Load16U, AI64Load8S, AI64Load8U, AI64Load16S, AI64Load16U, AI64Load32S, AI64Load32U:
  1367  			if p.From.Offset < 0 {
  1368  				panic("negative offset for *Load")
  1369  			}
  1370  			if p.From.Type != obj.TYPE_CONST {
  1371  				panic("bad type for *Load")
  1372  			}
  1373  			if p.From.Offset > math.MaxUint32 {
  1374  				ctxt.Diag("bad offset in %v", p)
  1375  			}
  1376  			writeUleb128(w, align(p.As))
  1377  			writeUleb128(w, uint64(p.From.Offset))
  1378  
  1379  		case AI32Store, AI64Store, AF32Store, AF64Store, AI32Store8, AI32Store16, AI64Store8, AI64Store16, AI64Store32:
  1380  			if p.To.Offset < 0 {
  1381  				panic("negative offset")
  1382  			}
  1383  			if p.From.Offset > math.MaxUint32 {
  1384  				ctxt.Diag("bad offset in %v", p)
  1385  			}
  1386  			writeUleb128(w, align(p.As))
  1387  			writeUleb128(w, uint64(p.To.Offset))
  1388  
  1389  		case ACurrentMemory, AGrowMemory, AMemoryFill:
  1390  			w.WriteByte(0x00)
  1391  
  1392  		case AMemoryCopy:
  1393  			w.WriteByte(0x00)
  1394  			w.WriteByte(0x00)
  1395  
  1396  		}
  1397  	}
  1398  
  1399  	w.WriteByte(0x0b) // end
  1400  
  1401  	s.P = w.Bytes()
  1402  }
  1403  
  1404  func updateLocalSP(w *bytes.Buffer) {
  1405  	writeOpcode(w, AGlobalGet)
  1406  	writeUleb128(w, 0) // global SP
  1407  	writeOpcode(w, ALocalSet)
  1408  	writeUleb128(w, 1) // local SP
  1409  }
  1410  
  1411  func writeOpcode(w *bytes.Buffer, as obj.As) {
  1412  	switch {
  1413  	case as < AUnreachable:
  1414  		panic(fmt.Sprintf("unexpected assembler op: %s", as))
  1415  	case as < AEnd:
  1416  		w.WriteByte(byte(as - AUnreachable + 0x00))
  1417  	case as < ADrop:
  1418  		w.WriteByte(byte(as - AEnd + 0x0B))
  1419  	case as < ALocalGet:
  1420  		w.WriteByte(byte(as - ADrop + 0x1A))
  1421  	case as < AI32Load:
  1422  		w.WriteByte(byte(as - ALocalGet + 0x20))
  1423  	case as < AI32TruncSatF32S:
  1424  		w.WriteByte(byte(as - AI32Load + 0x28))
  1425  	case as < ALast:
  1426  		w.WriteByte(0xFC)
  1427  		w.WriteByte(byte(as - AI32TruncSatF32S + 0x00))
  1428  	default:
  1429  		panic(fmt.Sprintf("unexpected assembler op: %s", as))
  1430  	}
  1431  }
  1432  
  1433  type valueType byte
  1434  
  1435  const (
  1436  	i32 valueType = 0x7F
  1437  	i64 valueType = 0x7E
  1438  	f32 valueType = 0x7D
  1439  	f64 valueType = 0x7C
  1440  )
  1441  
  1442  func regType(reg int16) valueType {
  1443  	switch {
  1444  	case reg == REG_SP:
  1445  		return i32
  1446  	case reg >= REG_R0 && reg <= REG_R15:
  1447  		return i64
  1448  	case reg >= REG_F0 && reg <= REG_F15:
  1449  		return f32
  1450  	case reg >= REG_F16 && reg <= REG_F31:
  1451  		return f64
  1452  	default:
  1453  		panic("invalid register")
  1454  	}
  1455  }
  1456  
  1457  func align(as obj.As) uint64 {
  1458  	switch as {
  1459  	case AI32Load8S, AI32Load8U, AI64Load8S, AI64Load8U, AI32Store8, AI64Store8:
  1460  		return 0
  1461  	case AI32Load16S, AI32Load16U, AI64Load16S, AI64Load16U, AI32Store16, AI64Store16:
  1462  		return 1
  1463  	case AI32Load, AF32Load, AI64Load32S, AI64Load32U, AI32Store, AF32Store, AI64Store32:
  1464  		return 2
  1465  	case AI64Load, AF64Load, AI64Store, AF64Store:
  1466  		return 3
  1467  	default:
  1468  		panic("align: bad op")
  1469  	}
  1470  }
  1471  
  1472  func writeUleb128(w io.ByteWriter, v uint64) {
  1473  	if v < 128 {
  1474  		w.WriteByte(uint8(v))
  1475  		return
  1476  	}
  1477  	more := true
  1478  	for more {
  1479  		c := uint8(v & 0x7f)
  1480  		v >>= 7
  1481  		more = v != 0
  1482  		if more {
  1483  			c |= 0x80
  1484  		}
  1485  		w.WriteByte(c)
  1486  	}
  1487  }
  1488  
  1489  func writeSleb128(w io.ByteWriter, v int64) {
  1490  	more := true
  1491  	for more {
  1492  		c := uint8(v & 0x7f)
  1493  		s := uint8(v & 0x40)
  1494  		v >>= 7
  1495  		more = !((v == 0 && s == 0) || (v == -1 && s != 0))
  1496  		if more {
  1497  			c |= 0x80
  1498  		}
  1499  		w.WriteByte(c)
  1500  	}
  1501  }
  1502  

View as plain text