483 lines
11 KiB
Go
483 lines
11 KiB
Go
/*
|
|
* 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 cl
|
|
|
|
import (
|
|
"fmt"
|
|
"go/ast"
|
|
"go/constant"
|
|
"go/token"
|
|
"go/types"
|
|
"log"
|
|
"os"
|
|
"sort"
|
|
"strings"
|
|
|
|
llssa "github.com/goplus/llgo/ssa"
|
|
"golang.org/x/tools/go/ssa"
|
|
)
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
type dbgFlags = int
|
|
|
|
const (
|
|
DbgFlagInstruction dbgFlags = 1 << iota
|
|
DbgFlagGoSSA
|
|
|
|
DbgFlagAll = DbgFlagInstruction | DbgFlagGoSSA
|
|
)
|
|
|
|
var (
|
|
debugInstr bool
|
|
debugGoSSA bool
|
|
)
|
|
|
|
// SetDebug sets debug flags.
|
|
func SetDebug(dbgFlags dbgFlags) {
|
|
debugInstr = (dbgFlags & DbgFlagInstruction) != 0
|
|
debugGoSSA = (dbgFlags & DbgFlagGoSSA) != 0
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
const (
|
|
fnNormal = iota
|
|
fnHasVArg
|
|
fnIgnore
|
|
)
|
|
|
|
func funcKind(vfn ssa.Value) int {
|
|
if fn, ok := vfn.(*ssa.Function); ok && fn.Signature.Recv() == nil {
|
|
params := fn.Signature.Params()
|
|
n := params.Len()
|
|
if n == 0 {
|
|
if fn.Name() == "init" && ignorePkgInit(fn.Pkg.Pkg.Path()) {
|
|
return fnIgnore
|
|
}
|
|
} else {
|
|
last := params.At(n - 1)
|
|
if last.Name() == llssa.NameValist {
|
|
return fnHasVArg
|
|
}
|
|
}
|
|
}
|
|
return fnNormal
|
|
}
|
|
|
|
func ignorePkgInit(pkgPath string) bool {
|
|
switch pkgPath {
|
|
case "unsafe", "syscall", "runtime/cgo":
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
func ignoreFunc(name string, fn *ssa.Function) bool {
|
|
/* TODO(xsw): confirm this is not needed more
|
|
if name == "unsafe.init" {
|
|
return true
|
|
}
|
|
*/
|
|
fnName := fn.Name()
|
|
if strings.HasPrefix(fnName, "_Cgo_") {
|
|
return true
|
|
}
|
|
const runtime = "runtime"
|
|
if strings.HasPrefix(name, runtime) {
|
|
left := name[len(runtime):]
|
|
return strings.HasPrefix(left, ".cgo") || strings.HasPrefix(left, "/cgo")
|
|
}
|
|
return false
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
type none = struct{}
|
|
|
|
type instrAndValue interface {
|
|
ssa.Instruction
|
|
ssa.Value
|
|
}
|
|
|
|
type context struct {
|
|
prog llssa.Program
|
|
pkg llssa.Package
|
|
fn llssa.Function
|
|
fset *token.FileSet
|
|
goProg *ssa.Program
|
|
goTyps *types.Package
|
|
goPkg *ssa.Package
|
|
link map[string]string // pkgPath.nameInPkg => linkname
|
|
loaded map[*types.Package]none // loaded packages
|
|
bvals map[ssa.Value]llssa.Expr // block values
|
|
vargs map[*ssa.Alloc][]llssa.Expr // varargs
|
|
inits []func()
|
|
}
|
|
|
|
func (p *context) compileType(pkg llssa.Package, t *ssa.Type) {
|
|
tn := t.Object().(*types.TypeName)
|
|
typ := tn.Type()
|
|
name := fullName(tn.Pkg(), tn.Name())
|
|
if debugInstr {
|
|
log.Println("==> NewType", name, typ)
|
|
}
|
|
p.compileMethods(pkg, typ)
|
|
p.compileMethods(pkg, types.NewPointer(typ))
|
|
}
|
|
|
|
func (p *context) compileMethods(pkg llssa.Package, typ types.Type) {
|
|
prog := p.goProg
|
|
mthds := prog.MethodSets.MethodSet(typ)
|
|
for i, n := 0, mthds.Len(); i < n; i++ {
|
|
mthd := mthds.At(i)
|
|
ssaMthd := prog.MethodValue(mthd)
|
|
p.compileFunc(pkg, mthd.Obj().Pkg(), ssaMthd)
|
|
}
|
|
}
|
|
|
|
// Global variable.
|
|
func (p *context) compileGlobal(pkg llssa.Package, gbl *ssa.Global) {
|
|
typ := gbl.Type()
|
|
name := fullName(gbl.Pkg.Pkg, gbl.Name())
|
|
if debugInstr {
|
|
log.Println("==> NewVar", name, typ)
|
|
}
|
|
g := pkg.NewVar(name, typ)
|
|
g.Init(p.prog.Null(g.Type))
|
|
}
|
|
|
|
func (p *context) compileFunc(pkg llssa.Package, pkgTypes *types.Package, f *ssa.Function) {
|
|
sig := f.Signature
|
|
name := p.funcName(pkgTypes, f)
|
|
if debugInstr {
|
|
log.Println("==> NewFunc", name, "type:", sig.Recv(), sig)
|
|
}
|
|
if ignoreFunc(name, f) {
|
|
return
|
|
}
|
|
fn := pkg.NewFunc(name, sig)
|
|
p.inits = append(p.inits, func() {
|
|
p.fn = fn
|
|
defer func() {
|
|
p.fn = nil
|
|
}()
|
|
nblk := len(f.Blocks)
|
|
if nblk == 0 { // external function
|
|
return
|
|
}
|
|
if debugGoSSA {
|
|
f.WriteTo(os.Stderr)
|
|
}
|
|
if debugInstr {
|
|
log.Println("==> FuncBody", name)
|
|
}
|
|
fn.MakeBlocks(nblk)
|
|
b := fn.NewBuilder()
|
|
for i, block := range f.Blocks {
|
|
p.compileBlock(b, block, i == 0 && name == "main")
|
|
}
|
|
})
|
|
}
|
|
|
|
func (p *context) compileBlock(b llssa.Builder, block *ssa.BasicBlock, doInit bool) llssa.BasicBlock {
|
|
ret := p.fn.Block(block.Index)
|
|
b.SetBlock(ret)
|
|
p.bvals = make(map[ssa.Value]llssa.Expr)
|
|
if doInit {
|
|
fn := p.pkg.FuncOf("main.init")
|
|
b.Call(fn.Expr)
|
|
}
|
|
for _, instr := range block.Instrs {
|
|
p.compileInstr(b, instr)
|
|
}
|
|
return ret
|
|
}
|
|
|
|
func isAny(t types.Type) bool {
|
|
if t, ok := t.(*types.Interface); ok {
|
|
return t.Empty()
|
|
}
|
|
return false
|
|
}
|
|
|
|
func intVal(v ssa.Value) int64 {
|
|
if c, ok := v.(*ssa.Const); ok {
|
|
if iv, exact := constant.Int64Val(c.Value); exact {
|
|
return iv
|
|
}
|
|
}
|
|
panic("intVal: ssa.Value is not a const int")
|
|
}
|
|
|
|
func (p *context) isVArgs(vx ssa.Value) (ret []llssa.Expr, ok bool) {
|
|
if va, vok := vx.(*ssa.Alloc); vok {
|
|
ret, ok = p.vargs[va] // varargs: this is a varargs index
|
|
}
|
|
return
|
|
}
|
|
|
|
func (p *context) checkVArgs(v *ssa.Alloc, t types.Type) bool {
|
|
if v.Comment == "varargs" { // this is a varargs allocation
|
|
if t, ok := t.(*types.Pointer); ok {
|
|
if arr, ok := t.Elem().(*types.Array); ok {
|
|
if isAny(arr.Elem()) {
|
|
p.vargs[v] = make([]llssa.Expr, arr.Len())
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (p *context) compileInstrAndValue(b llssa.Builder, iv instrAndValue) (ret llssa.Expr) {
|
|
if v, ok := p.bvals[iv]; ok {
|
|
return v
|
|
}
|
|
switch v := iv.(type) {
|
|
case *ssa.Call:
|
|
call := v.Call
|
|
cv := call.Value
|
|
kind := funcKind(cv)
|
|
if kind == fnIgnore {
|
|
return
|
|
}
|
|
if debugGoSSA {
|
|
log.Println(">>> Call", cv, call.Args)
|
|
}
|
|
if builtin, ok := cv.(*ssa.Builtin); ok {
|
|
fn := builtin.Name()
|
|
if fn == "ssa:wrapnilchk" { // TODO(xsw): check nil ptr
|
|
arg := call.Args[0]
|
|
ret = p.compileValue(b, arg)
|
|
// log.Println("wrapnilchk:", ret.TypeOf())
|
|
} else {
|
|
args := p.compileValues(b, call.Args, kind)
|
|
ret = b.BuiltinCall(fn, args...)
|
|
}
|
|
} else {
|
|
fn := p.compileValue(b, cv)
|
|
args := p.compileValues(b, call.Args, kind)
|
|
ret = b.Call(fn, args...)
|
|
}
|
|
case *ssa.BinOp:
|
|
x := p.compileValue(b, v.X)
|
|
y := p.compileValue(b, v.Y)
|
|
ret = b.BinOp(v.Op, x, y)
|
|
case *ssa.UnOp:
|
|
x := p.compileValue(b, v.X)
|
|
ret = b.UnOp(v.Op, x)
|
|
case *ssa.ChangeType:
|
|
t := v.Type()
|
|
x := p.compileValue(b, v.X)
|
|
ret = b.ChangeType(p.prog.Type(t), x)
|
|
case *ssa.IndexAddr:
|
|
vx := v.X
|
|
if _, ok := p.isVArgs(vx); ok { // varargs: this is a varargs index
|
|
return
|
|
}
|
|
x := p.compileValue(b, vx)
|
|
idx := p.compileValue(b, v.Index)
|
|
ret = b.IndexAddr(x, idx)
|
|
case *ssa.Slice:
|
|
vx := v.X
|
|
if _, ok := p.isVArgs(vx); ok { // varargs: this is a varargs slice
|
|
return
|
|
}
|
|
panic("todo")
|
|
case *ssa.Alloc:
|
|
t := v.Type()
|
|
if p.checkVArgs(v, t) { // varargs: this is a varargs allocation
|
|
return
|
|
}
|
|
ret = b.Alloc(p.prog.Type(t), v.Heap)
|
|
case *ssa.MakeInterface:
|
|
t := v.Type()
|
|
if isAny(t) { // varargs: don't need to convert an expr to any
|
|
return
|
|
}
|
|
panic("todo")
|
|
default:
|
|
panic(fmt.Sprintf("compileInstrAndValue: unknown instr - %T\n", iv))
|
|
}
|
|
p.bvals[iv] = ret
|
|
return ret
|
|
}
|
|
|
|
func (p *context) compileInstr(b llssa.Builder, instr ssa.Instruction) {
|
|
if iv, ok := instr.(instrAndValue); ok {
|
|
p.compileInstrAndValue(b, iv)
|
|
return
|
|
}
|
|
switch v := instr.(type) {
|
|
case *ssa.Store:
|
|
va := v.Addr
|
|
if va, ok := va.(*ssa.IndexAddr); ok {
|
|
if args, ok := p.isVArgs(va.X); ok { // varargs: this is a varargs store
|
|
idx := intVal(va.Index)
|
|
val := v.Val
|
|
if vi, ok := val.(*ssa.MakeInterface); ok {
|
|
val = vi.X
|
|
}
|
|
args[idx] = p.compileValue(b, val)
|
|
return
|
|
}
|
|
}
|
|
ptr := p.compileValue(b, va)
|
|
val := p.compileValue(b, v.Val)
|
|
b.Store(ptr, val)
|
|
case *ssa.Jump:
|
|
fn := p.fn
|
|
succs := v.Block().Succs
|
|
jmpb := fn.Block(succs[0].Index)
|
|
b.Jump(jmpb)
|
|
case *ssa.Return:
|
|
var results []llssa.Expr
|
|
if n := len(v.Results); n > 0 {
|
|
results = make([]llssa.Expr, n)
|
|
for i, r := range v.Results {
|
|
results[i] = p.compileValue(b, r)
|
|
}
|
|
}
|
|
b.Return(results...)
|
|
case *ssa.If:
|
|
fn := p.fn
|
|
cond := p.compileValue(b, v.Cond)
|
|
succs := v.Block().Succs
|
|
thenb := fn.Block(succs[0].Index)
|
|
elseb := fn.Block(succs[1].Index)
|
|
b.If(cond, thenb, elseb)
|
|
default:
|
|
panic(fmt.Sprintf("compileInstr: unknown instr - %T\n", instr))
|
|
}
|
|
}
|
|
|
|
func (p *context) compileValue(b llssa.Builder, v ssa.Value) llssa.Expr {
|
|
if iv, ok := v.(instrAndValue); ok {
|
|
return p.compileInstrAndValue(b, iv)
|
|
}
|
|
switch v := v.(type) {
|
|
case *ssa.Parameter:
|
|
fn := v.Parent()
|
|
for idx, param := range fn.Params {
|
|
if param == v {
|
|
return p.fn.Param(idx)
|
|
}
|
|
}
|
|
case *ssa.Function:
|
|
fn := p.funcOf(v)
|
|
return fn.Expr
|
|
case *ssa.Global:
|
|
g := p.varOf(v)
|
|
return g.Expr
|
|
case *ssa.Const:
|
|
t := v.Type()
|
|
return b.Const(v.Value, p.prog.Type(t))
|
|
}
|
|
panic(fmt.Sprintf("compileValue: unknown value - %T\n", v))
|
|
}
|
|
|
|
func (p *context) compileVArg(ret []llssa.Expr, b llssa.Builder, v ssa.Value) []llssa.Expr {
|
|
_ = b
|
|
switch v := v.(type) {
|
|
case *ssa.Slice: // varargs: this is a varargs slice
|
|
if args, ok := p.isVArgs(v.X); ok {
|
|
return append(ret, args...)
|
|
}
|
|
case *ssa.Const:
|
|
if v.Value == nil {
|
|
return ret
|
|
}
|
|
}
|
|
panic(fmt.Sprintf("compileVArg: unknown value - %T\n", v))
|
|
}
|
|
|
|
func (p *context) compileValues(b llssa.Builder, vals []ssa.Value, hasVArg int) []llssa.Expr {
|
|
n := len(vals) - hasVArg
|
|
ret := make([]llssa.Expr, n)
|
|
for i := 0; i < n; i++ {
|
|
ret[i] = p.compileValue(b, vals[i])
|
|
}
|
|
if hasVArg > 0 {
|
|
ret = p.compileVArg(ret, b, vals[n])
|
|
}
|
|
return ret
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
// NewPackage compiles a Go package to LLVM IR package.
|
|
func NewPackage(prog llssa.Program, pkg *ssa.Package, files []*ast.File) (ret llssa.Package, err error) {
|
|
type namedMember struct {
|
|
name string
|
|
val ssa.Member
|
|
}
|
|
|
|
// Sort by position, so that the order of the functions in the IR matches
|
|
// the order of functions in the source file. This is useful for testing,
|
|
// for example.
|
|
var members []*namedMember
|
|
for name, v := range pkg.Members {
|
|
members = append(members, &namedMember{name, v})
|
|
}
|
|
sort.Slice(members, func(i, j int) bool {
|
|
iPos := members[i].val.Pos()
|
|
jPos := members[j].val.Pos()
|
|
return iPos < jPos
|
|
})
|
|
|
|
pkgProg := pkg.Prog
|
|
pkgTypes := pkg.Pkg
|
|
pkgName, pkgPath := pkgTypes.Name(), pathOf(pkgTypes)
|
|
ret = prog.NewPackage(pkgName, pkgPath)
|
|
|
|
ctx := &context{
|
|
prog: prog,
|
|
pkg: ret,
|
|
fset: pkgProg.Fset,
|
|
goProg: pkgProg,
|
|
goTyps: pkgTypes,
|
|
goPkg: pkg,
|
|
link: make(map[string]string),
|
|
loaded: make(map[*types.Package]none),
|
|
vargs: make(map[*ssa.Alloc][]llssa.Expr),
|
|
}
|
|
ctx.initFiles(pkgPath, files)
|
|
for _, m := range members {
|
|
member := m.val
|
|
switch member := member.(type) {
|
|
case *ssa.Function:
|
|
if member.TypeParams() != nil {
|
|
// Do not try to build generic (non-instantiated) functions.
|
|
continue
|
|
}
|
|
ctx.compileFunc(ret, member.Pkg.Pkg, member)
|
|
case *ssa.Type:
|
|
ctx.compileType(ret, member)
|
|
case *ssa.Global:
|
|
ctx.compileGlobal(ret, member)
|
|
}
|
|
}
|
|
for _, ini := range ctx.inits {
|
|
ini()
|
|
}
|
|
return
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|