654 lines
15 KiB
Go
654 lines
15 KiB
Go
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
|
|
}
|
|
|
|
func hasTypesKind(typs []llvm.Type, kind llvm.TypeKind) bool {
|
|
for _, t := range typs {
|
|
if t.TypeKind() == kind {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
type TypeInfoAmd64 struct {
|
|
*Transformer
|
|
}
|
|
|
|
func (p *TypeInfoAmd64) SupportByVal() bool {
|
|
return true
|
|
}
|
|
|
|
func (p *TypeInfoAmd64) SkipEmptyParams() bool {
|
|
return true
|
|
}
|
|
|
|
func (p *TypeInfoAmd64) IsWrapType(ctx llvm.Context, ftyp llvm.Type, typ llvm.Type, index int) bool {
|
|
return elementTypesCount(typ) >= 2
|
|
}
|
|
|
|
func (p *TypeInfoAmd64) GetTypeInfo(ctx llvm.Context, ftyp llvm.Type, typ llvm.Type, index int) *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 {
|
|
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 (i64|double,*) (*,i64/double)
|
|
if p.Sizeof(types[0]) == 8 || p.Sizeof(types[1]) == 8 {
|
|
info.Kind = AttrWidthType2
|
|
info.Type1 = types[0]
|
|
info.Type2 = types[1]
|
|
return info
|
|
}
|
|
}
|
|
var offset int
|
|
var index int
|
|
for i, et := range types {
|
|
align := p.Alignof(et)
|
|
offset = (offset + p.Sizeof(et) + align - 1) &^ (align - 1)
|
|
if offset < 8 {
|
|
continue
|
|
} else if offset > 8 {
|
|
index = i
|
|
} else {
|
|
index = i + 1
|
|
}
|
|
break
|
|
}
|
|
subType := func(subs []llvm.Type, left bool) llvm.Type {
|
|
if len(subs) == 1 {
|
|
return subs[0]
|
|
} else if len(subs) == 2 && subs[0] == ctx.FloatType() && subs[1] == ctx.FloatType() {
|
|
return llvm.VectorType(ctx.FloatType(), 2)
|
|
}
|
|
if left {
|
|
return ctx.Int64Type()
|
|
}
|
|
var n int
|
|
for _, sub := range subs {
|
|
align := p.Alignof(sub)
|
|
n = (n + p.Sizeof(sub) + align - 1) &^ (align - 1)
|
|
}
|
|
n = (n + info.Align - 1) &^ (info.Align - 1)
|
|
return ctx.IntType(n * 8)
|
|
}
|
|
info.Kind = AttrWidthType2
|
|
info.Type1 = subType(types[0:index], true)
|
|
info.Type2 = subType(types[index:], false)
|
|
}
|
|
}
|
|
return info
|
|
}
|
|
|
|
type TypeInfoArm64 struct {
|
|
*Transformer
|
|
}
|
|
|
|
func (p *TypeInfoArm64) SupportByVal() bool {
|
|
return false
|
|
}
|
|
|
|
func (p *TypeInfoArm64) SkipEmptyParams() bool {
|
|
return true
|
|
}
|
|
|
|
func (p *TypeInfoArm64) IsWrapType(ctx llvm.Context, ftyp llvm.Type, typ llvm.Type, index int) bool {
|
|
bret := index == 0
|
|
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, ftyp llvm.Type, typ llvm.Type, index int) *TypeInfo {
|
|
bret := index == 0
|
|
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) SkipEmptyParams() bool {
|
|
return true
|
|
}
|
|
|
|
func (p *TypeInfoArm) IsWrapType(ctx llvm.Context, ftyp llvm.Type, typ llvm.Type, index int) bool {
|
|
switch typ.TypeKind() {
|
|
case llvm.StructTypeKind, llvm.ArrayTypeKind:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func (p *TypeInfoArm) GetTypeInfo(ctx llvm.Context, ftyp llvm.Type, typ llvm.Type, index int) *TypeInfo {
|
|
bret := index == 0
|
|
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 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.IntType(info.Size * 8)
|
|
}
|
|
} 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()) {
|
|
size := (info.Size + 7) &^ 7
|
|
info.Type1 = llvm.ArrayType(ctx.Int64Type(), size/8)
|
|
} else {
|
|
size := (info.Size + 3) &^ 3
|
|
info.Type1 = llvm.ArrayType(ctx.Int32Type(), size/4)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return info
|
|
}
|
|
|
|
type TypeInfoWasm struct {
|
|
*Transformer
|
|
}
|
|
|
|
func (p *TypeInfoWasm) SupportByVal() bool {
|
|
return true
|
|
}
|
|
|
|
func (p *TypeInfoWasm) SkipEmptyParams() bool {
|
|
return true
|
|
}
|
|
|
|
func (p *TypeInfoWasm) IsWrapType(ctx llvm.Context, ftyp llvm.Type, typ llvm.Type, index int) bool {
|
|
return elementTypesCount(typ) >= 2
|
|
}
|
|
|
|
func (p *TypeInfoWasm) GetTypeInfo(ctx llvm.Context, ftyp llvm.Type, typ llvm.Type, index int) *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
|
|
mabi string
|
|
}
|
|
|
|
func (p *TypeInfoRiscv64) SupportByVal() bool {
|
|
return false
|
|
}
|
|
|
|
func (p *TypeInfoRiscv64) SkipEmptyParams() bool {
|
|
return true
|
|
}
|
|
|
|
func (p *TypeInfoRiscv64) IsWrapType(ctx llvm.Context, ftyp llvm.Type, typ llvm.Type, index int) bool {
|
|
switch typ.TypeKind() {
|
|
case llvm.StructTypeKind, llvm.ArrayTypeKind:
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (p *TypeInfoRiscv64) GetTypeInfo(ctx llvm.Context, ftyp llvm.Type, typ llvm.Type, index int) *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
|
|
}
|
|
switch p.mabi {
|
|
case MABI_LP64F, MABI_LP64D:
|
|
if types[0] == ctx.FloatType() {
|
|
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
|
|
}
|
|
switch p.mabi {
|
|
case MABI_LP64F:
|
|
if hasTypes(types, ctx.FloatType()) && !hasTypes(types, ctx.DoubleType()) && !hasTypesKind(types, llvm.PointerTypeKind) {
|
|
info.Kind = AttrWidthType2
|
|
info.Type1 = types[0]
|
|
info.Type2 = types[1]
|
|
return info
|
|
}
|
|
case MABI_LP64D:
|
|
if (hasTypes(types, ctx.FloatType()) || hasTypes(types, ctx.DoubleType())) && !hasTypesKind(types, llvm.PointerTypeKind) {
|
|
info.Kind = AttrWidthType2
|
|
info.Type1 = types[0]
|
|
info.Type2 = types[1]
|
|
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
|
|
}
|
|
|
|
const (
|
|
MABI_LP64 = "lp64"
|
|
MABI_LP64F = "lp64f"
|
|
MABI_LP64D = "lp64d"
|
|
)
|
|
|
|
const (
|
|
MABI_ILP32 = "ilp32"
|
|
MABI_ILP32F = "ilp32f"
|
|
MABI_ILP32D = "ilp32d"
|
|
)
|
|
|
|
type TypeInfoRiscv32 struct {
|
|
*Transformer
|
|
mabi string
|
|
}
|
|
|
|
func (p *TypeInfoRiscv32) SupportByVal() bool {
|
|
return false
|
|
}
|
|
|
|
func (p *TypeInfoRiscv32) SkipEmptyParams() bool {
|
|
return true
|
|
}
|
|
|
|
func (p *TypeInfoRiscv32) IsWrapType(ctx llvm.Context, ftyp llvm.Type, typ llvm.Type, index int) bool {
|
|
switch typ.TypeKind() {
|
|
case llvm.StructTypeKind, llvm.ArrayTypeKind:
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (p *TypeInfoRiscv32) GetTypeInfo(ctx llvm.Context, ftyp llvm.Type, typ llvm.Type, index int) *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] == ctx.Int64Type() {
|
|
return info
|
|
}
|
|
if types[0] == ctx.DoubleType() {
|
|
info.Kind = AttrWidthType
|
|
info.Type1 = ctx.Int64Type()
|
|
return info
|
|
}
|
|
case 2:
|
|
switch p.mabi {
|
|
case MABI_ILP32F:
|
|
if info.Align != 8 && hasTypes(types, ctx.FloatType()) && !hasTypesKind(types, llvm.PointerTypeKind) {
|
|
info.Kind = AttrWidthType2
|
|
info.Type1 = types[0]
|
|
info.Type2 = types[1]
|
|
return info
|
|
}
|
|
case MABI_ILP32D:
|
|
if (hasTypes(types, ctx.FloatType()) || hasTypes(types, ctx.DoubleType())) &&
|
|
!hasTypesKind(types, llvm.PointerTypeKind) && !hasTypes(types, ctx.Int64Type()) {
|
|
info.Kind = AttrWidthType2
|
|
info.Type1 = types[0]
|
|
info.Type2 = types[1]
|
|
return info
|
|
}
|
|
}
|
|
}
|
|
if info.Size > 8 {
|
|
info.Kind = AttrPointer
|
|
info.Type1 = llvm.PointerType(typ, 0)
|
|
} else if info.Size <= 4 {
|
|
info.Kind = AttrWidthType
|
|
info.Type1 = ctx.Int32Type()
|
|
} else {
|
|
info.Kind = AttrWidthType
|
|
info.Type1 = llvm.ArrayType(ctx.Int32Type(), 2)
|
|
}
|
|
}
|
|
return info
|
|
}
|
|
|
|
type TypeInfo386 struct {
|
|
*Transformer
|
|
}
|
|
|
|
func (p *TypeInfo386) SupportByVal() bool {
|
|
return true
|
|
}
|
|
|
|
func (p *TypeInfo386) SkipEmptyParams() bool {
|
|
return false
|
|
}
|
|
|
|
func (p *TypeInfo386) IsWrapType(ctx llvm.Context, ftyp llvm.Type, typ llvm.Type, index int) bool {
|
|
switch typ.TypeKind() {
|
|
case llvm.ArrayTypeKind, llvm.StructTypeKind:
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (p *TypeInfo386) GetTypeInfo(ctx llvm.Context, ftyp llvm.Type, typ llvm.Type, index int) *TypeInfo {
|
|
bret := index == 0
|
|
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 info.Size == 0 {
|
|
if bret {
|
|
return info
|
|
}
|
|
if index == 1 {
|
|
info.Kind = AttrPointer
|
|
info.Type1 = llvm.PointerType(typ, 0)
|
|
return info
|
|
}
|
|
info.Kind = AttrVoid
|
|
info.Type1 = ctx.VoidType()
|
|
return info
|
|
}
|
|
switch typ.TypeKind() {
|
|
case llvm.StructTypeKind:
|
|
if !bret && info.Size <= 16 {
|
|
var extract bool
|
|
subs := typ.StructElementTypes()
|
|
loop:
|
|
for _, sub := range subs {
|
|
switch sub.TypeKind() {
|
|
case llvm.FloatTypeKind, llvm.DoubleTypeKind, llvm.PointerTypeKind:
|
|
extract = true
|
|
case llvm.IntegerTypeKind:
|
|
if width := sub.IntTypeWidth(); width == 32 || width == 64 {
|
|
extract = true
|
|
} else {
|
|
extract = false
|
|
break loop
|
|
}
|
|
default:
|
|
extract = false
|
|
break loop
|
|
}
|
|
}
|
|
if extract {
|
|
if len(subs) == 1 {
|
|
info.Kind = AttrWidthType
|
|
info.Type1 = subs[0]
|
|
} else {
|
|
info.Kind = AttrExtract
|
|
}
|
|
return info
|
|
}
|
|
}
|
|
info.Kind = AttrPointer
|
|
info.Type1 = llvm.PointerType(typ, 0)
|
|
case llvm.ArrayTypeKind:
|
|
info.Kind = AttrPointer
|
|
info.Type1 = llvm.PointerType(typ, 0)
|
|
}
|
|
return info
|
|
}
|
|
|
|
type TypeInfoEsp32 struct {
|
|
*Transformer
|
|
}
|
|
|
|
func (p *TypeInfoEsp32) SupportByVal() bool {
|
|
return true
|
|
}
|
|
|
|
func (p *TypeInfoEsp32) SkipEmptyParams() bool {
|
|
return false
|
|
}
|
|
|
|
func (p *TypeInfoEsp32) IsWrapType(ctx llvm.Context, ftyp llvm.Type, typ llvm.Type, index int) bool {
|
|
switch typ.TypeKind() {
|
|
case llvm.ArrayTypeKind, llvm.StructTypeKind:
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (p *TypeInfoEsp32) GetTypeInfo(ctx llvm.Context, ftyp llvm.Type, typ llvm.Type, index int) *TypeInfo {
|
|
bret := index == 0
|
|
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 info.Size == 0 {
|
|
if bret {
|
|
return info
|
|
}
|
|
if index == 1 {
|
|
info.Kind = AttrPointer
|
|
info.Type1 = llvm.PointerType(typ, 0)
|
|
return info
|
|
}
|
|
info.Kind = AttrVoid
|
|
info.Type1 = ctx.VoidType()
|
|
return info
|
|
}
|
|
switch typ.TypeKind() {
|
|
case llvm.StructTypeKind, llvm.ArrayTypeKind:
|
|
types := elementTypes(p.td, typ)
|
|
if (bret && (info.Size > 16 ||
|
|
(info.Size <= 4 && info.Align < 4) || (info.Size < 8 && info.Align >= 4))) ||
|
|
(info.Size > 24) {
|
|
info.Kind = AttrPointer
|
|
info.Type1 = llvm.PointerType(typ, 0)
|
|
return info
|
|
}
|
|
info.Kind = AttrWidthType
|
|
if hasTypes(types, ctx.Int64Type()) || hasTypes(types, ctx.DoubleType()) {
|
|
size := (info.Size + 7) &^ 7
|
|
info.Type1 = llvm.ArrayType(ctx.Int64Type(), size/8)
|
|
} else {
|
|
size := (info.Size + 3) &^ 3
|
|
info.Type1 = llvm.ArrayType(ctx.Int32Type(), size/4)
|
|
}
|
|
}
|
|
return info
|
|
}
|