internal/cabi: transform pkg to cabi
This commit is contained in:
visualfc
356
internal/cabi/arch.go
Normal file
356
internal/cabi/arch.go
Normal file
@@ -0,0 +1,356 @@
|
|||||||
|
package cabi
|
||||||
|
|
||||||
|
import (
|
||||||
|
"github.com/goplus/llvm"
|
||||||
|
)
|
||||||
|
|
||||||
|
func elementTypesCount(typ llvm.Type) int {
|
||||||
|
switch typ.TypeKind() {
|
||||||
|
case llvm.VoidTypeKind:
|
||||||
|
return 0
|
||||||
|
case llvm.StructTypeKind:
|
||||||
|
var count int
|
||||||
|
for _, t := range typ.StructElementTypes() {
|
||||||
|
count += elementTypesCount(t)
|
||||||
|
}
|
||||||
|
return count
|
||||||
|
case llvm.ArrayTypeKind:
|
||||||
|
return typ.ArrayLength() * elementTypesCount(typ.ElementType())
|
||||||
|
}
|
||||||
|
return 1
|
||||||
|
}
|
||||||
|
|
||||||
|
func elementTypes(td llvm.TargetData, typ llvm.Type) (types []llvm.Type) {
|
||||||
|
switch typ.TypeKind() {
|
||||||
|
case llvm.VoidTypeKind:
|
||||||
|
case llvm.StructTypeKind:
|
||||||
|
for _, t := range typ.StructElementTypes() {
|
||||||
|
types = append(types, elementTypes(td, t)...)
|
||||||
|
}
|
||||||
|
case llvm.ArrayTypeKind:
|
||||||
|
sub := elementTypes(td, typ.ElementType())
|
||||||
|
n := typ.ArrayLength()
|
||||||
|
for i := 0; i < n; i++ {
|
||||||
|
types = append(types, sub...)
|
||||||
|
}
|
||||||
|
default:
|
||||||
|
types = append(types, typ)
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
func checkTypes(typs []llvm.Type, typ llvm.Type) bool {
|
||||||
|
for _, t := range typs {
|
||||||
|
if t != typ {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
|
func hasTypes(typs []llvm.Type, typ llvm.Type) bool {
|
||||||
|
for _, t := range typs {
|
||||||
|
if t == typ {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
type TypeInfoAmd64 struct {
|
||||||
|
*Transformer
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *TypeInfoAmd64) SupportByVal() bool {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *TypeInfoAmd64) IsWrapType(ctx llvm.Context, typ llvm.Type, bret bool) bool {
|
||||||
|
return elementTypesCount(typ) >= 2
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *TypeInfoAmd64) GetTypeInfo(ctx llvm.Context, typ llvm.Type, bret bool) *TypeInfo {
|
||||||
|
info := &TypeInfo{}
|
||||||
|
info.Type = typ
|
||||||
|
info.Type1 = typ
|
||||||
|
if typ.TypeKind() == llvm.VoidTypeKind {
|
||||||
|
info.Kind = AttrVoid
|
||||||
|
return info
|
||||||
|
} else if typ.TypeKind() == llvm.PointerTypeKind {
|
||||||
|
}
|
||||||
|
info.Size = p.Sizeof(typ)
|
||||||
|
info.Align = p.Alignof(typ)
|
||||||
|
if n := elementTypesCount(typ); n >= 2 {
|
||||||
|
if info.Size > 16 {
|
||||||
|
info.Kind = AttrPointer
|
||||||
|
info.Type1 = llvm.PointerType(typ, 0)
|
||||||
|
} else if info.Size <= 8 {
|
||||||
|
info.Kind = AttrWidthType
|
||||||
|
info.Type1 = ctx.IntType(info.Size * 8)
|
||||||
|
types := elementTypes(p.td, typ)
|
||||||
|
if types[0] == ctx.FloatType() && types[1] == ctx.FloatType() {
|
||||||
|
info.Type1 = llvm.VectorType(ctx.FloatType(), 2)
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
types := elementTypes(p.td, typ)
|
||||||
|
if n == 2 {
|
||||||
|
// skip (float32,float32)
|
||||||
|
if types[0] == ctx.FloatType() && types[1] == ctx.FloatType() {
|
||||||
|
return info
|
||||||
|
}
|
||||||
|
// skip (i64|double,*) (*,i64/double)
|
||||||
|
if p.Sizeof(types[0]) == 8 || p.Sizeof(types[1]) == 8 {
|
||||||
|
return info
|
||||||
|
}
|
||||||
|
}
|
||||||
|
info.Kind = AttrWidthType2
|
||||||
|
var count int
|
||||||
|
for i, et := range types {
|
||||||
|
count += p.Sizeof(et)
|
||||||
|
if count >= 8 {
|
||||||
|
if i == 0 {
|
||||||
|
info.Type1 = et
|
||||||
|
} else if i == 1 && types[0] == ctx.FloatType() && types[1] == ctx.FloatType() {
|
||||||
|
info.Type1 = llvm.VectorType(ctx.FloatType(), 2)
|
||||||
|
} else {
|
||||||
|
info.Type1 = ctx.Int64Type()
|
||||||
|
}
|
||||||
|
right := len(types) - i
|
||||||
|
if count == 8 {
|
||||||
|
right--
|
||||||
|
}
|
||||||
|
if right == 1 {
|
||||||
|
info.Type2 = types[len(types)-1]
|
||||||
|
} else if right == 2 && types[len(types)-1] == ctx.FloatType() && types[len(types)-2] == ctx.FloatType() {
|
||||||
|
info.Type2 = llvm.VectorType(ctx.FloatType(), 2)
|
||||||
|
} else {
|
||||||
|
info.Type2 = ctx.IntType((info.Size - 8) * 8)
|
||||||
|
}
|
||||||
|
break
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return info
|
||||||
|
}
|
||||||
|
|
||||||
|
type TypeInfoArm64 struct {
|
||||||
|
*Transformer
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *TypeInfoArm64) SupportByVal() bool {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *TypeInfoArm64) IsWrapType(ctx llvm.Context, typ llvm.Type, bret bool) bool {
|
||||||
|
switch typ.TypeKind() {
|
||||||
|
case llvm.StructTypeKind, llvm.ArrayTypeKind:
|
||||||
|
if bret && elementTypesCount(typ) == 1 {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
return true
|
||||||
|
default:
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *TypeInfoArm64) GetTypeInfo(ctx llvm.Context, typ llvm.Type, bret bool) *TypeInfo {
|
||||||
|
info := &TypeInfo{}
|
||||||
|
info.Type = typ
|
||||||
|
info.Type1 = typ
|
||||||
|
kind := typ.TypeKind()
|
||||||
|
if kind == llvm.VoidTypeKind {
|
||||||
|
info.Kind = AttrVoid
|
||||||
|
return info
|
||||||
|
}
|
||||||
|
info.Size = p.Sizeof(typ)
|
||||||
|
info.Align = p.Alignof(typ)
|
||||||
|
switch kind {
|
||||||
|
case llvm.StructTypeKind, llvm.ArrayTypeKind:
|
||||||
|
types := elementTypes(p.td, typ)
|
||||||
|
n := len(types)
|
||||||
|
if bret && n == 1 {
|
||||||
|
return info
|
||||||
|
}
|
||||||
|
if n == 2 {
|
||||||
|
// skip (i64/ptr,i64/ptr)
|
||||||
|
if (types[0].TypeKind() == llvm.PointerTypeKind || types[0] == ctx.Int64Type()) &&
|
||||||
|
(types[1].TypeKind() == llvm.PointerTypeKind || types[1] == ctx.Int64Type()) {
|
||||||
|
return info
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if n <= 4 {
|
||||||
|
if checkTypes(types, ctx.FloatType()) || checkTypes(types, ctx.DoubleType()) {
|
||||||
|
return info
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if info.Size > 16 {
|
||||||
|
info.Kind = AttrPointer
|
||||||
|
info.Type1 = llvm.PointerType(typ, 0)
|
||||||
|
} else if info.Size <= 8 {
|
||||||
|
info.Kind = AttrWidthType
|
||||||
|
if bret {
|
||||||
|
info.Type1 = ctx.IntType(info.Size * 8)
|
||||||
|
} else {
|
||||||
|
info.Type1 = ctx.Int64Type()
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
info.Kind = AttrWidthType
|
||||||
|
info.Type1 = llvm.ArrayType(ctx.Int64Type(), 2)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return info
|
||||||
|
}
|
||||||
|
|
||||||
|
type TypeInfoArm struct {
|
||||||
|
*Transformer
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *TypeInfoArm) SupportByVal() bool {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *TypeInfoArm) IsWrapType(ctx llvm.Context, typ llvm.Type, bret bool) bool {
|
||||||
|
switch typ.TypeKind() {
|
||||||
|
case llvm.StructTypeKind, llvm.ArrayTypeKind:
|
||||||
|
if bret && elementTypesCount(typ) == 1 {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
return true
|
||||||
|
default:
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *TypeInfoArm) GetTypeInfo(ctx llvm.Context, typ llvm.Type, bret bool) *TypeInfo {
|
||||||
|
info := &TypeInfo{}
|
||||||
|
info.Type = typ
|
||||||
|
info.Type1 = typ
|
||||||
|
kind := typ.TypeKind()
|
||||||
|
if kind == llvm.VoidTypeKind {
|
||||||
|
info.Kind = AttrVoid
|
||||||
|
return info
|
||||||
|
}
|
||||||
|
info.Size = p.Sizeof(typ)
|
||||||
|
info.Align = p.Alignof(typ)
|
||||||
|
switch kind {
|
||||||
|
case llvm.StructTypeKind, llvm.ArrayTypeKind:
|
||||||
|
types := elementTypes(p.td, typ)
|
||||||
|
n := len(types)
|
||||||
|
if bret && n == 1 {
|
||||||
|
return info
|
||||||
|
}
|
||||||
|
if n <= 4 {
|
||||||
|
if checkTypes(types, ctx.FloatType()) || checkTypes(types, ctx.DoubleType()) {
|
||||||
|
return info
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if bret {
|
||||||
|
if info.Size > 4 {
|
||||||
|
info.Kind = AttrPointer
|
||||||
|
info.Type1 = llvm.PointerType(typ, 0)
|
||||||
|
} else {
|
||||||
|
info.Kind = AttrWidthType
|
||||||
|
info.Type1 = ctx.Int32Type()
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
if info.Size > 64 {
|
||||||
|
info.Kind = AttrPointer
|
||||||
|
info.Type1 = llvm.PointerType(typ, 0)
|
||||||
|
} else {
|
||||||
|
info.Kind = AttrWidthType
|
||||||
|
if hasTypes(types, ctx.Int64Type()) || hasTypes(types, ctx.DoubleType()) {
|
||||||
|
info.Type1 = llvm.ArrayType(ctx.Int64Type(), info.Size/8)
|
||||||
|
} else {
|
||||||
|
info.Type1 = llvm.ArrayType(ctx.Int32Type(), info.Size/4)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return info
|
||||||
|
}
|
||||||
|
|
||||||
|
type TypeInfo32 struct {
|
||||||
|
*Transformer
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *TypeInfo32) SupportByVal() bool {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *TypeInfo32) IsWrapType(ctx llvm.Context, typ llvm.Type, bret bool) bool {
|
||||||
|
return elementTypesCount(typ) >= 2
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *TypeInfo32) GetTypeInfo(ctx llvm.Context, typ llvm.Type, bret bool) *TypeInfo {
|
||||||
|
info := &TypeInfo{}
|
||||||
|
info.Type = typ
|
||||||
|
info.Type1 = typ
|
||||||
|
if typ.TypeKind() == llvm.VoidTypeKind {
|
||||||
|
info.Kind = AttrVoid
|
||||||
|
return info
|
||||||
|
}
|
||||||
|
info.Size = p.Sizeof(typ)
|
||||||
|
info.Align = p.Alignof(typ)
|
||||||
|
if n := elementTypesCount(typ); n >= 2 {
|
||||||
|
info.Kind = AttrPointer
|
||||||
|
info.Type1 = llvm.PointerType(typ, 0)
|
||||||
|
}
|
||||||
|
return info
|
||||||
|
}
|
||||||
|
|
||||||
|
type TypeInfoRiscv64 struct {
|
||||||
|
*Transformer
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *TypeInfoRiscv64) SupportByVal() bool {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *TypeInfoRiscv64) IsWrapType(ctx llvm.Context, typ llvm.Type, bret bool) bool {
|
||||||
|
switch typ.TypeKind() {
|
||||||
|
case llvm.StructTypeKind, llvm.ArrayTypeKind:
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *TypeInfoRiscv64) GetTypeInfo(ctx llvm.Context, typ llvm.Type, bret bool) *TypeInfo {
|
||||||
|
info := &TypeInfo{}
|
||||||
|
info.Type = typ
|
||||||
|
info.Type1 = typ
|
||||||
|
if typ.TypeKind() == llvm.VoidTypeKind {
|
||||||
|
info.Kind = AttrVoid
|
||||||
|
return info
|
||||||
|
}
|
||||||
|
info.Size = p.Sizeof(typ)
|
||||||
|
info.Align = p.Alignof(typ)
|
||||||
|
switch typ.TypeKind() {
|
||||||
|
case llvm.StructTypeKind, llvm.ArrayTypeKind:
|
||||||
|
types := elementTypes(p.td, typ)
|
||||||
|
switch len(types) {
|
||||||
|
case 1:
|
||||||
|
if types[0].TypeKind() == llvm.PointerTypeKind || types[0] == ctx.Int64Type() {
|
||||||
|
return info
|
||||||
|
}
|
||||||
|
case 2:
|
||||||
|
if (types[0].TypeKind() == llvm.PointerTypeKind || types[0] == ctx.Int64Type()) &&
|
||||||
|
(types[1].TypeKind() == llvm.PointerTypeKind || types[1] == ctx.Int64Type()) {
|
||||||
|
return info
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if info.Size > 16 {
|
||||||
|
info.Kind = AttrPointer
|
||||||
|
info.Type1 = llvm.PointerType(typ, 0)
|
||||||
|
} else if info.Size <= 8 {
|
||||||
|
info.Kind = AttrWidthType
|
||||||
|
info.Type1 = ctx.Int64Type()
|
||||||
|
} else {
|
||||||
|
info.Kind = AttrWidthType
|
||||||
|
info.Type1 = llvm.ArrayType(ctx.Int64Type(), 2)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return info
|
||||||
|
}
|
||||||
545
internal/cabi/cabi.go
Normal file
545
internal/cabi/cabi.go
Normal file
@@ -0,0 +1,545 @@
|
|||||||
|
package cabi
|
||||||
|
|
||||||
|
import (
|
||||||
|
"strings"
|
||||||
|
|
||||||
|
"github.com/goplus/llgo/ssa"
|
||||||
|
"github.com/goplus/llvm"
|
||||||
|
)
|
||||||
|
|
||||||
|
type Mode int
|
||||||
|
|
||||||
|
const (
|
||||||
|
ModeNone Mode = iota
|
||||||
|
ModeCFunc
|
||||||
|
ModeAllFunc
|
||||||
|
)
|
||||||
|
|
||||||
|
func NewTransformer(prog ssa.Program, mode Mode) *Transformer {
|
||||||
|
target := prog.Target()
|
||||||
|
tr := &Transformer{
|
||||||
|
prog: prog,
|
||||||
|
td: prog.TargetData(),
|
||||||
|
GOOS: target.GOOS,
|
||||||
|
GOARCH: target.GOARCH,
|
||||||
|
mode: mode,
|
||||||
|
}
|
||||||
|
switch target.GOARCH {
|
||||||
|
case "amd64":
|
||||||
|
tr.sys = &TypeInfoAmd64{tr}
|
||||||
|
case "arm64":
|
||||||
|
tr.sys = &TypeInfoArm64{tr}
|
||||||
|
case "arm":
|
||||||
|
tr.sys = &TypeInfoArm{tr}
|
||||||
|
case "wasm", "i386":
|
||||||
|
tr.sys = &TypeInfo32{tr}
|
||||||
|
case "riscv64":
|
||||||
|
tr.sys = &TypeInfoRiscv64{tr}
|
||||||
|
}
|
||||||
|
return tr
|
||||||
|
}
|
||||||
|
|
||||||
|
type Transformer struct {
|
||||||
|
prog ssa.Program
|
||||||
|
td llvm.TargetData
|
||||||
|
GOOS string
|
||||||
|
GOARCH string
|
||||||
|
sys TypeInfoSys
|
||||||
|
mode Mode
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *Transformer) isCFunc(name string) bool {
|
||||||
|
return !strings.Contains(name, ".")
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *Transformer) TransformModule(pkg ssa.Package) {
|
||||||
|
m := pkg.Module()
|
||||||
|
ctx := m.Context()
|
||||||
|
var fns []llvm.Value
|
||||||
|
var callInstrs []llvm.Value
|
||||||
|
switch p.mode {
|
||||||
|
case ModeNone:
|
||||||
|
return
|
||||||
|
case ModeCFunc:
|
||||||
|
fn := m.FirstFunction()
|
||||||
|
for !fn.IsNil() {
|
||||||
|
if p.isCFunc(fn.Name()) {
|
||||||
|
p.transformFuncCall(m, fn)
|
||||||
|
if p.isWrapFunctionType(m.Context(), fn.GlobalValueType()) {
|
||||||
|
fns = append(fns, fn)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
fn = llvm.NextFunction(fn)
|
||||||
|
}
|
||||||
|
case ModeAllFunc:
|
||||||
|
fn := m.FirstFunction()
|
||||||
|
for !fn.IsNil() {
|
||||||
|
if p.isWrapFunctionType(ctx, fn.GlobalValueType()) {
|
||||||
|
fns = append(fns, fn)
|
||||||
|
}
|
||||||
|
bb := fn.FirstBasicBlock()
|
||||||
|
for !bb.IsNil() {
|
||||||
|
instr := bb.FirstInstruction()
|
||||||
|
for !instr.IsNil() {
|
||||||
|
if call := instr.IsACallInst(); !call.IsNil() {
|
||||||
|
if p.isWrapFunctionType(ctx, call.CalledFunctionType()) {
|
||||||
|
callInstrs = append(callInstrs, call)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
instr = llvm.NextInstruction(instr)
|
||||||
|
}
|
||||||
|
bb = llvm.NextBasicBlock(bb)
|
||||||
|
}
|
||||||
|
fn = llvm.NextFunction(fn)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
for _, call := range callInstrs {
|
||||||
|
p.transformCallInstr(ctx, call)
|
||||||
|
}
|
||||||
|
for _, fn := range fns {
|
||||||
|
p.transformFunc(m, fn)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *Transformer) isWrapFunctionType(ctx llvm.Context, ft llvm.Type) bool {
|
||||||
|
if p.IsWrapType(ctx, ft.ReturnType(), true) {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
for _, typ := range ft.ParamTypes() {
|
||||||
|
if p.IsWrapType(ctx, typ, false) {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
type TypeInfoSys interface {
|
||||||
|
SupportByVal() bool
|
||||||
|
IsWrapType(ctx llvm.Context, typ llvm.Type, bret bool) bool
|
||||||
|
GetTypeInfo(ctx llvm.Context, typ llvm.Type, bret bool) *TypeInfo
|
||||||
|
}
|
||||||
|
|
||||||
|
type AttrKind int
|
||||||
|
|
||||||
|
const (
|
||||||
|
AttrNone AttrKind = iota
|
||||||
|
AttrVoid // param type void
|
||||||
|
AttrPointer // param type => type*
|
||||||
|
AttrWidthType // type => width int i16/i24/i32/i40/i48/i56/i64 float/double
|
||||||
|
AttrWidthType2 // type => width two int {i64,i16} float/double
|
||||||
|
)
|
||||||
|
|
||||||
|
type FuncInfo struct {
|
||||||
|
Type llvm.Type // func type
|
||||||
|
Return *TypeInfo // return info
|
||||||
|
Params []*TypeInfo // params info
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *FuncInfo) HasWrap() bool {
|
||||||
|
if p.Return.Kind > AttrVoid {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
for _, t := range p.Params {
|
||||||
|
if t.Kind > AttrVoid {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
type TypeInfo struct {
|
||||||
|
Type llvm.Type
|
||||||
|
Kind AttrKind
|
||||||
|
Type1 llvm.Type // AttrWidthType
|
||||||
|
Type2 llvm.Type // AttrWidthType2
|
||||||
|
Size int
|
||||||
|
Align int
|
||||||
|
}
|
||||||
|
|
||||||
|
func byvalAttribute(ctx llvm.Context, typ llvm.Type) llvm.Attribute {
|
||||||
|
id := llvm.AttributeKindID("byval")
|
||||||
|
return ctx.CreateTypeAttribute(id, typ)
|
||||||
|
}
|
||||||
|
|
||||||
|
func sretAttribute(ctx llvm.Context, typ llvm.Type) llvm.Attribute {
|
||||||
|
id := llvm.AttributeKindID("sret")
|
||||||
|
return ctx.CreateTypeAttribute(id, typ)
|
||||||
|
}
|
||||||
|
|
||||||
|
func funcInlineHint(ctx llvm.Context) llvm.Attribute {
|
||||||
|
return ctx.CreateEnumAttribute(llvm.AttributeKindID("inlinehint"), 0)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *Transformer) IsWrapType(ctx llvm.Context, typ llvm.Type, bret bool) bool {
|
||||||
|
if p.sys != nil {
|
||||||
|
return p.sys.IsWrapType(ctx, typ, bret)
|
||||||
|
}
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *Transformer) GetTypeInfo(ctx llvm.Context, typ llvm.Type, bret bool) *TypeInfo {
|
||||||
|
if p.sys != nil {
|
||||||
|
return p.sys.GetTypeInfo(ctx, typ, bret)
|
||||||
|
}
|
||||||
|
panic("not implment: " + p.GOARCH)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *Transformer) Sizeof(typ llvm.Type) int {
|
||||||
|
return int(p.td.TypeAllocSize(typ))
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *Transformer) Alignof(typ llvm.Type) int {
|
||||||
|
return int(p.td.ABITypeAlignment(typ))
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *Transformer) GetFuncInfo(ctx llvm.Context, typ llvm.Type) (info FuncInfo) {
|
||||||
|
info.Type = typ
|
||||||
|
info.Return = p.GetTypeInfo(ctx, typ.ReturnType(), true)
|
||||||
|
params := typ.ParamTypes()
|
||||||
|
info.Params = make([]*TypeInfo, len(params))
|
||||||
|
for i, t := range params {
|
||||||
|
info.Params[i] = p.GetTypeInfo(ctx, t, false)
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *Transformer) transformFuncType(ctx llvm.Context, info *FuncInfo) (llvm.Type, map[int]llvm.Attribute) {
|
||||||
|
var paramTypes []llvm.Type
|
||||||
|
var returnType llvm.Type
|
||||||
|
attrs := make(map[int]llvm.Attribute)
|
||||||
|
switch info.Return.Kind {
|
||||||
|
case AttrPointer:
|
||||||
|
returnType = ctx.VoidType()
|
||||||
|
paramTypes = append(paramTypes, info.Return.Type1)
|
||||||
|
attrs[1] = sretAttribute(ctx, info.Return.Type)
|
||||||
|
case AttrWidthType:
|
||||||
|
returnType = info.Return.Type1
|
||||||
|
case AttrWidthType2:
|
||||||
|
returnType = llvm.StructType([]llvm.Type{info.Return.Type1, info.Return.Type2}, false)
|
||||||
|
default:
|
||||||
|
returnType = info.Return.Type1
|
||||||
|
}
|
||||||
|
|
||||||
|
for _, ti := range info.Params {
|
||||||
|
switch ti.Kind {
|
||||||
|
case AttrNone, AttrWidthType:
|
||||||
|
paramTypes = append(paramTypes, ti.Type1)
|
||||||
|
case AttrPointer:
|
||||||
|
paramTypes = append(paramTypes, ti.Type1)
|
||||||
|
if p.sys.SupportByVal() {
|
||||||
|
attrs[len(paramTypes)] = byvalAttribute(ctx, ti.Type)
|
||||||
|
}
|
||||||
|
case AttrWidthType2:
|
||||||
|
paramTypes = append(paramTypes, ti.Type1, ti.Type2)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return llvm.FunctionType(returnType, paramTypes, info.Type.IsFunctionVarArg()), attrs
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *Transformer) transformFunc(m llvm.Module, fn llvm.Value) bool {
|
||||||
|
ctx := m.Context()
|
||||||
|
info := p.GetFuncInfo(ctx, fn.GlobalValueType())
|
||||||
|
if !info.HasWrap() {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
nft, attrs := p.transformFuncType(ctx, &info)
|
||||||
|
fname := fn.Name()
|
||||||
|
fn.SetName("")
|
||||||
|
nfn := llvm.AddFunction(m, fname, nft)
|
||||||
|
for i, attr := range attrs {
|
||||||
|
nfn.AddAttributeAtIndex(i, attr)
|
||||||
|
}
|
||||||
|
nfn.SetLinkage(fn.Linkage())
|
||||||
|
nfn.SetFunctionCallConv(fn.FunctionCallConv())
|
||||||
|
for _, attr := range fn.GetFunctionAttributes() {
|
||||||
|
nfn.AddAttributeAtIndex(-1, attr)
|
||||||
|
}
|
||||||
|
if sp := fn.Subprogram(); !sp.IsNil() {
|
||||||
|
nfn.SetSubprogram(sp)
|
||||||
|
}
|
||||||
|
|
||||||
|
if !fn.IsDeclaration() {
|
||||||
|
p.transformFuncBody(ctx, &info, fn, nfn, nft)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn.ReplaceAllUsesWith(nfn)
|
||||||
|
fn.EraseFromParentAsFunction()
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *Transformer) transformFuncBody(ctx llvm.Context, info *FuncInfo, fn llvm.Value, nfn llvm.Value, nft llvm.Type) {
|
||||||
|
var blocks []llvm.BasicBlock
|
||||||
|
bb := fn.FirstBasicBlock()
|
||||||
|
for !bb.IsNil() {
|
||||||
|
blocks = append(blocks, bb)
|
||||||
|
bb = llvm.NextBasicBlock(bb)
|
||||||
|
}
|
||||||
|
for _, bb := range blocks {
|
||||||
|
bb.RemoveFromParent()
|
||||||
|
llvm.AppendExistingBasicBlock(nfn, bb)
|
||||||
|
}
|
||||||
|
|
||||||
|
b := ctx.NewBuilder()
|
||||||
|
b.SetInsertPointBefore(nfn.EntryBasicBlock().FirstInstruction())
|
||||||
|
|
||||||
|
params := nfn.Params()
|
||||||
|
index := 0
|
||||||
|
if info.Return.Kind == AttrPointer {
|
||||||
|
index++
|
||||||
|
}
|
||||||
|
for i, ti := range info.Params {
|
||||||
|
nv := params[index]
|
||||||
|
switch ti.Kind {
|
||||||
|
default:
|
||||||
|
case AttrPointer:
|
||||||
|
nv = b.CreateLoad(ti.Type, params[index], "")
|
||||||
|
case AttrWidthType:
|
||||||
|
iptr := llvm.CreateAlloca(b, ti.Type1)
|
||||||
|
b.CreateStore(params[index], iptr)
|
||||||
|
ptr := b.CreateBitCast(iptr, llvm.PointerType(ti.Type, 0), "")
|
||||||
|
nv = b.CreateLoad(ti.Type, ptr, "")
|
||||||
|
case AttrWidthType2:
|
||||||
|
typ := llvm.StructType([]llvm.Type{ti.Type1, ti.Type2}, false)
|
||||||
|
iptr := llvm.CreateAlloca(b, typ)
|
||||||
|
b.CreateStore(params[index], b.CreateStructGEP(typ, iptr, 0, ""))
|
||||||
|
index++
|
||||||
|
b.CreateStore(params[index], b.CreateStructGEP(typ, iptr, 1, ""))
|
||||||
|
ptr := b.CreateBitCast(iptr, llvm.PointerType(ti.Type, 0), "")
|
||||||
|
nv = b.CreateLoad(ti.Type, ptr, "")
|
||||||
|
}
|
||||||
|
fn.Param(i).ReplaceAllUsesWith(nv)
|
||||||
|
index++
|
||||||
|
}
|
||||||
|
if info.Return.Kind >= AttrPointer {
|
||||||
|
var retInstrs []llvm.Value
|
||||||
|
bb := nfn.FirstBasicBlock()
|
||||||
|
for !bb.IsNil() {
|
||||||
|
instr := bb.FirstInstruction()
|
||||||
|
for !instr.IsNil() {
|
||||||
|
if !instr.IsAReturnInst().IsNil() {
|
||||||
|
retInstrs = append(retInstrs, instr)
|
||||||
|
}
|
||||||
|
instr = llvm.NextInstruction(instr)
|
||||||
|
}
|
||||||
|
bb = llvm.NextBasicBlock(bb)
|
||||||
|
}
|
||||||
|
for _, instr := range retInstrs {
|
||||||
|
ret := instr.Operand(0)
|
||||||
|
b.SetInsertPointBefore(instr)
|
||||||
|
var rv llvm.Value
|
||||||
|
switch info.Return.Kind {
|
||||||
|
case AttrPointer:
|
||||||
|
b.CreateStore(ret, params[0])
|
||||||
|
rv = b.CreateRetVoid()
|
||||||
|
case AttrWidthType, AttrWidthType2:
|
||||||
|
ptr := llvm.CreateAlloca(b, info.Return.Type)
|
||||||
|
b.CreateStore(ret, ptr)
|
||||||
|
iptr := b.CreateBitCast(ptr, llvm.PointerType(nft.ReturnType(), 0), "")
|
||||||
|
rv = b.CreateRet(b.CreateLoad(nft.ReturnType(), iptr, ""))
|
||||||
|
}
|
||||||
|
instr.ReplaceAllUsesWith(rv)
|
||||||
|
instr.EraseFromParentAsInstruction()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *Transformer) transformCallInstr(ctx llvm.Context, call llvm.Value) bool {
|
||||||
|
nfn := call.CalledValue()
|
||||||
|
info := p.GetFuncInfo(ctx, call.CalledFunctionType())
|
||||||
|
if !info.HasWrap() {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
nft, attrs := p.transformFuncType(ctx, &info)
|
||||||
|
b := ctx.NewBuilder()
|
||||||
|
b.SetInsertPointBefore(call)
|
||||||
|
operandCount := len(info.Params)
|
||||||
|
var nparams []llvm.Value
|
||||||
|
for i := 0; i < operandCount; i++ {
|
||||||
|
param := call.Operand(i)
|
||||||
|
ti := info.Params[i]
|
||||||
|
switch ti.Kind {
|
||||||
|
default:
|
||||||
|
nparams = append(nparams, param)
|
||||||
|
case AttrPointer:
|
||||||
|
ptr := llvm.CreateAlloca(b, ti.Type)
|
||||||
|
b.CreateStore(param, ptr)
|
||||||
|
nparams = append(nparams, ptr)
|
||||||
|
case AttrWidthType:
|
||||||
|
ptr := llvm.CreateAlloca(b, ti.Type)
|
||||||
|
b.CreateStore(param, ptr)
|
||||||
|
iptr := b.CreateBitCast(ptr, llvm.PointerType(ti.Type1, 0), "")
|
||||||
|
nparams = append(nparams, b.CreateLoad(ti.Type1, iptr, ""))
|
||||||
|
case AttrWidthType2:
|
||||||
|
ptr := llvm.CreateAlloca(b, ti.Type)
|
||||||
|
b.CreateStore(param, ptr)
|
||||||
|
typ := llvm.StructType([]llvm.Type{ti.Type1, ti.Type2}, false) // {i8,i64}
|
||||||
|
iptr := b.CreateBitCast(ptr, llvm.PointerType(typ, 0), "")
|
||||||
|
nparams = append(nparams, b.CreateLoad(ti.Type1, b.CreateStructGEP(typ, iptr, 0, ""), ""))
|
||||||
|
nparams = append(nparams, b.CreateLoad(ti.Type2, b.CreateStructGEP(typ, iptr, 1, ""), ""))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
updateCallAttr := func(call llvm.Value) {
|
||||||
|
for i, attr := range attrs {
|
||||||
|
call.AddCallSiteAttribute(i, attr)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
var instr llvm.Value
|
||||||
|
switch info.Return.Kind {
|
||||||
|
case AttrVoid:
|
||||||
|
instr = llvm.CreateCall(b, nft, nfn, nparams)
|
||||||
|
updateCallAttr(instr)
|
||||||
|
case AttrPointer:
|
||||||
|
ret := llvm.CreateAlloca(b, info.Return.Type)
|
||||||
|
call := llvm.CreateCall(b, nft, nfn, append([]llvm.Value{ret}, nparams...))
|
||||||
|
updateCallAttr(call)
|
||||||
|
instr = b.CreateLoad(info.Return.Type, ret, "")
|
||||||
|
case AttrWidthType, AttrWidthType2:
|
||||||
|
ret := llvm.CreateCall(b, nft, nfn, nparams)
|
||||||
|
updateCallAttr(ret)
|
||||||
|
ptr := llvm.CreateAlloca(b, nft.ReturnType())
|
||||||
|
b.CreateStore(ret, ptr)
|
||||||
|
pret := b.CreateBitCast(ptr, llvm.PointerType(info.Return.Type, 0), "")
|
||||||
|
instr = b.CreateLoad(info.Return.Type, pret, "")
|
||||||
|
default:
|
||||||
|
instr = llvm.CreateCall(b, nft, nfn, nparams)
|
||||||
|
updateCallAttr(instr)
|
||||||
|
}
|
||||||
|
call.ReplaceAllUsesWith(instr)
|
||||||
|
call.RemoveFromParentAsInstruction()
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *Transformer) transformFuncCall(m llvm.Module, fn llvm.Value) {
|
||||||
|
u := fn.FirstUse()
|
||||||
|
ctx := m.Context()
|
||||||
|
for !u.IsNil() {
|
||||||
|
if call := u.User().IsACallInst(); !call.IsNil() {
|
||||||
|
n := call.OperandsCount()
|
||||||
|
for i := 0; i < n; i++ {
|
||||||
|
op := call.Operand(i)
|
||||||
|
if op == fn {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if gv := op.IsAGlobalValue(); !gv.IsNil() {
|
||||||
|
if ft := gv.GlobalValueType(); ft.TypeKind() == llvm.FunctionTypeKind {
|
||||||
|
if p.isCFunc(gv.Name()) {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if p.isWrapFunctionType(ctx, ft) {
|
||||||
|
if wrap, ok := p.transformCallbackFunc(m, gv); ok {
|
||||||
|
call.SetOperand(i, wrap)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
u = u.NextUse()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *Transformer) transformCallbackFunc(m llvm.Module, fn llvm.Value) (wrap llvm.Value, ok bool) {
|
||||||
|
var paramTypes []llvm.Type
|
||||||
|
var returnType llvm.Type
|
||||||
|
attrs := make(map[int]llvm.Attribute)
|
||||||
|
ctx := m.Context()
|
||||||
|
info := p.GetFuncInfo(ctx, fn.GlobalValueType())
|
||||||
|
if !info.HasWrap() {
|
||||||
|
return fn, false
|
||||||
|
}
|
||||||
|
|
||||||
|
switch info.Return.Kind {
|
||||||
|
case AttrPointer:
|
||||||
|
returnType = ctx.VoidType()
|
||||||
|
paramTypes = append(paramTypes, info.Return.Type1)
|
||||||
|
attrs[1] = sretAttribute(ctx, info.Return.Type)
|
||||||
|
case AttrWidthType:
|
||||||
|
returnType = info.Return.Type1
|
||||||
|
case AttrWidthType2:
|
||||||
|
returnType = llvm.StructType([]llvm.Type{info.Return.Type1, info.Return.Type2}, false)
|
||||||
|
default:
|
||||||
|
returnType = info.Return.Type1
|
||||||
|
}
|
||||||
|
|
||||||
|
for _, ti := range info.Params {
|
||||||
|
switch ti.Kind {
|
||||||
|
case AttrNone, AttrWidthType:
|
||||||
|
paramTypes = append(paramTypes, ti.Type1)
|
||||||
|
case AttrPointer:
|
||||||
|
paramTypes = append(paramTypes, ti.Type1)
|
||||||
|
if p.sys.SupportByVal() {
|
||||||
|
attrs[len(paramTypes)] = byvalAttribute(ctx, ti.Type)
|
||||||
|
}
|
||||||
|
case AttrWidthType2:
|
||||||
|
paramTypes = append(paramTypes, ti.Type1, ti.Type2)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fname := fn.Name()
|
||||||
|
nft := llvm.FunctionType(returnType, paramTypes, info.Type.IsFunctionVarArg())
|
||||||
|
wrapName := "__llgo_cdecl$" + fname
|
||||||
|
if wrapFunc := m.NamedFunction(wrapName); !wrapFunc.IsNil() {
|
||||||
|
return wrapFunc, true
|
||||||
|
}
|
||||||
|
wrapFunc := llvm.AddFunction(m, wrapName, nft)
|
||||||
|
wrapFunc.SetLinkage(llvm.LinkOnceAnyLinkage)
|
||||||
|
wrapFunc.AddFunctionAttr(funcInlineHint(ctx))
|
||||||
|
|
||||||
|
for i, attr := range attrs {
|
||||||
|
wrapFunc.AddAttributeAtIndex(i, attr)
|
||||||
|
}
|
||||||
|
|
||||||
|
b := ctx.NewBuilder()
|
||||||
|
block := llvm.AddBasicBlock(wrapFunc, "entry")
|
||||||
|
b.SetInsertPointAtEnd(block)
|
||||||
|
|
||||||
|
var nparams []llvm.Value
|
||||||
|
params := wrapFunc.Params()
|
||||||
|
index := 0
|
||||||
|
if info.Return.Kind == AttrPointer {
|
||||||
|
index++
|
||||||
|
}
|
||||||
|
for _, ti := range info.Params {
|
||||||
|
switch ti.Kind {
|
||||||
|
default:
|
||||||
|
case AttrPointer:
|
||||||
|
nparams = append(nparams, b.CreateLoad(ti.Type, params[index], ""))
|
||||||
|
case AttrWidthType:
|
||||||
|
iptr := llvm.CreateAlloca(b, ti.Type1)
|
||||||
|
b.CreateStore(params[index], iptr)
|
||||||
|
ptr := b.CreateBitCast(iptr, llvm.PointerType(ti.Type, 0), "")
|
||||||
|
nparams = append(nparams, b.CreateLoad(ti.Type, ptr, ""))
|
||||||
|
case AttrWidthType2:
|
||||||
|
typ := llvm.StructType([]llvm.Type{ti.Type1, ti.Type2}, false)
|
||||||
|
iptr := llvm.CreateAlloca(b, typ)
|
||||||
|
b.CreateStore(params[index], b.CreateStructGEP(typ, iptr, 0, ""))
|
||||||
|
index++
|
||||||
|
b.CreateStore(params[index], b.CreateStructGEP(typ, iptr, 1, ""))
|
||||||
|
ptr := b.CreateBitCast(iptr, llvm.PointerType(ti.Type, 0), "")
|
||||||
|
nparams = append(nparams, b.CreateLoad(ti.Type, ptr, ""))
|
||||||
|
}
|
||||||
|
index++
|
||||||
|
}
|
||||||
|
|
||||||
|
switch info.Return.Kind {
|
||||||
|
case AttrVoid:
|
||||||
|
llvm.CreateCall(b, info.Type, fn, nparams)
|
||||||
|
b.CreateRetVoid()
|
||||||
|
case AttrPointer:
|
||||||
|
ret := llvm.CreateCall(b, info.Type, fn, nparams)
|
||||||
|
b.CreateStore(ret, params[0])
|
||||||
|
b.CreateRetVoid()
|
||||||
|
case AttrWidthType, AttrWidthType2:
|
||||||
|
ret := llvm.CreateCall(b, info.Type, fn, nparams)
|
||||||
|
ptr := llvm.CreateAlloca(b, info.Return.Type)
|
||||||
|
b.CreateStore(ret, ptr)
|
||||||
|
iptr := b.CreateBitCast(ptr, llvm.PointerType(returnType, 0), "")
|
||||||
|
b.CreateRet(b.CreateLoad(returnType, iptr, ""))
|
||||||
|
default:
|
||||||
|
ret := llvm.CreateCall(b, info.Type, fn, nparams)
|
||||||
|
b.CreateRet(ret)
|
||||||
|
}
|
||||||
|
return wrapFunc, true
|
||||||
|
}
|
||||||
Reference in New Issue
Block a user