ssa: sliceOf arrayOf

ssa/abi/abi.go

@@ -121,6 +121,12 @@ func (b *Builder) TypeName(t types.Type) (ret string, pub bool) {
 		return b.StructName(t)
 	case *types.Signature:
 		return b.FuncName(t), true
+	case *types.Slice:
+		ret, pub = b.TypeName(t.Elem())
+		return "[]" + ret, pub
+	case *types.Array:
+		ret, pub = b.TypeName(t.Elem())
+		return fmt.Sprintf("[%v]%s", t.Len(), ret), pub
 	case *types.Named:
 		o := t.Obj()
 		return "_llgo_" + TypeName(o), o.Exported()

ssa/interface.go

@@ -59,6 +59,10 @@ func (b Builder) abiTypeOf(t types.Type) Expr {
 		return b.abiInterfaceOf(t)
 	case *types.Signature:
 		return b.abiFuncOf(t)
+	case *types.Slice:
+		return b.abiSliceOf(t)
+	case *types.Array:
+		return b.abiArrayOf(t)
 	}
 	panic("todo")
 }
@@ -156,6 +160,16 @@ func (b Builder) abiPointerOf(t *types.Pointer) Expr {
 	return b.Call(b.Pkg.rtFunc("PointerTo"), elem)
 }
 
+func (b Builder) abiSliceOf(t *types.Slice) Expr {
+	elem := b.abiTypeOf(t.Elem())
+	return b.Call(b.Pkg.rtFunc("SliceOf"), elem)
+}
+
+func (b Builder) abiArrayOf(t *types.Array) Expr {
+	elem := b.abiTypeOf(t.Elem())
+	return b.Call(b.Pkg.rtFunc("ArrayOf"), b.Prog.IntVal(uint64(t.Len()), b.Prog.Uintptr()), elem)
+}
+
 // func Struct(pkgPath string, size uintptr, fields []abi.StructField)
 func (b Builder) abiStructOf(t *types.Struct) Expr {
 	pkg := b.Pkg

ssa/package.go

@@ -178,7 +178,7 @@ func NewProgram(target *Target) Program {
 		target = &Target{}
 	}
 	ctx := llvm.NewContext()
-	td := llvm.NewTargetData("") // TODO(xsw): target config
+	td := target.targetData() // TODO(xsw): target config
 	/*
 		arch := target.GOARCH
 		if arch == "" {

ssa/target.go

@@ -16,6 +16,10 @@
 
 package ssa
 
+import (
+	"github.com/goplus/llvm"
+)
+
 // -----------------------------------------------------------------------------
 
 type Target struct {
@@ -24,6 +28,19 @@ type Target struct {
 	GOARM  string // "5", "6", "7" (default)
 }
 
+func (p *Target) targetData() llvm.TargetData {
+	spec := p.toSpec()
+	if spec.triple == "" {
+		spec.triple = llvm.DefaultTargetTriple()
+	}
+	t, err := llvm.GetTargetFromTriple(spec.triple)
+	if err != nil {
+		panic(err)
+	}
+	machine := t.CreateTargetMachine(spec.triple, spec.cpu, spec.features, llvm.CodeGenLevelDefault, llvm.RelocDefault, llvm.CodeModelDefault)
+	return machine.CreateTargetData()
+}
+
 /*
 func (p *Program) targetMachine() llvm.TargetMachine {
 	if p.tm.C == nil {
@@ -43,6 +60,7 @@ func (p *Program) targetMachine() llvm.TargetMachine {
 	}
 	return p.tm
 }
+*/
 
 type targetSpec struct {
 	triple   string
@@ -50,6 +68,12 @@ type targetSpec struct {
 	features string
 }
 
+// TODO config
+func (p *Target) toSpec() (spec targetSpec) {
+	return
+}
+
+/*
 func (p *Target) toSpec() (spec targetSpec) {
 	// Configure based on GOOS/GOARCH environment variables (falling back to
 	// runtime.GOOS/runtime.GOARCH), and generate a LLVM target based on it.