podman

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
	"github.com/twitchyliquid64/golang-asm/obj"
10
	"github.com/twitchyliquid64/golang-asm/objabi"
11
	"github.com/twitchyliquid64/golang-asm/sys"
12
	"encoding/binary"
13
	"fmt"
14
	"io"
15
	"math"
16
)
17

18
var Register = map[string]int16{
19
	"SP":    REG_SP,
20
	"CTXT":  REG_CTXT,
21
	"g":     REG_g,
22
	"RET0":  REG_RET0,
23
	"RET1":  REG_RET1,
24
	"RET2":  REG_RET2,
25
	"RET3":  REG_RET3,
26
	"PAUSE": REG_PAUSE,
27

28
	"R0":  REG_R0,
29
	"R1":  REG_R1,
30
	"R2":  REG_R2,
31
	"R3":  REG_R3,
32
	"R4":  REG_R4,
33
	"R5":  REG_R5,
34
	"R6":  REG_R6,
35
	"R7":  REG_R7,
36
	"R8":  REG_R8,
37
	"R9":  REG_R9,
38
	"R10": REG_R10,
39
	"R11": REG_R11,
40
	"R12": REG_R12,
41
	"R13": REG_R13,
42
	"R14": REG_R14,
43
	"R15": REG_R15,
44

45
	"F0":  REG_F0,
46
	"F1":  REG_F1,
47
	"F2":  REG_F2,
48
	"F3":  REG_F3,
49
	"F4":  REG_F4,
50
	"F5":  REG_F5,
51
	"F6":  REG_F6,
52
	"F7":  REG_F7,
53
	"F8":  REG_F8,
54
	"F9":  REG_F9,
55
	"F10": REG_F10,
56
	"F11": REG_F11,
57
	"F12": REG_F12,
58
	"F13": REG_F13,
59
	"F14": REG_F14,
60
	"F15": REG_F15,
61

62
	"F16": REG_F16,
63
	"F17": REG_F17,
64
	"F18": REG_F18,
65
	"F19": REG_F19,
66
	"F20": REG_F20,
67
	"F21": REG_F21,
68
	"F22": REG_F22,
69
	"F23": REG_F23,
70
	"F24": REG_F24,
71
	"F25": REG_F25,
72
	"F26": REG_F26,
73
	"F27": REG_F27,
74
	"F28": REG_F28,
75
	"F29": REG_F29,
76
	"F30": REG_F30,
77
	"F31": REG_F31,
78

79
	"PC_B": REG_PC_B,
80
}
81

82
var registerNames []string
83

84
func init() {
85
	obj.RegisterRegister(MINREG, MAXREG, rconv)
86
	obj.RegisterOpcode(obj.ABaseWasm, Anames)
87

88
	registerNames = make([]string, MAXREG-MINREG)
89
	for name, reg := range Register {
90
		registerNames[reg-MINREG] = name
91
	}
92
}
93

94
func rconv(r int) string {
95
	return registerNames[r-MINREG]
96
}
97

98
var unaryDst = map[obj.As]bool{
99
	ASet:          true,
100
	ATee:          true,
101
	ACall:         true,
102
	ACallIndirect: true,
103
	ACallImport:   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
	gcWriteBarrier  *obj.LSym
131
	sigpanic        *obj.LSym
132
	sigpanic0       *obj.LSym
133
	deferreturn     *obj.LSym
134
	jmpdefer        *obj.LSym
135
)
136

137
const (
138
	/* mark flags */
139
	WasmImport = 1 << 0
140
)
141

142
func instinit(ctxt *obj.Link) {
143
	morestack = ctxt.Lookup("runtime.morestack")
144
	morestackNoCtxt = ctxt.Lookup("runtime.morestack_noctxt")
145
	gcWriteBarrier = ctxt.Lookup("runtime.gcWriteBarrier")
146
	sigpanic = ctxt.LookupABI("runtime.sigpanic", obj.ABIInternal)
147
	sigpanic0 = ctxt.LookupABI("runtime.sigpanic", 0) // sigpanic called from assembly, which has ABI0
148
	deferreturn = ctxt.LookupABI("runtime.deferreturn", obj.ABIInternal)
149
	// jmpdefer is defined in assembly as ABI0, but what we're
150
	// looking for is the *call* to jmpdefer from the Go function
151
	// deferreturn, so we're looking for the ABIInternal version
152
	// of jmpdefer that's called by Go.
153
	jmpdefer = ctxt.LookupABI(`"".jmpdefer`, obj.ABIInternal)
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 s.Func.Text.From.Sym.Wrapper() {
193
		// if g._panic != nil && g._panic.argp == FP {
194
		//   g._panic.argp = bottom-of-frame
195
		// }
196
		//
197
		// MOVD g_panic(g), R0
198
		// Get R0
199
		// I64Eqz
200
		// Not
201
		// If
202
		//   Get SP
203
		//   I64ExtendI32U
204
		//   I64Const $framesize+8
205
		//   I64Add
206
		//   I64Load panic_argp(R0)
207
		//   I64Eq
208
		//   If
209
		//     MOVD SP, panic_argp(R0)
210
		//   End
211
		// End
212

213
		gpanic := obj.Addr{
214
			Type:   obj.TYPE_MEM,
215
			Reg:    REGG,
216
			Offset: 4 * 8, // g_panic
217
		}
218

219
		panicargp := obj.Addr{
220
			Type:   obj.TYPE_MEM,
221
			Reg:    REG_R0,
222
			Offset: 0, // panic.argp
223
		}
224

225
		p := s.Func.Text
226
		p = appendp(p, AMOVD, gpanic, regAddr(REG_R0))
227

228
		p = appendp(p, AGet, regAddr(REG_R0))
229
		p = appendp(p, AI64Eqz)
230
		p = appendp(p, ANot)
231
		p = appendp(p, AIf)
232

233
		p = appendp(p, AGet, regAddr(REG_SP))
234
		p = appendp(p, AI64ExtendI32U)
235
		p = appendp(p, AI64Const, constAddr(framesize+8))
236
		p = appendp(p, AI64Add)
237
		p = appendp(p, AI64Load, panicargp)
238

239
		p = appendp(p, AI64Eq)
240
		p = appendp(p, AIf)
241
		p = appendp(p, AMOVD, regAddr(REG_SP), panicargp)
242
		p = appendp(p, AEnd)
243

244
		p = appendp(p, AEnd)
245
	}
246

247
	if framesize > 0 {
248
		p := s.Func.Text
249
		p = appendp(p, AGet, regAddr(REG_SP))
250
		p = appendp(p, AI32Const, constAddr(framesize))
251
		p = appendp(p, AI32Sub)
252
		p = appendp(p, ASet, regAddr(REG_SP))
253
		p.Spadj = int32(framesize)
254
	}
255

256
	// Introduce resume points for CALL instructions
257
	// and collect other explicit resume points.
258
	numResumePoints := 0
259
	explicitBlockDepth := 0
260
	pc := int64(0) // pc is only incremented when necessary, this avoids bloat of the BrTable instruction
261
	var tableIdxs []uint64
262
	tablePC := int64(0)
263
	base := ctxt.PosTable.Pos(s.Func.Text.Pos).Base()
264
	for p := s.Func.Text; p != nil; p = p.Link {
265
		prevBase := base
266
		base = ctxt.PosTable.Pos(p.Pos).Base()
267
		switch p.As {
268
		case ABlock, ALoop, AIf:
269
			explicitBlockDepth++
270

271
		case AEnd:
272
			if explicitBlockDepth == 0 {
273
				panic("End without block")
274
			}
275
			explicitBlockDepth--
276

277
		case ARESUMEPOINT:
278
			if explicitBlockDepth != 0 {
279
				panic("RESUME can only be used on toplevel")
280
			}
281
			p.As = AEnd
282
			for tablePC <= pc {
283
				tableIdxs = append(tableIdxs, uint64(numResumePoints))
284
				tablePC++
285
			}
286
			numResumePoints++
287
			pc++
288

289
		case obj.ACALL:
290
			if explicitBlockDepth != 0 {
291
				panic("CALL can only be used on toplevel, try CALLNORESUME instead")
292
			}
293
			appendp(p, ARESUMEPOINT)
294
		}
295

296
		p.Pc = pc
297

298
		// Increase pc whenever some pc-value table needs a new entry. Don't increase it
299
		// more often to avoid bloat of the BrTable instruction.
300
		// The "base != prevBase" condition detects inlined instructions. They are an
301
		// implicit call, so entering and leaving this section affects the stack trace.
302
		if p.As == ACALLNORESUME || p.As == obj.ANOP || p.As == ANop || p.Spadj != 0 || base != prevBase {
303
			pc++
304
			if p.To.Sym == sigpanic {
305
				// The panic stack trace expects the PC at the call of sigpanic,
306
				// not the next one. However, runtime.Caller subtracts 1 from the
307
				// PC. To make both PC and PC-1 work (have the same line number),
308
				// we advance the PC by 2 at sigpanic.
309
				pc++
310
			}
311
		}
312
	}
313
	tableIdxs = append(tableIdxs, uint64(numResumePoints))
314
	s.Size = pc + 1
315

316
	if !s.Func.Text.From.Sym.NoSplit() {
317
		p := s.Func.Text
318

319
		if framesize <= objabi.StackSmall {
320
			// small stack: SP <= stackguard
321
			// Get SP
322
			// Get g
323
			// I32WrapI64
324
			// I32Load $stackguard0
325
			// I32GtU
326

327
			p = appendp(p, AGet, regAddr(REG_SP))
328
			p = appendp(p, AGet, regAddr(REGG))
329
			p = appendp(p, AI32WrapI64)
330
			p = appendp(p, AI32Load, constAddr(2*int64(ctxt.Arch.PtrSize))) // G.stackguard0
331
			p = appendp(p, AI32LeU)
332
		} else {
333
			// large stack: SP-framesize <= stackguard-StackSmall
334
			//              SP <= stackguard+(framesize-StackSmall)
335
			// Get SP
336
			// Get g
337
			// I32WrapI64
338
			// I32Load $stackguard0
339
			// I32Const $(framesize-StackSmall)
340
			// I32Add
341
			// I32GtU
342

343
			p = appendp(p, AGet, regAddr(REG_SP))
344
			p = appendp(p, AGet, regAddr(REGG))
345
			p = appendp(p, AI32WrapI64)
346
			p = appendp(p, AI32Load, constAddr(2*int64(ctxt.Arch.PtrSize))) // G.stackguard0
347
			p = appendp(p, AI32Const, constAddr(int64(framesize)-objabi.StackSmall))
348
			p = appendp(p, AI32Add)
349
			p = appendp(p, AI32LeU)
350
		}
351
		// TODO(neelance): handle wraparound case
352

353
		p = appendp(p, AIf)
354
		p = appendp(p, obj.ACALL, constAddr(0))
355
		if s.Func.Text.From.Sym.NeedCtxt() {
356
			p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: morestack}
357
		} else {
358
			p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: morestackNoCtxt}
359
		}
360
		p = appendp(p, AEnd)
361
	}
362

363
	// record the branches targeting the entry loop and the unwind exit,
364
	// their targets with be filled in later
365
	var entryPointLoopBranches []*obj.Prog
366
	var unwindExitBranches []*obj.Prog
367
	currentDepth := 0
368
	for p := s.Func.Text; p != nil; p = p.Link {
369
		switch p.As {
370
		case ABlock, ALoop, AIf:
371
			currentDepth++
372
		case AEnd:
373
			currentDepth--
374
		}
375

376
		switch p.As {
377
		case obj.AJMP:
378
			jmp := *p
379
			p.As = obj.ANOP
380

381
			if jmp.To.Type == obj.TYPE_BRANCH {
382
				// jump to basic block
383
				p = appendp(p, AI32Const, constAddr(jmp.To.Val.(*obj.Prog).Pc))
384
				p = appendp(p, ASet, regAddr(REG_PC_B)) // write next basic block to PC_B
385
				p = appendp(p, ABr)                     // jump to beginning of entryPointLoop
386
				entryPointLoopBranches = append(entryPointLoopBranches, p)
387
				break
388
			}
389

390
			// low-level WebAssembly call to function
391
			switch jmp.To.Type {
392
			case obj.TYPE_MEM:
393
				if !notUsePC_B[jmp.To.Sym.Name] {
394
					// Set PC_B parameter to function entry.
395
					p = appendp(p, AI32Const, constAddr(0))
396
				}
397
				p = appendp(p, ACall, jmp.To)
398

399
			case obj.TYPE_NONE:
400
				// (target PC is on stack)
401
				p = appendp(p, AI32WrapI64)
402
				p = appendp(p, AI32Const, constAddr(16)) // only needs PC_F bits (16-31), PC_B bits (0-15) are zero
403
				p = appendp(p, AI32ShrU)
404

405
				// Set PC_B parameter to function entry.
406
				// We need to push this before pushing the target PC_F,
407
				// so temporarily pop PC_F, using our REG_PC_B as a
408
				// scratch register, and push it back after pushing 0.
409
				p = appendp(p, ASet, regAddr(REG_PC_B))
410
				p = appendp(p, AI32Const, constAddr(0))
411
				p = appendp(p, AGet, regAddr(REG_PC_B))
412

413
				p = appendp(p, ACallIndirect)
414

415
			default:
416
				panic("bad target for JMP")
417
			}
418

419
			p = appendp(p, AReturn)
420

421
		case obj.ACALL, ACALLNORESUME:
422
			call := *p
423
			p.As = obj.ANOP
424

425
			pcAfterCall := call.Link.Pc
426
			if call.To.Sym == sigpanic {
427
				pcAfterCall-- // sigpanic expects to be called without advancing the pc
428
			}
429

430
			// jmpdefer manipulates the return address on the stack so deferreturn gets called repeatedly.
431
			// Model this in WebAssembly with a loop.
432
			if call.To.Sym == deferreturn {
433
				p = appendp(p, ALoop)
434
			}
435

436
			// SP -= 8
437
			p = appendp(p, AGet, regAddr(REG_SP))
438
			p = appendp(p, AI32Const, constAddr(8))
439
			p = appendp(p, AI32Sub)
440
			p = appendp(p, ASet, regAddr(REG_SP))
441

442
			// write return address to Go stack
443
			p = appendp(p, AGet, regAddr(REG_SP))
444
			p = appendp(p, AI64Const, obj.Addr{
445
				Type:   obj.TYPE_ADDR,
446
				Name:   obj.NAME_EXTERN,
447
				Sym:    s,           // PC_F
448
				Offset: pcAfterCall, // PC_B
449
			})
450
			p = appendp(p, AI64Store, constAddr(0))
451

452
			// low-level WebAssembly call to function
453
			switch call.To.Type {
454
			case obj.TYPE_MEM:
455
				if !notUsePC_B[call.To.Sym.Name] {
456
					// Set PC_B parameter to function entry.
457
					p = appendp(p, AI32Const, constAddr(0))
458
				}
459
				p = appendp(p, ACall, call.To)
460

461
			case obj.TYPE_NONE:
462
				// (target PC is on stack)
463
				p = appendp(p, AI32WrapI64)
464
				p = appendp(p, AI32Const, constAddr(16)) // only needs PC_F bits (16-31), PC_B bits (0-15) are zero
465
				p = appendp(p, AI32ShrU)
466

467
				// Set PC_B parameter to function entry.
468
				// We need to push this before pushing the target PC_F,
469
				// so temporarily pop PC_F, using our PC_B as a
470
				// scratch register, and push it back after pushing 0.
471
				p = appendp(p, ASet, regAddr(REG_PC_B))
472
				p = appendp(p, AI32Const, constAddr(0))
473
				p = appendp(p, AGet, regAddr(REG_PC_B))
474

475
				p = appendp(p, ACallIndirect)
476

477
			default:
478
				panic("bad target for CALL")
479
			}
480

481
			// gcWriteBarrier has no return value, it never unwinds the stack
482
			if call.To.Sym == gcWriteBarrier {
483
				break
484
			}
485

486
			// jmpdefer removes the frame of deferreturn from the Go stack.
487
			// However, its WebAssembly function still returns normally,
488
			// so we need to return from deferreturn without removing its
489
			// stack frame (no RET), because the frame is already gone.
490
			if call.To.Sym == jmpdefer {
491
				p = appendp(p, AReturn)
492
				break
493
			}
494

495
			// return value of call is on the top of the stack, indicating whether to unwind the WebAssembly stack
496
			if call.As == ACALLNORESUME && call.To.Sym != sigpanic && call.To.Sym != sigpanic0 { // sigpanic unwinds the stack, but it never resumes
497
				// trying to unwind WebAssembly stack but call has no resume point, terminate with error
498
				p = appendp(p, AIf)
499
				p = appendp(p, obj.AUNDEF)
500
				p = appendp(p, AEnd)
501
			} else {
502
				// unwinding WebAssembly stack to switch goroutine, return 1
503
				p = appendp(p, ABrIf)
504
				unwindExitBranches = append(unwindExitBranches, p)
505
			}
506

507
			// jump to before the call if jmpdefer has reset the return address to the call's PC
508
			if call.To.Sym == deferreturn {
509
				// get PC_B from -8(SP)
510
				p = appendp(p, AGet, regAddr(REG_SP))
511
				p = appendp(p, AI32Const, constAddr(8))
512
				p = appendp(p, AI32Sub)
513
				p = appendp(p, AI32Load16U, constAddr(0))
514
				p = appendp(p, ATee, regAddr(REG_PC_B))
515

516
				p = appendp(p, AI32Const, constAddr(call.Pc))
517
				p = appendp(p, AI32Eq)
518
				p = appendp(p, ABrIf, constAddr(0))
519
				p = appendp(p, AEnd) // end of Loop
520
			}
521

522
		case obj.ARET, ARETUNWIND:
523
			ret := *p
524
			p.As = obj.ANOP
525

526
			if framesize > 0 {
527
				// SP += framesize
528
				p = appendp(p, AGet, regAddr(REG_SP))
529
				p = appendp(p, AI32Const, constAddr(framesize))
530
				p = appendp(p, AI32Add)
531
				p = appendp(p, ASet, regAddr(REG_SP))
532
				// TODO(neelance): This should theoretically set Spadj, but it only works without.
533
				// p.Spadj = int32(-framesize)
534
			}
535

536
			if ret.To.Type == obj.TYPE_MEM {
537
				// Set PC_B parameter to function entry.
538
				p = appendp(p, AI32Const, constAddr(0))
539

540
				// low-level WebAssembly call to function
541
				p = appendp(p, ACall, ret.To)
542
				p = appendp(p, AReturn)
543
				break
544
			}
545

546
			// SP += 8
547
			p = appendp(p, AGet, regAddr(REG_SP))
548
			p = appendp(p, AI32Const, constAddr(8))
549
			p = appendp(p, AI32Add)
550
			p = appendp(p, ASet, regAddr(REG_SP))
551

552
			if ret.As == ARETUNWIND {
553
				// function needs to unwind the WebAssembly stack, return 1
554
				p = appendp(p, AI32Const, constAddr(1))
555
				p = appendp(p, AReturn)
556
				break
557
			}
558

559
			// not unwinding the WebAssembly stack, return 0
560
			p = appendp(p, AI32Const, constAddr(0))
561
			p = appendp(p, AReturn)
562
		}
563
	}
564

565
	for p := s.Func.Text; p != nil; p = p.Link {
566
		switch p.From.Name {
567
		case obj.NAME_AUTO:
568
			p.From.Offset += int64(framesize)
569
		case obj.NAME_PARAM:
570
			p.From.Reg = REG_SP
571
			p.From.Offset += int64(framesize) + 8 // parameters are after the frame and the 8-byte return address
572
		}
573

574
		switch p.To.Name {
575
		case obj.NAME_AUTO:
576
			p.To.Offset += int64(framesize)
577
		case obj.NAME_PARAM:
578
			p.To.Reg = REG_SP
579
			p.To.Offset += int64(framesize) + 8 // parameters are after the frame and the 8-byte return address
580
		}
581

582
		switch p.As {
583
		case AGet:
584
			if p.From.Type == obj.TYPE_ADDR {
585
				get := *p
586
				p.As = obj.ANOP
587

588
				switch get.From.Name {
589
				case obj.NAME_EXTERN:
590
					p = appendp(p, AI64Const, get.From)
591
				case obj.NAME_AUTO, obj.NAME_PARAM:
592
					p = appendp(p, AGet, regAddr(get.From.Reg))
593
					if get.From.Reg == REG_SP {
594
						p = appendp(p, AI64ExtendI32U)
595
					}
596
					if get.From.Offset != 0 {
597
						p = appendp(p, AI64Const, constAddr(get.From.Offset))
598
						p = appendp(p, AI64Add)
599
					}
600
				default:
601
					panic("bad Get: invalid name")
602
				}
603
			}
604

605
		case AI32Load, AI64Load, AF32Load, AF64Load, AI32Load8S, AI32Load8U, AI32Load16S, AI32Load16U, AI64Load8S, AI64Load8U, AI64Load16S, AI64Load16U, AI64Load32S, AI64Load32U:
606
			if p.From.Type == obj.TYPE_MEM {
607
				as := p.As
608
				from := p.From
609

610
				p.As = AGet
611
				p.From = regAddr(from.Reg)
612

613
				if from.Reg != REG_SP {
614
					p = appendp(p, AI32WrapI64)
615
				}
616

617
				p = appendp(p, as, constAddr(from.Offset))
618
			}
619

620
		case AMOVB, AMOVH, AMOVW, AMOVD:
621
			mov := *p
622
			p.As = obj.ANOP
623

624
			var loadAs obj.As
625
			var storeAs obj.As
626
			switch mov.As {
627
			case AMOVB:
628
				loadAs = AI64Load8U
629
				storeAs = AI64Store8
630
			case AMOVH:
631
				loadAs = AI64Load16U
632
				storeAs = AI64Store16
633
			case AMOVW:
634
				loadAs = AI64Load32U
635
				storeAs = AI64Store32
636
			case AMOVD:
637
				loadAs = AI64Load
638
				storeAs = AI64Store
639
			}
640

641
			appendValue := func() {
642
				switch mov.From.Type {
643
				case obj.TYPE_CONST:
644
					p = appendp(p, AI64Const, constAddr(mov.From.Offset))
645

646
				case obj.TYPE_ADDR:
647
					switch mov.From.Name {
648
					case obj.NAME_NONE, obj.NAME_PARAM, obj.NAME_AUTO:
649
						p = appendp(p, AGet, regAddr(mov.From.Reg))
650
						if mov.From.Reg == REG_SP {
651
							p = appendp(p, AI64ExtendI32U)
652
						}
653
						p = appendp(p, AI64Const, constAddr(mov.From.Offset))
654
						p = appendp(p, AI64Add)
655
					case obj.NAME_EXTERN:
656
						p = appendp(p, AI64Const, mov.From)
657
					default:
658
						panic("bad name for MOV")
659
					}
660

661
				case obj.TYPE_REG:
662
					p = appendp(p, AGet, mov.From)
663
					if mov.From.Reg == REG_SP {
664
						p = appendp(p, AI64ExtendI32U)
665
					}
666

667
				case obj.TYPE_MEM:
668
					p = appendp(p, AGet, regAddr(mov.From.Reg))
669
					if mov.From.Reg != REG_SP {
670
						p = appendp(p, AI32WrapI64)
671
					}
672
					p = appendp(p, loadAs, constAddr(mov.From.Offset))
673

674
				default:
675
					panic("bad MOV type")
676
				}
677
			}
678

679
			switch mov.To.Type {
680
			case obj.TYPE_REG:
681
				appendValue()
682
				if mov.To.Reg == REG_SP {
683
					p = appendp(p, AI32WrapI64)
684
				}
685
				p = appendp(p, ASet, mov.To)
686

687
			case obj.TYPE_MEM:
688
				switch mov.To.Name {
689
				case obj.NAME_NONE, obj.NAME_PARAM:
690
					p = appendp(p, AGet, regAddr(mov.To.Reg))
691
					if mov.To.Reg != REG_SP {
692
						p = appendp(p, AI32WrapI64)
693
					}
694
				case obj.NAME_EXTERN:
695
					p = appendp(p, AI32Const, obj.Addr{Type: obj.TYPE_ADDR, Name: obj.NAME_EXTERN, Sym: mov.To.Sym})
696
				default:
697
					panic("bad MOV name")
698
				}
699
				appendValue()
700
				p = appendp(p, storeAs, constAddr(mov.To.Offset))
701

702
			default:
703
				panic("bad MOV type")
704
			}
705

706
		case ACallImport:
707
			p.As = obj.ANOP
708
			p = appendp(p, AGet, regAddr(REG_SP))
709
			p = appendp(p, ACall, obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: s})
710
			p.Mark = WasmImport
711
		}
712
	}
713

714
	{
715
		p := s.Func.Text
716
		if len(unwindExitBranches) > 0 {
717
			p = appendp(p, ABlock) // unwindExit, used to return 1 when unwinding the stack
718
			for _, b := range unwindExitBranches {
719
				b.To = obj.Addr{Type: obj.TYPE_BRANCH, Val: p}
720
			}
721
		}
722
		if len(entryPointLoopBranches) > 0 {
723
			p = appendp(p, ALoop) // entryPointLoop, used to jump between basic blocks
724
			for _, b := range entryPointLoopBranches {
725
				b.To = obj.Addr{Type: obj.TYPE_BRANCH, Val: p}
726
			}
727
		}
728
		if numResumePoints > 0 {
729
			// Add Block instructions for resume points and BrTable to jump to selected resume point.
730
			for i := 0; i < numResumePoints+1; i++ {
731
				p = appendp(p, ABlock)
732
			}
733
			p = appendp(p, AGet, regAddr(REG_PC_B)) // read next basic block from PC_B
734
			p = appendp(p, ABrTable, obj.Addr{Val: tableIdxs})
735
			p = appendp(p, AEnd) // end of Block
736
		}
737
		for p.Link != nil {
738
			p = p.Link // function instructions
739
		}
740
		if len(entryPointLoopBranches) > 0 {
741
			p = appendp(p, AEnd) // end of entryPointLoop
742
		}
743
		p = appendp(p, obj.AUNDEF)
744
		if len(unwindExitBranches) > 0 {
745
			p = appendp(p, AEnd) // end of unwindExit
746
			p = appendp(p, AI32Const, constAddr(1))
747
		}
748
	}
749

750
	currentDepth = 0
751
	blockDepths := make(map[*obj.Prog]int)
752
	for p := s.Func.Text; p != nil; p = p.Link {
753
		switch p.As {
754
		case ABlock, ALoop, AIf:
755
			currentDepth++
756
			blockDepths[p] = currentDepth
757
		case AEnd:
758
			currentDepth--
759
		}
760

761
		switch p.As {
762
		case ABr, ABrIf:
763
			if p.To.Type == obj.TYPE_BRANCH {
764
				blockDepth, ok := blockDepths[p.To.Val.(*obj.Prog)]
765
				if !ok {
766
					panic("label not at block")
767
				}
768
				p.To = constAddr(int64(currentDepth - blockDepth))
769
			}
770
		}
771
	}
772
}
773

774
func constAddr(value int64) obj.Addr {
775
	return obj.Addr{Type: obj.TYPE_CONST, Offset: value}
776
}
777

778
func regAddr(reg int16) obj.Addr {
779
	return obj.Addr{Type: obj.TYPE_REG, Reg: reg}
780
}
781

782
// Most of the Go functions has a single parameter (PC_B) in
783
// Wasm ABI. This is a list of exceptions.
784
var notUsePC_B = map[string]bool{
785
	"_rt0_wasm_js":           true,
786
	"wasm_export_run":        true,
787
	"wasm_export_resume":     true,
788
	"wasm_export_getsp":      true,
789
	"wasm_pc_f_loop":         true,
790
	"runtime.wasmMove":       true,
791
	"runtime.wasmZero":       true,
792
	"runtime.wasmDiv":        true,
793
	"runtime.wasmTruncS":     true,
794
	"runtime.wasmTruncU":     true,
795
	"runtime.gcWriteBarrier": true,
796
	"cmpbody":                true,
797
	"memeqbody":              true,
798
	"memcmp":                 true,
799
	"memchr":                 true,
800
}
801

802
func assemble(ctxt *obj.Link, s *obj.LSym, newprog obj.ProgAlloc) {
803
	type regVar struct {
804
		global bool
805
		index  uint64
806
	}
807

808
	type varDecl struct {
809
		count uint64
810
		typ   valueType
811
	}
812

813
	hasLocalSP := false
814
	regVars := [MAXREG - MINREG]*regVar{
815
		REG_SP - MINREG:    {true, 0},
816
		REG_CTXT - MINREG:  {true, 1},
817
		REG_g - MINREG:     {true, 2},
818
		REG_RET0 - MINREG:  {true, 3},
819
		REG_RET1 - MINREG:  {true, 4},
820
		REG_RET2 - MINREG:  {true, 5},
821
		REG_RET3 - MINREG:  {true, 6},
822
		REG_PAUSE - MINREG: {true, 7},
823
	}
824
	var varDecls []*varDecl
825
	useAssemblyRegMap := func() {
826
		for i := int16(0); i < 16; i++ {
827
			regVars[REG_R0+i-MINREG] = &regVar{false, uint64(i)}
828
		}
829
	}
830

831
	// Function starts with declaration of locals: numbers and types.
832
	// Some functions use a special calling convention.
833
	switch s.Name {
834
	case "_rt0_wasm_js", "wasm_export_run", "wasm_export_resume", "wasm_export_getsp", "wasm_pc_f_loop",
835
		"runtime.wasmMove", "runtime.wasmZero", "runtime.wasmDiv", "runtime.wasmTruncS", "runtime.wasmTruncU", "memeqbody":
836
		varDecls = []*varDecl{}
837
		useAssemblyRegMap()
838
	case "memchr", "memcmp":
839
		varDecls = []*varDecl{{count: 2, typ: i32}}
840
		useAssemblyRegMap()
841
	case "cmpbody":
842
		varDecls = []*varDecl{{count: 2, typ: i64}}
843
		useAssemblyRegMap()
844
	case "runtime.gcWriteBarrier":
845
		varDecls = []*varDecl{{count: 4, typ: i64}}
846
		useAssemblyRegMap()
847
	default:
848
		// Normal calling convention: PC_B as WebAssembly parameter. First local variable is local SP cache.
849
		regVars[REG_PC_B-MINREG] = &regVar{false, 0}
850
		hasLocalSP = true
851

852
		var regUsed [MAXREG - MINREG]bool
853
		for p := s.Func.Text; p != nil; p = p.Link {
854
			if p.From.Reg != 0 {
855
				regUsed[p.From.Reg-MINREG] = true
856
			}
857
			if p.To.Reg != 0 {
858
				regUsed[p.To.Reg-MINREG] = true
859
			}
860
		}
861

862
		regs := []int16{REG_SP}
863
		for reg := int16(REG_R0); reg <= REG_F31; reg++ {
864
			if regUsed[reg-MINREG] {
865
				regs = append(regs, reg)
866
			}
867
		}
868

869
		var lastDecl *varDecl
870
		for i, reg := range regs {
871
			t := regType(reg)
872
			if lastDecl == nil || lastDecl.typ != t {
873
				lastDecl = &varDecl{
874
					count: 0,
875
					typ:   t,
876
				}
877
				varDecls = append(varDecls, lastDecl)
878
			}
879
			lastDecl.count++
880
			if reg != REG_SP {
881
				regVars[reg-MINREG] = &regVar{false, 1 + uint64(i)}
882
			}
883
		}
884
	}
885

886
	w := new(bytes.Buffer)
887

888
	writeUleb128(w, uint64(len(varDecls)))
889
	for _, decl := range varDecls {
890
		writeUleb128(w, decl.count)
891
		w.WriteByte(byte(decl.typ))
892
	}
893

894
	if hasLocalSP {
895
		// Copy SP from its global variable into a local variable. Accessing a local variable is more efficient.
896
		updateLocalSP(w)
897
	}
898

899
	for p := s.Func.Text; p != nil; p = p.Link {
900
		switch p.As {
901
		case AGet:
902
			if p.From.Type != obj.TYPE_REG {
903
				panic("bad Get: argument is not a register")
904
			}
905
			reg := p.From.Reg
906
			v := regVars[reg-MINREG]
907
			if v == nil {
908
				panic("bad Get: invalid register")
909
			}
910
			if reg == REG_SP && hasLocalSP {
911
				writeOpcode(w, ALocalGet)
912
				writeUleb128(w, 1) // local SP
913
				continue
914
			}
915
			if v.global {
916
				writeOpcode(w, AGlobalGet)
917
			} else {
918
				writeOpcode(w, ALocalGet)
919
			}
920
			writeUleb128(w, v.index)
921
			continue
922

923
		case ASet:
924
			if p.To.Type != obj.TYPE_REG {
925
				panic("bad Set: argument is not a register")
926
			}
927
			reg := p.To.Reg
928
			v := regVars[reg-MINREG]
929
			if v == nil {
930
				panic("bad Set: invalid register")
931
			}
932
			if reg == REG_SP && hasLocalSP {
933
				writeOpcode(w, ALocalTee)
934
				writeUleb128(w, 1) // local SP
935
			}
936
			if v.global {
937
				writeOpcode(w, AGlobalSet)
938
			} else {
939
				if p.Link.As == AGet && p.Link.From.Reg == reg {
940
					writeOpcode(w, ALocalTee)
941
					p = p.Link
942
				} else {
943
					writeOpcode(w, ALocalSet)
944
				}
945
			}
946
			writeUleb128(w, v.index)
947
			continue
948

949
		case ATee:
950
			if p.To.Type != obj.TYPE_REG {
951
				panic("bad Tee: argument is not a register")
952
			}
953
			reg := p.To.Reg
954
			v := regVars[reg-MINREG]
955
			if v == nil {
956
				panic("bad Tee: invalid register")
957
			}
958
			writeOpcode(w, ALocalTee)
959
			writeUleb128(w, v.index)
960
			continue
961

962
		case ANot:
963
			writeOpcode(w, AI32Eqz)
964
			continue
965

966
		case obj.AUNDEF:
967
			writeOpcode(w, AUnreachable)
968
			continue
969

970
		case obj.ANOP, obj.ATEXT, obj.AFUNCDATA, obj.APCDATA:
971
			// ignore
972
			continue
973
		}
974

975
		writeOpcode(w, p.As)
976

977
		switch p.As {
978
		case ABlock, ALoop, AIf:
979
			if p.From.Offset != 0 {
980
				// block type, rarely used, e.g. for code compiled with emscripten
981
				w.WriteByte(0x80 - byte(p.From.Offset))
982
				continue
983
			}
984
			w.WriteByte(0x40)
985

986
		case ABr, ABrIf:
987
			if p.To.Type != obj.TYPE_CONST {
988
				panic("bad Br/BrIf")
989
			}
990
			writeUleb128(w, uint64(p.To.Offset))
991

992
		case ABrTable:
993
			idxs := p.To.Val.([]uint64)
994
			writeUleb128(w, uint64(len(idxs)-1))
995
			for _, idx := range idxs {
996
				writeUleb128(w, idx)
997
			}
998

999
		case ACall:
1000
			switch p.To.Type {
1001
			case obj.TYPE_CONST:
1002
				writeUleb128(w, uint64(p.To.Offset))
1003

1004
			case obj.TYPE_MEM:
1005
				if p.To.Name != obj.NAME_EXTERN && p.To.Name != obj.NAME_STATIC {
1006
					fmt.Println(p.To)
1007
					panic("bad name for Call")
1008
				}
1009
				r := obj.Addrel(s)
1010
				r.Off = int32(w.Len())
1011
				r.Type = objabi.R_CALL
1012
				if p.Mark&WasmImport != 0 {
1013
					r.Type = objabi.R_WASMIMPORT
1014
				}
1015
				r.Sym = p.To.Sym
1016
				if hasLocalSP {
1017
					// The stack may have moved, which changes SP. Update the local SP variable.
1018
					updateLocalSP(w)
1019
				}
1020

1021
			default:
1022
				panic("bad type for Call")
1023
			}
1024

1025
		case ACallIndirect:
1026
			writeUleb128(w, uint64(p.To.Offset))
1027
			w.WriteByte(0x00) // reserved value
1028
			if hasLocalSP {
1029
				// The stack may have moved, which changes SP. Update the local SP variable.
1030
				updateLocalSP(w)
1031
			}
1032

1033
		case AI32Const, AI64Const:
1034
			if p.From.Name == obj.NAME_EXTERN {
1035
				r := obj.Addrel(s)
1036
				r.Off = int32(w.Len())
1037
				r.Type = objabi.R_ADDR
1038
				r.Sym = p.From.Sym
1039
				r.Add = p.From.Offset
1040
				break
1041
			}
1042
			writeSleb128(w, p.From.Offset)
1043

1044
		case AF32Const:
1045
			b := make([]byte, 4)
1046
			binary.LittleEndian.PutUint32(b, math.Float32bits(float32(p.From.Val.(float64))))
1047
			w.Write(b)
1048

1049
		case AF64Const:
1050
			b := make([]byte, 8)
1051
			binary.LittleEndian.PutUint64(b, math.Float64bits(p.From.Val.(float64)))
1052
			w.Write(b)
1053

1054
		case AI32Load, AI64Load, AF32Load, AF64Load, AI32Load8S, AI32Load8U, AI32Load16S, AI32Load16U, AI64Load8S, AI64Load8U, AI64Load16S, AI64Load16U, AI64Load32S, AI64Load32U:
1055
			if p.From.Offset < 0 {
1056
				panic("negative offset for *Load")
1057
			}
1058
			if p.From.Type != obj.TYPE_CONST {
1059
				panic("bad type for *Load")
1060
			}
1061
			if p.From.Offset > math.MaxUint32 {
1062
				ctxt.Diag("bad offset in %v", p)
1063
			}
1064
			writeUleb128(w, align(p.As))
1065
			writeUleb128(w, uint64(p.From.Offset))
1066

1067
		case AI32Store, AI64Store, AF32Store, AF64Store, AI32Store8, AI32Store16, AI64Store8, AI64Store16, AI64Store32:
1068
			if p.To.Offset < 0 {
1069
				panic("negative offset")
1070
			}
1071
			if p.From.Offset > math.MaxUint32 {
1072
				ctxt.Diag("bad offset in %v", p)
1073
			}
1074
			writeUleb128(w, align(p.As))
1075
			writeUleb128(w, uint64(p.To.Offset))
1076

1077
		case ACurrentMemory, AGrowMemory:
1078
			w.WriteByte(0x00)
1079

1080
		}
1081
	}
1082

1083
	w.WriteByte(0x0b) // end
1084

1085
	s.P = w.Bytes()
1086
}
1087

1088
func updateLocalSP(w *bytes.Buffer) {
1089
	writeOpcode(w, AGlobalGet)
1090
	writeUleb128(w, 0) // global SP
1091
	writeOpcode(w, ALocalSet)
1092
	writeUleb128(w, 1) // local SP
1093
}
1094

1095
func writeOpcode(w *bytes.Buffer, as obj.As) {
1096
	switch {
1097
	case as < AUnreachable:
1098
		panic(fmt.Sprintf("unexpected assembler op: %s", as))
1099
	case as < AEnd:
1100
		w.WriteByte(byte(as - AUnreachable + 0x00))
1101
	case as < ADrop:
1102
		w.WriteByte(byte(as - AEnd + 0x0B))
1103
	case as < ALocalGet:
1104
		w.WriteByte(byte(as - ADrop + 0x1A))
1105
	case as < AI32Load:
1106
		w.WriteByte(byte(as - ALocalGet + 0x20))
1107
	case as < AI32TruncSatF32S:
1108
		w.WriteByte(byte(as - AI32Load + 0x28))
1109
	case as < ALast:
1110
		w.WriteByte(0xFC)
1111
		w.WriteByte(byte(as - AI32TruncSatF32S + 0x00))
1112
	default:
1113
		panic(fmt.Sprintf("unexpected assembler op: %s", as))
1114
	}
1115
}
1116

1117
type valueType byte
1118

1119
const (
1120
	i32 valueType = 0x7F
1121
	i64 valueType = 0x7E
1122
	f32 valueType = 0x7D
1123
	f64 valueType = 0x7C
1124
)
1125

1126
func regType(reg int16) valueType {
1127
	switch {
1128
	case reg == REG_SP:
1129
		return i32
1130
	case reg >= REG_R0 && reg <= REG_R15:
1131
		return i64
1132
	case reg >= REG_F0 && reg <= REG_F15:
1133
		return f32
1134
	case reg >= REG_F16 && reg <= REG_F31:
1135
		return f64
1136
	default:
1137
		panic("invalid register")
1138
	}
1139
}
1140

1141
func align(as obj.As) uint64 {
1142
	switch as {
1143
	case AI32Load8S, AI32Load8U, AI64Load8S, AI64Load8U, AI32Store8, AI64Store8:
1144
		return 0
1145
	case AI32Load16S, AI32Load16U, AI64Load16S, AI64Load16U, AI32Store16, AI64Store16:
1146
		return 1
1147
	case AI32Load, AF32Load, AI64Load32S, AI64Load32U, AI32Store, AF32Store, AI64Store32:
1148
		return 2
1149
	case AI64Load, AF64Load, AI64Store, AF64Store:
1150
		return 3
1151
	default:
1152
		panic("align: bad op")
1153
	}
1154
}
1155

1156
func writeUleb128(w io.ByteWriter, v uint64) {
1157
	if v < 128 {
1158
		w.WriteByte(uint8(v))
1159
		return
1160
	}
1161
	more := true
1162
	for more {
1163
		c := uint8(v & 0x7f)
1164
		v >>= 7
1165
		more = v != 0
1166
		if more {
1167
			c |= 0x80
1168
		}
1169
		w.WriteByte(c)
1170
	}
1171
}
1172

1173
func writeSleb128(w io.ByteWriter, v int64) {
1174
	more := true
1175
	for more {
1176
		c := uint8(v & 0x7f)
1177
		s := uint8(v & 0x40)
1178
		v >>= 7
1179
		more = !((v == 0 && s == 0) || (v == -1 && s != 0))
1180
		if more {
1181
			c |= 0x80
1182
		}
1183
		w.WriteByte(c)
1184
	}
1185
}
1186