cmd/compile: add wasm architecture

This commit adds the wasm architecture to the compile command.
A later commit will contain the corresponding linker changes.

Design doc: https://docs.google.com/document/d/131vjr4DH6JFnb-blm_uRdaC0_Nv3OUwjEY5qVCxCup4

The following files are generated:
- src/cmd/compile/internal/ssa/opGen.go
- src/cmd/compile/internal/ssa/rewriteWasm.go
- src/cmd/internal/obj/wasm/anames.go

Updates #18892

Change-Id: Ifb4a96a3e427aac2362a1c97967d5667450fba3b
Reviewed-on: https://go-review.googlesource.com/103295
Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>

src/cmd/asm/internal/arch/arch.go

@@ -11,6 +11,7 @@ import (
 	"cmd/internal/obj/mips"
 	"cmd/internal/obj/ppc64"
 	"cmd/internal/obj/s390x"
+	"cmd/internal/obj/wasm"
 	"cmd/internal/obj/x86"
 	"fmt"
 	"strings"
@@ -87,6 +88,8 @@ func Set(GOARCH string) *Arch {
 		a := archS390x()
 		a.LinkArch = &s390x.Links390x
 		return a
+	case "wasm":
+		return archWasm()
 	}
 	return nil
 }
@@ -95,6 +98,10 @@ func jumpX86(word string) bool {
 	return word[0] == 'J' || word == "CALL" || strings.HasPrefix(word, "LOOP") || word == "XBEGIN"
 }
 
+func jumpWasm(word string) bool {
+	return word == "JMP" || word == "CALL" || word == "Call" || word == "Br" || word == "BrIf"
+}
+
 func archX86(linkArch *obj.LinkArch) *Arch {
 	register := make(map[string]int16)
 	// Create maps for easy lookup of instruction names etc.
@@ -577,3 +584,24 @@ func archS390x() *Arch {
 		IsJump:         jumpS390x,
 	}
 }
+
+func archWasm() *Arch {
+	instructions := make(map[string]obj.As)
+	for i, s := range obj.Anames {
+		instructions[s] = obj.As(i)
+	}
+	for i, s := range wasm.Anames {
+		if obj.As(i) >= obj.A_ARCHSPECIFIC {
+			instructions[s] = obj.As(i) + obj.ABaseWasm
+		}
+	}
+
+	return &Arch{
+		LinkArch:       &wasm.Linkwasm,
+		Instructions:   instructions,
+		Register:       wasm.Register,
+		RegisterPrefix: nil,
+		RegisterNumber: nilRegisterNumber,
+		IsJump:         jumpWasm,
+	}
+}

src/cmd/asm/internal/asm/asm.go

@@ -343,6 +343,13 @@ func (p *Parser) asmJump(op obj.As, cond string, a []obj.Addr) {
 		As:   op,
 	}
 	switch len(a) {
+	case 0:
+		if p.arch.Family == sys.Wasm {
+			target = &obj.Addr{Type: obj.TYPE_NONE}
+			break
+		}
+		p.errorf("wrong number of arguments to %s instruction", op)
+		return
 	case 1:
 		target = &a[0]
 	case 2:
@@ -445,6 +452,8 @@ func (p *Parser) asmJump(op obj.As, cond string, a []obj.Addr) {
 	case target.Type == obj.TYPE_CONST:
 		// JMP $4
 		prog.To = a[0]
+	case target.Type == obj.TYPE_NONE:
+		// JMP
 	default:
 		p.errorf("cannot assemble jump %+v", target)
 		return

src/cmd/compile/internal/gc/go.go

@@ -311,4 +311,12 @@ var (
 	// GO386=387
 	ControlWord64trunc,
 	ControlWord32 *obj.LSym
+
+	// Wasm
+	WasmMove,
+	WasmZero,
+	WasmDiv,
+	WasmTruncS,
+	WasmTruncU,
+	SigPanic *obj.LSym
 )

src/cmd/compile/internal/gc/main.go

@@ -180,6 +180,7 @@ func Main(archInit func(*Arch)) {
 	gopkg = types.NewPkg("go", "")
 
 	Nacl = objabi.GOOS == "nacl"
+	Wasm := objabi.GOARCH == "wasm"
 
 	flag.BoolVar(&compiling_runtime, "+", false, "compiling runtime")
 	flag.BoolVar(&compiling_std, "std", false, "compiling standard library")
@@ -200,7 +201,7 @@ func Main(archInit func(*Arch)) {
 	flag.IntVar(&nBackendWorkers, "c", 1, "concurrency during compilation, 1 means no concurrency")
 	flag.BoolVar(&pure_go, "complete", false, "compiling complete package (no C or assembly)")
 	flag.StringVar(&debugstr, "d", "", "print debug information about items in `list`; try -d help")
-	flag.BoolVar(&flagDWARF, "dwarf", true, "generate DWARF symbols")
+	flag.BoolVar(&flagDWARF, "dwarf", !Wasm, "generate DWARF symbols")
 	flag.BoolVar(&Ctxt.Flag_locationlists, "dwarflocationlists", true, "add location lists to DWARF in optimized mode")
 	flag.IntVar(&genDwarfInline, "gendwarfinl", 2, "generate DWARF inline info records")
 	objabi.Flagcount("e", "no limit on number of errors reported", &Debug['e'])
@@ -265,6 +266,7 @@ func Main(archInit func(*Arch)) {
 	} else {
 		// turn off inline generation if no dwarf at all
 		genDwarfInline = 0
+		Ctxt.Flag_locationlists = false
 	}
 
 	if flag.NArg() < 1 && debugstr != "help" && debugstr != "ssa/help" {

src/cmd/compile/internal/gc/ssa.go

@@ -87,6 +87,14 @@ func initssaconfig() {
 	// GO386=387 runtime functions
 	ControlWord64trunc = sysfunc("controlWord64trunc")
 	ControlWord32 = sysfunc("controlWord32")
+
+	// Wasm
+	WasmMove = sysfunc("wasmMove")
+	WasmZero = sysfunc("wasmZero")
+	WasmDiv = sysfunc("wasmDiv")
+	WasmTruncS = sysfunc("wasmTruncS")
+	WasmTruncU = sysfunc("wasmTruncU")
+	SigPanic = sysfunc("sigpanic")
 }
 
 // buildssa builds an SSA function for fn.
@@ -1794,7 +1802,7 @@ func (s *state) expr(n *Node) *ssa.Value {
 					conv = conv1
 				}
 			}
-			if thearch.LinkArch.Family == sys.ARM64 || s.softFloat {
+			if thearch.LinkArch.Family == sys.ARM64 || thearch.LinkArch.Family == sys.Wasm || s.softFloat {
 				if conv1, ok1 := uint64fpConvOpToSSA[twoTypes{s.concreteEtype(ft), s.concreteEtype(tt)}]; ok1 {
 					conv = conv1
 				}
@@ -5222,7 +5230,7 @@ func (s *SSAGenState) Call(v *ssa.Value) *obj.Prog {
 	} else {
 		// TODO(mdempsky): Can these differences be eliminated?
 		switch thearch.LinkArch.Family {
-		case sys.AMD64, sys.I386, sys.PPC64, sys.S390X:
+		case sys.AMD64, sys.I386, sys.PPC64, sys.S390X, sys.Wasm:
 			p.To.Type = obj.TYPE_REG
 		case sys.ARM, sys.ARM64, sys.MIPS, sys.MIPS64:
 			p.To.Type = obj.TYPE_MEM

src/cmd/compile/internal/ssa/config.go

@@ -311,6 +311,20 @@ func NewConfig(arch string, types Types, ctxt *obj.Link, optimize bool) *Config
 		c.LinkReg = linkRegMIPS
 		c.hasGReg = true
 		c.noDuffDevice = true
+	case "wasm":
+		c.PtrSize = 8
+		c.RegSize = 8
+		c.lowerBlock = rewriteBlockWasm
+		c.lowerValue = rewriteValueWasm
+		c.registers = registersWasm[:]
+		c.gpRegMask = gpRegMaskWasm
+		c.fpRegMask = fpRegMaskWasm
+		c.FPReg = framepointerRegWasm
+		c.LinkReg = linkRegWasm
+		c.hasGReg = true
+		c.noDuffDevice = true
+		c.useAvg = false
+		c.useHmul = false
 	default:
 		ctxt.Diag("arch %s not implemented", arch)
 	}

src/cmd/compile/internal/ssa/schedule.go

@@ -90,7 +90,8 @@ func schedule(f *Func) {
 			case v.Op == OpAMD64LoweredGetClosurePtr || v.Op == OpPPC64LoweredGetClosurePtr ||
 				v.Op == OpARMLoweredGetClosurePtr || v.Op == OpARM64LoweredGetClosurePtr ||
 				v.Op == Op386LoweredGetClosurePtr || v.Op == OpMIPS64LoweredGetClosurePtr ||
-				v.Op == OpS390XLoweredGetClosurePtr || v.Op == OpMIPSLoweredGetClosurePtr:
+				v.Op == OpS390XLoweredGetClosurePtr || v.Op == OpMIPSLoweredGetClosurePtr ||
+				v.Op == OpWasmLoweredGetClosurePtr:
 				// We also score GetLoweredClosurePtr as early as possible to ensure that the
 				// context register is not stomped. GetLoweredClosurePtr should only appear
 				// in the entry block where there are no phi functions, so there is no
@@ -102,7 +103,8 @@ func schedule(f *Func) {
 			case v.Op == OpAMD64LoweredNilCheck || v.Op == OpPPC64LoweredNilCheck ||
 				v.Op == OpARMLoweredNilCheck || v.Op == OpARM64LoweredNilCheck ||
 				v.Op == Op386LoweredNilCheck || v.Op == OpMIPS64LoweredNilCheck ||
-				v.Op == OpS390XLoweredNilCheck || v.Op == OpMIPSLoweredNilCheck:
+				v.Op == OpS390XLoweredNilCheck || v.Op == OpMIPSLoweredNilCheck ||
+				v.Op == OpWasmLoweredNilCheck:
 				// Nil checks must come before loads from the same address.
 				score[v.ID] = ScoreNilCheck
 			case v.Op == OpPhi:

src/cmd/compile/internal/ssa/tighten.go

@@ -18,7 +18,8 @@ func tighten(f *Func) {
 				OpAMD64LoweredGetClosurePtr, Op386LoweredGetClosurePtr,
 				OpARMLoweredGetClosurePtr, OpARM64LoweredGetClosurePtr,
 				OpMIPSLoweredGetClosurePtr, OpMIPS64LoweredGetClosurePtr,
-				OpS390XLoweredGetClosurePtr, OpPPC64LoweredGetClosurePtr:
+				OpS390XLoweredGetClosurePtr, OpPPC64LoweredGetClosurePtr,
+				OpWasmLoweredGetClosurePtr:
 				// Phis need to stay in their block.
 				// GetClosurePtr & Arg must stay in the entry block.
 				// Tuple selectors must stay with the tuple generator.

src/cmd/compile/main.go

@@ -13,6 +13,7 @@ import (
 	"cmd/compile/internal/mips64"
 	"cmd/compile/internal/ppc64"
 	"cmd/compile/internal/s390x"
+	"cmd/compile/internal/wasm"
 	"cmd/compile/internal/x86"
 	"cmd/internal/objabi"
 	"fmt"
@@ -33,6 +34,7 @@ var archInits = map[string]func(*gc.Arch){
 	"ppc64":    ppc64.Init,
 	"ppc64le":  ppc64.Init,
 	"s390x":    s390x.Init,
+	"wasm":     wasm.Init,
 }
 
 func main() {

src/cmd/dist/buildtool.go

@@ -49,6 +49,7 @@ var bootstrapDirs = []string{
 	"cmd/compile/internal/ssa",
 	"cmd/compile/internal/syntax",
 	"cmd/compile/internal/x86",
+	"cmd/compile/internal/wasm",
 	"cmd/internal/bio",
 	"cmd/internal/gcprog",
 	"cmd/internal/dwarf",
@@ -61,6 +62,7 @@ var bootstrapDirs = []string{
 	"cmd/internal/obj/ppc64",
 	"cmd/internal/obj/s390x",
 	"cmd/internal/obj/x86",
+	"cmd/internal/obj/wasm",
 	"cmd/internal/src",
 	"cmd/internal/sys",
 	"cmd/link",
@@ -100,6 +102,8 @@ var ignorePrefixes = []string{
 var ignoreSuffixes = []string{
 	"_arm64.s",
 	"_arm64.go",
+	"_wasm.s",
+	"_wasm.go",
 }
 
 func bootstrapBuildTools() {

src/cmd/go/internal/work/gc.go

@@ -89,7 +89,7 @@ func (gcToolchain) gc(b *Builder, a *Action, archive string, importcfg []byte, a
 		gcargs = append(gcargs, "-buildid", a.buildID)
 	}
 	platform := cfg.Goos + "/" + cfg.Goarch
-	if p.Internal.OmitDebug || platform == "nacl/amd64p32" || cfg.Goos == "plan9" {
+	if p.Internal.OmitDebug || platform == "nacl/amd64p32" || cfg.Goos == "plan9" || cfg.Goarch == "wasm" {
 		gcargs = append(gcargs, "-dwarf=false")
 	}
 	if strings.HasPrefix(runtimeVersion, "go1") && !strings.Contains(os.Args[0], "go_bootstrap") {

src/cmd/internal/obj/link.go

@@ -364,6 +364,7 @@ const (
 	ABaseARM64
 	ABaseMIPS
 	ABaseS390X
+	ABaseWasm
 
 	AllowedOpCodes = 1 << 11            // The number of opcodes available for any given architecture.
 	AMask          = AllowedOpCodes - 1 // AND with this to use the opcode as an array index.
@@ -595,7 +596,7 @@ func (ctxt *Link) Logf(format string, args ...interface{}) {
 // the hardware stack pointer and the local variable area.
 func (ctxt *Link) FixedFrameSize() int64 {
 	switch ctxt.Arch.Family {
-	case sys.AMD64, sys.I386:
+	case sys.AMD64, sys.I386, sys.Wasm:
 		return 0
 	case sys.PPC64:
 		// PIC code on ppc64le requires 32 bytes of stack, and it's easier to

src/cmd/internal/obj/stringer.go

@@ -26,7 +26,7 @@ var (
 	pkg    = flag.String("p", "", "package name")
 )
 
-var Are = regexp.MustCompile(`^\tA([A-Z0-9]+)`)
+var Are = regexp.MustCompile(`^\tA([A-Za-z0-9]+)`)
 
 func main() {
 	flag.Parse()

src/cmd/internal/obj/util.go

@@ -394,6 +394,7 @@ const (
 	RBaseARM64 = 8 * 1024  // range [8k, 13k)
 	RBaseMIPS  = 13 * 1024 // range [13k, 14k)
 	RBaseS390X = 14 * 1024 // range [14k, 15k)
+	RBaseWasm  = 16 * 1024
 )
 
 // RegisterRegister binds a pretty-printer (Rconv) for register

src/cmd/internal/obj/wasm/a.out.go

+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package wasm
+
+import "cmd/internal/obj"
+
+//go:generate go run ../stringer.go -i $GOFILE -o anames.go -p wasm
+
+const (
+	/* mark flags */
+	DONE          = 1 << iota
+	PRESERVEFLAGS // not allowed to clobber flags
+)
+
+/*
+ *	wasm
+ */
+const (
+	ACallImport = obj.ABaseWasm + obj.A_ARCHSPECIFIC + iota
+	AGet
+	ASet
+	ATee
+	ANot // alias for I32Eqz
+
+	// The following are low-level WebAssembly instructions.
+	// Their order matters, since it matches the opcode encoding.
+	// Gaps in the encoding are indicated by comments.
+
+	AUnreachable // opcode 0x00
+	ANop
+	ABlock
+	ALoop
+	AIf
+	AElse
+
+	AEnd // opcode 0x0B
+	ABr
+	ABrIf
+	ABrTable
+	// ACall and AReturn are WebAssembly instructions. obj.ACALL and obj.ARET are higher level instructions
+	// with Go semantics, e.g. they manipulate the Go stack on the linear memory.
+	AReturn
+	ACall
+	ACallIndirect
+
+	ADrop // opcode 0x1A
+	ASelect
+
+	AI32Load // opcode 0x28
+	AI64Load
+	AF32Load
+	AF64Load
+	AI32Load8S
+	AI32Load8U
+	AI32Load16S
+	AI32Load16U
+	AI64Load8S
+	AI64Load8U
+	AI64Load16S
+	AI64Load16U
+	AI64Load32S
+	AI64Load32U
+	AI32Store
+	AI64Store
+	AF32Store
+	AF64Store
+	AI32Store8
+	AI32Store16
+	AI64Store8
+	AI64Store16
+	AI64Store32
+	ACurrentMemory
+	AGrowMemory
+
+	AI32Const
+	AI64Const
+	AF32Const
+	AF64Const
+
+	AI32Eqz
+	AI32Eq
+	AI32Ne
+	AI32LtS
+	AI32LtU
+	AI32GtS
+	AI32GtU
+	AI32LeS
+	AI32LeU
+	AI32GeS
+	AI32GeU
+
+	AI64Eqz
+	AI64Eq
+	AI64Ne
+	AI64LtS
+	AI64LtU
+	AI64GtS
+	AI64GtU
+	AI64LeS
+	AI64LeU
+	AI64GeS
+	AI64GeU
+
+	AF32Eq
+	AF32Ne
+	AF32Lt
+	AF32Gt
+	AF32Le
+	AF32Ge
+
+	AF64Eq
+	AF64Ne
+	AF64Lt
+	AF64Gt
+	AF64Le
+	AF64Ge
+
+	AI32Clz
+	AI32Ctz
+	AI32Popcnt
+	AI32Add
+	AI32Sub
+	AI32Mul
+	AI32DivS
+	AI32DivU
+	AI32RemS
+	AI32RemU
+	AI32And
+	AI32Or
+	AI32Xor
+	AI32Shl
+	AI32ShrS
+	AI32ShrU
+	AI32Rotl
+	AI32Rotr
+
+	AI64Clz
+	AI64Ctz
+	AI64Popcnt
+	AI64Add
+	AI64Sub
+	AI64Mul
+	AI64DivS
+	AI64DivU
+	AI64RemS
+	AI64RemU
+	AI64And
+	AI64Or
+	AI64Xor
+	AI64Shl
+	AI64ShrS
+	AI64ShrU
+	AI64Rotl
+	AI64Rotr
+
+	AF32Abs
+	AF32Neg
+	AF32Ceil
+	AF32Floor
+	AF32Trunc
+	AF32Nearest
+	AF32Sqrt
+	AF32Add
+	AF32Sub
+	AF32Mul
+	AF32Div
+	AF32Min
+	AF32Max
+	AF32Copysign
+
+	AF64Abs
+	AF64Neg
+	AF64Ceil
+	AF64Floor
+	AF64Trunc
+	AF64Nearest
+	AF64Sqrt
+	AF64Add
+	AF64Sub
+	AF64Mul
+	AF64Div
+	AF64Min
+	AF64Max
+	AF64Copysign
+
+	AI32WrapI64
+	AI32TruncSF32
+	AI32TruncUF32
+	AI32TruncSF64
+	AI32TruncUF64
+	AI64ExtendSI32
+	AI64ExtendUI32
+	AI64TruncSF32
+	AI64TruncUF32
+	AI64TruncSF64
+	AI64TruncUF64
+	AF32ConvertSI32
+	AF32ConvertUI32
+	AF32ConvertSI64
+	AF32ConvertUI64
+	AF32DemoteF64
+	AF64ConvertSI32
+	AF64ConvertUI32
+	AF64ConvertSI64
+	AF64ConvertUI64
+	AF64PromoteF32
+	AI32ReinterpretF32
+	AI64ReinterpretF64
+	AF32ReinterpretI32
+	AF64ReinterpretI64
+
+	// End of low-level WebAssembly instructions.
+
+	ARESUMEPOINT
+	// ACALLNORESUME is a call which is not followed by a resume point.
+	// It is allowed inside of WebAssembly blocks, whereas obj.ACALL is not.
+	// However, it is not allowed to switch goroutines while inside of an ACALLNORESUME call.
+	ACALLNORESUME
+
+	AMOVB
+	AMOVH
+	AMOVW
+	AMOVD
+
+	AWORD
+	ALAST
+)
+
+const (
+	REG_NONE = 0
+)
+
+const (
+	// globals
+	REG_PC_F = obj.RBaseWasm + iota
+	REG_PC_B
+	REG_SP // SP is currently 32-bit, until 64-bit memory operations are available
+	REG_CTXT
+	REG_g
+	// RET* are used by runtime.return0 and runtime.reflectcall. These functions pass return values in registers.
+	REG_RET0
+	REG_RET1
+	REG_RET2
+	REG_RET3
+
+	// locals
+	REG_R0
+	REG_R1
+	REG_R2
+	REG_R3
+	REG_R4
+	REG_R5
+	REG_R6
+	REG_R7
+	REG_R8
+	REG_R9
+	REG_R10
+	REG_R11
+	REG_R12
+	REG_R13
+	REG_R14
+	REG_R15
+	REG_F0
+	REG_F1
+	REG_F2
+	REG_F3
+	REG_F4
+	REG_F5
+	REG_F6
+	REG_F7
+	REG_F8
+	REG_F9
+	REG_F10
+	REG_F11
+	REG_F12
+	REG_F13
+	REG_F14
+	REG_F15
+
+	MAXREG
+
+	MINREG  = REG_PC_F
+	REGSP   = REG_SP
+	REGCTXT = REG_CTXT
+	REGG    = REG_g
+)

src/cmd/internal/obj/wasm/anames.go

+// Generated by stringer -i a.out.go -o anames.go -p wasm
+// Do not edit.
+
+package wasm
+
+import "cmd/internal/obj"
+
+var Anames = []string{
+	obj.A_ARCHSPECIFIC: "CallImport",
+	"Get",
+	"Set",
+	"Tee",
+	"Not",
+	"Unreachable",
+	"Nop",
+	"Block",
+	"Loop",
+	"If",
+	"Else",
+	"End",
+	"Br",
+	"BrIf",
+	"BrTable",
+	"Return",
+	"Call",
+	"CallIndirect",
+	"Drop",
+	"Select",
+	"I32Load",
+	"I64Load",
+	"F32Load",
+	"F64Load",
+	"I32Load8S",
+	"I32Load8U",
+	"I32Load16S",
+	"I32Load16U",
+	"I64Load8S",
+	"I64Load8U",
+	"I64Load16S",
+	"I64Load16U",
+	"I64Load32S",
+	"I64Load32U",
+	"I32Store",
+	"I64Store",
+	"F32Store",
+	"F64Store",
+	"I32Store8",
+	"I32Store16",
+	"I64Store8",
+	"I64Store16",
+	"I64Store32",
+	"CurrentMemory",
+	"GrowMemory",
+	"I32Const",
+	"I64Const",
+	"F32Const",
+	"F64Const",
+	"I32Eqz",
+	"I32Eq",
+	"I32Ne",
+	"I32LtS",
+	"I32LtU",
+	"I32GtS",
+	"I32GtU",
+	"I32LeS",
+	"I32LeU",
+	"I32GeS",
+	"I32GeU",
+	"I64Eqz",
+	"I64Eq",
+	"I64Ne",
+	"I64LtS",
+	"I64LtU",
+	"I64GtS",
+	"I64GtU",
+	"I64LeS",
+	"I64LeU",
+	"I64GeS",
+	"I64GeU",
+	"F32Eq",
+	"F32Ne",
+	"F32Lt",
+	"F32Gt",
+	"F32Le",
+	"F32Ge",
+	"F64Eq",
+	"F64Ne",
+	"F64Lt",
+	"F64Gt",
+	"F64Le",
+	"F64Ge",
+	"I32Clz",
+	"I32Ctz",
+	"I32Popcnt",
+	"I32Add",
+	"I32Sub",
+	"I32Mul",
+	"I32DivS",
+	"I32DivU",
+	"I32RemS",
+	"I32RemU",
+	"I32And",
+	"I32Or",
+	"I32Xor",
+	"I32Shl",
+	"I32ShrS",
+	"I32ShrU",
+	"I32Rotl",
+	"I32Rotr",
+	"I64Clz",
+	"I64Ctz",
+	"I64Popcnt",
+	"I64Add",
+	"I64Sub",
+	"I64Mul",
+	"I64DivS",
+	"I64DivU",
+	"I64RemS",
+	"I64RemU",
+	"I64And",
+	"I64Or",
+	"I64Xor",
+	"I64Shl",
+	"I64ShrS",
+	"I64ShrU",
+	"I64Rotl",
+	"I64Rotr",
+	"F32Abs",
+	"F32Neg",
+	"F32Ceil",
+	"F32Floor",
+	"F32Trunc",
+	"F32Nearest",
+	"F32Sqrt",
+	"F32Add",
+	"F32Sub",
+	"F32Mul",
+	"F32Div",
+	"F32Min",
+	"F32Max",
+	"F32Copysign",
+	"F64Abs",
+	"F64Neg",
+	"F64Ceil",
+	"F64Floor",
+	"F64Trunc",
+	"F64Nearest",
+	"F64Sqrt",
+	"F64Add",
+	"F64Sub",
+	"F64Mul",
+	"F64Div",
+	"F64Min",
+	"F64Max",
+	"F64Copysign",
+	"I32WrapI64",
+	"I32TruncSF32",
+	"I32TruncUF32",
+	"I32TruncSF64",
+	"I32TruncUF64",
+	"I64ExtendSI32",
+	"I64ExtendUI32",
+	"I64TruncSF32",
+	"I64TruncUF32",
+	"I64TruncSF64",
+	"I64TruncUF64",
+	"F32ConvertSI32",
+	"F32ConvertUI32",
+	"F32ConvertSI64",
+	"F32ConvertUI64",
+	"F32DemoteF64",
+	"F64ConvertSI32",
+	"F64ConvertUI32",
+	"F64ConvertSI64",
+	"F64ConvertUI64",
+	"F64PromoteF32",
+	"I32ReinterpretF32",
+	"I64ReinterpretF64",
+	"F32ReinterpretI32",
+	"F64ReinterpretI64",
+	"RESUMEPOINT",
+	"CALLNORESUME",
+	"MOVB",
+	"MOVH",
+	"MOVW",
+	"MOVD",
+	"WORD",
+	"LAST",
+}

src/cmd/internal/objabi/head.go

@@ -40,6 +40,7 @@ const (
 	Hdarwin
 	Hdragonfly
 	Hfreebsd
+	Hjs
 	Hlinux
 	Hnacl
 	Hnetbsd
@@ -57,6 +58,8 @@ func (h *HeadType) Set(s string) error {
 		*h = Hdragonfly
 	case "freebsd":
 		*h = Hfreebsd
+	case "js":
+		*h = Hjs
 	case "linux", "android":
 		*h = Hlinux
 	case "nacl":
@@ -85,6 +88,8 @@ func (h *HeadType) String() string {
 		return "dragonfly"
 	case Hfreebsd:
 		return "freebsd"
+	case Hjs:
+		return "js"
 	case Hlinux:
 		return "linux"
 	case Hnacl:

src/cmd/internal/objabi/reloctype.go

@@ -193,6 +193,9 @@ const (
 	// R_ADDRCUOFF resolves to a pointer-sized offset from the start of the
 	// symbol's DWARF compile unit.
 	R_ADDRCUOFF
+
+	// R_WASMIMPORT resolves to the index of the WebAssembly function import.
+	R_WASMIMPORT
 )
 
 // IsDirectJump returns whether r is a relocation for a direct jump.

src/cmd/internal/sys/arch.go

@@ -21,6 +21,7 @@ const (
 	MIPS64
 	PPC64
 	S390X
+	Wasm
 )
 
 // Arch represents an individual architecture.
@@ -160,6 +161,15 @@ var ArchS390X = &Arch{
 	MinLC:     2,
 }
 
+var ArchWasm = &Arch{
+	Name:      "wasm",
+	Family:    Wasm,
+	ByteOrder: binary.LittleEndian,
+	PtrSize:   8,
+	RegSize:   8,
+	MinLC:     1,
+}
+
 var Archs = [...]*Arch{
 	Arch386,
 	ArchAMD64,
@@ -173,4 +183,5 @@ var Archs = [...]*Arch{
 	ArchPPC64,
 	ArchPPC64LE,
 	ArchS390X,
+	ArchWasm,
 }