admin/llgo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

llgo/ssa: Builder add Pkg

Browse Source
This commit is contained in:
xushiwei
2024-05-19 13:00:58 +08:00
parent 3bf3a276de
commit 39268c681f
6 changed files with 49 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
ssa/datastruct.go
View File

@@ -148,12 +148,14 @@ func (b Builder) IndexAddr(x, idx Expr) Expr {
// check index >= 0 and size to uint // check index >= 0 and size to uint
func (b Builder) checkIndex(idx Expr) Expr { func (b Builder) checkIndex(idx Expr) Expr {
prog := b.Prog
if needsNegativeCheck(idx) { if needsNegativeCheck(idx) {
check := Expr{b.impl.CreateICmp(llvm.IntSLT, idx.impl, llvm.ConstInt(idx.ll, 0, false), ""), b.Prog.Bool()} zero := llvm.ConstInt(idx.ll, 0, false)
b.InlineCall(b.Func.Pkg.rtFunc("AssertIndexRange"), check) check := Expr{b.impl.CreateICmp(llvm.IntSLT, idx.impl, zero, ""), prog.Bool()}
b.InlineCall(b.Pkg.rtFunc("AssertIndexRange"), check)
} }
typ := b.Prog.Uint() typ := prog.Uint()
if b.Prog.SizeOf(idx.Type) < b.Prog.SizeOf(typ) { if prog.SizeOf(idx.Type) < prog.SizeOf(typ) {
idx.Type = typ idx.Type = typ
idx.impl = castUintptr(b, idx.impl, typ) idx.impl = castUintptr(b, idx.impl, typ)
} }
@@ -235,7 +237,6 @@ func (b Builder) Slice(x, low, high, max Expr) (ret Expr) {
log.Printf("Slice %v, %v, %v\n", x.impl, low.impl, high.impl) log.Printf("Slice %v, %v, %v\n", x.impl, low.impl, high.impl)
} }
prog := b.Prog prog := b.Prog
pkg := b.Func.Pkg
var nCap Expr var nCap Expr
var nEltSize Expr var nEltSize Expr
var base Expr var base Expr
@@ -251,7 +252,7 @@ func (b Builder) Slice(x, low, high, max Expr) (ret Expr) {
high = b.StringLen(x) high = b.StringLen(x)
} }
ret.Type = x.Type ret.Type = x.Type
ret.impl = b.InlineCall(pkg.rtFunc("NewStringSlice"), x, low, high).impl ret.impl = b.InlineCall(b.Pkg.rtFunc("NewStringSlice"), x, low, high).impl
return return
case *types.Slice: case *types.Slice:
nEltSize = b.SizeOf(prog.Index(x.Type)) nEltSize = b.SizeOf(prog.Index(x.Type))
@@ -278,7 +279,7 @@ func (b Builder) Slice(x, low, high, max Expr) (ret Expr) {
if max.IsNil() { if max.IsNil() {
max = nCap max = nCap
} }
ret.impl = b.InlineCall(pkg.rtFunc("NewSlice3"), base, nEltSize, nCap, low, high, max).impl ret.impl = b.InlineCall(b.Pkg.rtFunc("NewSlice3"), base, nEltSize, nCap, low, high, max).impl
return return
} }
@@ -297,9 +298,8 @@ func (b Builder) MakeMap(t Type, nReserve Expr) (ret Expr) {
if debugInstr { if debugInstr {
log.Printf("MakeMap %v, %v\n", t.RawType(), nReserve.impl) log.Printf("MakeMap %v, %v\n", t.RawType(), nReserve.impl)
} }
pkg := b.Func.Pkg
ret.Type = t ret.Type = t
ret.impl = b.InlineCall(pkg.rtFunc("MakeSmallMap")).impl ret.impl = b.InlineCall(b.Pkg.rtFunc("MakeSmallMap")).impl
// TODO(xsw): nReserve // TODO(xsw): nReserve
return return
} }
@@ -322,7 +322,7 @@ func (b Builder) MakeSlice(t Type, len, cap Expr) (ret Expr) {
if debugInstr { if debugInstr {
log.Printf("MakeSlice %v, %v, %v\n", t.RawType(), len.impl, cap.impl) log.Printf("MakeSlice %v, %v, %v\n", t.RawType(), len.impl, cap.impl)
} }
pkg := b.Func.Pkg pkg := b.Pkg
if cap.IsNil() { if cap.IsNil() {
cap = len cap = len
} }

8
ssa/decl.go
View File

@@ -248,7 +248,7 @@ func (p Function) NewBuilder() Builder {
b := prog.ctx.NewBuilder() b := prog.ctx.NewBuilder()
// TODO(xsw): Finalize may cause panic, so comment it. // TODO(xsw): Finalize may cause panic, so comment it.
// b.Finalize() // b.Finalize()
return &aBuilder{b, p, prog} return &aBuilder{b, p, p.Pkg, prog}
} }
// HasBody reports whether the function has a body. // HasBody reports whether the function has a body.
@@ -305,16 +305,14 @@ type PyGlobal = *aPyGlobal
// PyNewVar creates a Python variable. // PyNewVar creates a Python variable.
func (b Builder) PyNewVar(modName, name string) PyGlobal { func (b Builder) PyNewVar(modName, name string) PyGlobal {
pkg := b.Func.Pkg modPtr := b.Pkg.PyNewModVar(modName, false).Expr
modPtr := pkg.PyNewModVar(modName, false).Expr
mod := b.Load(modPtr) mod := b.Load(modPtr)
return &aPyGlobal{pyVarExpr(mod, name)} return &aPyGlobal{pyVarExpr(mod, name)}
} }
func (b Builder) pyLoad(ptr Expr) Expr { func (b Builder) pyLoad(ptr Expr) Expr {
pkg := b.Func.Pkg
t := ptr.raw.Type.(*pyVarTy) t := ptr.raw.Type.(*pyVarTy)
fn := pkg.pyFunc("PyObject_GetAttrString", b.Prog.tyGetAttrString()) fn := b.Pkg.pyFunc("PyObject_GetAttrString", b.Prog.tyGetAttrString())
return b.Call(fn, t.mod, b.CStr(t.name)) return b.Call(fn, t.mod, b.CStr(t.name))
} }

30
ssa/expr.go
View File

@@ -190,7 +190,7 @@ func (b Builder) CStr(v string) Expr {
func (b Builder) Str(v string) (ret Expr) { func (b Builder) Str(v string) (ret Expr) {
prog := b.Prog prog := b.Prog
cstr := b.CStr(v) cstr := b.CStr(v)
ret = b.InlineCall(b.Func.Pkg.rtFunc("NewString"), cstr, prog.Val(len(v))) ret = b.InlineCall(b.Pkg.rtFunc("NewString"), cstr, prog.Val(len(v)))
ret.Type = prog.String() ret.Type = prog.String()
return return
} }
@@ -308,8 +308,7 @@ func (b Builder) BinOp(op token.Token, x, y Expr) Expr {
switch kind { switch kind {
case vkString: case vkString:
if op == token.ADD { if op == token.ADD {
pkg := b.Func.Pkg return Expr{b.InlineCall(b.Pkg.rtFunc("StringCat"), x, y).impl, x.Type}
return Expr{b.InlineCall(pkg.rtFunc("StringCat"), x, y).impl, x.Type}
} }
case vkComplex: case vkComplex:
default: default:
@@ -324,8 +323,9 @@ func (b Builder) BinOp(op token.Token, x, y Expr) Expr {
return Expr{b.impl.CreateAnd(x.impl, b.impl.CreateNot(y.impl, ""), ""), x.Type} return Expr{b.impl.CreateAnd(x.impl, b.impl.CreateNot(y.impl, ""), ""), x.Type}
case token.SHL, token.SHR: case token.SHL, token.SHR:
if needsNegativeCheck(y) { if needsNegativeCheck(y) {
check := Expr{b.impl.CreateICmp(llvm.IntSLT, y.impl, llvm.ConstInt(y.ll, 0, false), ""), b.Prog.Bool()} zero := llvm.ConstInt(y.ll, 0, false)
b.InlineCall(b.Func.Pkg.rtFunc("AssertNegativeShift"), check) check := Expr{b.impl.CreateICmp(llvm.IntSLT, y.impl, zero, ""), b.Prog.Bool()}
b.InlineCall(b.Pkg.rtFunc("AssertNegativeShift"), check)
} }
xsize, ysize := b.Prog.SizeOf(x.Type), b.Prog.SizeOf(y.Type) xsize, ysize := b.Prog.SizeOf(x.Type), b.Prog.SizeOf(y.Type)
if xsize != ysize { if xsize != ysize {
@@ -416,7 +416,7 @@ func (b Builder) UnOp(op token.Token, x Expr) (ret Expr) {
func checkExpr(v Expr, t types.Type, b Builder) Expr { func checkExpr(v Expr, t types.Type, b Builder) Expr {
if t, ok := t.(*types.Struct); ok && isClosure(t) { if t, ok := t.(*types.Struct); ok && isClosure(t) {
if v.kind != vkClosure { if v.kind != vkClosure {
return b.Func.Pkg.closureStub(b, t, v) return b.Pkg.closureStub(b, t, v)
} }
} }
return v return v
@@ -584,9 +584,8 @@ func (b Builder) Store(ptr, val Expr) Builder {
func (b Builder) aggregateAlloc(t Type, flds ...llvm.Value) llvm.Value { func (b Builder) aggregateAlloc(t Type, flds ...llvm.Value) llvm.Value {
prog := b.Prog prog := b.Prog
pkg := b.Func.Pkg
size := prog.SizeOf(t) size := prog.SizeOf(t)
ptr := b.InlineCall(pkg.rtFunc("AllocU"), prog.IntVal(size, prog.Uintptr())).impl ptr := b.InlineCall(b.Pkg.rtFunc("AllocU"), prog.IntVal(size, prog.Uintptr())).impl
tll := t.ll tll := t.ll
impl := b.impl impl := b.impl
for i, fld := range flds { for i, fld := range flds {
@@ -654,7 +653,7 @@ func (b Builder) Alloc(elem Type, heap bool) (ret Expr) {
log.Printf("Alloc %v, %v\n", elem.RawType(), heap) log.Printf("Alloc %v, %v\n", elem.RawType(), heap)
} }
prog := b.Prog prog := b.Prog
pkg := b.Func.Pkg pkg := b.Pkg
size := b.SizeOf(elem) size := b.SizeOf(elem)
if heap { if heap {
ret = b.InlineCall(pkg.rtFunc("AllocZ"), size) ret = b.InlineCall(pkg.rtFunc("AllocZ"), size)
@@ -695,11 +694,10 @@ func (b Builder) AllocaCStr(gostr Expr) (ret Expr) {
if debugInstr { if debugInstr {
log.Printf("AllocaCStr %v\n", gostr.impl) log.Printf("AllocaCStr %v\n", gostr.impl)
} }
pkg := b.Func.Pkg
n := b.StringLen(gostr) n := b.StringLen(gostr)
n1 := b.BinOp(token.ADD, n, b.Prog.Val(1)) n1 := b.BinOp(token.ADD, n, b.Prog.Val(1))
cstr := b.Alloca(n1) cstr := b.Alloca(n1)
return b.InlineCall(pkg.rtFunc("CStrCopy"), cstr, gostr) return b.InlineCall(b.Pkg.rtFunc("CStrCopy"), cstr, gostr)
} }
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
@@ -968,13 +966,13 @@ func (b Builder) BuiltinCall(fn string, args ...Expr) (ret Expr) {
case vkSlice: case vkSlice:
etSize := b.Prog.SizeOf(b.Prog.Elem(elem.Type)) etSize := b.Prog.SizeOf(b.Prog.Elem(elem.Type))
ret.Type = src.Type ret.Type = src.Type
ret.impl = b.InlineCall(b.Func.Pkg.rtFunc("SliceAppend"), ret.impl = b.InlineCall(b.Pkg.rtFunc("SliceAppend"),
src, b.SliceData(elem), b.SliceLen(elem), b.Prog.Val(int(etSize))).impl src, b.SliceData(elem), b.SliceLen(elem), b.Prog.Val(int(etSize))).impl
return return
case vkString: case vkString:
etSize := b.Prog.SizeOf(b.Prog.Byte()) etSize := b.Prog.SizeOf(b.Prog.Byte())
ret.Type = src.Type ret.Type = src.Type
ret.impl = b.InlineCall(b.Func.Pkg.rtFunc("SliceAppend"), ret.impl = b.InlineCall(b.Pkg.rtFunc("SliceAppend"),
src, b.StringData(elem), b.StringLen(elem), b.Prog.Val(int(etSize))).impl src, b.StringData(elem), b.StringLen(elem), b.Prog.Val(int(etSize))).impl
return return
} }
@@ -985,7 +983,7 @@ func (b Builder) BuiltinCall(fn string, args ...Expr) (ret Expr) {
ret.Type = b.Prog.Void() ret.Type = b.Prog.Void()
for i, arg := range args { for i, arg := range args {
if ln && i > 0 { if ln && i > 0 {
b.InlineCall(b.Func.Pkg.rtFunc("PrintString"), b.Str(" ")) b.InlineCall(b.Pkg.rtFunc("PrintString"), b.Str(" "))
} }
var fn string var fn string
var typ Type var typ Type
@@ -1018,10 +1016,10 @@ func (b Builder) BuiltinCall(fn string, args ...Expr) (ret Expr) {
if typ != nil && typ != arg.Type { if typ != nil && typ != arg.Type {
arg = b.Convert(typ, arg) arg = b.Convert(typ, arg)
} }
b.InlineCall(b.Func.Pkg.rtFunc(fn), arg) b.InlineCall(b.Pkg.rtFunc(fn), arg)
} }
if ln { if ln {
b.InlineCall(b.Func.Pkg.rtFunc("PrintString"), b.Str("\n")) b.InlineCall(b.Pkg.rtFunc("PrintString"), b.Str("\n"))
} }
return return
} }

19
ssa/interface.go
View File

@@ -27,6 +27,13 @@ import (
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
// AbiBasic returns the abi type of the specified basic kind.
func (b Builder) AbiBasic(kind types.BasicKind) Expr {
return b.InlineCall(b.Pkg.rtFunc("Basic"), b.Prog.Val(int(kind)))
}
// -----------------------------------------------------------------------------
// MakeInterface constructs an instance of an interface type from a // MakeInterface constructs an instance of an interface type from a
// value of a concrete type. // value of a concrete type.
// //
@@ -47,24 +54,24 @@ func (b Builder) MakeInterface(tinter Type, x Expr) (ret Expr) {
log.Printf("MakeInterface %v, %v\n", raw, x.impl) log.Printf("MakeInterface %v, %v\n", raw, x.impl)
} }
prog := b.Prog prog := b.Prog
pkg := b.Func.Pkg pkg := b.Pkg
switch tx := x.raw.Type.Underlying().(type) { switch tx := x.raw.Type.Underlying().(type) {
case *types.Basic: case *types.Basic:
kind := tx.Kind() kind := tx.Kind()
switch { switch {
case kind >= types.Bool && kind <= types.Uintptr: case kind >= types.Bool && kind <= types.Uintptr:
t := b.InlineCall(pkg.rtFunc("Basic"), prog.Val(int(kind))) t := b.AbiBasic(kind)
tptr := prog.Uintptr() tptr := prog.Uintptr()
vptr := Expr{llvm.CreateIntCast(b.impl, x.impl, tptr.ll), tptr} vptr := Expr{llvm.CreateIntCast(b.impl, x.impl, tptr.ll), tptr}
return Expr{b.InlineCall(pkg.rtFunc("MakeAnyInt"), t, vptr).impl, tinter} return Expr{b.InlineCall(pkg.rtFunc("MakeAnyInt"), t, vptr).impl, tinter}
case kind == types.Float32: case kind == types.Float32:
t := b.InlineCall(pkg.rtFunc("Basic"), prog.Val(int(kind))) t := b.AbiBasic(kind)
tptr := prog.Uintptr() tptr := prog.Uintptr()
i32 := b.impl.CreateBitCast(x.impl, prog.tyInt32(), "") i32 := b.impl.CreateBitCast(x.impl, prog.tyInt32(), "")
vptr := Expr{llvm.CreateIntCast(b.impl, i32, tptr.ll), tptr} vptr := Expr{llvm.CreateIntCast(b.impl, i32, tptr.ll), tptr}
return Expr{b.InlineCall(pkg.rtFunc("MakeAnyInt"), t, vptr).impl, tinter} return Expr{b.InlineCall(pkg.rtFunc("MakeAnyInt"), t, vptr).impl, tinter}
case kind == types.Float64: case kind == types.Float64:
t := b.InlineCall(pkg.rtFunc("Basic"), prog.Val(int(kind))) t := b.AbiBasic(kind)
tptr := prog.Uintptr() tptr := prog.Uintptr()
vptr := Expr{b.impl.CreateBitCast(x.impl, tptr.ll, ""), tptr} vptr := Expr{b.impl.CreateBitCast(x.impl, tptr.ll, ""), tptr}
return Expr{b.InlineCall(pkg.rtFunc("MakeAnyInt"), t, vptr).impl, tinter} return Expr{b.InlineCall(pkg.rtFunc("MakeAnyInt"), t, vptr).impl, tinter}
@@ -122,7 +129,7 @@ func (b Builder) TypeAssert(x Expr, assertedTyp Type, commaOk bool) (ret Expr) {
} }
switch assertedTyp.kind { switch assertedTyp.kind {
case vkSigned, vkUnsigned, vkFloat, vkBool: case vkSigned, vkUnsigned, vkFloat, vkBool:
pkg := b.Func.Pkg pkg := b.Pkg
fnName := "I2Int" fnName := "I2Int"
if commaOk { if commaOk {
fnName = "CheckI2Int" fnName = "CheckI2Int"
@@ -167,7 +174,7 @@ func (b Builder) TypeAssert(x Expr, assertedTyp Type, commaOk bool) (ret Expr) {
} }
return return
case vkString: case vkString:
pkg := b.Func.Pkg pkg := b.Pkg
fnName := "I2String" fnName := "I2String"
if commaOk { if commaOk {
fnName = "CheckI2String" fnName = "CheckI2String"

19
ssa/package.go
View File

@@ -694,14 +694,13 @@ func (p Package) PyNewModVar(name string, doInit bool) Global {
// PyImportMod imports a Python module. // PyImportMod imports a Python module.
func (b Builder) PyImportMod(path string) Expr { func (b Builder) PyImportMod(path string) Expr {
pkg := b.Func.Pkg fnImp := b.Pkg.pyFunc("PyImport_ImportModule", b.Prog.tyImportPyModule())
fnImp := pkg.pyFunc("PyImport_ImportModule", b.Prog.tyImportPyModule())
return b.Call(fnImp, b.CStr(path)) return b.Call(fnImp, b.CStr(path))
} }
// PyLoadModSyms loads python objects from specified module. // PyLoadModSyms loads python objects from specified module.
func (b Builder) PyLoadModSyms(modName string, objs ...PyObjRef) Expr { func (b Builder) PyLoadModSyms(modName string, objs ...PyObjRef) Expr {
pkg := b.Func.Pkg pkg := b.Pkg
fnLoad := pkg.pyFunc("llgoLoadPyModSyms", b.Prog.tyLoadPyModSyms()) fnLoad := pkg.pyFunc("llgoLoadPyModSyms", b.Prog.tyLoadPyModSyms())
modPtr := pkg.PyNewModVar(modName, false).Expr modPtr := pkg.PyNewModVar(modName, false).Expr
mod := b.Load(modPtr) mod := b.Load(modPtr)
@@ -721,7 +720,7 @@ func (b Builder) PyLoadModSyms(modName string, objs ...PyObjRef) Expr {
func (b Builder) pyCall(fn Expr, args []Expr) (ret Expr) { func (b Builder) pyCall(fn Expr, args []Expr) (ret Expr) {
prog := b.Prog prog := b.Prog
pkg := b.Func.Pkg pkg := b.Pkg
fn = b.Load(fn) fn = b.Load(fn)
sig := fn.raw.Type.(*types.Signature) sig := fn.raw.Type.(*types.Signature)
params := sig.Params() params := sig.Params()
@@ -751,16 +750,14 @@ func (b Builder) pyCall(fn Expr, args []Expr) (ret Expr) {
// PyNewList(n uintptr) *Object // PyNewList(n uintptr) *Object
func (b Builder) PyNewList(n Expr) (ret Expr) { func (b Builder) PyNewList(n Expr) (ret Expr) {
prog := b.Prog prog := b.Prog
pkg := b.Func.Pkg fn := b.Pkg.pyFunc("PyList_New", prog.tyNewList())
fn := pkg.pyFunc("PyList_New", prog.tyNewList())
return b.Call(fn, n) return b.Call(fn, n)
} }
// PyListSetItem(list *Object, index uintptr, item *Object) c.Int // PyListSetItem(list *Object, index uintptr, item *Object) c.Int
func (b Builder) PyListSetItem(list, index, item Expr) (ret Expr) { func (b Builder) PyListSetItem(list, index, item Expr) (ret Expr) {
prog := b.Prog prog := b.Prog
pkg := b.Func.Pkg fn := b.Pkg.pyFunc("PyList_SetItem", prog.tyListSetItem())
fn := pkg.pyFunc("PyList_SetItem", prog.tyListSetItem())
return b.Call(fn, list, index, item) return b.Call(fn, list, index, item)
} }
@@ -793,15 +790,13 @@ func (b Builder) PyVal(v Expr) (ret Expr) {
// PyFloat(fltVal float64) *Object // PyFloat(fltVal float64) *Object
func (b Builder) PyFloat(fltVal Expr) (ret Expr) { func (b Builder) PyFloat(fltVal Expr) (ret Expr) {
prog := b.Prog fn := b.Pkg.pyFunc("PyFloat_FromDouble", b.Prog.tyFloatFromDouble())
pkg := b.Func.Pkg
fn := pkg.pyFunc("PyFloat_FromDouble", prog.tyFloatFromDouble())
return b.Call(fn, fltVal) return b.Call(fn, fltVal)
} }
// callPyInit calls Py_Initialize. // callPyInit calls Py_Initialize.
func (b Builder) callPyInit() (ret Expr) { func (b Builder) callPyInit() (ret Expr) {
fn := b.Func.Pkg.pyFunc("Py_Initialize", NoArgsNoRet) fn := b.Pkg.pyFunc("Py_Initialize", NoArgsNoRet)
return b.Call(fn) return b.Call(fn)
} }

4
ssa/stmt_builder.go
View File

@@ -52,6 +52,7 @@ func (p BasicBlock) Index() int {
type aBuilder struct { type aBuilder struct {
impl llvm.Builder impl llvm.Builder
Func Function Func Function
Pkg Package
Prog Program Prog Program
} }
@@ -124,8 +125,7 @@ func (b Builder) Panic(v Expr) {
if debugInstr { if debugInstr {
log.Printf("Panic %v\n", v.impl) log.Printf("Panic %v\n", v.impl)
} }
pkg := b.Func.Pkg b.Call(b.Pkg.rtFunc("TracePanic"), v)
b.Call(pkg.rtFunc("TracePanic"), v)
b.impl.CreateUnreachable() b.impl.CreateUnreachable()
} }