Merge branch 'backend_wasm'

_examples/interface_named.wa

@@ -46,6 +46,14 @@ func main() {
 	ni = &v2  //具体类型到空接口
 	i1 = ni.(I1)  //接口动态互转
 	i1.f()
+
+	var ival i32 = 777
+	ni = ival
+	doConcreteType(ni)
+
+	doConcreteType(v1)
+	doConcreteType(v2)
+	doConcreteType("你好凹语言")
 	
 	//i2 := ni.(I2)  //接口互转，由于v2未实现I2，这会触发异常
 	//i2.f2()
@@ -55,7 +63,7 @@ func main() {
 	anoi.f()
 }
 
-func doConcreteType(i I1) {
+func doConcreteType(i interface{}) {
 	//接口到具体类型断言
 	switch c := i.(type){
 		case *S1:
@@ -65,5 +73,17 @@ func doConcreteType(i I1) {
 		case *S2:
 			println("*S2")
 			c.b *= 2
+
+		case i32:
+			println("i32: ", c)
+
+		case string:
+			println("string: ", c)
+
+		case S1:
+			println("S1, S1.a==", c.a)
+
+		case S2:
+			println("S2, S2.b==", c.b)
 	}
 }
\ No newline at end of file

internal/backends/compiler_wat/wir/instruction_emitter.go

@@ -448,8 +448,8 @@ func (m *Module) EmitGenMakeInterface(x Value, itype ValueType) (insts []wat.Ins
 		return itype.(*Interface).emitGenFromSPtr(x)
 
 	default:
-		logger.Fatalf("Todo: %T", x)
-		return
+		sptr_t := m.GenValueType_SPtr(x.Type())
+		return itype.(*Interface).emitGenFromValue(x, sptr_t)
 	}
 }
 

internal/backends/compiler_wat/wir/value_closure.go

@@ -98,9 +98,12 @@ func (t *Closure) Equal(u ValueType) bool {
 }
 
 func (t *Closure) EmitLoadFromAddr(addr Value, offset int) []wat.Inst {
-	if !addr.Type().(*Ptr).Base.Equal(t) {
-		logger.Fatal("Type not match")
-		return nil
+	//if !addr.Type().(*Ptr).Base.Equal(t) {
+	//	logger.Fatal("Type not match")
+	//	return nil
+	//}
+	if _, ok := addr.(*aPtr); !ok {
+		logger.Fatal("addr should be `*aPtr`")
 	}
 
 	return t.underlying.EmitLoadFromAddr(addr, offset)

internal/backends/compiler_wat/wir/value_interface.go

@@ -63,6 +63,18 @@ func (t *Interface) emitGenFromSPtr(x *aSPtr) (insts []wat.Inst) {
 	return
 }
 
+func (t *Interface) emitGenFromValue(x Value, xSptrType *SPtr) (insts []wat.Inst) {
+	insts = append(insts, xSptrType.emitHeapAlloc()...)
+	insts = append(insts, x.emitStore(0)...) //data
+
+	insts = append(insts, wat.NewInstConst(wat.I32{}, strconv.Itoa(x.Type().Hash())))
+	insts = append(insts, wat.NewInstConst(wat.I32{}, strconv.Itoa(t.Hash())))
+	insts = append(insts, wat.NewInstConst(wat.I32{}, "0"))
+	insts = append(insts, wat.NewInstCall("$wa.runtime.getItab")) //itab
+
+	return
+}
+
 func (t *Interface) emitGenFromInterface(x *aInterface) (insts []wat.Inst) {
 	insts = append(insts, x.Extract("data").EmitPush()...) //data
 
@@ -115,7 +127,7 @@ func (v *aInterface) emitGetData(destType ValueType, commaOk bool) (insts []wat.
 	if _, ok := destType.(*SPtr); ok {
 		ifBlock.True = v.Extract("data").EmitPush()
 	} else {
-		ifBlock.True = destType.EmitLoadFromAddr(v.Extract("data"), 0)
+		ifBlock.True = destType.EmitLoadFromAddr(v.Extract("data").(*aSPtr).Extract("data"), 0)
 	}
 
 	// false:

internal/backends/compiler_wat/wir/value_pointer.go

@@ -45,9 +45,12 @@ func (t *Ptr) Equal(u ValueType) bool {
 }
 
 func (t *Ptr) EmitLoadFromAddr(addr Value, offset int) []wat.Inst {
-	if !addr.Type().(*Ptr).Base.Equal(t) {
-		logger.Fatal("Type not match")
-		return nil
+	//if !addr.Type().(*Ptr).Base.Equal(t) {
+	//	logger.Fatal("Type not match")
+	//	return nil
+	//}
+	if _, ok := addr.(*aPtr); !ok {
+		logger.Fatal("addr should be `*aPtr`")
 	}
 	insts := addr.EmitPush()
 	insts = append(insts, wat.NewInstLoad(toWatType(t), offset, 1))

internal/backends/compiler_wat/wir/value_type.go

@@ -155,10 +155,14 @@ func (t *tI8) onFree() int            { return 0 }
 func (t *tI8) Raw() []wat.ValueType   { return []wat.ValueType{wat.I32{}} }
 func (t *tI8) Equal(u ValueType) bool { _, ok := u.(*tI8); return ok }
 func (t *tI8) EmitLoadFromAddr(addr Value, offset int) []wat.Inst {
-	if !addr.Type().(*Ptr).Base.Equal(t) {
-		logger.Fatal("Type not match")
-		return nil
+	//if !addr.Type().(*Ptr).Base.Equal(t) {
+	//	logger.Fatal("Type not match")
+	//	return nil
+	//}
+	if _, ok := addr.(*aPtr); !ok {
+		logger.Fatal("addr should be `*aPtr`")
 	}
+
 	insts := addr.EmitPush()
 	insts = append(insts, wat.NewInstLoad8s(offset, 1))
 	return insts
@@ -179,9 +183,12 @@ func (t *tU8) onFree() int            { return 0 }
 func (t *tU8) Raw() []wat.ValueType   { return []wat.ValueType{wat.I32{}} }
 func (t *tU8) Equal(u ValueType) bool { _, ok := u.(*tU8); return ok }
 func (t *tU8) EmitLoadFromAddr(addr Value, offset int) []wat.Inst {
-	if !addr.Type().(*Ptr).Base.Equal(t) {
-		logger.Fatal("Type not match")
-		return nil
+	//if !addr.Type().(*Ptr).Base.Equal(t) {
+	//	logger.Fatal("Type not match")
+	//	return nil
+	//}
+	if _, ok := addr.(*aPtr); !ok {
+		logger.Fatal("addr should be `*aPtr`")
 	}
 	insts := addr.EmitPush()
 	insts = append(insts, wat.NewInstLoad8u(offset, 1))
@@ -203,9 +210,12 @@ func (t *tI16) onFree() int            { return 0 }
 func (t *tI16) Raw() []wat.ValueType   { return []wat.ValueType{wat.I32{}} }
 func (t *tI16) Equal(u ValueType) bool { _, ok := u.(*tI16); return ok }
 func (t *tI16) EmitLoadFromAddr(addr Value, offset int) []wat.Inst {
-	if !addr.Type().(*Ptr).Base.Equal(t) {
-		logger.Fatal("Type not match")
-		return nil
+	//if !addr.Type().(*Ptr).Base.Equal(t) {
+	//	logger.Fatal("Type not match")
+	//	return nil
+	//}
+	if _, ok := addr.(*aPtr); !ok {
+		logger.Fatal("addr should be `*aPtr`")
 	}
 	insts := addr.EmitPush()
 	insts = append(insts, wat.NewInstLoad16s(offset, 1))
@@ -227,9 +237,12 @@ func (t *tU16) onFree() int            { return 0 }
 func (t *tU16) Raw() []wat.ValueType   { return []wat.ValueType{wat.I32{}} }
 func (t *tU16) Equal(u ValueType) bool { _, ok := u.(*tU16); return ok }
 func (t *tU16) EmitLoadFromAddr(addr Value, offset int) []wat.Inst {
-	if !addr.Type().(*Ptr).Base.Equal(t) {
-		logger.Fatal("Type not match")
-		return nil
+	//if !addr.Type().(*Ptr).Base.Equal(t) {
+	//	logger.Fatal("Type not match")
+	//	return nil
+	//}
+	if _, ok := addr.(*aPtr); !ok {
+		logger.Fatal("addr should be `*aPtr`")
 	}
 	insts := addr.EmitPush()
 	insts = append(insts, wat.NewInstLoad16u(offset, 1))
@@ -251,9 +264,12 @@ func (t *tI32) onFree() int            { return 0 }
 func (t *tI32) Raw() []wat.ValueType   { return []wat.ValueType{wat.I32{}} }
 func (t *tI32) Equal(u ValueType) bool { _, ok := u.(*tI32); return ok }
 func (t *tI32) EmitLoadFromAddr(addr Value, offset int) []wat.Inst {
-	if !addr.Type().(*Ptr).Base.Equal(t) {
-		logger.Fatal("Type not match")
-		return nil
+	//if !addr.Type().(*Ptr).Base.Equal(t) {
+	//	logger.Fatal("Type not match")
+	//	return nil
+	//}
+	if _, ok := addr.(*aPtr); !ok {
+		logger.Fatal("addr should be `*aPtr`")
 	}
 	insts := addr.EmitPush()
 	insts = append(insts, wat.NewInstLoad(toWatType(t), offset, 1))
@@ -275,9 +291,12 @@ func (t *tU32) onFree() int            { return 0 }
 func (t *tU32) Raw() []wat.ValueType   { return []wat.ValueType{wat.U32{}} }
 func (t *tU32) Equal(u ValueType) bool { _, ok := u.(*tU32); return ok }
 func (t *tU32) EmitLoadFromAddr(addr Value, offset int) []wat.Inst {
-	if !addr.Type().(*Ptr).Base.Equal(t) {
-		logger.Fatal("Type not match")
-		return nil
+	//if !addr.Type().(*Ptr).Base.Equal(t) {
+	//	logger.Fatal("Type not match")
+	//	return nil
+	//}
+	if _, ok := addr.(*aPtr); !ok {
+		logger.Fatal("addr should be `*aPtr`")
 	}
 	insts := addr.EmitPush()
 	insts = append(insts, wat.NewInstLoad(toWatType(t), offset, 1))
@@ -299,9 +318,12 @@ func (t *tI64) onFree() int            { return 0 }
 func (t *tI64) Raw() []wat.ValueType   { return []wat.ValueType{wat.I64{}} }
 func (t *tI64) Equal(u ValueType) bool { _, ok := u.(*tI64); return ok }
 func (t *tI64) EmitLoadFromAddr(addr Value, offset int) []wat.Inst {
-	if !addr.Type().(*Ptr).Base.Equal(t) {
-		logger.Fatal("Type not match")
-		return nil
+	//if !addr.Type().(*Ptr).Base.Equal(t) {
+	//	logger.Fatal("Type not match")
+	//	return nil
+	//}
+	if _, ok := addr.(*aPtr); !ok {
+		logger.Fatal("addr should be `*aPtr`")
 	}
 	insts := addr.EmitPush()
 	insts = append(insts, wat.NewInstLoad(toWatType(t), offset, 1))
@@ -323,9 +345,12 @@ func (t *tU64) onFree() int            { return 0 }
 func (t *tU64) Raw() []wat.ValueType   { return []wat.ValueType{wat.U64{}} }
 func (t *tU64) Equal(u ValueType) bool { _, ok := u.(*tU64); return ok }
 func (t *tU64) EmitLoadFromAddr(addr Value, offset int) []wat.Inst {
-	if !addr.Type().(*Ptr).Base.Equal(t) {
-		logger.Fatal("Type not match")
-		return nil
+	//if !addr.Type().(*Ptr).Base.Equal(t) {
+	//	logger.Fatal("Type not match")
+	//	return nil
+	//}
+	if _, ok := addr.(*aPtr); !ok {
+		logger.Fatal("addr should be `*aPtr`")
 	}
 	insts := addr.EmitPush()
 	insts = append(insts, wat.NewInstLoad(toWatType(t), offset, 1))
@@ -347,9 +372,12 @@ func (t *tF32) onFree() int            { return 0 }
 func (t *tF32) Raw() []wat.ValueType   { return []wat.ValueType{wat.F32{}} }
 func (t *tF32) Equal(u ValueType) bool { _, ok := u.(*tF32); return ok }
 func (t *tF32) EmitLoadFromAddr(addr Value, offset int) []wat.Inst {
-	if !addr.Type().(*Ptr).Base.Equal(t) {
-		logger.Fatal("Type not match")
-		return nil
+	//if !addr.Type().(*Ptr).Base.Equal(t) {
+	//	logger.Fatal("Type not match")
+	//	return nil
+	//}
+	if _, ok := addr.(*aPtr); !ok {
+		logger.Fatal("addr should be `*aPtr`")
 	}
 	insts := addr.EmitPush()
 	insts = append(insts, wat.NewInstLoad(toWatType(t), offset, 1))
@@ -371,9 +399,12 @@ func (t *tF64) onFree() int            { return 0 }
 func (t *tF64) Raw() []wat.ValueType   { return []wat.ValueType{wat.F64{}} }
 func (t *tF64) Equal(u ValueType) bool { _, ok := u.(*tF64); return ok }
 func (t *tF64) EmitLoadFromAddr(addr Value, offset int) []wat.Inst {
-	if !addr.Type().(*Ptr).Base.Equal(t) {
-		logger.Fatal("Type not match")
-		return nil
+	//if !addr.Type().(*Ptr).Base.Equal(t) {
+	//	logger.Fatal("Type not match")
+	//	return nil
+	//}
+	if _, ok := addr.(*aPtr); !ok {
+		logger.Fatal("addr should be `*aPtr`")
 	}
 	insts := addr.EmitPush()
 	insts = append(insts, wat.NewInstLoad(toWatType(t), offset, 1))