func TestMMXString(t *testing.T) {
const want = "x86_mmx"
typ := types.NewMMX()
got := typ.String()
if got != want {
t.Fatalf("expected %v, got %v", want, got)
}
}
func init() {
var err error
// Void type.
// void
voidTyp = types.NewVoid()
// Integer types.
// i1
i1Typ, err = types.NewInt(1)
if err != nil {
log.Fatalln(err)
}
// i8
i8Typ, err = types.NewInt(8)
if err != nil {
log.Fatalln(err)
}
// i32
i32Typ, err = types.NewInt(32)
if err != nil {
log.Fatalln(err)
}
// i64
i64Typ, err = types.NewInt(64)
if err != nil {
log.Fatalln(err)
}
// Floating point types.
// half
f16Typ, err = types.NewFloat(types.Float16)
if err != nil {
log.Fatalln(err)
}
// float
f32Typ, err = types.NewFloat(types.Float32)
if err != nil {
log.Fatalln(err)
}
// double
f64Typ, err = types.NewFloat(types.Float64)
if err != nil {
log.Fatalln(err)
}
// fp128
f128Typ, err = types.NewFloat(types.Float128)
if err != nil {
log.Fatalln(err)
}
// x86_fp80
f80_x86Typ, err = types.NewFloat(types.Float80_x86)
if err != nil {
log.Fatalln(err)
}
// ppc_fp128
f128_ppcTyp, err = types.NewFloat(types.Float128_PPC)
// MMX type.
// x86_mmx
mmxTyp = types.NewMMX()
// Label type.
// label
labelTyp = types.NewLabel()
// Metadata type.
// metadata
metadataTyp = types.NewMetadata()
// Function types.
// void ()
voidFuncTyp, err = types.NewFunc(voidTyp, nil, false)
if err != nil {
log.Fatalln(err)
}
// i32 ()
i32FuncTyp, err = types.NewFunc(i32Typ, nil, false)
if err != nil {
log.Fatalln(err)
}
// void (i32)
i32Param := types.NewParam(i32Typ, "")
i32Params := []*types.Param{i32Param}
voidFunci32Typ, err = types.NewFunc(voidTyp, i32Params, false)
if err != nil {
log.Fatalln(err)
}
// void (float)
f32Param := types.NewParam(f32Typ, "")
f32Params := []*types.Param{f32Param}
voidFuncf32Typ, err = types.NewFunc(voidTyp, f32Params, false)
if err != nil {
log.Fatalln(err)
}
// void (i32, ...)
voidFunci32EllipsisTyp, err = types.NewFunc(voidTyp, i32Params, true)
if err != nil {
log.Fatalln(err)
}
// i32 (i32)
funcTyp, err = types.NewFunc(i32Typ, i32Params, false)
if err != nil {
log.Fatalln(err)
}
// Pointer types.
// i8*
i8PtrTyp, err = types.NewPointer(i8Typ)
if err != nil {
log.Fatalln(err)
}
// half*
f16PtrTyp, err = types.NewPointer(f16Typ)
if err != nil {
log.Fatalln(err)
}
// x86_mmx*
mmxPtrTyp, err = types.NewPointer(mmxTyp)
if err != nil {
log.Fatalln(err)
}
// i32 (i32)*
funcPtrTyp, err = types.NewPointer(funcTyp)
if err != nil {
log.Fatalln(err)
}
// Vector types.
// <1 x i8>
i8x1VecTyp, err = types.NewVector(i8Typ, 1)
if err != nil {
log.Fatalln(err)
}
// <2 x i32>
i32x2VecTyp, err = types.NewVector(i32Typ, 2)
if err != nil {
log.Fatalln(err)
}
// <3 x i32>
i32x3VecTyp, err = types.NewVector(i32Typ, 3)
if err != nil {
log.Fatalln(err)
}
// <3 x half>
f16x3VecTyp, err = types.NewVector(f16Typ, 3)
if err != nil {
log.Fatalln(err)
}
// <4 x float>
f32x4VecTyp, err = types.NewVector(f32Typ, 4)
if err != nil {
log.Fatalln(err)
}
// <5 x double>
f64x5VecTyp, err = types.NewVector(f64Typ, 5)
if err != nil {
log.Fatalln(err)
}
// <6 x fp128>
f128x6VecTyp, err = types.NewVector(f128Typ, 6)
if err != nil {
log.Fatalln(err)
}
// <7 x x86_fp80>
f80_x86x7VecTyp, err = types.NewVector(f80_x86Typ, 7)
if err != nil {
log.Fatalln(err)
}
// <8 x ppc_fp128>
f128_ppcx8VecTyp, err = types.NewVector(f128_ppcTyp, 8)
if err != nil {
log.Fatalln(err)
}
// <9 x i8*>
i8Ptrx9VecTyp, err = types.NewVector(i8PtrTyp, 9)
if err != nil {
log.Fatalln(err)
}
// <10 x half*>
f16Ptrx10VecTyp, err = types.NewVector(f16PtrTyp, 10)
if err != nil {
log.Fatalln(err)
}
// Array types.
// [1 x i8]
i8x1ArrTyp, err = types.NewArray(i8Typ, 1)
if err != nil {
log.Fatalln(err)
}
// [2 x i32]
i32x2ArrTyp, err = types.NewArray(i32Typ, 2)
if err != nil {
log.Fatalln(err)
}
// [3 x i32]
i32x3ArrTyp, err = types.NewArray(i32Typ, 3)
if err != nil {
log.Fatalln(err)
}
// [3 x half]
f16x3ArrTyp, err = types.NewArray(f16Typ, 3)
if err != nil {
log.Fatalln(err)
}
// [4 x float]
f32x4ArrTyp, err = types.NewArray(f32Typ, 4)
if err != nil {
log.Fatalln(err)
}
// [5 x double]
f64x5ArrTyp, err = types.NewArray(f64Typ, 5)
if err != nil {
log.Fatalln(err)
}
// [6 x fp128]
f128x6ArrTyp, err = types.NewArray(f128Typ, 6)
if err != nil {
log.Fatalln(err)
}
// [7 x x86_fp80]
f80_x86x7ArrTyp, err = types.NewArray(f80_x86Typ, 7)
if err != nil {
log.Fatalln(err)
}
// [8 x ppc_fp128]
f128_ppcx8ArrTyp, err = types.NewArray(f128_ppcTyp, 8)
if err != nil {
log.Fatalln(err)
}
// [9 x i8*]
i8Ptrx9ArrTyp, err = types.NewArray(i8PtrTyp, 9)
if err != nil {
log.Fatalln(err)
}
// [10 x half*]
f16Ptrx10ArrTyp, err = types.NewArray(f16PtrTyp, 10)
if err != nil {
log.Fatalln(err)
}
// Structure types.
// {i32, i8}
fields := []types.Type{i32Typ, i8Typ}
i32i8structTyp, err = types.NewStruct(fields, false)
if err != nil {
log.Fatalln(err)
}
// {i32, i32}
fields = []types.Type{i32Typ, i32Typ}
i32i32structTyp, err = types.NewStruct(fields, false)
if err != nil {
log.Fatalln(err)
}
// {i32, i8, i8}
fields = []types.Type{i32Typ, i8Typ, i8Typ}
i32i8i8structTyp, err = types.NewStruct(fields, false)
if err != nil {
log.Fatalln(err)
}
// {i1, float, x86_mmx, i32 (i32)*, <1 x i8>, [3 x half]}
fields = []types.Type{i1Typ, f32Typ, mmxTyp, funcPtrTyp, i8x1VecTyp, f16x3ArrTyp}
structTyp, err = types.NewStruct(fields, false)
if err != nil {
log.Fatalln(err)
}
}