llgo/internal/runtime

internal/runtime/iface.go

@@ -0,0 +1,5 @@
+// Copyright 2014 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 runtime

internal/runtime/runtime2.go

@@ -0,0 +1,37 @@
+// Copyright 2009 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 runtime
+
+import (
+	"unsafe"
+)
+
+type iface struct {
+	tab  *itab
+	data unsafe.Pointer
+}
+
+/*
+type eface struct {
+	_type *_type
+	data  unsafe.Pointer
+}
+
+func efaceOf(ep *any) *eface {
+	return (*eface)(unsafe.Pointer(ep))
+}
+*/
+
+// layout of Itab known to compilers
+// allocated in non-garbage-collected memory
+// Needs to be in sync with
+// ../cmd/compile/internal/reflectdata/reflect.go:/^func.WriteTabs.
+type itab struct {
+	inter *interfacetype
+	_type *_type
+	hash  uint32 // copy of _type.hash. Used for type switches.
+	_     [4]byte
+	fun   [1]uintptr // variable sized. fun[0]==0 means _type does not implement inter.
+}

internal/runtime/type.go

@@ -0,0 +1,18 @@
+// Copyright 2009 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.
+
+// Runtime type representation.
+
+package runtime
+
+import (
+	"github.com/goplus/llgo/internal/abi"
+)
+
+// type nameOff = abi.NameOff
+// type typeOff = abi.TypeOff
+
+type _type = abi.Type
+
+type interfacetype = abi.InterfaceType

internal/runtime/z_iface.go

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2024 The GoPlus Authors (goplus.org). All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package runtime
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/internal/abi"
+)
+
+type Interface = iface
+
+type InterfaceType = abi.InterfaceType
+
+type Type = abi.Type
+
+var (
+	TyAny = &InterfaceType{}
+)
+
+func MakeAny(typ *Type, data unsafe.Pointer) Interface {
+	return Interface{
+		tab:  &itab{inter: TyAny, _type: typ, hash: 0, fun: [1]uintptr{0}},
+		data: data,
+	}
+}

ssa/package.go

@@ -90,10 +90,17 @@ func Initialize(flags InitFlags) {
 
 // -----------------------------------------------------------------------------
 
+type Runtime interface {
+	Runtime() *types.Package
+}
+
 type aProgram struct {
 	ctx  llvm.Context
 	typs typeutil.Map
 
+	rt    *types.Scope
+	rtget Runtime
+
 	target *Target
 	td     llvm.TargetData
 	// tm  llvm.TargetMachine
@@ -107,6 +114,7 @@ type aProgram struct {
 	voidType  llvm.Type
 	voidPtrTy llvm.Type
 
+	anyTy  Type
 	voidTy Type
 	boolTy Type
 	intTy  Type
@@ -128,6 +136,18 @@ func NewProgram(target *Target) Program {
 	return &aProgram{ctx: ctx, target: target, td: td}
 }
 
+// SetRuntime sets the runtime package.
+func (p Program) SetRuntime(runtime Runtime) {
+	p.rtget = runtime
+}
+
+func (p Program) runtime() *types.Scope {
+	if p.rt == nil {
+		p.rt = p.rtget.Runtime().Scope()
+	}
+	return p.rt
+}
+
 // NewPackage creates a new package.
 func (p Program) NewPackage(name, pkgPath string) Package {
 	mod := p.ctx.NewModule(pkgPath)
@@ -154,6 +174,13 @@ func (p Program) Bool() Type {
 	return p.boolTy
 }
 
+func (p Program) Any() Type {
+	if p.anyTy == nil {
+		p.anyTy = p.Type(tyAny)
+	}
+	return p.anyTy
+}
+
 // Int returns int type.
 func (p Program) Int() Type {
 	if p.intTy == nil {

ssa/type.go

@@ -23,6 +23,10 @@ import (
 	"github.com/goplus/llvm"
 )
 
+var (
+	tyAny = types.NewInterfaceType(nil, nil)
+)
+
 // -----------------------------------------------------------------------------
 
 type valueKind = int
@@ -237,6 +241,9 @@ func (p Program) toLLVMType(typ types.Type) Type {
 	case *types.Pointer:
 		elem := p.Type(t.Elem())
 		return &aType{llvm.PointerType(elem.ll, 0), typ, vkInvalid}
+	case *types.Interface:
+		tyIface := p.runtime().Lookup("Interface").(*types.TypeName).Type().(*types.Named)
+		return p.toLLVMNamed(tyIface)
 	case *types.Slice:
 	case *types.Map:
 	case *types.Struct: