// toIrType converts the given uC type to the corresponding LLVM IR type. func toIrType(n uctypes.Type) irtypes.Type { //TODO: implement, placeholder implementation var t irtypes.Type var err error switch ucType := n.(type) { case *uctypes.Basic: switch ucType.Kind { case uctypes.Int: //TODO: Get int width from compile env t, err = irtypes.NewInt(32) case uctypes.Char: t, err = irtypes.NewInt(8) case uctypes.Void: t = irtypes.NewVoid() } case *uctypes.Array: elem := toIrType(ucType.Elem) if ucType.Len == 0 { t, err = irtypes.NewPointer(elem) } else { t, err = irtypes.NewArray(elem, ucType.Len) } case *uctypes.Func: var params []*irtypes.Param variadic := false for _, p := range ucType.Params { //TODO: Add support for variadic if uctypes.IsVoid(p.Type) { break } pt := toIrType(p.Type) dbg.Printf("converting type %#v to %#v", p.Type, pt) params = append(params, irtypes.NewParam(pt, p.Name)) } result := toIrType(ucType.Result) t, err = irtypes.NewFunc(result, params, variadic) default: panic(fmt.Sprintf("support for translating type %T not yet implemented.", ucType)) } if err != nil { panic(errutil.Err(err)) } if t == nil { panic(errutil.Newf("Conversion failed: %#v", n)) } return t }
func TestIntString(t *testing.T) { golden := []struct { n int want string err string }{ // i=0 { n: 1, want: "i1", }, // i=1 { n: 32, want: "i32", }, // i=2 { n: 1<<23 - 1, want: "i8388607", }, // i=3 { n: -1, want: "", err: "invalid integer size (-1)", }, // i=4 { n: 0, want: "", err: "invalid integer size (0)", }, // i=5 { n: 1 << 23, want: "", err: "invalid integer size (8388608)", }, } for i, g := range golden { typ, err := types.NewInt(g.n) if !sameError(err, g.err) { t.Errorf("i=%d: error mismatch; expected %v, got %v", i, g.err, err) continue } else if err != nil { // Expected error match, check next test case. continue } got := typ.String() if got != g.want { t.Errorf("i=%d: string mismatch; expected %v, got %v", i, g.want, got) } } }
// NewIntType returns a new integer type based on the given integer type lexeme. func NewIntType(typToken interface{}) (*types.Int, error) { if typToken, ok := typToken.(*token.Token); ok { // Skip "i" prefix in integer type (e.g. i32). s := string(typToken.Lit) if !strings.HasPrefix(s, "i") { return nil, errutil.Newf("invalid prefix of integer type %q; expected 'i'", s) } s = s[1:] size, err := strconv.Atoi(s) if err != nil { return nil, errutil.Err(err) } return types.NewInt(size) } return nil, errutil.Newf("invalid integer type; expected *token.Token, got %T", typToken) }
func init() { // i1 var err error i1Typ, err = types.NewInt(1) if err != nil { log.Fatalln(err) } // i3 i3Typ, err = types.NewInt(3) if err != nil { log.Fatalln(err) } // i5 i5Typ, err = types.NewInt(5) 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) } // 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) } // ppc_fp128 f128_ppcTyp, err = types.NewFloat(types.Float128_PPC) 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) } // <2 x float> f32x2VecTyp, err = types.NewVector(f32Typ, 2) if err != nil { log.Fatalln(err) } // <3 x float> f32x3VecTyp, err = types.NewVector(f32Typ, 3) if err != nil { log.Fatalln(err) } // [2 x i32] i32x2ArrTyp, err = types.NewArray(i32Typ, 2) if err != nil { log.Fatalln(err) } // {i32, i8} i32i8StructTyp, err = types.NewStruct([]types.Type{i32Typ, i8Typ}, false) if err != nil { log.Fatalln(err) } // [2 x {i32, i8}] i32i8x2ArrTyp, err = types.NewArray(i32i8StructTyp, 2) if err != nil { log.Fatalln(err) } // i1 1 i1One, err = constant.NewInt(i1Typ, "1") if err != nil { log.Fatalln(err) } // i8 3 i8Three, err = constant.NewInt(i8Typ, "3") if err != nil { log.Fatalln(err) } // i8 4 i8Four, err = constant.NewInt(i8Typ, "4") if err != nil { log.Fatalln(err) } // i32 -13 i32MinusThirteen, err = constant.NewInt(i32Typ, "-13") if err != nil { log.Fatalln(err) } // i32 -4 i32MinusFour, err = constant.NewInt(i32Typ, "-4") if err != nil { log.Fatalln(err) } // i32 -3 i32MinusThree, err = constant.NewInt(i32Typ, "-3") if err != nil { log.Fatalln(err) } // i32 1 i32One, err = constant.NewInt(i32Typ, "1") if err != nil { log.Fatalln(err) } // i32 2 i32Two, err = constant.NewInt(i32Typ, "2") if err != nil { log.Fatalln(err) } // i32 3 i32Three, err = constant.NewInt(i32Typ, "3") if err != nil { log.Fatalln(err) } // i32 4 i32Four, err = constant.NewInt(i32Typ, "4") if err != nil { log.Fatalln(err) } // i32 15 i32Fifteen, err = constant.NewInt(i32Typ, "15") if err != nil { log.Fatalln(err) } // i32 42 i32FortyTwo, err = constant.NewInt(i32Typ, "42") if err != nil { log.Fatalln(err) } // float -3.0 f32MinusThree, err = constant.NewFloat(f32Typ, "-3.0") if err != nil { log.Fatalln(err) } // float -4.0 f32MinusFour, err = constant.NewFloat(f32Typ, "-4.0") if err != nil { log.Fatalln(err) } // float 1.0 f32One, err = constant.NewFloat(f32Typ, "1.0") if err != nil { log.Fatalln(err) } // float 2.0 f32Two, err = constant.NewFloat(f32Typ, "2.0") if err != nil { log.Fatalln(err) } // float 3.0 f32Three, err = constant.NewFloat(f32Typ, "3.0") if err != nil { log.Fatalln(err) } // float 4.0 f32Four, err = constant.NewFloat(f32Typ, "4.0") if err != nil { log.Fatalln(err) } // double 4.0 f64Four, err = constant.NewFloat(f64Typ, "4.0") if err != nil { log.Fatalln(err) } // TODO: Uncomment when fp128 and ppc_fp128 are supported. /* // fp128 3.0 f128Three, err = constant.NewFloat(f128Typ, "3.0") if err != nil { log.Fatalln(err) } // ppc_fp128 4.0 f128_ppcFour, err = constant.NewFloat(f128_ppcTyp, "4.0") if err != nil { log.Fatalln(err) } */ // <3 x i32> <i32 1, i32 2, i32 3> i32x3OneTwoThree, err = constant.NewVector(i32x3VecTyp, []constant.Constant{i32One, i32Two, i32Three}) if err != nil { log.Fatalln(err) } // <2 x i32> <i32 3, i32 42> i32x2VecThreeFortyTwo, err = constant.NewVector(i32x2VecTyp, []constant.Constant{i32Three, i32FortyTwo}) if err != nil { log.Fatalln(err) } // <2 x i32> <i32 -3, i32 15> i32x2VecMinusThreeFifteen, err = constant.NewVector(i32x2VecTyp, []constant.Constant{i32MinusThree, i32Fifteen}) if err != nil { log.Fatalln(err) } // <2 x float> <float 3.0, float 4.0> f32x2VecThreeFour, err = constant.NewVector(f32x2VecTyp, []constant.Constant{f32Three, f32Four}) if err != nil { log.Fatalln(err) } // <2 x float> <float -3.0, float 4.0> f32x2VecMinusThreeFour, err = constant.NewVector(f32x2VecTyp, []constant.Constant{f32MinusThree, f32Four}) if err != nil { log.Fatalln(err) } // <3 x float> <float 3.0, float 2.0, float 1.0> f32x3VecThreeFourFifteen, err = constant.NewVector(f32x3VecTyp, []constant.Constant{f32Three, f32Two, f32One}) if err != nil { log.Fatalln(err) } // {i32, i8} {i32 4, i8 3} i32i8FourThree, err = constant.NewStruct(i32i8StructTyp, []constant.Constant{i32Four, i8Three}) if err != nil { log.Fatalln(err) } // {i32, i8} {i32 3, i8 4} i32i8ThreeFour, err = constant.NewStruct(i32i8StructTyp, []constant.Constant{i32Three, i8Four}) if err != nil { log.Fatalln(err) } }
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) } }