wa-lang
/
wa
0
0
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity

wat 输出使用 strings.Builder 代替字符串加法

This commit is contained in:
3dgen 2023-09-26 15:49:22 +08:00
parent b37d27cb47
commit 740948bcbb
13 changed files with 508 additions and 220 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
internal/backends/compiler_wat/wir/wat/function.go
View File

@ -2,47 +2,68 @@
package wat
func (f *Function) Format(indent string) string {
s := indent + "(func $" + f.InternalName
import "strings"
func (f *Function) Format(sb *strings.Builder) {
sb.WriteString("(func $")
sb.WriteString(f.InternalName)
if len(f.ExternalName) > 0 {
s += " (export \"" + f.ExternalName + "\")"
sb.WriteString(" (export \"")
sb.WriteString(f.ExternalName)
sb.WriteString("\")")
}
for _, param := range f.Params {
s += " (param $" + param.Name() + " " + param.Type().Name() + ")"
sb.WriteString(" (param $")
sb.WriteString(param.Name())
sb.WriteByte(' ')
sb.WriteString(param.Type().Name())
sb.WriteByte(')')
}
if len(f.Results) > 0 {
s += " (result"
sb.WriteString(" (result")
for _, r := range f.Results {
s += " " + r.Name()
sb.WriteByte(' ')
sb.WriteString(r.Name())
}
s += ")"
sb.WriteByte(')')
}
s += "\n"
sb.WriteByte('\n')
for _, local := range f.Locals {
s += indent
s += " (local $" + local.Name() + " " + local.Type().Name() + ")"
s += "\n"
sb.WriteString(" (local $")
sb.WriteString(local.Name())
sb.WriteByte(' ')
sb.WriteString(local.Type().Name())
sb.WriteByte(')')
sb.WriteByte('\n')
}
indent_t := " "
for _, inst := range f.Insts {
s += inst.Format(indent+" ") + "\n"
inst.Format(indent_t, sb)
sb.WriteByte('\n')
}
s += indent + ") ;;" + f.InternalName
return s
sb.WriteString(") ;;")
sb.WriteString(f.InternalName)
}
func (sig *FuncSig) String() string {
str := ""
var sb strings.Builder
for _, param := range sig.Params {
str += " (param " + param.Name() + ")"
sb.WriteString(" (param ")
sb.WriteString(param.Name())
sb.WriteByte(')')
}
for _, ret := range sig.Results {
str += " (result " + ret.Name() + ")"
sb.WriteString(" (result ")
sb.WriteString(ret.Name())
sb.WriteByte(')')
}
return str
return sb.String()
}

14
internal/backends/compiler_wat/wir/wat/import.go
View File

@ -2,6 +2,8 @@
package wat
import "strings"
/**************************************
ImpObj:
**************************************/
@ -27,5 +29,15 @@ func NewImpFunc(moduleName string, objName string, funcName string, sig FuncSig)
}
func (o *ImpFunc) Type() ObjType { return ObjTypeFunc }
func (o *ImpFunc) Format(indent string) string {
return indent + "(import \"" + o.moduleName + "\" \"" + o.objName + "\" (func $" + o.funcName + o.sig.String() + "))"
var sb strings.Builder
sb.WriteString(indent)
sb.WriteString("(import \"")
sb.WriteString(o.moduleName)
sb.WriteString("\" \"")
sb.WriteString(o.objName)
sb.WriteString("\" (func $")
sb.WriteString(o.funcName)
sb.WriteString(o.sig.String())
sb.WriteString("))")
return sb.String()
}

69
internal/backends/compiler_wat/wir/wat/instruction_arith.go
View File

@ -3,6 +3,8 @@
package wat
import (
"strings"
"wa-lang.org/wa/internal/logger"
)
@ -19,8 +21,12 @@ type instAdd struct {
typ ValueType
}
func NewInstAdd(t ValueType) *instAdd { return &instAdd{typ: t} }
func (i *instAdd) Format(indent string) string { return indent + i.typ.Name() + ".add" }
func NewInstAdd(t ValueType) *instAdd { return &instAdd{typ: t} }
func (i *instAdd) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString(i.typ.Name())
sb.WriteString(".add")
}
/**************************************
instSub:
@ -30,8 +36,12 @@ type instSub struct {
typ ValueType
}
func NewInstSub(t ValueType) *instSub { return &instSub{typ: t} }
func (i *instSub) Format(indent string) string { return indent + i.typ.Name() + ".sub" }
func NewInstSub(t ValueType) *instSub { return &instSub{typ: t} }
func (i *instSub) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString(i.typ.Name())
sb.WriteString(".sub")
}
/**************************************
instMul:
@ -41,8 +51,12 @@ type instMul struct {
typ ValueType
}
func NewInstMul(t ValueType) *instMul { return &instMul{typ: t} }
func (i *instMul) Format(indent string) string { return indent + i.typ.Name() + ".mul" }
func NewInstMul(t ValueType) *instMul { return &instMul{typ: t} }
func (i *instMul) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString(i.typ.Name())
sb.WriteString(".mul")
}
/**************************************
instDiv:
@ -53,29 +67,35 @@ type instDiv struct {
}
func NewInstDiv(t ValueType) *instDiv { return &instDiv{typ: t} }
func (i *instDiv) Format(indent string) string {
func (i *instDiv) Format(indent string, sb *strings.Builder) {
switch i.typ.(type) {
case I32:
return indent + "i32.div_s"
sb.WriteString(indent)
sb.WriteString("i32.div_s")
case U32:
return indent + "i32.div_u"
sb.WriteString(indent)
sb.WriteString("i32.div_u")
case I64:
return indent + "i64.div_s"
sb.WriteString(indent)
sb.WriteString("i64.div_s")
case U64:
return indent + "i64.div_u"
sb.WriteString(indent)
sb.WriteString("i64.div_u")
case F32:
return indent + "f32.div"
sb.WriteString(indent)
sb.WriteString("f32.div")
case F64:
return indent + "f64.div"
sb.WriteString(indent)
sb.WriteString("f64.div")
default:
logger.Fatal("Todo")
}
logger.Fatal("Todo")
return ""
}
/**************************************
@ -87,20 +107,25 @@ type instRem struct {
}
func NewInstRem(t ValueType) *instRem { return &instRem{typ: t} }
func (i *instRem) Format(indent string) string {
func (i *instRem) Format(indent string, sb *strings.Builder) {
switch i.typ.(type) {
case I32:
return indent + "i32.rem_s"
sb.WriteString(indent)
sb.WriteString("i32.rem_s")
case U32:
return indent + "i32.rem_u"
sb.WriteString(indent)
sb.WriteString("i32.rem_u")
case I64:
return indent + "i64.rem_s"
sb.WriteString(indent)
sb.WriteString("i64.rem_s")
case U64:
return indent + "i64.rem_u"
sb.WriteString(indent)
sb.WriteString("i64.rem_u")
default:
logger.Fatal("Todo")
}
logger.Fatal("Todo")
return ""
}

53
internal/backends/compiler_wat/wir/wat/instruction_bit.go
View File

@ -2,7 +2,11 @@
package wat
import "wa-lang.org/wa/internal/logger"
import (
"strings"
"wa-lang.org/wa/internal/logger"
)
/**************************************
instAnd:
@ -12,8 +16,12 @@ type instAnd struct {
typ ValueType
}
func NewInstAnd(t ValueType) *instAnd { return &instAnd{typ: t} }
func (i *instAnd) Format(indent string) string { return indent + i.typ.Name() + ".and" }
func NewInstAnd(t ValueType) *instAnd { return &instAnd{typ: t} }
func (i *instAnd) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString(i.typ.Name())
sb.WriteString(".and")
}
/**************************************
instOr:
@ -23,8 +31,12 @@ type instOr struct {
typ ValueType
}
func NewInstOr(t ValueType) *instOr { return &instOr{typ: t} }
func (i *instOr) Format(indent string) string { return indent + i.typ.Name() + ".or" }
func NewInstOr(t ValueType) *instOr { return &instOr{typ: t} }
func (i *instOr) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString(i.typ.Name())
sb.WriteString(".or")
}
/**************************************
instXor:
@ -34,8 +46,12 @@ type instXor struct {
typ ValueType
}
func NewInstXor(t ValueType) *instXor { return &instXor{typ: t} }
func (i *instXor) Format(indent string) string { return indent + i.typ.Name() + ".xor" }
func NewInstXor(t ValueType) *instXor { return &instXor{typ: t} }
func (i *instXor) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString(i.typ.Name())
sb.WriteString(".xor")
}
/**************************************
instShl:
@ -45,8 +61,12 @@ type instShl struct {
typ ValueType
}
func NewInstShl(t ValueType) *instShl { return &instShl{typ: t} }
func (i *instShl) Format(indent string) string { return indent + i.typ.Name() + ".shl" }
func NewInstShl(t ValueType) *instShl { return &instShl{typ: t} }
func (i *instShl) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString(i.typ.Name())
sb.WriteString(".shl")
}
/**************************************
instShr:
@ -57,14 +77,19 @@ type instShr struct {
}
func NewInstShr(t ValueType) *instShr { return &instShr{typ: t} }
func (i *instShr) Format(indent string) string {
func (i *instShr) Format(indent string, sb *strings.Builder) {
switch i.typ.(type) {
case I32, I64:
return indent + i.typ.Name() + ".shr_s"
sb.WriteString(indent)
sb.WriteString(i.typ.Name())
sb.WriteString(".shr_s")
case U32, U64:
return indent + i.typ.Name() + ".shr_u"
sb.WriteString(indent)
sb.WriteString(i.typ.Name())
sb.WriteString(".shr_u")
default:
logger.Fatal("Todo")
}
logger.Fatal("Todo")
return ""
}

124
internal/backends/compiler_wat/wir/wat/instruction_comp.go
View File

@ -2,7 +2,11 @@
package wat
import "wa-lang.org/wa/internal/logger"
import (
"strings"
"wa-lang.org/wa/internal/logger"
)
/**************************************
instEqz:
@ -12,8 +16,12 @@ type instEqz struct {
typ ValueType
}
func NewInstEqz(t ValueType) *instEqz { return &instEqz{typ: t} }
func (i *instEqz) Format(indent string) string { return indent + i.typ.Name() + ".eqz" }
func NewInstEqz(t ValueType) *instEqz { return &instEqz{typ: t} }
func (i *instEqz) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString(i.typ.Name())
sb.WriteString(".eqz")
}
/**************************************
instEq:
@ -23,8 +31,12 @@ type instEq struct {
typ ValueType
}
func NewInstEq(t ValueType) *instEq { return &instEq{typ: t} }
func (i *instEq) Format(indent string) string { return indent + i.typ.Name() + ".eq" }
func NewInstEq(t ValueType) *instEq { return &instEq{typ: t} }
func (i *instEq) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString(i.typ.Name())
sb.WriteString(".eq")
}
/**************************************
instNe:
@ -34,8 +46,12 @@ type instNe struct {
typ ValueType
}
func NewInstNe(t ValueType) *instNe { return &instNe{typ: t} }
func (i *instNe) Format(indent string) string { return indent + i.typ.Name() + ".ne" }
func NewInstNe(t ValueType) *instNe { return &instNe{typ: t} }
func (i *instNe) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString(i.typ.Name())
sb.WriteString(".ne")
}
/**************************************
instLt:
@ -46,28 +62,35 @@ type instLt struct {
}
func NewInstLt(t ValueType) *instLt { return &instLt{typ: t} }
func (i *instLt) Format(indent string) string {
func (i *instLt) Format(indent string, sb *strings.Builder) {
switch i.typ.(type) {
case I32:
return indent + "i32.lt_s"
sb.WriteString(indent)
sb.WriteString("i32.lt_s")
case U32:
return indent + "i32.lt_u"
sb.WriteString(indent)
sb.WriteString("i32.lt_u")
case I64:
return indent + "i64.lt_s"
sb.WriteString(indent)
sb.WriteString("i64.lt_s")
case U64:
return indent + "i64.lt_u"
sb.WriteString(indent)
sb.WriteString("i64.lt_u")
case F32:
return indent + "f32.lt"
sb.WriteString(indent)
sb.WriteString("f32.lt")
case F64:
return indent + "f64.lt"
sb.WriteString(indent)
sb.WriteString("f64.lt")
default:
logger.Fatal("Todo")
}
logger.Fatal("Todo")
return ""
}
/**************************************
@ -79,28 +102,35 @@ type instGt struct {
}
func NewInstGt(t ValueType) *instGt { return &instGt{typ: t} }
func (i *instGt) Format(indent string) string {
func (i *instGt) Format(indent string, sb *strings.Builder) {
switch i.typ.(type) {
case I32:
return indent + "i32.gt_s"
sb.WriteString(indent)
sb.WriteString("i32.gt_s")
case U32:
return indent + "i32.gt_u"
sb.WriteString(indent)
sb.WriteString("i32.gt_u")
case I64:
return indent + "i64.gt_s"
sb.WriteString(indent)
sb.WriteString("i64.gt_s")
case U64:
return indent + "i64.gt_u"
sb.WriteString(indent)
sb.WriteString("i64.gt_u")
case F32:
return indent + "f32.gt"
sb.WriteString(indent)
sb.WriteString("f32.gt")
case F64:
return indent + "f64.gt"
sb.WriteString(indent)
sb.WriteString("f64.gt")
default:
logger.Fatal("Todo")
}
logger.Fatal("Todo")
return ""
}
/**************************************
@ -112,28 +142,35 @@ type instLe struct {
}
func NewInstLe(t ValueType) *instLe { return &instLe{typ: t} }
func (i *instLe) Format(indent string) string {
func (i *instLe) Format(indent string, sb *strings.Builder) {
switch i.typ.(type) {
case I32:
return indent + "i32.le_s"
sb.WriteString(indent)
sb.WriteString("i32.le_s")
case U32:
return indent + "i32.le_u"
sb.WriteString(indent)
sb.WriteString("i32.le_u")
case I64:
return indent + "i64.le_s"
sb.WriteString(indent)
sb.WriteString("i64.le_s")
case U64:
return indent + "i64.le_u"
sb.WriteString(indent)
sb.WriteString("i64.le_u")
case F32:
return indent + "f32.le"
sb.WriteString(indent)
sb.WriteString("f32.le")
case F64:
return indent + "f64.le"
sb.WriteString(indent)
sb.WriteString("f64.le")
default:
logger.Fatal("Todo")
}
logger.Fatal("Todo")
return ""
}
/**************************************
@ -145,17 +182,24 @@ type instGe struct {
}
func NewInstGe(t ValueType) *instGe { return &instGe{typ: t} }
func (i *instGe) Format(indent string) string {
func (i *instGe) Format(indent string, sb *strings.Builder) {
switch i.typ.(type) {
case I32, I64:
return indent + i.typ.Name() + ".ge_s"
sb.WriteString(indent)
sb.WriteString(i.typ.Name())
sb.WriteString(".ge_s")
case U32, U64:
return indent + i.typ.Name() + ".ge_u"
sb.WriteString(indent)
sb.WriteString(i.typ.Name())
sb.WriteString(".ge_u")
case F32, F64:
return indent + i.typ.Name() + ".ge"
sb.WriteString(indent)
sb.WriteString(i.typ.Name())
sb.WriteString(".ge")
default:
logger.Fatal("Todo")
}
logger.Fatal("Todo")
return ""
}

9
internal/backends/compiler_wat/wir/wat/instruction_const.go
View File

@ -2,6 +2,8 @@
package wat
import "strings"
/**************************************
instConst:
**************************************/
@ -14,6 +16,9 @@ type instConst struct {
func NewInstConst(typ ValueType, literal string) *instConst {
return &instConst{typ: typ, literal: literal}
}
func (i *instConst) Format(indent string) string {
return indent + i.typ.Name() + ".const " + i.literal
func (i *instConst) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString(i.typ.Name())
sb.WriteString(".const ")
sb.WriteString(i.literal)
}

89
internal/backends/compiler_wat/wir/wat/instruction_convert.go
View File

@ -1,5 +1,7 @@
package wat
import "strings"
/**************************************
instConvert_i32_wrap_i64:
**************************************/
@ -7,8 +9,11 @@ type instConvert_i32_wrap_i64 struct {
anInstruction
}
func NewInstConvert_i32_wrap_i64() *instConvert_i32_wrap_i64 { return &instConvert_i32_wrap_i64{} }
func (i *instConvert_i32_wrap_i64) Format(indent string) string { return indent + "i32.wrap_i64" }
func NewInstConvert_i32_wrap_i64() *instConvert_i32_wrap_i64 { return &instConvert_i32_wrap_i64{} }
func (i *instConvert_i32_wrap_i64) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("i32.wrap_i64")
}
/**************************************
instConvert_i32_trunc_f32_s:
@ -20,7 +25,10 @@ type instConvert_i32_trunc_f32_s struct {
func NewInstConvert_i32_trunc_f32_s() *instConvert_i32_trunc_f32_s {
return &instConvert_i32_trunc_f32_s{}
}
func (i *instConvert_i32_trunc_f32_s) Format(indent string) string { return indent + "i32.trunc_f32_s" }
func (i *instConvert_i32_trunc_f32_s) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("i32.trunc_f32_s")
}
/**************************************
instConvert_i32_trunc_f64_s:
@ -32,7 +40,10 @@ type instConvert_i32_trunc_f64_s struct {
func NewInstConvert_i32_trunc_f64_s() *instConvert_i32_trunc_f64_s {
return &instConvert_i32_trunc_f64_s{}
}
func (i *instConvert_i32_trunc_f64_s) Format(indent string) string { return indent + "i32.trunc_f64_s" }
func (i *instConvert_i32_trunc_f64_s) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("i32.trunc_f64_s")
}
/**************************************
instConvert_i64_extend_i32_s:
@ -44,8 +55,9 @@ type instConvert_i64_extend_i32_s struct {
func NewInstConvert_i64_extend_i32_s() *instConvert_i64_extend_i32_s {
return &instConvert_i64_extend_i32_s{}
}
func (i *instConvert_i64_extend_i32_s) Format(indent string) string {
return indent + "i64.extend_i32_s"
func (i *instConvert_i64_extend_i32_s) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("i64.extend_i32_s")
}
/**************************************
@ -58,8 +70,9 @@ type instConvert_i64_extend_i32_u struct {
func NewInstConvert_i64_extend_i32_u() *instConvert_i64_extend_i32_u {
return &instConvert_i64_extend_i32_u{}
}
func (i *instConvert_i64_extend_i32_u) Format(indent string) string {
return indent + "i64.extend_i32_u"
func (i *instConvert_i64_extend_i32_u) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("i64.extend_i32_u")
}
/**************************************
@ -72,7 +85,10 @@ type instConvert_i64_trunc_f32_s struct {
func NewInstConvert_i64_trunc_f32_s() *instConvert_i64_trunc_f32_s {
return &instConvert_i64_trunc_f32_s{}
}
func (i *instConvert_i64_trunc_f32_s) Format(indent string) string { return indent + "i64.trunc_f32_s" }
func (i *instConvert_i64_trunc_f32_s) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("i64.trunc_f32_s")
}
/**************************************
instConvert_i64_trunc_f64_s:
@ -84,7 +100,10 @@ type instConvert_i64_trunc_f64_s struct {
func NewInstConvert_i64_trunc_f64_s() *instConvert_i64_trunc_f64_s {
return &instConvert_i64_trunc_f64_s{}
}
func (i *instConvert_i64_trunc_f64_s) Format(indent string) string { return indent + "i64.trunc_f64_s" }
func (i *instConvert_i64_trunc_f64_s) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("i64.trunc_f64_s")
}
/**************************************
instConvert_f32_convert_i32_s:
@ -96,8 +115,9 @@ type instConvert_f32_convert_i32_s struct {
func NewInstConvert_f32_convert_i32_s() *instConvert_f32_convert_i32_s {
return &instConvert_f32_convert_i32_s{}
}
func (i *instConvert_f32_convert_i32_s) Format(indent string) string {
return indent + "f32.convert_i32_s"
func (i *instConvert_f32_convert_i32_s) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("f32.convert_i32_s")
}
/**************************************
@ -110,8 +130,9 @@ type instConvert_f32_convert_i32_u struct {
func NewInstConvert_f32_convert_i32_u() *instConvert_f32_convert_i32_u {
return &instConvert_f32_convert_i32_u{}
}
func (i *instConvert_f32_convert_i32_u) Format(indent string) string {
return indent + "f32.convert_i32_u"
func (i *instConvert_f32_convert_i32_u) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("f32.convert_i32_u")
}
/**************************************
@ -124,8 +145,9 @@ type instConvert_f32_convert_i64_s struct {
func NewInstConvert_f32_convert_i64_s() *instConvert_f32_convert_i64_s {
return &instConvert_f32_convert_i64_s{}
}
func (i *instConvert_f32_convert_i64_s) Format(indent string) string {
return indent + "f32.convert_i64_s"
func (i *instConvert_f32_convert_i64_s) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("f32.convert_i64_s")
}
/**************************************
@ -138,8 +160,9 @@ type instConvert_f32_convert_i64_u struct {
func NewInstConvert_f32_convert_i64_u() *instConvert_f32_convert_i64_u {
return &instConvert_f32_convert_i64_u{}
}
func (i *instConvert_f32_convert_i64_u) Format(indent string) string {
return indent + "f32.convert_i64_u"
func (i *instConvert_f32_convert_i64_u) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("f32.convert_i64_u")
}
/**************************************
@ -152,8 +175,9 @@ type instConvert_f32_demote_f64 struct {
func NewInstConvert_f32_demote_f64() *instConvert_f32_demote_f64 {
return &instConvert_f32_demote_f64{}
}
func (i *instConvert_f32_demote_f64) Format(indent string) string {
return indent + "f32.demote_f64"
func (i *instConvert_f32_demote_f64) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("f32.demote_f64")
}
/**************************************
@ -166,8 +190,9 @@ type instConvert_f64_convert_i32_s struct {
func NewInstConvert_f64_convert_i32_s() *instConvert_f64_convert_i32_s {
return &instConvert_f64_convert_i32_s{}
}
func (i *instConvert_f64_convert_i32_s) Format(indent string) string {
return indent + "f64.convert_i32_s"
func (i *instConvert_f64_convert_i32_s) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("f64.convert_i32_s")
}
/**************************************
@ -180,8 +205,9 @@ type instConvert_f64_convert_i32_u struct {
func NewInstConvert_f64_convert_i32_u() *instConvert_f64_convert_i32_u {
return &instConvert_f64_convert_i32_u{}
}
func (i *instConvert_f64_convert_i32_u) Format(indent string) string {
return indent + "f64.convert_i32_u"
func (i *instConvert_f64_convert_i32_u) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("f64.convert_i32_u")
}
/**************************************
@ -194,8 +220,9 @@ type instConvert_f64_convert_i64_s struct {
func NewInstConvert_f64_convert_i64_s() *instConvert_f64_convert_i64_s {
return &instConvert_f64_convert_i64_s{}
}
func (i *instConvert_f64_convert_i64_s) Format(indent string) string {
return indent + "f64.convert_i64_s"
func (i *instConvert_f64_convert_i64_s) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("f64.convert_i64_s")
}
/**************************************
@ -208,8 +235,9 @@ type instConvert_f64_convert_i64_u struct {
func NewInstConvert_f64_convert_i64_u() *instConvert_f64_convert_i64_u {
return &instConvert_f64_convert_i64_u{}
}
func (i *instConvert_f64_convert_i64_u) Format(indent string) string {
return indent + "f64.convert_i64_u"
func (i *instConvert_f64_convert_i64_u) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("f64.convert_i64_u")
}
/**************************************
@ -222,6 +250,7 @@ type instConvert_f64_promote_f32 struct {
func NewInstConvert_f64_promote_f32() *instConvert_f64_promote_f32 {
return &instConvert_f64_promote_f32{}
}
func (i *instConvert_f64_promote_f32) Format(indent string) string {
return indent + "f64.promote_f32"
func (i *instConvert_f64_promote_f32) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("f64.promote_f32")
}

122
internal/backends/compiler_wat/wir/wat/instruction_ctl.go
View File

@ -2,7 +2,10 @@
package wat
import "strconv"
import (
"strconv"
"strings"
)
/**************************************
instCall:
@ -12,8 +15,12 @@ type instCall struct {
name string
}
func NewInstCall(name string) *instCall { return &instCall{name: name} }
func (i *instCall) Format(indent string) string { return indent + "call $" + i.name }
func NewInstCall(name string) *instCall { return &instCall{name: name} }
func (i *instCall) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("call $")
sb.WriteString(i.name)
}
/**************************************
instCallIndirect:
@ -26,8 +33,11 @@ type instCallIndirect struct {
func NewInstCallIndirect(func_type string) *instCallIndirect {
return &instCallIndirect{func_type: func_type}
}
func (i *instCallIndirect) Format(indent string) string {
return indent + "call_indirect (type $" + i.func_type + ")"
func (i *instCallIndirect) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("call_indirect (type $")
sb.WriteString(i.func_type)
sb.WriteString(")")
}
/**************************************
@ -40,14 +50,22 @@ type instBlock struct {
}
func NewInstBlock(name string) *instBlock { return &instBlock{name: name} }
func (i *instBlock) Format(indent string) string {
s := indent + "(block $"
s += i.name + "\n"
func (i *instBlock) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("(block $")
sb.WriteString(i.name)
sb.WriteString("\n")
indent_t := indent + " "
for _, v := range i.Insts {
s += v.Format(indent+" ") + "\n"
v.Format(indent_t, sb)
sb.WriteString("\n")
}
s += indent + ") ;;" + i.name
return s
sb.WriteString(indent)
sb.WriteString(") ;;")
sb.WriteString(i.name)
}
/**************************************
@ -60,14 +78,22 @@ type instLoop struct {
}
func NewInstLoop(name string) *instLoop { return &instLoop{name: name} }
func (i *instLoop) Format(indent string) string {
s := indent + "(loop $"
s += i.name + "\n"
func (i *instLoop) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("(loop $")
sb.WriteString(i.name)
sb.WriteString("\n")
indent_t := indent + " "
for _, v := range i.Insts {
s += v.Format(indent+" ") + "\n"
v.Format(indent_t, sb)
sb.WriteString("\n")
}
s += indent + ") ;;" + i.name
return s
sb.WriteString(indent)
sb.WriteString(") ;;")
sb.WriteString(i.name)
}
/**************************************
@ -78,8 +104,12 @@ type instBr struct {
Name string
}
func NewInstBr(name string) *instBr { return &instBr{Name: name} }
func (i *instBr) Format(indent string) string { return indent + "br $" + i.Name }
func NewInstBr(name string) *instBr { return &instBr{Name: name} }
func (i *instBr) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("br $")
sb.WriteString(i.Name)
}
/**************************************
instBrTable:
@ -90,12 +120,13 @@ type instBrTable struct {
}
func NewInstBrTable(t []int) *instBrTable { return &instBrTable{Table: t} }
func (i *instBrTable) Format(indent string) string {
s := indent + "br_table"
func (i *instBrTable) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("br_table")
for _, v := range i.Table {
s += " " + strconv.Itoa(v)
sb.WriteString(" ")
sb.WriteString(strconv.Itoa(v))
}
return s
}
/**************************************
@ -111,26 +142,34 @@ type instIf struct {
func NewInstIf(instsTrue, instsFalse []Inst, ret []ValueType) *instIf {
return &instIf{True: instsTrue, False: instsFalse, Ret: ret}
}
func (i *instIf) Format(indent string) string {
s := indent + "if"
if len(i.Ret) > 0 {
s += " (result"
for _, r := range i.Ret {
s += " " + r.Name()
}
s += ")"
}
s += "\n"
func (i *instIf) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("if")
if len(i.Ret) > 0 {
sb.WriteString(" (result")
for _, r := range i.Ret {
sb.WriteString(" ")
sb.WriteString(r.Name())
}
sb.WriteString(")")
}
sb.WriteString("\n")
indent_t := indent + " "
for _, v := range i.True {
s += v.Format(indent+" ") + "\n"
v.Format(indent_t, sb)
sb.WriteString("\n")
}
s += indent + "else\n"
sb.WriteString(indent)
sb.WriteString("else\n")
for _, v := range i.False {
s += v.Format(indent+" ") + "\n"
v.Format(indent_t, sb)
sb.WriteString("\n")
}
s += indent + "end"
return s
sb.WriteString(indent)
sb.WriteString("end")
}
/**************************************
@ -140,5 +179,8 @@ type instReturn struct {
anInstruction
}
func NewInstReturn() *instReturn { return &instReturn{} }
func (i *instReturn) Format(indent string) string { return indent + "return" }
func NewInstReturn() *instReturn { return &instReturn{} }
func (i *instReturn) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("return")
}

71
internal/backends/compiler_wat/wir/wat/instruction_mem.go
View File

@ -2,7 +2,10 @@
package wat
import "strconv"
import (
"strconv"
"strings"
)
/**************************************
instLoad:
@ -16,8 +19,13 @@ type instLoad struct {
func NewInstLoad(typ ValueType, offset int, align int) *instLoad {
return &instLoad{typ: typ, offset: offset, align: align}
}
func (i *instLoad) Format(indent string) string {
return indent + i.typ.Name() + ".load offset=" + strconv.Itoa(i.offset) + " align=" + strconv.Itoa(i.align)
func (i *instLoad) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString(i.typ.Name())
sb.WriteString(".load offset=")
sb.WriteString(strconv.Itoa(i.offset))
sb.WriteString(" align=")
sb.WriteString(strconv.Itoa(i.align))
}
/**************************************
@ -31,8 +39,12 @@ type instLoad8s struct {
func NewInstLoad8s(offset int, align int) *instLoad8s {
return &instLoad8s{offset: offset, align: align}
}
func (i *instLoad8s) Format(indent string) string {
return indent + "i32.load8_s offset=" + strconv.Itoa(i.offset) + " align=" + strconv.Itoa(i.align)
func (i *instLoad8s) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("i32.load8_s offset=")
sb.WriteString(strconv.Itoa(i.offset))
sb.WriteString(" align=")
sb.WriteString(strconv.Itoa(i.align))
}
/**************************************
@ -46,8 +58,12 @@ type instLoad8u struct {
func NewInstLoad8u(offset int, align int) *instLoad8u {
return &instLoad8u{offset: offset, align: align}
}
func (i *instLoad8u) Format(indent string) string {
return indent + "i32.load8_u offset=" + strconv.Itoa(i.offset) + " align=" + strconv.Itoa(i.align)
func (i *instLoad8u) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("i32.load8_u offset=")
sb.WriteString(strconv.Itoa(i.offset))
sb.WriteString(" align=")
sb.WriteString(strconv.Itoa(i.align))
}
/**************************************
@ -61,8 +77,12 @@ type instLoad16s struct {
func NewInstLoad16s(offset int, align int) *instLoad16s {
return &instLoad16s{offset: offset, align: align}
}
func (i *instLoad16s) Format(indent string) string {
return indent + "i32.load16_s offset=" + strconv.Itoa(i.offset) + " align=" + strconv.Itoa(i.align)
func (i *instLoad16s) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("i32.load16_s offset=")
sb.WriteString(strconv.Itoa(i.offset))
sb.WriteString(" align=")
sb.WriteString(strconv.Itoa(i.align))
}
/**************************************
@ -76,8 +96,12 @@ type instLoad16u struct {
func NewInstLoad16u(offset int, align int) *instLoad16u {
return &instLoad16u{offset: offset, align: align}
}
func (i *instLoad16u) Format(indent string) string {
return indent + "i32.load16_u offset=" + strconv.Itoa(i.offset) + " align=" + strconv.Itoa(i.align)
func (i *instLoad16u) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("i32.load16_u offset=")
sb.WriteString(strconv.Itoa(i.offset))
sb.WriteString(" align=")
sb.WriteString(strconv.Itoa(i.align))
}
/**************************************
@ -92,8 +116,13 @@ type instStore struct {
func NewInstStore(typ ValueType, offset int, align int) *instStore {
return &instStore{typ: typ, offset: offset, align: align}
}
func (i *instStore) Format(indent string) string {
return indent + i.typ.Name() + ".store offset=" + strconv.Itoa(i.offset) + " align=" + strconv.Itoa(i.align)
func (i *instStore) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString(i.typ.Name())
sb.WriteString(".store offset=")
sb.WriteString(strconv.Itoa(i.offset))
sb.WriteString(" align=")
sb.WriteString(strconv.Itoa(i.align))
}
/**************************************
@ -107,8 +136,12 @@ type instStore8 struct {
func NewInstStore8(offset int, align int) *instStore8 {
return &instStore8{offset: offset, align: align}
}
func (i *instStore8) Format(indent string) string {
return indent + "i32.store8 offset=" + strconv.Itoa(i.offset) + " align=" + strconv.Itoa(i.align)
func (i *instStore8) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("i32.store8 offset=")
sb.WriteString(strconv.Itoa(i.offset))
sb.WriteString(" align=")
sb.WriteString(strconv.Itoa(i.align))
}
/**************************************
@ -122,6 +155,10 @@ type instStore16 struct {
func NewInstStore16(offset int, align int) *instStore16 {
return &instStore16{offset: offset, align: align}
}
func (i *instStore16) Format(indent string) string {
return indent + "i32.store16 offset=" + strconv.Itoa(i.offset) + " align=" + strconv.Itoa(i.align)
func (i *instStore16) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("i32.store16 offset=")
sb.WriteString(strconv.Itoa(i.offset))
sb.WriteString(" align=")
sb.WriteString(strconv.Itoa(i.align))
}

28
internal/backends/compiler_wat/wir/wat/instruction_misc.go
View File

@ -1,5 +1,7 @@
package wat
import "strings"
/**************************************
instDrop:
**************************************/
@ -7,8 +9,11 @@ type instDrop struct {
anInstruction
}
func NewInstDrop() *instDrop { return &instDrop{} }
func (i *instDrop) Format(indent string) string { return indent + "drop" }
func NewInstDrop() *instDrop { return &instDrop{} }
func (i *instDrop) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("drop")
}
/**************************************
comment:
@ -18,8 +23,12 @@ type comment struct {
name string
}
func NewComment(name string) *comment { return &comment{name: name} }
func (i *comment) Format(indent string) string { return indent + ";;" + i.name }
func NewComment(name string) *comment { return &comment{name: name} }
func (i *comment) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString(";;")
sb.WriteString(i.name)
}
/**************************************
blank:
@ -28,8 +37,8 @@ type blank struct {
anInstruction
}
func NewBlank() *blank { return &blank{} }
func (i *blank) Format(indent string) string { return "" }
func NewBlank() *blank { return &blank{} }
func (i *blank) Format(indent string, sb *strings.Builder) {}
/**************************************
instUnreachable:
@ -38,5 +47,8 @@ type instUnreachable struct {
anInstruction
}
func NewInstUnreachable() *instUnreachable { return &instUnreachable{} }
func (i *instUnreachable) Format(indent string) string { return indent + "unreachable" }
func NewInstUnreachable() *instUnreachable { return &instUnreachable{} }
func (i *instUnreachable) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("unreachable")
}

34
internal/backends/compiler_wat/wir/wat/instruction_var.go
View File

@ -2,6 +2,8 @@
package wat
import "strings"
/**************************************
instGetLocal:
**************************************/
@ -10,8 +12,12 @@ type instGetLocal struct {
name string
}
func NewInstGetLocal(name string) *instGetLocal { return &instGetLocal{name: name} }
func (i *instGetLocal) Format(indent string) string { return indent + "local.get $" + i.name }
func NewInstGetLocal(name string) *instGetLocal { return &instGetLocal{name: name} }
func (i *instGetLocal) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("local.get $")
sb.WriteString(i.name)
}
/**************************************
instSetLocal:
@ -21,8 +27,12 @@ type instSetLocal struct {
name string
}
func NewInstSetLocal(name string) *instSetLocal { return &instSetLocal{name: name} }
func (i *instSetLocal) Format(indent string) string { return indent + "local.set $" + i.name }
func NewInstSetLocal(name string) *instSetLocal { return &instSetLocal{name: name} }
func (i *instSetLocal) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("local.set $")
sb.WriteString(i.name)
}
/**************************************
instGetGlobal:
@ -32,8 +42,12 @@ type instGetGlobal struct {
name string
}
func NewInstGetGlobal(name string) *instGetGlobal { return &instGetGlobal{name: name} }
func (i *instGetGlobal) Format(indent string) string { return indent + "global.get $" + i.name }
func NewInstGetGlobal(name string) *instGetGlobal { return &instGetGlobal{name: name} }
func (i *instGetGlobal) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("global.get $")
sb.WriteString(i.name)
}
/**************************************
instSetGlobal:
@ -43,5 +57,9 @@ type instSetGlobal struct {
name string
}
func NewInstSetGlobal(name string) *instSetGlobal { return &instSetGlobal{name: name} }
func (i *instSetGlobal) Format(indent string) string { return indent + "global.set $" + i.name }
func NewInstSetGlobal(name string) *instSetGlobal { return &instSetGlobal{name: name} }
func (i *instSetGlobal) Format(indent string, sb *strings.Builder) {
sb.WriteString(indent)
sb.WriteString("global.set $")
sb.WriteString(i.name)
}

54
internal/backends/compiler_wat/wir/wat/module.go
View File

@ -4,6 +4,7 @@ package wat
import (
"strconv"
"strings"
)
// 模块对象
@ -21,55 +22,70 @@ type Module struct {
}
func (m *Module) String() string {
s := "(module $__walang__\n"
var sb strings.Builder
sb.WriteString("(module $__walang__\n")
for _, i := range m.Imports {
s += i.Format(" ") + "\n"
sb.WriteString(i.Format(" "))
sb.WriteByte('\n')
}
s += m.BaseWat
sb.WriteString(m.BaseWat)
if len(m.DataSeg.data) > 0 {
s += "(data (i32.const " + strconv.Itoa(m.DataSeg.start) + ") \""
sb.WriteString("(data (i32.const ")
sb.WriteString(strconv.Itoa(m.DataSeg.start))
sb.WriteString(") \"")
for _, d := range m.DataSeg.data {
s += "\\"
sb.WriteByte('\\')
i := strconv.FormatInt(int64(d), 16)
if len(i) < 2 {
i = "0" + i
}
s += i
sb.WriteString(i)
}
s += "\")\n"
sb.WriteString("\")\n")
}
s += m.Tables.String()
sb.WriteString(m.Tables.String())
for _, ft := range m.FuncTypes {
s += ft.String()
sb.WriteString(ft.String())
}
for _, g := range m.Globals {
s += "(global $"
s += g.V.Name()
sb.WriteString("(global $")
sb.WriteString(g.V.Name())
if g.IsMut {
s += " (mut " + g.V.Type().Name() + ")"
sb.WriteString(" (mut ")
sb.WriteString(g.V.Type().Name())
sb.WriteByte(')')
} else {
s += " " + g.V.Type().Name()
sb.WriteByte(' ')
sb.WriteString(g.V.Type().Name())
} //
if len(g.InitValue) > 0 {
s += " (" + g.V.Type().Name() + ".const " + g.InitValue + ")"
sb.WriteString(" (")
sb.WriteString(g.V.Type().Name())
sb.WriteString(".const ")
sb.WriteString(g.InitValue)
sb.WriteByte(')')
} else {
s += " (" + g.V.Type().Name() + ".const 0)"
sb.WriteString(" (")
sb.WriteString(g.V.Type().Name())
sb.WriteString(".const 0)")
}
s += ")\n"
sb.WriteString(")\n")
}
for _, f := range m.Funcs {
s += "\n\n" + f.Format("")
sb.WriteString("\n\n")
f.Format(&sb)
}
s += "\n) ;;module"
return s
sb.WriteString("\n) ;;module")
return sb.String()
}
func (t Table) String() string {

4
internal/backends/compiler_wat/wir/wat/wat.go
View File

@ -2,6 +2,8 @@
package wat
import "strings"
/**************************************
Import:
**************************************/
@ -52,7 +54,7 @@ type FuncSig struct {
Inst:
**************************************/
type Inst interface {
Format(indent string) string
Format(indent string, sb *strings.Builder)
isInstruction()
}