diff --git a/asm/const.go b/asm/const.go index d9a23895..be5e9cbb 100644 --- a/asm/const.go +++ b/asm/const.go @@ -14,32 +14,32 @@ import ( func (gen *generator) irConstant(t types.Type, old ast.Constant) (constant.Constant, error) { switch old := old.(type) { - case *ast.BoolConst: + case ast.BoolConst: return gen.irBoolConst(t, old) - case *ast.IntConst: + case ast.IntConst: return gen.irIntConst(t, old) - case *ast.FloatConst: + case ast.FloatConst: return gen.irFloatConst(t, old) - case *ast.NullConst: + case ast.NullConst: return gen.irNullConst(t, old) - case *ast.NoneConst: + case ast.NoneConst: return gen.irNoneConst(t, old) - case *ast.StructConst: + case ast.StructConst: return gen.irStructConst(t, old) - case *ast.ArrayConst: + case ast.ArrayConst: return gen.irArrayConst(t, old) - case *ast.CharArrayConst: + case ast.CharArrayConst: return gen.irCharArrayConst(t, old) - case *ast.VectorConst: + case ast.VectorConst: return gen.irVectorConst(t, old) - case *ast.ZeroInitializerConst: + case ast.ZeroInitializerConst: return gen.irZeroInitializerConst(t, old) - case *ast.UndefConst: + case ast.UndefConst: return gen.irUndefConst(t, old) - case *ast.BlockAddressConst: + case ast.BlockAddressConst: return gen.irBlockAddressConst(t, old) - case *ast.GlobalIdent: - ident := globalIdent(*old) + case ast.GlobalIdent: + ident := globalIdent(old) v, ok := gen.new.globals[ident] if !ok { return nil, errors.Errorf("unable to locate global identifier %q", ident) @@ -64,7 +64,7 @@ func (gen *generator) irTypeConst(old ast.TypeConst) (constant.Constant, error) // --- [ Boolean Constants ] --------------------------------------------------- -func (gen *generator) irBoolConst(t types.Type, old *ast.BoolConst) (*constant.Int, error) { +func (gen *generator) irBoolConst(t types.Type, old ast.BoolConst) (*constant.Int, error) { typ, ok := t.(*types.IntType) if !ok { return nil, errors.Errorf("invalid type of boolean constant; expected *types.IntType, got %T", t) @@ -81,7 +81,7 @@ func (gen *generator) irBoolConst(t types.Type, old *ast.BoolConst) (*constant.I // --- [ Integer Constants ] --------------------------------------------------- -func (gen *generator) irIntConst(t types.Type, old *ast.IntConst) (*constant.Int, error) { +func (gen *generator) irIntConst(t types.Type, old ast.IntConst) (*constant.Int, error) { typ, ok := t.(*types.IntType) if !ok { return nil, errors.Errorf("invalid type of integer constant; expected *types.IntType, got %T", t) @@ -92,7 +92,7 @@ func (gen *generator) irIntConst(t types.Type, old *ast.IntConst) (*constant.Int // --- [ Floating-point Constants ] -------------------------------------------- -func (gen *generator) irFloatConst(t types.Type, old *ast.FloatConst) (*constant.Float, error) { +func (gen *generator) irFloatConst(t types.Type, old ast.FloatConst) (*constant.Float, error) { typ, ok := t.(*types.FloatType) if !ok { return nil, errors.Errorf("invalid type of floating-point constant; expected *types.FloatType, got %T", t) @@ -103,7 +103,7 @@ func (gen *generator) irFloatConst(t types.Type, old *ast.FloatConst) (*constant // --- [ Null Pointer Constants ] ---------------------------------------------- -func (gen *generator) irNullConst(t types.Type, old *ast.NullConst) (*constant.Null, error) { +func (gen *generator) irNullConst(t types.Type, old ast.NullConst) (*constant.Null, error) { typ, ok := t.(*types.PointerType) if !ok { return nil, errors.Errorf("invalid type of null constant; expected *types.PointerType, got %T", t) @@ -113,14 +113,14 @@ func (gen *generator) irNullConst(t types.Type, old *ast.NullConst) (*constant.N // --- [ Token Constants ] ----------------------------------------------------- -func (gen *generator) irNoneConst(t types.Type, old *ast.NoneConst) (constant.Constant, error) { +func (gen *generator) irNoneConst(t types.Type, old ast.NoneConst) (constant.Constant, error) { // TODO: validate type t. return constant.None, nil } // --- [ Structure Constants ] ------------------------------------------------- -func (gen *generator) irStructConst(t types.Type, old *ast.StructConst) (*constant.Struct, error) { +func (gen *generator) irStructConst(t types.Type, old ast.StructConst) (*constant.Struct, error) { typ, ok := t.(*types.StructType) if !ok { return nil, errors.Errorf("invalid type of struct constant; expected *types.StructType, got %T", t) @@ -141,7 +141,7 @@ func (gen *generator) irStructConst(t types.Type, old *ast.StructConst) (*consta // --- [ Array Constants ] ----------------------------------------------------- -func (gen *generator) irArrayConst(t types.Type, old *ast.ArrayConst) (*constant.Array, error) { +func (gen *generator) irArrayConst(t types.Type, old ast.ArrayConst) (*constant.Array, error) { typ, ok := t.(*types.ArrayType) if !ok { return nil, errors.Errorf("invalid type of array constant; expected *types.ArrayType, got %T", t) @@ -166,7 +166,7 @@ func (gen *generator) irArrayConst(t types.Type, old *ast.ArrayConst) (*constant return c, nil } -func (gen *generator) irCharArrayConst(t types.Type, old *ast.CharArrayConst) (*constant.CharArray, error) { +func (gen *generator) irCharArrayConst(t types.Type, old ast.CharArrayConst) (*constant.CharArray, error) { data := stringLitBytes(old.Val()) expr := constant.NewCharArray(data) // TODO: validate t against expr.Typ. @@ -175,7 +175,7 @@ func (gen *generator) irCharArrayConst(t types.Type, old *ast.CharArrayConst) (* // --- [ Vector Constants ] ---------------------------------------------------- -func (gen *generator) irVectorConst(t types.Type, old *ast.VectorConst) (*constant.Vector, error) { +func (gen *generator) irVectorConst(t types.Type, old ast.VectorConst) (*constant.Vector, error) { typ, ok := t.(*types.VectorType) if !ok { return nil, errors.Errorf("invalid type of vector constant; expected *types.VectorType, got %T", t) @@ -202,19 +202,19 @@ func (gen *generator) irVectorConst(t types.Type, old *ast.VectorConst) (*consta // --- [ Zero Initialization Constants ] --------------------------------------- -func (gen *generator) irZeroInitializerConst(t types.Type, old *ast.ZeroInitializerConst) (*constant.ZeroInitializer, error) { +func (gen *generator) irZeroInitializerConst(t types.Type, old ast.ZeroInitializerConst) (*constant.ZeroInitializer, error) { return constant.NewZeroInitializer(t), nil } // --- [ Undefined Values ] ---------------------------------------------------- -func (gen *generator) irUndefConst(t types.Type, old *ast.UndefConst) (*constant.Undef, error) { +func (gen *generator) irUndefConst(t types.Type, old ast.UndefConst) (*constant.Undef, error) { return constant.NewUndef(t), nil } // --- [ Addresses of Basic Blocks ] ------------------------------------------- -func (gen *generator) irBlockAddressConst(t types.Type, old *ast.BlockAddressConst) (*constant.BlockAddress, error) { +func (gen *generator) irBlockAddressConst(t types.Type, old ast.BlockAddressConst) (*constant.BlockAddress, error) { // Function. funcName := globalIdent(old.Func()) v, ok := gen.new.globals[funcName] diff --git a/asm/const_expr.go b/asm/const_expr.go index 70477e64..2f3258ea 100644 --- a/asm/const_expr.go +++ b/asm/const_expr.go @@ -17,91 +17,91 @@ import ( func (gen *generator) irConstantExpr(t types.Type, old ast.ConstantExpr) (constant.Expression, error) { switch old := old.(type) { // Binary expressions - case *ast.AddExpr: + case ast.AddExpr: return gen.irAddExpr(t, old) - case *ast.FAddExpr: + case ast.FAddExpr: return gen.irFAddExpr(t, old) - case *ast.SubExpr: + case ast.SubExpr: return gen.irSubExpr(t, old) - case *ast.FSubExpr: + case ast.FSubExpr: return gen.irFSubExpr(t, old) - case *ast.MulExpr: + case ast.MulExpr: return gen.irMulExpr(t, old) - case *ast.FMulExpr: + case ast.FMulExpr: return gen.irFMulExpr(t, old) - case *ast.UDivExpr: + case ast.UDivExpr: return gen.irUDivExpr(t, old) - case *ast.SDivExpr: + case ast.SDivExpr: return gen.irSDivExpr(t, old) - case *ast.FDivExpr: + case ast.FDivExpr: return gen.irFDivExpr(t, old) - case *ast.URemExpr: + case ast.URemExpr: return gen.irURemExpr(t, old) - case *ast.SRemExpr: + case ast.SRemExpr: return gen.irSRemExpr(t, old) - case *ast.FRemExpr: + case ast.FRemExpr: return gen.irFRemExpr(t, old) // Bitwise expressions - case *ast.ShlExpr: + case ast.ShlExpr: return gen.irShlExpr(t, old) - case *ast.LShrExpr: + case ast.LShrExpr: return gen.irLShrExpr(t, old) - case *ast.AShrExpr: + case ast.AShrExpr: return gen.irAShrExpr(t, old) - case *ast.AndExpr: + case ast.AndExpr: return gen.irAndExpr(t, old) - case *ast.OrExpr: + case ast.OrExpr: return gen.irOrExpr(t, old) - case *ast.XorExpr: + case ast.XorExpr: return gen.irXorExpr(t, old) // Vector expressions - case *ast.ExtractElementExpr: + case ast.ExtractElementExpr: return gen.irExtractElementExpr(t, old) - case *ast.InsertElementExpr: + case ast.InsertElementExpr: return gen.irInsertElementExpr(t, old) - case *ast.ShuffleVectorExpr: + case ast.ShuffleVectorExpr: return gen.irShuffleVectorExpr(t, old) // Aggregate expressions - case *ast.ExtractValueExpr: + case ast.ExtractValueExpr: return gen.irExtractValueExpr(t, old) - case *ast.InsertValueExpr: + case ast.InsertValueExpr: return gen.irInsertValueExpr(t, old) // Memory expressions - case *ast.GetElementPtrExpr: + case ast.GetElementPtrExpr: return gen.irGetElementPtrExpr(t, old) // Conversion expressions - case *ast.TruncExpr: + case ast.TruncExpr: return gen.irTruncExpr(t, old) - case *ast.ZExtExpr: + case ast.ZExtExpr: return gen.irZExtExpr(t, old) - case *ast.SExtExpr: + case ast.SExtExpr: return gen.irSExtExpr(t, old) - case *ast.FPTruncExpr: + case ast.FPTruncExpr: return gen.irFPTruncExpr(t, old) - case *ast.FPExtExpr: + case ast.FPExtExpr: return gen.irFPExtExpr(t, old) - case *ast.FPToUIExpr: + case ast.FPToUIExpr: return gen.irFPToUIExpr(t, old) - case *ast.FPToSIExpr: + case ast.FPToSIExpr: return gen.irFPToSIExpr(t, old) - case *ast.UIToFPExpr: + case ast.UIToFPExpr: return gen.irUIToFPExpr(t, old) - case *ast.SIToFPExpr: + case ast.SIToFPExpr: return gen.irSIToFPExpr(t, old) - case *ast.PtrToIntExpr: + case ast.PtrToIntExpr: return gen.irPtrToIntExpr(t, old) - case *ast.IntToPtrExpr: + case ast.IntToPtrExpr: return gen.irIntToPtrExpr(t, old) - case *ast.BitCastExpr: + case ast.BitCastExpr: return gen.irBitCastExpr(t, old) - case *ast.AddrSpaceCastExpr: + case ast.AddrSpaceCastExpr: return gen.irAddrSpaceCastExpr(t, old) // Other expressions - case *ast.ICmpExpr: + case ast.ICmpExpr: return gen.irICmpExpr(t, old) - case *ast.FCmpExpr: + case ast.FCmpExpr: return gen.irFCmpExpr(t, old) - case *ast.SelectExpr: + case ast.SelectExpr: return gen.irSelectExpr(t, old) default: panic(fmt.Errorf("support for AST constant expression %T not yet implemented", old)) @@ -114,7 +114,7 @@ func (gen *generator) irConstantExpr(t types.Type, old ast.ConstantExpr) (consta // irAddExpr translates the given AST add constant expression into an equivalent // IR constant expression. -func (gen *generator) irAddExpr(t types.Type, old *ast.AddExpr) (*constant.ExprAdd, error) { +func (gen *generator) irAddExpr(t types.Type, old ast.AddExpr) (*constant.ExprAdd, error) { // (optional) Overflow flags. overflowFlags := irOverflowFlags(old.OverflowFlags()) // X operand. @@ -136,7 +136,7 @@ func (gen *generator) irAddExpr(t types.Type, old *ast.AddExpr) (*constant.ExprA // irFAddExpr translates the given AST fadd constant expression into an // equivalent IR constant expression. -func (gen *generator) irFAddExpr(t types.Type, old *ast.FAddExpr) (*constant.ExprFAdd, error) { +func (gen *generator) irFAddExpr(t types.Type, old ast.FAddExpr) (*constant.ExprFAdd, error) { // X operand. x, err := gen.irTypeConst(old.X()) if err != nil { @@ -155,7 +155,7 @@ func (gen *generator) irFAddExpr(t types.Type, old *ast.FAddExpr) (*constant.Exp // irSubExpr translates the given AST sub constant expression into an equivalent // IR constant expression. -func (gen *generator) irSubExpr(t types.Type, old *ast.SubExpr) (*constant.ExprSub, error) { +func (gen *generator) irSubExpr(t types.Type, old ast.SubExpr) (*constant.ExprSub, error) { // (optional) Overflow flags. overflowFlags := irOverflowFlags(old.OverflowFlags()) // X operand. @@ -177,7 +177,7 @@ func (gen *generator) irSubExpr(t types.Type, old *ast.SubExpr) (*constant.ExprS // irFSubExpr translates the given AST fsub constant expression into an // equivalent IR constant expression. -func (gen *generator) irFSubExpr(t types.Type, old *ast.FSubExpr) (*constant.ExprFSub, error) { +func (gen *generator) irFSubExpr(t types.Type, old ast.FSubExpr) (*constant.ExprFSub, error) { // X operand. x, err := gen.irTypeConst(old.X()) if err != nil { @@ -196,7 +196,7 @@ func (gen *generator) irFSubExpr(t types.Type, old *ast.FSubExpr) (*constant.Exp // irMulExpr translates the given AST mul constant expression into an equivalent // IR constant expression. -func (gen *generator) irMulExpr(t types.Type, old *ast.MulExpr) (*constant.ExprMul, error) { +func (gen *generator) irMulExpr(t types.Type, old ast.MulExpr) (*constant.ExprMul, error) { // (optional) Overflow flags. overflowFlags := irOverflowFlags(old.OverflowFlags()) // X operand. @@ -218,7 +218,7 @@ func (gen *generator) irMulExpr(t types.Type, old *ast.MulExpr) (*constant.ExprM // irFMulExpr translates the given AST fmul constant expression into an // equivalent IR constant expression. -func (gen *generator) irFMulExpr(t types.Type, old *ast.FMulExpr) (*constant.ExprFMul, error) { +func (gen *generator) irFMulExpr(t types.Type, old ast.FMulExpr) (*constant.ExprFMul, error) { // X operand. x, err := gen.irTypeConst(old.X()) if err != nil { @@ -237,7 +237,7 @@ func (gen *generator) irFMulExpr(t types.Type, old *ast.FMulExpr) (*constant.Exp // irUDivExpr translates the given AST udiv constant expression into an // equivalent IR constant expression. -func (gen *generator) irUDivExpr(t types.Type, old *ast.UDivExpr) (*constant.ExprUDiv, error) { +func (gen *generator) irUDivExpr(t types.Type, old ast.UDivExpr) (*constant.ExprUDiv, error) { // (optional) Exact. exact := old.Exact().IsValid() // X operand. @@ -259,7 +259,7 @@ func (gen *generator) irUDivExpr(t types.Type, old *ast.UDivExpr) (*constant.Exp // irSDivExpr translates the given AST sdiv constant expression into an // equivalent IR constant expression. -func (gen *generator) irSDivExpr(t types.Type, old *ast.SDivExpr) (*constant.ExprSDiv, error) { +func (gen *generator) irSDivExpr(t types.Type, old ast.SDivExpr) (*constant.ExprSDiv, error) { // (optional) Exact. exact := old.Exact().IsValid() // X operand. @@ -281,7 +281,7 @@ func (gen *generator) irSDivExpr(t types.Type, old *ast.SDivExpr) (*constant.Exp // irFDivExpr translates the given AST fdiv constant expression into an // equivalent IR constant expression. -func (gen *generator) irFDivExpr(t types.Type, old *ast.FDivExpr) (*constant.ExprFDiv, error) { +func (gen *generator) irFDivExpr(t types.Type, old ast.FDivExpr) (*constant.ExprFDiv, error) { // X operand. x, err := gen.irTypeConst(old.X()) if err != nil { @@ -300,7 +300,7 @@ func (gen *generator) irFDivExpr(t types.Type, old *ast.FDivExpr) (*constant.Exp // irURemExpr translates the given AST urem constant expression into an // equivalent IR constant expression. -func (gen *generator) irURemExpr(t types.Type, old *ast.URemExpr) (*constant.ExprURem, error) { +func (gen *generator) irURemExpr(t types.Type, old ast.URemExpr) (*constant.ExprURem, error) { // X operand. x, err := gen.irTypeConst(old.X()) if err != nil { @@ -319,7 +319,7 @@ func (gen *generator) irURemExpr(t types.Type, old *ast.URemExpr) (*constant.Exp // irSRemExpr translates the given AST srem constant expression into an // equivalent IR constant expression. -func (gen *generator) irSRemExpr(t types.Type, old *ast.SRemExpr) (*constant.ExprSRem, error) { +func (gen *generator) irSRemExpr(t types.Type, old ast.SRemExpr) (*constant.ExprSRem, error) { // X operand. x, err := gen.irTypeConst(old.X()) if err != nil { @@ -338,7 +338,7 @@ func (gen *generator) irSRemExpr(t types.Type, old *ast.SRemExpr) (*constant.Exp // irFRemExpr translates the given AST frem constant expression into an // equivalent IR constant expression. -func (gen *generator) irFRemExpr(t types.Type, old *ast.FRemExpr) (*constant.ExprFRem, error) { +func (gen *generator) irFRemExpr(t types.Type, old ast.FRemExpr) (*constant.ExprFRem, error) { // X operand. x, err := gen.irTypeConst(old.X()) if err != nil { @@ -359,7 +359,7 @@ func (gen *generator) irFRemExpr(t types.Type, old *ast.FRemExpr) (*constant.Exp // irShlExpr translates the given AST shl constant expression into an equivalent // IR constant expression. -func (gen *generator) irShlExpr(t types.Type, old *ast.ShlExpr) (*constant.ExprShl, error) { +func (gen *generator) irShlExpr(t types.Type, old ast.ShlExpr) (*constant.ExprShl, error) { // (optional) Overflow flags. overflowFlags := irOverflowFlags(old.OverflowFlags()) // X operand. @@ -381,7 +381,7 @@ func (gen *generator) irShlExpr(t types.Type, old *ast.ShlExpr) (*constant.ExprS // irLShrExpr translates the given AST lshr constant expression into an // equivalent IR constant expression. -func (gen *generator) irLShrExpr(t types.Type, old *ast.LShrExpr) (*constant.ExprLShr, error) { +func (gen *generator) irLShrExpr(t types.Type, old ast.LShrExpr) (*constant.ExprLShr, error) { // (optional) Exact. exact := old.Exact().IsValid() // X operand. @@ -403,7 +403,7 @@ func (gen *generator) irLShrExpr(t types.Type, old *ast.LShrExpr) (*constant.Exp // irAShrExpr translates the given AST ashr constant expression into an // equivalent IR constant expression. -func (gen *generator) irAShrExpr(t types.Type, old *ast.AShrExpr) (*constant.ExprAShr, error) { +func (gen *generator) irAShrExpr(t types.Type, old ast.AShrExpr) (*constant.ExprAShr, error) { // (optional) Exact. exact := old.Exact().IsValid() // X operand. @@ -425,7 +425,7 @@ func (gen *generator) irAShrExpr(t types.Type, old *ast.AShrExpr) (*constant.Exp // irAndExpr translates the given AST and constant expression into an equivalent // IR constant expression. -func (gen *generator) irAndExpr(t types.Type, old *ast.AndExpr) (*constant.ExprAnd, error) { +func (gen *generator) irAndExpr(t types.Type, old ast.AndExpr) (*constant.ExprAnd, error) { // X operand. x, err := gen.irTypeConst(old.X()) if err != nil { @@ -444,7 +444,7 @@ func (gen *generator) irAndExpr(t types.Type, old *ast.AndExpr) (*constant.ExprA // irOrExpr translates the given AST or constant expression into an equivalent // IR constant expression. -func (gen *generator) irOrExpr(t types.Type, old *ast.OrExpr) (*constant.ExprOr, error) { +func (gen *generator) irOrExpr(t types.Type, old ast.OrExpr) (*constant.ExprOr, error) { // X operand. x, err := gen.irTypeConst(old.X()) if err != nil { @@ -463,7 +463,7 @@ func (gen *generator) irOrExpr(t types.Type, old *ast.OrExpr) (*constant.ExprOr, // irXorExpr translates the given AST xor constant expression into an equivalent // IR constant expression. -func (gen *generator) irXorExpr(t types.Type, old *ast.XorExpr) (*constant.ExprXor, error) { +func (gen *generator) irXorExpr(t types.Type, old ast.XorExpr) (*constant.ExprXor, error) { // X operand. x, err := gen.irTypeConst(old.X()) if err != nil { @@ -484,7 +484,7 @@ func (gen *generator) irXorExpr(t types.Type, old *ast.XorExpr) (*constant.ExprX // irExtractElementExpr translates the given AST extractelement constant // expression into an equivalent IR constant expression. -func (gen *generator) irExtractElementExpr(t types.Type, old *ast.ExtractElementExpr) (*constant.ExprExtractElement, error) { +func (gen *generator) irExtractElementExpr(t types.Type, old ast.ExtractElementExpr) (*constant.ExprExtractElement, error) { // Vector. x, err := gen.irTypeConst(old.X()) if err != nil { @@ -503,7 +503,7 @@ func (gen *generator) irExtractElementExpr(t types.Type, old *ast.ExtractElement // irInsertElementExpr translates the given AST insertelement constant // expression into an equivalent IR constant expression. -func (gen *generator) irInsertElementExpr(t types.Type, old *ast.InsertElementExpr) (*constant.ExprInsertElement, error) { +func (gen *generator) irInsertElementExpr(t types.Type, old ast.InsertElementExpr) (*constant.ExprInsertElement, error) { // Vector. x, err := gen.irTypeConst(old.X()) if err != nil { @@ -527,7 +527,7 @@ func (gen *generator) irInsertElementExpr(t types.Type, old *ast.InsertElementEx // irShuffleVectorExpr translates the given AST shufflevector constant // expression into an equivalent IR constant expression. -func (gen *generator) irShuffleVectorExpr(t types.Type, old *ast.ShuffleVectorExpr) (*constant.ExprShuffleVector, error) { +func (gen *generator) irShuffleVectorExpr(t types.Type, old ast.ShuffleVectorExpr) (*constant.ExprShuffleVector, error) { // X vector. x, err := gen.irTypeConst(old.X()) if err != nil { @@ -553,7 +553,7 @@ func (gen *generator) irShuffleVectorExpr(t types.Type, old *ast.ShuffleVectorEx // irExtractValueExpr translates the given AST extractvalue constant expression // into an equivalent IR constant expression. -func (gen *generator) irExtractValueExpr(t types.Type, old *ast.ExtractValueExpr) (*constant.ExprExtractValue, error) { +func (gen *generator) irExtractValueExpr(t types.Type, old ast.ExtractValueExpr) (*constant.ExprExtractValue, error) { // Aggregate value. x, err := gen.irTypeConst(old.X()) if err != nil { @@ -572,7 +572,7 @@ func (gen *generator) irExtractValueExpr(t types.Type, old *ast.ExtractValueExpr // irInsertValueExpr translates the given AST insertvalue constant expression // into an equivalent IR constant expression. -func (gen *generator) irInsertValueExpr(t types.Type, old *ast.InsertValueExpr) (*constant.ExprInsertValue, error) { +func (gen *generator) irInsertValueExpr(t types.Type, old ast.InsertValueExpr) (*constant.ExprInsertValue, error) { // Aggregate value. x, err := gen.irTypeConst(old.X()) if err != nil { @@ -598,7 +598,7 @@ func (gen *generator) irInsertValueExpr(t types.Type, old *ast.InsertValueExpr) // irGetElementPtrExpr translates the given AST getelementptr constant // expression into an equivalent IR constant expression. -func (gen *generator) irGetElementPtrExpr(t types.Type, old *ast.GetElementPtrExpr) (*constant.ExprGetElementPtr, error) { +func (gen *generator) irGetElementPtrExpr(t types.Type, old ast.GetElementPtrExpr) (*constant.ExprGetElementPtr, error) { // (optional) In-bounds. inBounds := old.InBounds().IsValid() // Element type. @@ -650,7 +650,7 @@ func (gen *generator) irGEPIndex(old ast.GEPIndex) (*constant.Index, error) { // irTruncExpr translates the given AST trunc constant expression into an // equivalent IR constant expression. -func (gen *generator) irTruncExpr(t types.Type, old *ast.TruncExpr) (*constant.ExprTrunc, error) { +func (gen *generator) irTruncExpr(t types.Type, old ast.TruncExpr) (*constant.ExprTrunc, error) { // From. from, err := gen.irTypeConst(old.From()) if err != nil { @@ -670,7 +670,7 @@ func (gen *generator) irTruncExpr(t types.Type, old *ast.TruncExpr) (*constant.E // irZExtExpr translates the given AST zext constant expression into an // equivalent IR constant expression. -func (gen *generator) irZExtExpr(t types.Type, old *ast.ZExtExpr) (*constant.ExprZExt, error) { +func (gen *generator) irZExtExpr(t types.Type, old ast.ZExtExpr) (*constant.ExprZExt, error) { // From. from, err := gen.irTypeConst(old.From()) if err != nil { @@ -690,7 +690,7 @@ func (gen *generator) irZExtExpr(t types.Type, old *ast.ZExtExpr) (*constant.Exp // irSExtExpr translates the given AST sext constant expression into an // equivalent IR constant expression. -func (gen *generator) irSExtExpr(t types.Type, old *ast.SExtExpr) (*constant.ExprSExt, error) { +func (gen *generator) irSExtExpr(t types.Type, old ast.SExtExpr) (*constant.ExprSExt, error) { // From. from, err := gen.irTypeConst(old.From()) if err != nil { @@ -710,7 +710,7 @@ func (gen *generator) irSExtExpr(t types.Type, old *ast.SExtExpr) (*constant.Exp // irFPTruncExpr translates the given AST fptrunc constant expression into an // equivalent IR constant expression. -func (gen *generator) irFPTruncExpr(t types.Type, old *ast.FPTruncExpr) (*constant.ExprFPTrunc, error) { +func (gen *generator) irFPTruncExpr(t types.Type, old ast.FPTruncExpr) (*constant.ExprFPTrunc, error) { // From. from, err := gen.irTypeConst(old.From()) if err != nil { @@ -730,7 +730,7 @@ func (gen *generator) irFPTruncExpr(t types.Type, old *ast.FPTruncExpr) (*consta // irFPExtExpr translates the given AST fpext constant expression into an // equivalent IR constant expression. -func (gen *generator) irFPExtExpr(t types.Type, old *ast.FPExtExpr) (*constant.ExprFPExt, error) { +func (gen *generator) irFPExtExpr(t types.Type, old ast.FPExtExpr) (*constant.ExprFPExt, error) { // From. from, err := gen.irTypeConst(old.From()) if err != nil { @@ -750,7 +750,7 @@ func (gen *generator) irFPExtExpr(t types.Type, old *ast.FPExtExpr) (*constant.E // irFPToUIExpr translates the given AST fptoui constant expression into an // equivalent IR constant expression. -func (gen *generator) irFPToUIExpr(t types.Type, old *ast.FPToUIExpr) (*constant.ExprFPToUI, error) { +func (gen *generator) irFPToUIExpr(t types.Type, old ast.FPToUIExpr) (*constant.ExprFPToUI, error) { // From. from, err := gen.irTypeConst(old.From()) if err != nil { @@ -770,7 +770,7 @@ func (gen *generator) irFPToUIExpr(t types.Type, old *ast.FPToUIExpr) (*constant // irFPToSIExpr translates the given AST fptosi constant expression into an // equivalent IR constant expression. -func (gen *generator) irFPToSIExpr(t types.Type, old *ast.FPToSIExpr) (*constant.ExprFPToSI, error) { +func (gen *generator) irFPToSIExpr(t types.Type, old ast.FPToSIExpr) (*constant.ExprFPToSI, error) { // From. from, err := gen.irTypeConst(old.From()) if err != nil { @@ -790,7 +790,7 @@ func (gen *generator) irFPToSIExpr(t types.Type, old *ast.FPToSIExpr) (*constant // irUIToFPExpr translates the given AST uitofp constant expression into an // equivalent IR constant expression. -func (gen *generator) irUIToFPExpr(t types.Type, old *ast.UIToFPExpr) (*constant.ExprUIToFP, error) { +func (gen *generator) irUIToFPExpr(t types.Type, old ast.UIToFPExpr) (*constant.ExprUIToFP, error) { // From. from, err := gen.irTypeConst(old.From()) if err != nil { @@ -810,7 +810,7 @@ func (gen *generator) irUIToFPExpr(t types.Type, old *ast.UIToFPExpr) (*constant // irSIToFPExpr translates the given AST sitofp constant expression into an // equivalent IR constant expression. -func (gen *generator) irSIToFPExpr(t types.Type, old *ast.SIToFPExpr) (*constant.ExprSIToFP, error) { +func (gen *generator) irSIToFPExpr(t types.Type, old ast.SIToFPExpr) (*constant.ExprSIToFP, error) { // From. from, err := gen.irTypeConst(old.From()) if err != nil { @@ -830,7 +830,7 @@ func (gen *generator) irSIToFPExpr(t types.Type, old *ast.SIToFPExpr) (*constant // irPtrToIntExpr translates the given AST ptrtoint constant expression into an // equivalent IR constant expression. -func (gen *generator) irPtrToIntExpr(t types.Type, old *ast.PtrToIntExpr) (*constant.ExprPtrToInt, error) { +func (gen *generator) irPtrToIntExpr(t types.Type, old ast.PtrToIntExpr) (*constant.ExprPtrToInt, error) { // From. from, err := gen.irTypeConst(old.From()) if err != nil { @@ -850,7 +850,7 @@ func (gen *generator) irPtrToIntExpr(t types.Type, old *ast.PtrToIntExpr) (*cons // irIntToPtrExpr translates the given AST inttoptr constant expression into an // equivalent IR constant expression. -func (gen *generator) irIntToPtrExpr(t types.Type, old *ast.IntToPtrExpr) (*constant.ExprIntToPtr, error) { +func (gen *generator) irIntToPtrExpr(t types.Type, old ast.IntToPtrExpr) (*constant.ExprIntToPtr, error) { // From. from, err := gen.irTypeConst(old.From()) if err != nil { @@ -870,7 +870,7 @@ func (gen *generator) irIntToPtrExpr(t types.Type, old *ast.IntToPtrExpr) (*cons // irBitCastExpr translates the given AST bitcast constant expression into an // equivalent IR constant expression. -func (gen *generator) irBitCastExpr(t types.Type, old *ast.BitCastExpr) (*constant.ExprBitCast, error) { +func (gen *generator) irBitCastExpr(t types.Type, old ast.BitCastExpr) (*constant.ExprBitCast, error) { // From. from, err := gen.irTypeConst(old.From()) if err != nil { @@ -890,7 +890,7 @@ func (gen *generator) irBitCastExpr(t types.Type, old *ast.BitCastExpr) (*consta // irAddrSpaceCastExpr translates the given AST addrspacecast constant // expression into an equivalent IR constant expression. -func (gen *generator) irAddrSpaceCastExpr(t types.Type, old *ast.AddrSpaceCastExpr) (*constant.ExprAddrSpaceCast, error) { +func (gen *generator) irAddrSpaceCastExpr(t types.Type, old ast.AddrSpaceCastExpr) (*constant.ExprAddrSpaceCast, error) { // From. from, err := gen.irTypeConst(old.From()) if err != nil { @@ -912,7 +912,7 @@ func (gen *generator) irAddrSpaceCastExpr(t types.Type, old *ast.AddrSpaceCastEx // irICmpExpr translates the given AST icmp constant expression into an // equivalent IR constant expression. -func (gen *generator) irICmpExpr(t types.Type, old *ast.ICmpExpr) (*constant.ExprICmp, error) { +func (gen *generator) irICmpExpr(t types.Type, old ast.ICmpExpr) (*constant.ExprICmp, error) { // Integer comparison predicate. pred := asmenum.IPredFromString(old.Pred().Text()) // X operand. @@ -933,7 +933,7 @@ func (gen *generator) irICmpExpr(t types.Type, old *ast.ICmpExpr) (*constant.Exp // irFCmpExpr translates the given AST fcmp constant expression into an // equivalent IR constant expression. -func (gen *generator) irFCmpExpr(t types.Type, old *ast.FCmpExpr) (*constant.ExprFCmp, error) { +func (gen *generator) irFCmpExpr(t types.Type, old ast.FCmpExpr) (*constant.ExprFCmp, error) { // Floating-point comparison predicate. pred := asmenum.FPredFromString(old.Pred().Text()) // X operand. @@ -954,7 +954,7 @@ func (gen *generator) irFCmpExpr(t types.Type, old *ast.FCmpExpr) (*constant.Exp // irSelectExpr translates the given AST select constant expression into an // equivalent IR constant expression. -func (gen *generator) irSelectExpr(t types.Type, old *ast.SelectExpr) (*constant.ExprSelect, error) { +func (gen *generator) irSelectExpr(t types.Type, old ast.SelectExpr) (*constant.ExprSelect, error) { // Selection condition. cond, err := gen.irTypeConst(old.Cond()) if err != nil { diff --git a/asm/generator.go b/asm/generator.go index 84735251..b9027f19 100644 --- a/asm/generator.go +++ b/asm/generator.go @@ -31,12 +31,12 @@ func newGenerator() *generator { return &generator{ m: &ir.Module{}, old: oldIndex{ - typeDefs: make(map[string]*ast.TypeDef), - comdatDefs: make(map[string]*ast.ComdatDef), + typeDefs: make(map[string]ast.TypeDef), + comdatDefs: make(map[string]ast.ComdatDef), globals: make(map[string]ast.LlvmNode), - attrGroupDefs: make(map[string]*ast.AttrGroupDef), - namedMetadataDefs: make(map[string]*ast.NamedMetadataDef), - metadataDefs: make(map[string]*ast.MetadataDef), + attrGroupDefs: make(map[string]ast.AttrGroupDef), + namedMetadataDefs: make(map[string]ast.NamedMetadataDef), + metadataDefs: make(map[string]ast.MetadataDef), }, new: newIndex{ typeDefs: make(map[string]types.Type), @@ -53,37 +53,37 @@ func newGenerator() *generator { type oldIndex struct { // typeDefs maps from type identifier (without '%' prefix) to type // definition. - typeDefs map[string]*ast.TypeDef + typeDefs map[string]ast.TypeDef // comdatDefs maps from comdat name (without '$' prefix) to comdat // definition. - comdatDefs map[string]*ast.ComdatDef + comdatDefs map[string]ast.ComdatDef // globals maps from global identifier (without '@' prefix) to global // declarations and defintions, indirect symbol definitions, function // declarations and definitions. // // The value has one of the following types. - // *ast.GlobalDecl - // *ast.GlobalDef - // *ast.AliasDef - // *ast.IFuncDef - // *ast.FuncDecl - // *ast.FuncDef + // ast.GlobalDecl + // ast.GlobalDef + // ast.AliasDef + // ast.IFuncDef + // ast.FuncDecl + // ast.FuncDef globals map[string]ast.LlvmNode // attrGroupDefs maps from attribute group ID (without '#' prefix) to // attribute group definition. - attrGroupDefs map[string]*ast.AttrGroupDef + attrGroupDefs map[string]ast.AttrGroupDef // namedMetadataDefs maps from metadata name (without '!' prefix) to named // metadata definition. - namedMetadataDefs map[string]*ast.NamedMetadataDef + namedMetadataDefs map[string]ast.NamedMetadataDef // metadataDefs maps from metadata ID (without '!' prefix) to metadata // definition. - metadataDefs map[string]*ast.MetadataDef + metadataDefs map[string]ast.MetadataDef // useListOrders is a slice of use-list orders in their order of occurrence // in the input. - useListOrders []*ast.UseListOrder + useListOrders []ast.UseListOrder // useListOrderBBs is a slice of basic block specific use-list orders in // their order of occurrence in the input. - useListOrderBBs []*ast.UseListOrderBB + useListOrderBBs []ast.UseListOrderBB // typeDefOrder records the local identifier of type definitions in their // order of occurrence in the input. typeDefOrder []string diff --git a/asm/global.go b/asm/global.go index 60f725fb..947d5ced 100644 --- a/asm/global.go +++ b/asm/global.go @@ -34,7 +34,7 @@ func (gen *generator) createGlobals() error { // definition, or function declaration or definition. func (gen *generator) newGlobal(name string, old ast.LlvmNode) (constant.Constant, error) { switch old := old.(type) { - case *ast.GlobalDecl: + case ast.GlobalDecl: new := &ir.Global{GlobalName: name} // Content type. contentType, err := gen.irType(old.ContentType()) @@ -48,7 +48,7 @@ func (gen *generator) newGlobal(name string, old ast.LlvmNode) (constant.Constan new.Typ.AddrSpace = irAddrSpace(n) } return new, nil - case *ast.GlobalDef: + case ast.GlobalDef: new := &ir.Global{GlobalName: name} // Content type. contentType, err := gen.irType(old.ContentType()) @@ -62,7 +62,7 @@ func (gen *generator) newGlobal(name string, old ast.LlvmNode) (constant.Constan new.Typ.AddrSpace = irAddrSpace(n) } return new, nil - case *ast.IndirectSymbolDef: + case ast.IndirectSymbolDef: // Content type. contentType, err := gen.irType(old.ContentType()) if err != nil { @@ -86,7 +86,7 @@ func (gen *generator) newGlobal(name string, old ast.LlvmNode) (constant.Constan default: panic(fmt.Errorf("support for indirect symbol kind %q not yet implemented", kind)) } - case *ast.FuncDecl: + case ast.FuncDecl: new := &ir.Function{GlobalName: name} // Function signature. sig, err := gen.sigFromHeader(old.Header()) @@ -100,7 +100,7 @@ func (gen *generator) newGlobal(name string, old ast.LlvmNode) (constant.Constan new.Typ.AddrSpace = irAddrSpace(n) } return new, nil - case *ast.FuncDef: + case ast.FuncDef: new := &ir.Function{GlobalName: name} // Function signature. sig, err := gen.sigFromHeader(old.Header()) @@ -132,7 +132,7 @@ func (gen *generator) translateGlobals() error { panic(fmt.Errorf("unable to locate global identifier %q", enc.Global(name))) } switch old := old.(type) { - case *ast.GlobalDecl: + case ast.GlobalDecl: new, ok := v.(*ir.Global) if !ok { panic(fmt.Errorf("invalid global declaration type; expected *ir.Global, got %T", v)) @@ -140,7 +140,7 @@ func (gen *generator) translateGlobals() error { if err := gen.translateGlobalDecl(new, old); err != nil { return errors.WithStack(err) } - case *ast.GlobalDef: + case ast.GlobalDef: new, ok := v.(*ir.Global) if !ok { panic(fmt.Errorf("invalid global definition type; expected *ir.Global, got %T", v)) @@ -148,7 +148,7 @@ func (gen *generator) translateGlobals() error { if err := gen.translateGlobalDef(new, old); err != nil { return errors.WithStack(err) } - case *ast.IndirectSymbolDef: + case ast.IndirectSymbolDef: kind := old.IndirectSymbolKind().Text() switch kind { case "alias": @@ -170,7 +170,7 @@ func (gen *generator) translateGlobals() error { default: panic(fmt.Errorf("support for indirect symbol kind %q not yet implemented", kind)) } - case *ast.FuncDecl: + case ast.FuncDecl: new, ok := v.(*ir.Function) if !ok { panic(fmt.Errorf("invalid function declaration type; expected *ir.Function, got %T", v)) @@ -178,7 +178,7 @@ func (gen *generator) translateGlobals() error { if err := gen.translateFuncDecl(new, old); err != nil { return errors.WithStack(err) } - case *ast.FuncDef: + case ast.FuncDef: new, ok := v.(*ir.Function) if !ok { panic(fmt.Errorf("invalid function definition type; expected *ir.Function, got %T", v)) @@ -196,7 +196,7 @@ func (gen *generator) translateGlobals() error { // --- [ Global declarations ] ------------------------------------------------- // translateGlobalDecl translates the given AST global declarations to IR. -func (gen *generator) translateGlobalDecl(new *ir.Global, old *ast.GlobalDecl) error { +func (gen *generator) translateGlobalDecl(new *ir.Global, old ast.GlobalDecl) error { // (optional) Linkage. new.Linkage = asmenum.LinkageFromString(old.ExternLinkage().Text()) // (optional) Preemption. @@ -264,7 +264,7 @@ func (gen *generator) translateGlobalDecl(new *ir.Global, old *ast.GlobalDecl) e // --- [ Global definitions ] -------------------------------------------------- // translateGlobalDef translates the given AST global definition to IR. -func (gen *generator) translateGlobalDef(new *ir.Global, old *ast.GlobalDef) error { +func (gen *generator) translateGlobalDef(new *ir.Global, old ast.GlobalDef) error { // (optional) Linkage. if n := old.Linkage(); n.IsValid() { new.Linkage = asmenum.LinkageFromString(n.Text()) @@ -340,7 +340,7 @@ func (gen *generator) translateGlobalDef(new *ir.Global, old *ast.GlobalDef) err // --- [ Alias definitions ] --------------------------------------------------- // translateAliasDef translates the given AST alias definition to IR. -func (gen *generator) translateAliasDef(new *ir.Alias, old *ast.IndirectSymbolDef) error { +func (gen *generator) translateAliasDef(new *ir.Alias, old ast.IndirectSymbolDef) error { // (optional) Linkage. // TODO: check that linkage is handled correctly. if n := old.Linkage(); n.IsValid() { @@ -382,7 +382,7 @@ func (gen *generator) translateAliasDef(new *ir.Alias, old *ast.IndirectSymbolDe // --- [ IFunc definitions ] --------------------------------------------------- // translateIFuncDef translates the given AST IFunc definition to IR. -func (gen *generator) translateIFuncDef(new *ir.IFunc, old *ast.IndirectSymbolDef) error { +func (gen *generator) translateIFuncDef(new *ir.IFunc, old ast.IndirectSymbolDef) error { // (optional) Linkage. // TODO: check that linkage is handled correctly. if n := old.Linkage(); n.IsValid() { @@ -424,7 +424,7 @@ func (gen *generator) translateIFuncDef(new *ir.IFunc, old *ast.IndirectSymbolDe // --- [ Function declarations ] ----------------------------------------------- // translateFuncDecl translates the given AST function declaration to IR. -func (gen *generator) translateFuncDecl(new *ir.Function, old *ast.FuncDecl) error { +func (gen *generator) translateFuncDecl(new *ir.Function, old ast.FuncDecl) error { // (optional) Metadata. md, err := gen.irMetadataAttachments(old.Metadata()) if err != nil { @@ -441,7 +441,7 @@ func (gen *generator) translateFuncDecl(new *ir.Function, old *ast.FuncDecl) err // --- [ Function definitions ] ------------------------------------------------ // translateFuncDef translates the given AST function definition to IR. -func (gen *generator) translateFuncDef(new *ir.Function, old *ast.FuncDef) error { +func (gen *generator) translateFuncDef(new *ir.Function, old ast.FuncDef) error { // Function header. if err := gen.translateFuncHeader(new, old.Header()); err != nil { return errors.WithStack(err) diff --git a/asm/helper.go b/asm/helper.go index 73b101d8..5c88717b 100644 --- a/asm/helper.go +++ b/asm/helper.go @@ -263,9 +263,9 @@ func (fgen *funcGen) irBasicBlock(old ast.Label) (*ir.BasicBlock, error) { // AST calling convention. func irCallingConv(n ast.CallingConv) enum.CallingConv { switch n := n.(type) { - case *ast.CallingConvEnum: + case ast.CallingConvEnum: return asmenum.CallingConvFromString(n.Text()) - case *ast.CallingConvInt: + case ast.CallingConvInt: cc := uintLit(n.UintLit()) switch cc { case 0: @@ -332,10 +332,10 @@ func (fgen *funcGen) irExceptionArg(n ast.ExceptionArg) (value.Value, error) { // AST exception scope. func (fgen *funcGen) irExceptionScope(n ast.ExceptionScope) (ir.ExceptionScope, error) { switch n := n.(type) { - case *ast.NoneConst: + case ast.NoneConst: return constant.None, nil - case *ast.LocalIdent: - ident := localIdent(*n) + case ast.LocalIdent: + ident := localIdent(n) v, ok := fgen.ls[ident] if !ok { return nil, errors.Errorf("unable to locate local identifier %q", ident.Ident()) @@ -361,15 +361,15 @@ func irFastMathFlags(ns []ast.FastMathFlag) []enum.FastMathFlag { // AST function attribute. func (gen *generator) irFuncAttribute(n ast.FuncAttribute) ir.FuncAttribute { switch n := n.(type) { - case *ast.AttrString: + case ast.AttrString: return ir.AttrString(unquote(n.Text())) - case *ast.AttrPair: + case ast.AttrPair: return ir.AttrPair{ Key: unquote(n.Key().Text()), Value: unquote(n.Val().Text()), } - case *ast.AttrGroupID: - id := attrGroupID(*n) + case ast.AttrGroupID: + id := attrGroupID(n) def, ok := gen.new.attrGroupDefs[id] if !ok { // Attribute group definition for ID not found. @@ -388,18 +388,18 @@ func (gen *generator) irFuncAttribute(n ast.FuncAttribute) ir.FuncAttribute { } return def // TODO: add support for Align. - //case *ast.Align: + //case ast.Align: // return ir.Align(uintLit(n.N())) - case *ast.AlignPair: + case ast.AlignPair: return ir.Align(uintLit(n.N())) - case *ast.AlignStack: + case ast.AlignStack: return ir.AlignStack(uintLit(n.N())) - case *ast.AlignStackPair: + case ast.AlignStackPair: return ir.AlignStack(uintLit(n.N())) - case *ast.AllocSize: + case ast.AllocSize: // TODO: add support for AllocSize. panic("support for function attribute AllocSize not yet implemented") - case *ast.FuncAttr: + case ast.FuncAttr: return asmenum.FuncAttrFromString(n.Text()) default: panic(fmt.Errorf("support for function attribute %T not yet implemented", n)) @@ -444,31 +444,31 @@ func (fgen *funcGen) irIncoming(xType types.Type, oldX ast.Value, oldPred ast.Lo // AST indirect symbol. func (gen *generator) irIndirectSymbol(typ *types.PointerType, old ast.IndirectSymbol) (constant.Constant, error) { switch old := old.(type) { - case *ast.TypeConst: - symbol, err := gen.irTypeConst(*old) + case ast.TypeConst: + symbol, err := gen.irTypeConst(old) if err != nil { return nil, errors.WithStack(err) } return symbol, nil - case *ast.BitCastExpr: + case ast.BitCastExpr: symbol, err := gen.irConstant(typ, old) if err != nil { return nil, errors.WithStack(err) } return symbol, nil - case *ast.GetElementPtrExpr: + case ast.GetElementPtrExpr: symbol, err := gen.irConstant(typ, old) if err != nil { return nil, errors.WithStack(err) } return symbol, nil - case *ast.AddrSpaceCastExpr: + case ast.AddrSpaceCastExpr: symbol, err := gen.irConstant(typ, old) if err != nil { return nil, errors.WithStack(err) } return symbol, nil - case *ast.IntToPtrExpr: + case ast.IntToPtrExpr: symbol, err := gen.irConstant(typ, old) if err != nil { return nil, errors.WithStack(err) @@ -485,16 +485,16 @@ func irOptLinkage(n ast.LlvmNode) enum.Linkage { if n == nil { return enum.LinkageNone } - switch n := n.(type) { - case *ast.ExternLinkage: - if n == nil { - return enum.LinkageNone - } - case *ast.Linkage: - if n == nil { - return enum.LinkageNone - } - } + // switch n := n.(type) { + // case ast.ExternLinkage: + // if n == nil { + // return enum.LinkageNone + // } + // case ast.Linkage: + // if n == nil { + // return enum.LinkageNone + // } + // } return asmenum.LinkageFromString(n.LlvmNode().Text()) } @@ -513,25 +513,25 @@ func irOverflowFlags(ns []ast.OverflowFlag) []enum.OverflowFlag { // AST parameter attribute. func irParamAttribute(n ast.ParamAttribute) ir.ParamAttribute { switch n := n.(type) { - case *ast.AttrString: + case ast.AttrString: return ir.AttrString(unquote(n.Text())) - case *ast.AttrPair: + case ast.AttrPair: return ir.AttrPair{ Key: unquote(n.Key().Text()), Value: unquote(n.Val().Text()), } - case *ast.Align: + case ast.Align: return ir.Align(uintLit(n.N())) - case *ast.Dereferenceable: + case ast.Dereferenceable: return ir.Dereferenceable{ N: uintLit(n.N()), } - case *ast.DereferenceableOrNull: + case ast.DereferenceableOrNull: return ir.Dereferenceable{ N: uintLit(n.N()), DerefOrNull: true, } - case *ast.ParamAttr: + case ast.ParamAttr: return asmenum.ParamAttrFromString(n.Text()) default: panic(fmt.Errorf("support for parameter attribute %T not yet implemented", n)) @@ -542,20 +542,20 @@ func irParamAttribute(n ast.ParamAttribute) ir.ParamAttribute { // AST return attribute. func irReturnAttribute(n ast.ReturnAttribute) ir.ReturnAttribute { switch n := n.(type) { - // TODO: add support for *ast.AttrString and *ast.AttrPair when supported by grammar. - //case *ast.AttrString: + // TODO: add support for ast.AttrString and ast.AttrPair when supported by grammar. + //case ast.AttrString: // return ir.AttrString(unquote(n.Text())) - //case *ast.AttrPair: + //case ast.AttrPair: // return ir.AttrPair{ // Key: unquote(n.Key().Text()), // Value: unquote(n.Val().Text()), // } - case *ast.Align: + case ast.Align: return ir.Align(uintLit(n.N())) - case *ast.Dereferenceable: + case ast.Dereferenceable: // TODO: add support for Dereferenceable. panic("support for return attribute Dereferenceable not yet implemented") - case *ast.ReturnAttr: + case ast.ReturnAttr: return asmenum.ReturnAttrFromString(n.Text()) default: panic(fmt.Errorf("support for return attribute %T not yet implemented", n)) diff --git a/asm/inst_aggregate.go b/asm/inst_aggregate.go index 3efbae1d..ff0fb564 100644 --- a/asm/inst_aggregate.go +++ b/asm/inst_aggregate.go @@ -14,7 +14,7 @@ import ( // astToIRInstExtractValue translates the given AST extractvalue instruction // into an equivalent IR instruction. -func (fgen *funcGen) astToIRInstExtractValue(inst ir.Instruction, old *ast.ExtractValueInst) (*ir.InstExtractValue, error) { +func (fgen *funcGen) astToIRInstExtractValue(inst ir.Instruction, old ast.ExtractValueInst) (*ir.InstExtractValue, error) { i, ok := inst.(*ir.InstExtractValue) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstExtractValue, got %T", inst)) @@ -43,7 +43,7 @@ func (fgen *funcGen) astToIRInstExtractValue(inst ir.Instruction, old *ast.Extra // astToIRInstInsertValue translates the given AST insertvalue instruction into // an equivalent IR instruction. -func (fgen *funcGen) astToIRInstInsertValue(inst ir.Instruction, old *ast.InsertValueInst) (*ir.InstInsertValue, error) { +func (fgen *funcGen) astToIRInstInsertValue(inst ir.Instruction, old ast.InsertValueInst) (*ir.InstInsertValue, error) { i, ok := inst.(*ir.InstInsertValue) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstInsertValue, got %T", inst)) diff --git a/asm/inst_binary.go b/asm/inst_binary.go index ae877412..fd5f10d3 100644 --- a/asm/inst_binary.go +++ b/asm/inst_binary.go @@ -14,7 +14,7 @@ import ( // astToIRInstAdd translates the given AST add instruction into an equivalent IR // instruction. -func (fgen *funcGen) astToIRInstAdd(inst ir.Instruction, old *ast.AddInst) (*ir.InstAdd, error) { +func (fgen *funcGen) astToIRInstAdd(inst ir.Instruction, old ast.AddInst) (*ir.InstAdd, error) { i, ok := inst.(*ir.InstAdd) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstAdd, got %T", inst)) @@ -46,7 +46,7 @@ func (fgen *funcGen) astToIRInstAdd(inst ir.Instruction, old *ast.AddInst) (*ir. // astToIRInstFAdd translates the given AST fadd instruction into an equivalent // IR instruction. -func (fgen *funcGen) astToIRInstFAdd(inst ir.Instruction, old *ast.FAddInst) (*ir.InstFAdd, error) { +func (fgen *funcGen) astToIRInstFAdd(inst ir.Instruction, old ast.FAddInst) (*ir.InstFAdd, error) { i, ok := inst.(*ir.InstFAdd) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstFAdd, got %T", inst)) @@ -78,7 +78,7 @@ func (fgen *funcGen) astToIRInstFAdd(inst ir.Instruction, old *ast.FAddInst) (*i // astToIRInstSub translates the given AST sub instruction into an equivalent IR // instruction. -func (fgen *funcGen) astToIRInstSub(inst ir.Instruction, old *ast.SubInst) (*ir.InstSub, error) { +func (fgen *funcGen) astToIRInstSub(inst ir.Instruction, old ast.SubInst) (*ir.InstSub, error) { i, ok := inst.(*ir.InstSub) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstSub, got %T", inst)) @@ -110,7 +110,7 @@ func (fgen *funcGen) astToIRInstSub(inst ir.Instruction, old *ast.SubInst) (*ir. // astToIRInstFSub translates the given AST fsub instruction into an equivalent // IR instruction. -func (fgen *funcGen) astToIRInstFSub(inst ir.Instruction, old *ast.FSubInst) (*ir.InstFSub, error) { +func (fgen *funcGen) astToIRInstFSub(inst ir.Instruction, old ast.FSubInst) (*ir.InstFSub, error) { i, ok := inst.(*ir.InstFSub) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstFSub, got %T", inst)) @@ -142,7 +142,7 @@ func (fgen *funcGen) astToIRInstFSub(inst ir.Instruction, old *ast.FSubInst) (*i // astToIRInstMul translates the given AST mul instruction into an equivalent IR // instruction. -func (fgen *funcGen) astToIRInstMul(inst ir.Instruction, old *ast.MulInst) (*ir.InstMul, error) { +func (fgen *funcGen) astToIRInstMul(inst ir.Instruction, old ast.MulInst) (*ir.InstMul, error) { i, ok := inst.(*ir.InstMul) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstMul, got %T", inst)) @@ -174,7 +174,7 @@ func (fgen *funcGen) astToIRInstMul(inst ir.Instruction, old *ast.MulInst) (*ir. // astToIRInstFMul translates the given AST fmul instruction into an equivalent // IR instruction. -func (fgen *funcGen) astToIRInstFMul(inst ir.Instruction, old *ast.FMulInst) (*ir.InstFMul, error) { +func (fgen *funcGen) astToIRInstFMul(inst ir.Instruction, old ast.FMulInst) (*ir.InstFMul, error) { i, ok := inst.(*ir.InstFMul) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstFMul, got %T", inst)) @@ -206,7 +206,7 @@ func (fgen *funcGen) astToIRInstFMul(inst ir.Instruction, old *ast.FMulInst) (*i // astToIRInstUDiv translates the given AST udiv instruction into an equivalent // IR instruction. -func (fgen *funcGen) astToIRInstUDiv(inst ir.Instruction, old *ast.UDivInst) (*ir.InstUDiv, error) { +func (fgen *funcGen) astToIRInstUDiv(inst ir.Instruction, old ast.UDivInst) (*ir.InstUDiv, error) { i, ok := inst.(*ir.InstUDiv) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstUDiv, got %T", inst)) @@ -238,7 +238,7 @@ func (fgen *funcGen) astToIRInstUDiv(inst ir.Instruction, old *ast.UDivInst) (*i // astToIRInstSDiv translates the given AST sdiv instruction into an equivalent // IR instruction. -func (fgen *funcGen) astToIRInstSDiv(inst ir.Instruction, old *ast.SDivInst) (*ir.InstSDiv, error) { +func (fgen *funcGen) astToIRInstSDiv(inst ir.Instruction, old ast.SDivInst) (*ir.InstSDiv, error) { i, ok := inst.(*ir.InstSDiv) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstSDiv, got %T", inst)) @@ -270,7 +270,7 @@ func (fgen *funcGen) astToIRInstSDiv(inst ir.Instruction, old *ast.SDivInst) (*i // astToIRInstFDiv translates the given AST fdiv instruction into an equivalent // IR instruction. -func (fgen *funcGen) astToIRInstFDiv(inst ir.Instruction, old *ast.FDivInst) (*ir.InstFDiv, error) { +func (fgen *funcGen) astToIRInstFDiv(inst ir.Instruction, old ast.FDivInst) (*ir.InstFDiv, error) { i, ok := inst.(*ir.InstFDiv) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstFDiv, got %T", inst)) @@ -302,7 +302,7 @@ func (fgen *funcGen) astToIRInstFDiv(inst ir.Instruction, old *ast.FDivInst) (*i // astToIRInstURem translates the given AST urem instruction into an equivalent // IR instruction. -func (fgen *funcGen) astToIRInstURem(inst ir.Instruction, old *ast.URemInst) (*ir.InstURem, error) { +func (fgen *funcGen) astToIRInstURem(inst ir.Instruction, old ast.URemInst) (*ir.InstURem, error) { i, ok := inst.(*ir.InstURem) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstURem, got %T", inst)) @@ -332,7 +332,7 @@ func (fgen *funcGen) astToIRInstURem(inst ir.Instruction, old *ast.URemInst) (*i // astToIRInstSRem translates the given AST srem instruction into an equivalent // IR instruction. -func (fgen *funcGen) astToIRInstSRem(inst ir.Instruction, old *ast.SRemInst) (*ir.InstSRem, error) { +func (fgen *funcGen) astToIRInstSRem(inst ir.Instruction, old ast.SRemInst) (*ir.InstSRem, error) { i, ok := inst.(*ir.InstSRem) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstSRem, got %T", inst)) @@ -362,7 +362,7 @@ func (fgen *funcGen) astToIRInstSRem(inst ir.Instruction, old *ast.SRemInst) (*i // astToIRInstFRem translates the given AST frem instruction into an equivalent // IR instruction. -func (fgen *funcGen) astToIRInstFRem(inst ir.Instruction, old *ast.FRemInst) (*ir.InstFRem, error) { +func (fgen *funcGen) astToIRInstFRem(inst ir.Instruction, old ast.FRemInst) (*ir.InstFRem, error) { i, ok := inst.(*ir.InstFRem) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstFRem, got %T", inst)) diff --git a/asm/inst_bitwise.go b/asm/inst_bitwise.go index 7629e1c4..b85798c1 100644 --- a/asm/inst_bitwise.go +++ b/asm/inst_bitwise.go @@ -14,7 +14,7 @@ import ( // astToIRInstShl translates the given AST shl instruction into an equivalent IR // instruction. -func (fgen *funcGen) astToIRInstShl(inst ir.Instruction, old *ast.ShlInst) (*ir.InstShl, error) { +func (fgen *funcGen) astToIRInstShl(inst ir.Instruction, old ast.ShlInst) (*ir.InstShl, error) { i, ok := inst.(*ir.InstShl) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstShl, got %T", inst)) @@ -46,7 +46,7 @@ func (fgen *funcGen) astToIRInstShl(inst ir.Instruction, old *ast.ShlInst) (*ir. // astToIRInstLShr translates the given AST lshr instruction into an equivalent // IR instruction. -func (fgen *funcGen) astToIRInstLShr(inst ir.Instruction, old *ast.LShrInst) (*ir.InstLShr, error) { +func (fgen *funcGen) astToIRInstLShr(inst ir.Instruction, old ast.LShrInst) (*ir.InstLShr, error) { i, ok := inst.(*ir.InstLShr) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstLShr, got %T", inst)) @@ -78,7 +78,7 @@ func (fgen *funcGen) astToIRInstLShr(inst ir.Instruction, old *ast.LShrInst) (*i // astToIRInstAShr translates the given AST ashr instruction into an equivalent // IR instruction. -func (fgen *funcGen) astToIRInstAShr(inst ir.Instruction, old *ast.AShrInst) (*ir.InstAShr, error) { +func (fgen *funcGen) astToIRInstAShr(inst ir.Instruction, old ast.AShrInst) (*ir.InstAShr, error) { i, ok := inst.(*ir.InstAShr) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstAShr, got %T", inst)) @@ -110,7 +110,7 @@ func (fgen *funcGen) astToIRInstAShr(inst ir.Instruction, old *ast.AShrInst) (*i // astToIRInstAnd translates the given AST and instruction into an equivalent IR // instruction. -func (fgen *funcGen) astToIRInstAnd(inst ir.Instruction, old *ast.AndInst) (*ir.InstAnd, error) { +func (fgen *funcGen) astToIRInstAnd(inst ir.Instruction, old ast.AndInst) (*ir.InstAnd, error) { i, ok := inst.(*ir.InstAnd) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstAnd, got %T", inst)) @@ -140,7 +140,7 @@ func (fgen *funcGen) astToIRInstAnd(inst ir.Instruction, old *ast.AndInst) (*ir. // astToIRInstOr translates the given AST or instruction into an equivalent IR // instruction. -func (fgen *funcGen) astToIRInstOr(inst ir.Instruction, old *ast.OrInst) (*ir.InstOr, error) { +func (fgen *funcGen) astToIRInstOr(inst ir.Instruction, old ast.OrInst) (*ir.InstOr, error) { i, ok := inst.(*ir.InstOr) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstOr, got %T", inst)) @@ -170,7 +170,7 @@ func (fgen *funcGen) astToIRInstOr(inst ir.Instruction, old *ast.OrInst) (*ir.In // astToIRInstXor translates the given AST xor instruction into an equivalent IR // instruction. -func (fgen *funcGen) astToIRInstXor(inst ir.Instruction, old *ast.XorInst) (*ir.InstXor, error) { +func (fgen *funcGen) astToIRInstXor(inst ir.Instruction, old ast.XorInst) (*ir.InstXor, error) { i, ok := inst.(*ir.InstXor) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstXor, got %T", inst)) diff --git a/asm/inst_conversion.go b/asm/inst_conversion.go index 0eb49931..94429009 100644 --- a/asm/inst_conversion.go +++ b/asm/inst_conversion.go @@ -14,7 +14,7 @@ import ( // astToIRInstTrunc translates the given AST trunc instruction into an // equivalent IR instruction. -func (fgen *funcGen) astToIRInstTrunc(inst ir.Instruction, old *ast.TruncInst) (*ir.InstTrunc, error) { +func (fgen *funcGen) astToIRInstTrunc(inst ir.Instruction, old ast.TruncInst) (*ir.InstTrunc, error) { i, ok := inst.(*ir.InstTrunc) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstTrunc, got %T", inst)) @@ -44,7 +44,7 @@ func (fgen *funcGen) astToIRInstTrunc(inst ir.Instruction, old *ast.TruncInst) ( // astToIRInstZExt translates the given AST zext instruction into an equivalent // IR instruction. -func (fgen *funcGen) astToIRInstZExt(inst ir.Instruction, old *ast.ZExtInst) (*ir.InstZExt, error) { +func (fgen *funcGen) astToIRInstZExt(inst ir.Instruction, old ast.ZExtInst) (*ir.InstZExt, error) { i, ok := inst.(*ir.InstZExt) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstZExt, got %T", inst)) @@ -74,7 +74,7 @@ func (fgen *funcGen) astToIRInstZExt(inst ir.Instruction, old *ast.ZExtInst) (*i // astToIRInstSExt translates the given AST sext instruction into an equivalent // IR instruction. -func (fgen *funcGen) astToIRInstSExt(inst ir.Instruction, old *ast.SExtInst) (*ir.InstSExt, error) { +func (fgen *funcGen) astToIRInstSExt(inst ir.Instruction, old ast.SExtInst) (*ir.InstSExt, error) { i, ok := inst.(*ir.InstSExt) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstSExt, got %T", inst)) @@ -104,7 +104,7 @@ func (fgen *funcGen) astToIRInstSExt(inst ir.Instruction, old *ast.SExtInst) (*i // astToIRInstFPTrunc translates the given AST fptrunc instruction into an // equivalent IR instruction. -func (fgen *funcGen) astToIRInstFPTrunc(inst ir.Instruction, old *ast.FPTruncInst) (*ir.InstFPTrunc, error) { +func (fgen *funcGen) astToIRInstFPTrunc(inst ir.Instruction, old ast.FPTruncInst) (*ir.InstFPTrunc, error) { i, ok := inst.(*ir.InstFPTrunc) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstFPTrunc, got %T", inst)) @@ -134,7 +134,7 @@ func (fgen *funcGen) astToIRInstFPTrunc(inst ir.Instruction, old *ast.FPTruncIns // astToIRInstFPExt translates the given AST fpext instruction into an // equivalent IR instruction. -func (fgen *funcGen) astToIRInstFPExt(inst ir.Instruction, old *ast.FPExtInst) (*ir.InstFPExt, error) { +func (fgen *funcGen) astToIRInstFPExt(inst ir.Instruction, old ast.FPExtInst) (*ir.InstFPExt, error) { i, ok := inst.(*ir.InstFPExt) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstFPExt, got %T", inst)) @@ -164,7 +164,7 @@ func (fgen *funcGen) astToIRInstFPExt(inst ir.Instruction, old *ast.FPExtInst) ( // astToIRInstFPToUI translates the given AST fptoui instruction into an // equivalent IR instruction. -func (fgen *funcGen) astToIRInstFPToUI(inst ir.Instruction, old *ast.FPToUIInst) (*ir.InstFPToUI, error) { +func (fgen *funcGen) astToIRInstFPToUI(inst ir.Instruction, old ast.FPToUIInst) (*ir.InstFPToUI, error) { i, ok := inst.(*ir.InstFPToUI) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstFPToUI, got %T", inst)) @@ -194,7 +194,7 @@ func (fgen *funcGen) astToIRInstFPToUI(inst ir.Instruction, old *ast.FPToUIInst) // astToIRInstFPToSI translates the given AST fptosi instruction into an // equivalent IR instruction. -func (fgen *funcGen) astToIRInstFPToSI(inst ir.Instruction, old *ast.FPToSIInst) (*ir.InstFPToSI, error) { +func (fgen *funcGen) astToIRInstFPToSI(inst ir.Instruction, old ast.FPToSIInst) (*ir.InstFPToSI, error) { i, ok := inst.(*ir.InstFPToSI) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstFPToSI, got %T", inst)) @@ -224,7 +224,7 @@ func (fgen *funcGen) astToIRInstFPToSI(inst ir.Instruction, old *ast.FPToSIInst) // astToIRInstUIToFP translates the given AST uitofp instruction into an // equivalent IR instruction. -func (fgen *funcGen) astToIRInstUIToFP(inst ir.Instruction, old *ast.UIToFPInst) (*ir.InstUIToFP, error) { +func (fgen *funcGen) astToIRInstUIToFP(inst ir.Instruction, old ast.UIToFPInst) (*ir.InstUIToFP, error) { i, ok := inst.(*ir.InstUIToFP) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstUIToFP, got %T", inst)) @@ -254,7 +254,7 @@ func (fgen *funcGen) astToIRInstUIToFP(inst ir.Instruction, old *ast.UIToFPInst) // astToIRInstSIToFP translates the given AST sitofp instruction into an // equivalent IR instruction. -func (fgen *funcGen) astToIRInstSIToFP(inst ir.Instruction, old *ast.SIToFPInst) (*ir.InstSIToFP, error) { +func (fgen *funcGen) astToIRInstSIToFP(inst ir.Instruction, old ast.SIToFPInst) (*ir.InstSIToFP, error) { i, ok := inst.(*ir.InstSIToFP) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstSIToFP, got %T", inst)) @@ -284,7 +284,7 @@ func (fgen *funcGen) astToIRInstSIToFP(inst ir.Instruction, old *ast.SIToFPInst) // astToIRInstPtrToInt translates the given AST ptrtoint instruction into an // equivalent IR instruction. -func (fgen *funcGen) astToIRInstPtrToInt(inst ir.Instruction, old *ast.PtrToIntInst) (*ir.InstPtrToInt, error) { +func (fgen *funcGen) astToIRInstPtrToInt(inst ir.Instruction, old ast.PtrToIntInst) (*ir.InstPtrToInt, error) { i, ok := inst.(*ir.InstPtrToInt) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstPtrToInt, got %T", inst)) @@ -314,7 +314,7 @@ func (fgen *funcGen) astToIRInstPtrToInt(inst ir.Instruction, old *ast.PtrToIntI // astToIRInstIntToPtr translates the given AST inttoptr instruction into an // equivalent IR instruction. -func (fgen *funcGen) astToIRInstIntToPtr(inst ir.Instruction, old *ast.IntToPtrInst) (*ir.InstIntToPtr, error) { +func (fgen *funcGen) astToIRInstIntToPtr(inst ir.Instruction, old ast.IntToPtrInst) (*ir.InstIntToPtr, error) { i, ok := inst.(*ir.InstIntToPtr) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstIntToPtr, got %T", inst)) @@ -344,7 +344,7 @@ func (fgen *funcGen) astToIRInstIntToPtr(inst ir.Instruction, old *ast.IntToPtrI // astToIRInstBitCast translates the given AST bitcast instruction into an // equivalent IR instruction. -func (fgen *funcGen) astToIRInstBitCast(inst ir.Instruction, old *ast.BitCastInst) (*ir.InstBitCast, error) { +func (fgen *funcGen) astToIRInstBitCast(inst ir.Instruction, old ast.BitCastInst) (*ir.InstBitCast, error) { i, ok := inst.(*ir.InstBitCast) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstBitCast, got %T", inst)) @@ -374,7 +374,7 @@ func (fgen *funcGen) astToIRInstBitCast(inst ir.Instruction, old *ast.BitCastIns // astToIRInstAddrSpaceCast translates the given AST addrspacecast instruction // into an equivalent IR instruction. -func (fgen *funcGen) astToIRInstAddrSpaceCast(inst ir.Instruction, old *ast.AddrSpaceCastInst) (*ir.InstAddrSpaceCast, error) { +func (fgen *funcGen) astToIRInstAddrSpaceCast(inst ir.Instruction, old ast.AddrSpaceCastInst) (*ir.InstAddrSpaceCast, error) { i, ok := inst.(*ir.InstAddrSpaceCast) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstAddrSpaceCast, got %T", inst)) diff --git a/asm/inst_memory.go b/asm/inst_memory.go index ae6041a1..5ebf4c86 100644 --- a/asm/inst_memory.go +++ b/asm/inst_memory.go @@ -15,7 +15,7 @@ import ( // astToIRInstAlloca translates the given AST alloca instruction into an // equivalent IR instruction. -func (fgen *funcGen) astToIRInstAlloca(inst ir.Instruction, old *ast.AllocaInst) (*ir.InstAlloca, error) { +func (fgen *funcGen) astToIRInstAlloca(inst ir.Instruction, old ast.AllocaInst) (*ir.InstAlloca, error) { i, ok := inst.(*ir.InstAlloca) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstAlloca, got %T", inst)) @@ -60,7 +60,7 @@ func (fgen *funcGen) astToIRInstAlloca(inst ir.Instruction, old *ast.AllocaInst) // astToIRInstLoad translates the given AST load instruction into an equivalent // IR instruction. -func (fgen *funcGen) astToIRInstLoad(inst ir.Instruction, old *ast.LoadInst) (*ir.InstLoad, error) { +func (fgen *funcGen) astToIRInstLoad(inst ir.Instruction, old ast.LoadInst) (*ir.InstLoad, error) { i, ok := inst.(*ir.InstLoad) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstLoad, got %T", inst)) @@ -100,7 +100,7 @@ func (fgen *funcGen) astToIRInstLoad(inst ir.Instruction, old *ast.LoadInst) (*i // astToIRInstStore translates the given AST store instruction into an // equivalent IR instruction. -func (fgen *funcGen) astToIRInstStore(inst ir.Instruction, old *ast.StoreInst) (*ir.InstStore, error) { +func (fgen *funcGen) astToIRInstStore(inst ir.Instruction, old ast.StoreInst) (*ir.InstStore, error) { i, ok := inst.(*ir.InstStore) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstStore, got %T", inst)) @@ -146,7 +146,7 @@ func (fgen *funcGen) astToIRInstStore(inst ir.Instruction, old *ast.StoreInst) ( // astToIRInstFence translates the given AST fence instruction into an // equivalent IR instruction. -func (fgen *funcGen) astToIRInstFence(inst ir.Instruction, old *ast.FenceInst) (*ir.InstFence, error) { +func (fgen *funcGen) astToIRInstFence(inst ir.Instruction, old ast.FenceInst) (*ir.InstFence, error) { i, ok := inst.(*ir.InstFence) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstFence, got %T", inst)) @@ -170,7 +170,7 @@ func (fgen *funcGen) astToIRInstFence(inst ir.Instruction, old *ast.FenceInst) ( // astToIRInstCmpXchg translates the given AST cmpxchg instruction into an // equivalent IR instruction. -func (fgen *funcGen) astToIRInstCmpXchg(inst ir.Instruction, old *ast.CmpXchgInst) (*ir.InstCmpXchg, error) { +func (fgen *funcGen) astToIRInstCmpXchg(inst ir.Instruction, old ast.CmpXchgInst) (*ir.InstCmpXchg, error) { i, ok := inst.(*ir.InstCmpXchg) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstCmpXchg, got %T", inst)) @@ -218,7 +218,7 @@ func (fgen *funcGen) astToIRInstCmpXchg(inst ir.Instruction, old *ast.CmpXchgIns // astToIRInstAtomicRMW translates the given AST atomicrmw instruction into an // equivalent IR instruction. -func (fgen *funcGen) astToIRInstAtomicRMW(inst ir.Instruction, old *ast.AtomicRMWInst) (*ir.InstAtomicRMW, error) { +func (fgen *funcGen) astToIRInstAtomicRMW(inst ir.Instruction, old ast.AtomicRMWInst) (*ir.InstAtomicRMW, error) { i, ok := inst.(*ir.InstAtomicRMW) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstAtomicRMW, got %T", inst)) @@ -258,7 +258,7 @@ func (fgen *funcGen) astToIRInstAtomicRMW(inst ir.Instruction, old *ast.AtomicRM // astToIRInstGetElementPtr translates the given AST getelementptr instruction // into an equivalent IR instruction. -func (fgen *funcGen) astToIRInstGetElementPtr(inst ir.Instruction, old *ast.GetElementPtrInst) (*ir.InstGetElementPtr, error) { +func (fgen *funcGen) astToIRInstGetElementPtr(inst ir.Instruction, old ast.GetElementPtrInst) (*ir.InstGetElementPtr, error) { i, ok := inst.(*ir.InstGetElementPtr) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstGetElementPtr, got %T", inst)) diff --git a/asm/inst_other.go b/asm/inst_other.go index 81a413b2..3c126ba9 100644 --- a/asm/inst_other.go +++ b/asm/inst_other.go @@ -16,7 +16,7 @@ import ( // astToIRInstICmp translates the given AST icmp instruction into an equivalent // IR instruction. -func (fgen *funcGen) astToIRInstICmp(inst ir.Instruction, old *ast.ICmpInst) (*ir.InstICmp, error) { +func (fgen *funcGen) astToIRInstICmp(inst ir.Instruction, old ast.ICmpInst) (*ir.InstICmp, error) { i, ok := inst.(*ir.InstICmp) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstICmp, got %T", inst)) @@ -48,7 +48,7 @@ func (fgen *funcGen) astToIRInstICmp(inst ir.Instruction, old *ast.ICmpInst) (*i // astToIRInstFCmp translates the given AST fcmp instruction into an equivalent // IR instruction. -func (fgen *funcGen) astToIRInstFCmp(inst ir.Instruction, old *ast.FCmpInst) (*ir.InstFCmp, error) { +func (fgen *funcGen) astToIRInstFCmp(inst ir.Instruction, old ast.FCmpInst) (*ir.InstFCmp, error) { i, ok := inst.(*ir.InstFCmp) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstFCmp, got %T", inst)) @@ -82,7 +82,7 @@ func (fgen *funcGen) astToIRInstFCmp(inst ir.Instruction, old *ast.FCmpInst) (*i // astToIRInstPhi translates the given AST phi instruction into an equivalent IR // instruction. -func (fgen *funcGen) astToIRInstPhi(inst ir.Instruction, old *ast.PhiInst) (*ir.InstPhi, error) { +func (fgen *funcGen) astToIRInstPhi(inst ir.Instruction, old ast.PhiInst) (*ir.InstPhi, error) { i, ok := inst.(*ir.InstPhi) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstPhi, got %T", inst)) @@ -112,7 +112,7 @@ func (fgen *funcGen) astToIRInstPhi(inst ir.Instruction, old *ast.PhiInst) (*ir. // astToIRInstSelect translates the given AST select instruction into an // equivalent IR instruction. -func (fgen *funcGen) astToIRInstSelect(inst ir.Instruction, old *ast.SelectInst) (*ir.InstSelect, error) { +func (fgen *funcGen) astToIRInstSelect(inst ir.Instruction, old ast.SelectInst) (*ir.InstSelect, error) { i, ok := inst.(*ir.InstSelect) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstSelect, got %T", inst)) @@ -148,7 +148,7 @@ func (fgen *funcGen) astToIRInstSelect(inst ir.Instruction, old *ast.SelectInst) // astToIRInstCall translates the given AST call instruction into an equivalent // IR instruction. -func (fgen *funcGen) astToIRInstCall(inst ir.Instruction, old *ast.CallInst) (*ir.InstCall, error) { +func (fgen *funcGen) astToIRInstCall(inst ir.Instruction, old ast.CallInst) (*ir.InstCall, error) { i, ok := inst.(*ir.InstCall) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstCall, got %T", inst)) @@ -223,7 +223,7 @@ func (fgen *funcGen) astToIRInstCall(inst ir.Instruction, old *ast.CallInst) (*i // astToIRInstVAArg translates the given AST vaarg instruction into an // equivalent IR instruction. -func (fgen *funcGen) astToIRInstVAArg(inst ir.Instruction, old *ast.VAArgInst) (*ir.InstVAArg, error) { +func (fgen *funcGen) astToIRInstVAArg(inst ir.Instruction, old ast.VAArgInst) (*ir.InstVAArg, error) { i, ok := inst.(*ir.InstVAArg) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstVAArg, got %T", inst)) @@ -253,7 +253,7 @@ func (fgen *funcGen) astToIRInstVAArg(inst ir.Instruction, old *ast.VAArgInst) ( // astToIRInstLandingPad translates the given AST landingpad instruction into an // equivalent IR instruction. -func (fgen *funcGen) astToIRInstLandingPad(inst ir.Instruction, old *ast.LandingPadInst) (*ir.InstLandingPad, error) { +func (fgen *funcGen) astToIRInstLandingPad(inst ir.Instruction, old ast.LandingPadInst) (*ir.InstLandingPad, error) { i, ok := inst.(*ir.InstLandingPad) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstLandingPad, got %T", inst)) @@ -287,7 +287,7 @@ func (fgen *funcGen) astToIRInstLandingPad(inst ir.Instruction, old *ast.Landing // astToIRInstCatchPad translates the given AST catchpad instruction into an // equivalent IR instruction. -func (fgen *funcGen) astToIRInstCatchPad(inst ir.Instruction, old *ast.CatchPadInst) (*ir.InstCatchPad, error) { +func (fgen *funcGen) astToIRInstCatchPad(inst ir.Instruction, old ast.CatchPadInst) (*ir.InstCatchPad, error) { i, ok := inst.(*ir.InstCatchPad) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstCatchPad, got %T", inst)) @@ -324,7 +324,7 @@ func (fgen *funcGen) astToIRInstCatchPad(inst ir.Instruction, old *ast.CatchPadI // astToIRInstCleanupPad translates the given AST cleanuppad instruction into an // equivalent IR instruction. -func (fgen *funcGen) astToIRInstCleanupPad(inst ir.Instruction, old *ast.CleanupPadInst) (*ir.InstCleanupPad, error) { +func (fgen *funcGen) astToIRInstCleanupPad(inst ir.Instruction, old ast.CleanupPadInst) (*ir.InstCleanupPad, error) { i, ok := inst.(*ir.InstCleanupPad) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstCleanupPad, got %T", inst)) diff --git a/asm/inst_vector.go b/asm/inst_vector.go index f1873051..dc92f6ec 100644 --- a/asm/inst_vector.go +++ b/asm/inst_vector.go @@ -14,7 +14,7 @@ import ( // astToIRInstExtractElement translates the given AST extractelement instruction // into an equivalent IR instruction. -func (fgen *funcGen) astToIRInstExtractElement(inst ir.Instruction, old *ast.ExtractElementInst) (*ir.InstExtractElement, error) { +func (fgen *funcGen) astToIRInstExtractElement(inst ir.Instruction, old ast.ExtractElementInst) (*ir.InstExtractElement, error) { i, ok := inst.(*ir.InstExtractElement) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstExtractElement, got %T", inst)) @@ -44,7 +44,7 @@ func (fgen *funcGen) astToIRInstExtractElement(inst ir.Instruction, old *ast.Ext // astToIRInstInsertElement translates the given AST insertelement instruction // into an equivalent IR instruction. -func (fgen *funcGen) astToIRInstInsertElement(inst ir.Instruction, old *ast.InsertElementInst) (*ir.InstInsertElement, error) { +func (fgen *funcGen) astToIRInstInsertElement(inst ir.Instruction, old ast.InsertElementInst) (*ir.InstInsertElement, error) { i, ok := inst.(*ir.InstInsertElement) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstInsertElement, got %T", inst)) @@ -80,7 +80,7 @@ func (fgen *funcGen) astToIRInstInsertElement(inst ir.Instruction, old *ast.Inse // astToIRInstShuffleVector translates the given AST shufflevector instruction // into an equivalent IR instruction. -func (fgen *funcGen) astToIRInstShuffleVector(inst ir.Instruction, old *ast.ShuffleVectorInst) (*ir.InstShuffleVector, error) { +func (fgen *funcGen) astToIRInstShuffleVector(inst ir.Instruction, old ast.ShuffleVectorInst) (*ir.InstShuffleVector, error) { i, ok := inst.(*ir.InstShuffleVector) if !ok { panic(fmt.Errorf("invalid IR instruction for AST instruction; expected *ir.InstShuffleVector, got %T", inst)) diff --git a/asm/local.go b/asm/local.go index 42fa9fd3..eb7ac974 100644 --- a/asm/local.go +++ b/asm/local.go @@ -85,15 +85,15 @@ func (fgen *funcGen) resolveLocals(body ast.FuncBody) error { func (fgen *funcGen) newIRInst(old ast.Instruction) (ir.Instruction, error) { switch old := old.(type) { // Value instructions. - case *ast.LocalDefInst: + case ast.LocalDefInst: ident := localIdent(old.Name()) return fgen.newIRValueInst(ident, old.Inst()) case ast.ValueInstruction: return fgen.newIRValueInst(ir.LocalIdent{}, old) // Non-value instructions. - case *ast.StoreInst: + case ast.StoreInst: return &ir.InstStore{}, nil - case *ast.FenceInst: + case ast.FenceInst: return &ir.InstFence{}, nil default: panic(fmt.Errorf("support for AST instruction type %T not yet implemented", old)) @@ -105,117 +105,117 @@ func (fgen *funcGen) newIRInst(old ast.Instruction) (ir.Instruction, error) { func (fgen *funcGen) newIRValueInst(ident ir.LocalIdent, old ast.ValueInstruction) (ir.Instruction, error) { switch old := old.(type) { // Binary instructions - case *ast.AddInst: + case ast.AddInst: typ, err := fgen.gen.irType(old.X().Typ()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstAdd{LocalIdent: ident, Typ: typ}, nil - case *ast.FAddInst: + case ast.FAddInst: typ, err := fgen.gen.irType(old.X().Typ()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstFAdd{LocalIdent: ident, Typ: typ}, nil - case *ast.SubInst: + case ast.SubInst: typ, err := fgen.gen.irType(old.X().Typ()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstSub{LocalIdent: ident, Typ: typ}, nil - case *ast.FSubInst: + case ast.FSubInst: typ, err := fgen.gen.irType(old.X().Typ()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstFSub{LocalIdent: ident, Typ: typ}, nil - case *ast.MulInst: + case ast.MulInst: typ, err := fgen.gen.irType(old.X().Typ()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstMul{LocalIdent: ident, Typ: typ}, nil - case *ast.FMulInst: + case ast.FMulInst: typ, err := fgen.gen.irType(old.X().Typ()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstFMul{LocalIdent: ident, Typ: typ}, nil - case *ast.UDivInst: + case ast.UDivInst: typ, err := fgen.gen.irType(old.X().Typ()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstUDiv{LocalIdent: ident, Typ: typ}, nil - case *ast.SDivInst: + case ast.SDivInst: typ, err := fgen.gen.irType(old.X().Typ()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstSDiv{LocalIdent: ident, Typ: typ}, nil - case *ast.FDivInst: + case ast.FDivInst: typ, err := fgen.gen.irType(old.X().Typ()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstFDiv{LocalIdent: ident, Typ: typ}, nil - case *ast.URemInst: + case ast.URemInst: typ, err := fgen.gen.irType(old.X().Typ()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstURem{LocalIdent: ident, Typ: typ}, nil - case *ast.SRemInst: + case ast.SRemInst: typ, err := fgen.gen.irType(old.X().Typ()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstSRem{LocalIdent: ident, Typ: typ}, nil - case *ast.FRemInst: + case ast.FRemInst: typ, err := fgen.gen.irType(old.X().Typ()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstFRem{LocalIdent: ident, Typ: typ}, nil // Bitwise instructions - case *ast.ShlInst: + case ast.ShlInst: typ, err := fgen.gen.irType(old.X().Typ()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstShl{LocalIdent: ident, Typ: typ}, nil - case *ast.LShrInst: + case ast.LShrInst: typ, err := fgen.gen.irType(old.X().Typ()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstLShr{LocalIdent: ident, Typ: typ}, nil - case *ast.AShrInst: + case ast.AShrInst: typ, err := fgen.gen.irType(old.X().Typ()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstAShr{LocalIdent: ident, Typ: typ}, nil - case *ast.AndInst: + case ast.AndInst: typ, err := fgen.gen.irType(old.X().Typ()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstAnd{LocalIdent: ident, Typ: typ}, nil - case *ast.OrInst: + case ast.OrInst: typ, err := fgen.gen.irType(old.X().Typ()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstOr{LocalIdent: ident, Typ: typ}, nil - case *ast.XorInst: + case ast.XorInst: typ, err := fgen.gen.irType(old.X().Typ()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstXor{LocalIdent: ident, Typ: typ}, nil // Vector instructions - case *ast.ExtractElementInst: + case ast.ExtractElementInst: xType, err := fgen.gen.irType(old.X().Typ()) if err != nil { return nil, errors.WithStack(err) @@ -225,7 +225,7 @@ func (fgen *funcGen) newIRValueInst(ident ir.LocalIdent, old ast.ValueInstructio panic(fmt.Errorf("invalid vector type; expected *types.VectorType, got %T", xType)) } return &ir.InstExtractElement{LocalIdent: ident, Typ: t.ElemType}, nil - case *ast.InsertElementInst: + case ast.InsertElementInst: xType, err := fgen.gen.irType(old.X().Typ()) if err != nil { return nil, errors.WithStack(err) @@ -235,7 +235,7 @@ func (fgen *funcGen) newIRValueInst(ident ir.LocalIdent, old ast.ValueInstructio panic(fmt.Errorf("invalid vector type; expected *types.VectorType, got %T", xType)) } return &ir.InstInsertElement{LocalIdent: ident, Typ: t}, nil - case *ast.ShuffleVectorInst: + case ast.ShuffleVectorInst: xType, err := fgen.gen.irType(old.X().Typ()) if err != nil { return nil, errors.WithStack(err) @@ -255,7 +255,7 @@ func (fgen *funcGen) newIRValueInst(ident ir.LocalIdent, old ast.ValueInstructio typ := types.NewVector(mt.Len, xt.ElemType) return &ir.InstShuffleVector{LocalIdent: ident, Typ: typ}, nil // Aggregate instructions - case *ast.ExtractValueInst: + case ast.ExtractValueInst: xType, err := fgen.gen.irType(old.X().Typ()) if err != nil { return nil, errors.WithStack(err) @@ -263,14 +263,14 @@ func (fgen *funcGen) newIRValueInst(ident ir.LocalIdent, old ast.ValueInstructio indices := uintSlice(old.Indices()) typ := aggregateElemType(xType, indices) return &ir.InstExtractValue{LocalIdent: ident, Typ: typ}, nil - case *ast.InsertValueInst: + case ast.InsertValueInst: typ, err := fgen.gen.irType(old.X().Typ()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstInsertValue{LocalIdent: ident, Typ: typ}, nil // Memory instructions - case *ast.AllocaInst: + case ast.AllocaInst: elemType, err := fgen.gen.irType(old.ElemType()) if err != nil { return nil, errors.WithStack(err) @@ -279,20 +279,20 @@ func (fgen *funcGen) newIRValueInst(ident ir.LocalIdent, old ast.ValueInstructio // Cache i.Typ. i.Type() return i, nil - case *ast.LoadInst: + case ast.LoadInst: elemType, err := fgen.gen.irType(old.ElemType()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstLoad{LocalIdent: ident, Typ: elemType}, nil - case *ast.CmpXchgInst: + case ast.CmpXchgInst: oldType, err := fgen.gen.irType(old.New().Typ()) if err != nil { return nil, errors.WithStack(err) } typ := types.NewStruct(oldType, types.I8) return &ir.InstCmpXchg{LocalIdent: ident, Typ: typ}, nil - case *ast.AtomicRMWInst: + case ast.AtomicRMWInst: dstType, err := fgen.gen.irType(old.Dst().Typ()) if err != nil { return nil, errors.WithStack(err) @@ -302,7 +302,7 @@ func (fgen *funcGen) newIRValueInst(ident ir.LocalIdent, old ast.ValueInstructio panic(fmt.Errorf("invalid pointer type; expected *types.PointerType, got %T", dstType)) } return &ir.InstAtomicRMW{LocalIdent: ident, Typ: t.ElemType}, nil - case *ast.GetElementPtrInst: + case ast.GetElementPtrInst: // TODO: handle address space of Src? // Element type. elemType, err := fgen.gen.irType(old.ElemType()) @@ -315,86 +315,86 @@ func (fgen *funcGen) newIRValueInst(ident ir.LocalIdent, old ast.ValueInstructio } return &ir.InstGetElementPtr{LocalIdent: ident, ElemType: elemType, Typ: typ}, nil // Conversion instructions - case *ast.TruncInst: + case ast.TruncInst: to, err := fgen.gen.irType(old.To()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstTrunc{LocalIdent: ident, To: to}, nil - case *ast.ZExtInst: + case ast.ZExtInst: to, err := fgen.gen.irType(old.To()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstZExt{LocalIdent: ident, To: to}, nil - case *ast.SExtInst: + case ast.SExtInst: to, err := fgen.gen.irType(old.To()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstSExt{LocalIdent: ident, To: to}, nil - case *ast.FPTruncInst: + case ast.FPTruncInst: to, err := fgen.gen.irType(old.To()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstFPTrunc{LocalIdent: ident, To: to}, nil - case *ast.FPExtInst: + case ast.FPExtInst: to, err := fgen.gen.irType(old.To()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstFPExt{LocalIdent: ident, To: to}, nil - case *ast.FPToUIInst: + case ast.FPToUIInst: to, err := fgen.gen.irType(old.To()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstFPToUI{LocalIdent: ident, To: to}, nil - case *ast.FPToSIInst: + case ast.FPToSIInst: to, err := fgen.gen.irType(old.To()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstFPToSI{LocalIdent: ident, To: to}, nil - case *ast.UIToFPInst: + case ast.UIToFPInst: to, err := fgen.gen.irType(old.To()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstUIToFP{LocalIdent: ident, To: to}, nil - case *ast.SIToFPInst: + case ast.SIToFPInst: to, err := fgen.gen.irType(old.To()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstSIToFP{LocalIdent: ident, To: to}, nil - case *ast.PtrToIntInst: + case ast.PtrToIntInst: to, err := fgen.gen.irType(old.To()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstPtrToInt{LocalIdent: ident, To: to}, nil - case *ast.IntToPtrInst: + case ast.IntToPtrInst: to, err := fgen.gen.irType(old.To()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstIntToPtr{LocalIdent: ident, To: to}, nil - case *ast.BitCastInst: + case ast.BitCastInst: to, err := fgen.gen.irType(old.To()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstBitCast{LocalIdent: ident, To: to}, nil - case *ast.AddrSpaceCastInst: + case ast.AddrSpaceCastInst: to, err := fgen.gen.irType(old.To()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstAddrSpaceCast{LocalIdent: ident, To: to}, nil // Other instructions - case *ast.ICmpInst: + case ast.ICmpInst: xType, err := fgen.gen.irType(old.X().Typ()) if err != nil { return nil, errors.WithStack(err) @@ -409,7 +409,7 @@ func (fgen *funcGen) newIRValueInst(ident ir.LocalIdent, old ast.ValueInstructio panic(fmt.Errorf("invalid icmp operand type; expected *types.IntType, *types.PointerType or *types.VectorType, got %T", xType)) } return &ir.InstICmp{LocalIdent: ident, Typ: typ}, nil - case *ast.FCmpInst: + case ast.FCmpInst: xType, err := fgen.gen.irType(old.X().Typ()) if err != nil { return nil, errors.WithStack(err) @@ -424,19 +424,19 @@ func (fgen *funcGen) newIRValueInst(ident ir.LocalIdent, old ast.ValueInstructio panic(fmt.Errorf("invalid fcmp operand type; expected *types.FloatType or *types.VectorType, got %T", xType)) } return &ir.InstFCmp{LocalIdent: ident, Typ: typ}, nil - case *ast.PhiInst: + case ast.PhiInst: typ, err := fgen.gen.irType(old.Typ()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstPhi{LocalIdent: ident, Typ: typ}, nil - case *ast.SelectInst: + case ast.SelectInst: typ, err := fgen.gen.irType(old.X().Typ()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstSelect{LocalIdent: ident, Typ: typ}, nil - case *ast.CallInst: + case ast.CallInst: // NOTE: We need to store the type of call instructions before invoking // f.AssignIDs, since call instructions may be value instructions or // non-value instructions based on return type. @@ -445,22 +445,22 @@ func (fgen *funcGen) newIRValueInst(ident ir.LocalIdent, old ast.ValueInstructio return nil, errors.WithStack(err) } return &ir.InstCall{LocalIdent: ident, Typ: typ}, nil - case *ast.VAArgInst: + case ast.VAArgInst: argType, err := fgen.gen.irType(old.ArgType()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstVAArg{LocalIdent: ident, ArgType: argType}, nil - case *ast.LandingPadInst: + case ast.LandingPadInst: resultType, err := fgen.gen.irType(old.ResultType()) if err != nil { return nil, errors.WithStack(err) } return &ir.InstLandingPad{LocalIdent: ident, ResultType: resultType}, nil - case *ast.CatchPadInst: + case ast.CatchPadInst: // Result type is always token. return &ir.InstCatchPad{LocalIdent: ident}, nil - case *ast.CleanupPadInst: + case ast.CleanupPadInst: // Result type is always token. return &ir.InstCleanupPad{LocalIdent: ident}, nil default: @@ -474,7 +474,7 @@ func (fgen *funcGen) newIRValueInst(ident ir.LocalIdent, old ast.ValueInstructio func (fgen *funcGen) astToIRInst(inst ir.Instruction, old ast.Instruction) (ir.Instruction, error) { switch old := old.(type) { // Value instruction. - case *ast.LocalDefInst: + case ast.LocalDefInst: ident := localIdent(old.Name()) v, ok := fgen.ls[ident] if !ok { @@ -488,9 +488,9 @@ func (fgen *funcGen) astToIRInst(inst ir.Instruction, old ast.Instruction) (ir.I case ast.ValueInstruction: return fgen.astToIRValueInst(inst, old) // Non-value instructions. - case *ast.StoreInst: + case ast.StoreInst: return fgen.astToIRInstStore(inst, old) - case *ast.FenceInst: + case ast.FenceInst: return fgen.astToIRInstFence(inst, old) default: panic(fmt.Errorf("support for instruction type %T not yet implemented", old)) @@ -502,111 +502,111 @@ func (fgen *funcGen) astToIRInst(inst ir.Instruction, old ast.Instruction) (ir.I func (fgen *funcGen) astToIRValueInst(inst ir.Instruction, old ast.ValueInstruction) (ir.Instruction, error) { switch old := old.(type) { // Binary instructions - case *ast.AddInst: + case ast.AddInst: return fgen.astToIRInstAdd(inst, old) - case *ast.FAddInst: + case ast.FAddInst: return fgen.astToIRInstFAdd(inst, old) - case *ast.SubInst: + case ast.SubInst: return fgen.astToIRInstSub(inst, old) - case *ast.FSubInst: + case ast.FSubInst: return fgen.astToIRInstFSub(inst, old) - case *ast.MulInst: + case ast.MulInst: return fgen.astToIRInstMul(inst, old) - case *ast.FMulInst: + case ast.FMulInst: return fgen.astToIRInstFMul(inst, old) - case *ast.UDivInst: + case ast.UDivInst: return fgen.astToIRInstUDiv(inst, old) - case *ast.SDivInst: + case ast.SDivInst: return fgen.astToIRInstSDiv(inst, old) - case *ast.FDivInst: + case ast.FDivInst: return fgen.astToIRInstFDiv(inst, old) - case *ast.URemInst: + case ast.URemInst: return fgen.astToIRInstURem(inst, old) - case *ast.SRemInst: + case ast.SRemInst: return fgen.astToIRInstSRem(inst, old) - case *ast.FRemInst: + case ast.FRemInst: return fgen.astToIRInstFRem(inst, old) // Bitwise instructions - case *ast.ShlInst: + case ast.ShlInst: return fgen.astToIRInstShl(inst, old) - case *ast.LShrInst: + case ast.LShrInst: return fgen.astToIRInstLShr(inst, old) - case *ast.AShrInst: + case ast.AShrInst: return fgen.astToIRInstAShr(inst, old) - case *ast.AndInst: + case ast.AndInst: return fgen.astToIRInstAnd(inst, old) - case *ast.OrInst: + case ast.OrInst: return fgen.astToIRInstOr(inst, old) - case *ast.XorInst: + case ast.XorInst: return fgen.astToIRInstXor(inst, old) // Vector instructions - case *ast.ExtractElementInst: + case ast.ExtractElementInst: return fgen.astToIRInstExtractElement(inst, old) - case *ast.InsertElementInst: + case ast.InsertElementInst: return fgen.astToIRInstInsertElement(inst, old) - case *ast.ShuffleVectorInst: + case ast.ShuffleVectorInst: return fgen.astToIRInstShuffleVector(inst, old) // Aggregate instructions - case *ast.ExtractValueInst: + case ast.ExtractValueInst: return fgen.astToIRInstExtractValue(inst, old) - case *ast.InsertValueInst: + case ast.InsertValueInst: return fgen.astToIRInstInsertValue(inst, old) // Memory instructions - case *ast.AllocaInst: + case ast.AllocaInst: return fgen.astToIRInstAlloca(inst, old) - case *ast.LoadInst: + case ast.LoadInst: return fgen.astToIRInstLoad(inst, old) - case *ast.CmpXchgInst: + case ast.CmpXchgInst: return fgen.astToIRInstCmpXchg(inst, old) - case *ast.AtomicRMWInst: + case ast.AtomicRMWInst: return fgen.astToIRInstAtomicRMW(inst, old) - case *ast.GetElementPtrInst: + case ast.GetElementPtrInst: return fgen.astToIRInstGetElementPtr(inst, old) // Conversion instructions - case *ast.TruncInst: + case ast.TruncInst: return fgen.astToIRInstTrunc(inst, old) - case *ast.ZExtInst: + case ast.ZExtInst: return fgen.astToIRInstZExt(inst, old) - case *ast.SExtInst: + case ast.SExtInst: return fgen.astToIRInstSExt(inst, old) - case *ast.FPTruncInst: + case ast.FPTruncInst: return fgen.astToIRInstFPTrunc(inst, old) - case *ast.FPExtInst: + case ast.FPExtInst: return fgen.astToIRInstFPExt(inst, old) - case *ast.FPToUIInst: + case ast.FPToUIInst: return fgen.astToIRInstFPToUI(inst, old) - case *ast.FPToSIInst: + case ast.FPToSIInst: return fgen.astToIRInstFPToSI(inst, old) - case *ast.UIToFPInst: + case ast.UIToFPInst: return fgen.astToIRInstUIToFP(inst, old) - case *ast.SIToFPInst: + case ast.SIToFPInst: return fgen.astToIRInstSIToFP(inst, old) - case *ast.PtrToIntInst: + case ast.PtrToIntInst: return fgen.astToIRInstPtrToInt(inst, old) - case *ast.IntToPtrInst: + case ast.IntToPtrInst: return fgen.astToIRInstIntToPtr(inst, old) - case *ast.BitCastInst: + case ast.BitCastInst: return fgen.astToIRInstBitCast(inst, old) - case *ast.AddrSpaceCastInst: + case ast.AddrSpaceCastInst: return fgen.astToIRInstAddrSpaceCast(inst, old) // Other instructions - case *ast.ICmpInst: + case ast.ICmpInst: return fgen.astToIRInstICmp(inst, old) - case *ast.FCmpInst: + case ast.FCmpInst: return fgen.astToIRInstFCmp(inst, old) - case *ast.PhiInst: + case ast.PhiInst: return fgen.astToIRInstPhi(inst, old) - case *ast.SelectInst: + case ast.SelectInst: return fgen.astToIRInstSelect(inst, old) - case *ast.CallInst: + case ast.CallInst: return fgen.astToIRInstCall(inst, old) - case *ast.VAArgInst: + case ast.VAArgInst: return fgen.astToIRInstVAArg(inst, old) - case *ast.LandingPadInst: + case ast.LandingPadInst: return fgen.astToIRInstLandingPad(inst, old) - case *ast.CatchPadInst: + case ast.CatchPadInst: return fgen.astToIRInstCatchPad(inst, old) - case *ast.CleanupPadInst: + case ast.CleanupPadInst: return fgen.astToIRInstCleanupPad(inst, old) default: panic(fmt.Errorf("support for value instruction type %T not yet implemented", old)) @@ -658,19 +658,19 @@ func (gen *generator) gepType(elemType types.Type, indices []ast.TypeValue) (typ e = t.ElemType case *types.StructType: switch index := index.Val().(type) { - case *ast.IntConst: + case ast.IntConst: i, err := strconv.ParseInt(index.Text(), 10, 64) if err != nil { panic(fmt.Errorf("unable to parse integer %q; %v", index.Text(), err)) } e = t.Fields[i] - case *ast.VectorConst: + case ast.VectorConst: // TODO: Validate how index vectors in gep are supposed to work. elems := index.Elems() elem := elems[0].Val() - idx, ok := elem.(*ast.IntConst) + idx, ok := elem.(ast.IntConst) if !ok { - panic(fmt.Errorf("invalid index type for structure element; expected *ast.IntConst, got %T", elem)) + panic(fmt.Errorf("invalid index type for structure element; expected ast.IntConst, got %T", elem)) } i, err := strconv.ParseInt(idx.Text(), 10, 64) if err != nil { @@ -679,9 +679,9 @@ func (gen *generator) gepType(elemType types.Type, indices []ast.TypeValue) (typ // Sanity check. All vector elements must be integers, and must have // the same value. for _, elem := range elems { - idx, ok := elem.Val().(*ast.IntConst) + idx, ok := elem.Val().(ast.IntConst) if !ok { - panic(fmt.Errorf("invalid index type for structure element; expected *ast.IntConst, got %T", elem.Val())) + panic(fmt.Errorf("invalid index type for structure element; expected ast.IntConst, got %T", elem.Val())) } j, err := strconv.ParseInt(idx.Text(), 10, 64) if err != nil { @@ -692,10 +692,10 @@ func (gen *generator) gepType(elemType types.Type, indices []ast.TypeValue) (typ } } e = t.Fields[i] - case *ast.ZeroInitializerConst: + case ast.ZeroInitializerConst: e = t.Fields[0] default: - panic(fmt.Errorf("invalid index type for structure element; expected *ast.IntConst, *ast.VectorConst or *ast.ZeroInitializerConst, got %T", index)) + panic(fmt.Errorf("invalid index type for structure element; expected ast.IntConst, ast.VectorConst or ast.ZeroInitializerConst, got %T", index)) } default: panic(fmt.Errorf("support for indexing element type %T not yet implemented", e)) diff --git a/asm/metadata.go b/asm/metadata.go index 326e613e..b72310c3 100644 --- a/asm/metadata.go +++ b/asm/metadata.go @@ -42,10 +42,10 @@ func (gen *generator) irMetadataAttachment(old ast.MetadataAttachment) (*metadat func (gen *generator) irMDNode(old ast.MDNode) (metadata.MDNode, error) { switch old := old.(type) { - case *ast.MDTuple: + case ast.MDTuple: return gen.irMDTuple(old) - case *ast.MetadataID: - id := metadataID(*old) + case ast.MetadataID: + id := metadataID(old) node, ok := gen.new.metadataDefs[id] if !ok { panic(fmt.Errorf("unable to locate metadata ID %q", enc.Metadata(id))) @@ -58,11 +58,11 @@ func (gen *generator) irMDNode(old ast.MDNode) (metadata.MDNode, error) { } } -func irDIExpression(old *ast.DIExpression) *metadata.DIExpression { +func irDIExpression(old ast.DIExpression) *metadata.DIExpression { panic("not yet implemented") } -func (gen *generator) irMDTuple(old *ast.MDTuple) (*metadata.MDTuple, error) { +func (gen *generator) irMDTuple(old ast.MDTuple) (*metadata.MDTuple, error) { tuple := &metadata.MDTuple{} for _, oldField := range old.MDFields().MDFields() { field, err := gen.irMDField(oldField) @@ -76,7 +76,7 @@ func (gen *generator) irMDTuple(old *ast.MDTuple) (*metadata.MDTuple, error) { func (gen *generator) irMDField(old ast.MDField) (metadata.MDField, error) { switch old := old.(type) { - case *ast.NullLit: + case ast.NullLit: return metadata.Null, nil case ast.Metadata: return gen.irMetadata(old) @@ -87,8 +87,8 @@ func (gen *generator) irMDField(old ast.MDField) (metadata.MDField, error) { func (fgen *funcGen) irMetadata(old ast.Metadata) (metadata.Metadata, error) { switch old := old.(type) { - case *ast.TypeValue: - return fgen.astToIRTypeValue(*old) + case ast.TypeValue: + return fgen.astToIRTypeValue(old) default: return fgen.gen.irMetadata(old) } @@ -96,7 +96,7 @@ func (fgen *funcGen) irMetadata(old ast.Metadata) (metadata.Metadata, error) { func (gen *generator) irMetadata(old ast.Metadata) (metadata.Metadata, error) { switch old := old.(type) { - case *ast.TypeValue: + case ast.TypeValue: typ, err := gen.irType(old.Typ()) if err != nil { return nil, errors.WithStack(err) @@ -107,12 +107,12 @@ func (gen *generator) irMetadata(old ast.Metadata) (metadata.Metadata, error) { default: panic(fmt.Errorf("support for metadata value %T not yet implemented", oldVal)) } - case *ast.MDString: + case ast.MDString: return &metadata.MDString{Value: stringLit(old.Val())}, nil - case *ast.MDTuple: + case ast.MDTuple: return gen.irMDTuple(old) - case *ast.MetadataID: - id := metadataID(*old) + case ast.MetadataID: + id := metadataID(old) node, ok := gen.new.metadataDefs[id] if !ok { panic(fmt.Errorf("unable to locate metadata ID %q", enc.Metadata(id))) @@ -127,14 +127,14 @@ func (gen *generator) irMetadata(old ast.Metadata) (metadata.Metadata, error) { func (gen *generator) irMetadataNode(old ast.MetadataNode) (metadata.MetadataNode, error) { switch old := old.(type) { - case *ast.MetadataID: - id := metadataID(*old) + case ast.MetadataID: + id := metadataID(old) node, ok := gen.new.metadataDefs[id] if !ok { return nil, errors.Errorf("unable to locate metadata ID %q", enc.Metadata(id)) } return node, nil - case *ast.DIExpression: + case ast.DIExpression: return irDIExpression(old), nil default: panic(fmt.Errorf("support for metadata node %T not yet implemented", old)) diff --git a/asm/module.go b/asm/module.go index a920acb7..dcd54060 100644 --- a/asm/module.go +++ b/asm/module.go @@ -14,26 +14,26 @@ import ( // === [ Index AST ] =========================================================== // indexTopLevelEntities indexes the AST top-level entities of the given module. -func (gen *generator) indexTopLevelEntities(old *ast.Module) error { +func (gen *generator) indexTopLevelEntities(old ast.Module) error { // Index AST top-level entities. // track added type definitions. addedTypeDef := make(map[string]bool) for _, entity := range old.TopLevelEntities() { switch entity := entity.(type) { - case *ast.SourceFilename: + case ast.SourceFilename: gen.m.SourceFilename = unquote(entity.Name().Text()) - case *ast.TargetDataLayout: + case ast.TargetDataLayout: gen.m.DataLayout = unquote(entity.DataLayout().Text()) - case *ast.TargetTriple: + case ast.TargetTriple: gen.m.TargetTriple = unquote(entity.TargetTriple().Text()) - case *ast.ModuleAsm: + case ast.ModuleAsm: asm := unquote(entity.Asm().Text()) gen.m.ModuleAsms = append(gen.m.ModuleAsms, asm) - case *ast.TypeDef: + case ast.TypeDef: ident := localIdent(entity.Name()) name := getTypeName(ident) if prev, ok := gen.old.typeDefs[name]; ok { - if _, ok := prev.Typ().(*ast.OpaqueType); !ok { + if _, ok := prev.Typ().(ast.OpaqueType); !ok { return errors.Errorf("type identifier %q already present; prev `%s`, new `%s`", enc.Local(name), text(prev), text(entity)) } } @@ -46,72 +46,72 @@ func (gen *generator) indexTopLevelEntities(old *ast.Module) error { gen.old.typeDefOrder = append(gen.old.typeDefOrder, name) } addedTypeDef[name] = true - case *ast.ComdatDef: + case ast.ComdatDef: name := comdatName(entity.Name()) if prev, ok := gen.old.comdatDefs[name]; ok { return errors.Errorf("comdat name %q already present; prev `%s`, new `%s`", enc.Comdat(name), text(prev), text(entity)) } gen.old.comdatDefs[name] = entity gen.old.comdatDefOrder = append(gen.old.comdatDefOrder, name) - case *ast.GlobalDecl: + case ast.GlobalDecl: ident := globalIdent(entity.Name()) if prev, ok := gen.old.globals[ident]; ok { return errors.Errorf("global identifier %q already present; prev `%s`, new `%s`", enc.Global(ident), text(prev), text(entity)) } gen.old.globals[ident] = entity gen.old.globalOrder = append(gen.old.globalOrder, ident) - case *ast.GlobalDef: + case ast.GlobalDef: ident := globalIdent(entity.Name()) if prev, ok := gen.old.globals[ident]; ok { return errors.Errorf("global identifier %q already present; prev `%s`, new `%s`", enc.Global(ident), text(prev), text(entity)) } gen.old.globals[ident] = entity gen.old.globalOrder = append(gen.old.globalOrder, ident) - case *ast.IndirectSymbolDef: + case ast.IndirectSymbolDef: ident := globalIdent(entity.Name()) if prev, ok := gen.old.globals[ident]; ok { return errors.Errorf("global identifier %q already present; prev `%s`, new `%s`", enc.Global(ident), text(prev), text(entity)) } gen.old.globals[ident] = entity gen.old.indirectSymbolDefOrder = append(gen.old.indirectSymbolDefOrder, ident) - case *ast.FuncDecl: + case ast.FuncDecl: ident := globalIdent(entity.Header().Name()) if prev, ok := gen.old.globals[ident]; ok { return errors.Errorf("global identifier %q already present; prev `%s`, new `%s`", enc.Global(ident), text(prev), text(entity)) } gen.old.globals[ident] = entity gen.old.funcOrder = append(gen.old.funcOrder, ident) - case *ast.FuncDef: + case ast.FuncDef: ident := globalIdent(entity.Header().Name()) if prev, ok := gen.old.globals[ident]; ok { return errors.Errorf("global identifier %q already present; prev `%s`, new `%s`", enc.Global(ident), text(prev), text(entity)) } gen.old.globals[ident] = entity gen.old.funcOrder = append(gen.old.funcOrder, ident) - case *ast.AttrGroupDef: + case ast.AttrGroupDef: id := attrGroupID(entity.ID()) if prev, ok := gen.old.attrGroupDefs[id]; ok { return errors.Errorf("attribute group ID %q already present; prev `%s`, new `%s`", enc.AttrGroupID(id), text(prev), text(entity)) } gen.old.attrGroupDefs[id] = entity gen.old.attrGroupDefOrder = append(gen.old.attrGroupDefOrder, id) - case *ast.NamedMetadataDef: + case ast.NamedMetadataDef: name := metadataName(entity.Name()) if prev, ok := gen.old.namedMetadataDefs[name]; ok { return errors.Errorf("metadata name %q already present; prev `%s`, new `%s`", enc.Metadata(name), text(prev), text(entity)) } gen.old.namedMetadataDefs[name] = entity gen.old.namedMetadataDefOrder = append(gen.old.namedMetadataDefOrder, name) - case *ast.MetadataDef: + case ast.MetadataDef: id := metadataID(entity.ID()) if prev, ok := gen.old.metadataDefs[id]; ok { return errors.Errorf("metadata ID %q already present; prev `%s`, new `%s`", enc.Metadata(id), text(prev), text(entity)) } gen.old.metadataDefs[id] = entity gen.old.metadataDefOrder = append(gen.old.metadataDefOrder, id) - case *ast.UseListOrder: + case ast.UseListOrder: gen.old.useListOrders = append(gen.old.useListOrders, entity) - case *ast.UseListOrderBB: + case ast.UseListOrderBB: gen.old.useListOrderBBs = append(gen.old.useListOrderBBs, entity) default: panic(fmt.Errorf("support for AST top-level entity %T not yet implemented", entity)) @@ -248,7 +248,7 @@ func (gen *generator) translateAttrGroupDefs() error { // translateAttrGroupDef translates the given AST attribute group definition to // IR. -func (gen *generator) translateAttrGroupDef(new *ir.AttrGroupDef, old *ast.AttrGroupDef) error { +func (gen *generator) translateAttrGroupDef(new *ir.AttrGroupDef, old ast.AttrGroupDef) error { for _, oldFuncAttr := range old.Attrs() { funcAttr := gen.irFuncAttribute(oldFuncAttr) new.FuncAttrs = append(new.FuncAttrs, funcAttr) @@ -276,7 +276,7 @@ func (gen *generator) translateNamedMetadataDefs() error { // translateNamedMetadataDef translates the given AST named metadata definition // to IR. -func (gen *generator) translateNamedMetadataDef(new *metadata.NamedMetadataDef, old *ast.NamedMetadataDef) error { +func (gen *generator) translateNamedMetadataDef(new *metadata.NamedMetadataDef, old ast.NamedMetadataDef) error { // Nodes. for _, oldNode := range old.MDNodes() { node, err := gen.irMetadataNode(oldNode) @@ -307,12 +307,12 @@ func (gen *generator) translateMetadataDefs() error { } // translateMetadataDef translates the given AST metadata definition to IR. -func (gen *generator) translateMetadataDef(new *metadata.MetadataDef, old *ast.MetadataDef) error { +func (gen *generator) translateMetadataDef(new *metadata.MetadataDef, old ast.MetadataDef) error { // (optional) Distinct. new.Distinct = old.Distinct().IsValid() // Node. switch oldNode := old.MDNode().(type) { - case *ast.MDTuple: + case ast.MDTuple: node, err := gen.irMDTuple(oldNode) if err != nil { return errors.WithStack(err) diff --git a/asm/parser.go b/asm/parser.go index aba57190..991ad858 100644 --- a/asm/parser.go +++ b/asm/parser.go @@ -61,5 +61,5 @@ func ParseString(path, content string) (*ir.Module, error) { } root := ast.ToLlvmNode(tree.Root()) dbg.Println("parsing into AST took:", time.Since(parseStart)) - return translate(root.(*ast.Module)) + return translate(root.(ast.Module)) } diff --git a/asm/specialized_metadata.go b/asm/specialized_metadata.go index a90ef985..8b6009b0 100644 --- a/asm/specialized_metadata.go +++ b/asm/specialized_metadata.go @@ -15,57 +15,57 @@ import ( func (gen *generator) irSpecializedMDNode(old ast.SpecializedMDNode) (metadata.SpecializedMDNode, error) { switch old := old.(type) { - case *ast.DIBasicType: + case ast.DIBasicType: return gen.irDIBasicType(old) - case *ast.DICompileUnit: + case ast.DICompileUnit: return gen.irDICompileUnit(old) - case *ast.DICompositeType: + case ast.DICompositeType: return gen.irDICompositeType(old) - case *ast.DIDerivedType: + case ast.DIDerivedType: return gen.irDIDerivedType(old) - case *ast.DIEnumerator: + case ast.DIEnumerator: return gen.irDIEnumerator(old) - case *ast.DIExpression: + case ast.DIExpression: return gen.irDIExpression(old) - case *ast.DIFile: + case ast.DIFile: return gen.irDIFile(old) - case *ast.DIGlobalVariable: + case ast.DIGlobalVariable: return gen.irDIGlobalVariable(old) - case *ast.DIGlobalVariableExpression: + case ast.DIGlobalVariableExpression: return gen.irDIGlobalVariableExpression(old) - case *ast.DIImportedEntity: + case ast.DIImportedEntity: return gen.irDIImportedEntity(old) - case *ast.DILabel: + case ast.DILabel: return gen.irDILabel(old) - case *ast.DILexicalBlock: + case ast.DILexicalBlock: return gen.irDILexicalBlock(old) - case *ast.DILexicalBlockFile: + case ast.DILexicalBlockFile: return gen.irDILexicalBlockFile(old) - case *ast.DILocalVariable: + case ast.DILocalVariable: return gen.irDILocalVariable(old) - case *ast.DILocation: + case ast.DILocation: return gen.irDILocation(old) - case *ast.DIMacro: + case ast.DIMacro: return gen.irDIMacro(old) - case *ast.DIMacroFile: + case ast.DIMacroFile: return gen.irDIMacroFile(old) - case *ast.DIModule: + case ast.DIModule: return gen.irDIModule(old) - case *ast.DINamespace: + case ast.DINamespace: return gen.irDINamespace(old) - case *ast.DIObjCProperty: + case ast.DIObjCProperty: return gen.irDIObjCProperty(old) - case *ast.DISubprogram: + case ast.DISubprogram: return gen.irDISubprogram(old) - case *ast.DISubrange: + case ast.DISubrange: return gen.irDISubrange(old) - case *ast.DISubroutineType: + case ast.DISubroutineType: return gen.irDISubroutineType(old) - case *ast.DITemplateTypeParameter: + case ast.DITemplateTypeParameter: return gen.irDITemplateTypeParameter(old) - case *ast.DITemplateValueParameter: + case ast.DITemplateValueParameter: return gen.irDITemplateValueParameter(old) - case *ast.GenericDINode: + case ast.GenericDINode: return gen.irGenericDINode(old) default: panic(fmt.Errorf("support for %T not yet implemented", old)) @@ -74,21 +74,21 @@ func (gen *generator) irSpecializedMDNode(old ast.SpecializedMDNode) (metadata.S // --- [ DIBasicType ] --------------------------------------------------------- -func (gen *generator) irDIBasicType(old *ast.DIBasicType) (*metadata.DIBasicType, error) { +func (gen *generator) irDIBasicType(old ast.DIBasicType) (*metadata.DIBasicType, error) { md := &metadata.DIBasicType{} for _, oldField := range old.Fields() { switch oldField := oldField.(type) { - case *ast.TagField: + case ast.TagField: md.Tag = irDwarfTag(oldField.Tag()) - case *ast.NameField: + case ast.NameField: md.Name = stringLit(oldField.Name()) - case *ast.SizeField: + case ast.SizeField: md.Size = uintLit(oldField.Size()) - case *ast.AlignField: + case ast.AlignField: md.Align = uintLit(oldField.Align()) - case *ast.EncodingField: + case ast.EncodingField: md.Encoding = irDwarfAttEncoding(oldField.Encoding()) - case *ast.FlagsField: + case ast.FlagsField: md.Flags = irDIFlags(oldField.Flags()) default: panic(fmt.Errorf("support for DIBasicType field %T not yet implemented", old)) @@ -99,67 +99,67 @@ func (gen *generator) irDIBasicType(old *ast.DIBasicType) (*metadata.DIBasicType // --- [ DICompileUnit ] ------------------------------------------------------- -func (gen *generator) irDICompileUnit(old *ast.DICompileUnit) (*metadata.DICompileUnit, error) { +func (gen *generator) irDICompileUnit(old ast.DICompileUnit) (*metadata.DICompileUnit, error) { md := &metadata.DICompileUnit{} for _, oldField := range old.Fields() { switch oldField := oldField.(type) { - case *ast.LanguageField: + case ast.LanguageField: md.Language = irDwarfLang(oldField.Language()) - case *ast.FileField: + case ast.FileField: file, err := gen.irMDField(oldField.File()) if err != nil { return nil, errors.WithStack(err) } md.File = file - case *ast.ProducerField: + case ast.ProducerField: md.Producer = stringLit(oldField.Producer()) - case *ast.IsOptimizedField: + case ast.IsOptimizedField: md.IsOptimized = boolLit(oldField.IsOptimized()) - case *ast.FlagsStringField: + case ast.FlagsStringField: md.Flags = stringLit(oldField.Flags()) - case *ast.RuntimeVersionField: + case ast.RuntimeVersionField: md.RuntimeVersion = uintLit(oldField.RuntimeVersion()) - case *ast.SplitDebugFilenameField: + case ast.SplitDebugFilenameField: md.SplitDebugFilename = stringLit(oldField.SplitDebugFilename()) - case *ast.EmissionKindField: + case ast.EmissionKindField: md.EmissionKind = irEmissionKind(oldField.EmissionKind()) - case *ast.EnumsField: + case ast.EnumsField: enums, err := gen.irMDField(oldField.Enums()) if err != nil { return nil, errors.WithStack(err) } md.Enums = enums - case *ast.RetainedTypesField: + case ast.RetainedTypesField: retainedTypes, err := gen.irMDField(oldField.RetainedTypes()) if err != nil { return nil, errors.WithStack(err) } md.RetainedTypes = retainedTypes - case *ast.GlobalsField: + case ast.GlobalsField: globals, err := gen.irMDField(oldField.Globals()) if err != nil { return nil, errors.WithStack(err) } md.Globals = globals - case *ast.ImportsField: + case ast.ImportsField: imports, err := gen.irMDField(oldField.Imports()) if err != nil { return nil, errors.WithStack(err) } md.Imports = imports - case *ast.MacrosField: + case ast.MacrosField: macros, err := gen.irMDField(oldField.Macros()) if err != nil { return nil, errors.WithStack(err) } md.Macros = macros - case *ast.DwoIdField: + case ast.DwoIdField: md.DwoID = uintLit(oldField.DwoId()) - case *ast.SplitDebugInliningField: + case ast.SplitDebugInliningField: md.SplitDebugInlining = boolLit(oldField.SplitDebugInlining()) - case *ast.DebugInfoForProfilingField: + case ast.DebugInfoForProfilingField: md.DebugInfoForProfiling = boolLit(oldField.DebugInfoForProfiling()) - case *ast.NameTableKindField: + case ast.NameTableKindField: md.NameTableKind = irNameTableKind(oldField.NameTableKind()) default: panic(fmt.Errorf("support for DICompileUnit field %T not yet implemented", old)) @@ -170,65 +170,65 @@ func (gen *generator) irDICompileUnit(old *ast.DICompileUnit) (*metadata.DICompi // --- [ DICompositeType ] ----------------------------------------------------- -func (gen *generator) irDICompositeType(old *ast.DICompositeType) (*metadata.DICompositeType, error) { +func (gen *generator) irDICompositeType(old ast.DICompositeType) (*metadata.DICompositeType, error) { md := &metadata.DICompositeType{} for _, oldField := range old.Fields() { switch oldField := oldField.(type) { - case *ast.TagField: + case ast.TagField: md.Tag = irDwarfTag(oldField.Tag()) - case *ast.NameField: + case ast.NameField: md.Name = stringLit(oldField.Name()) - case *ast.ScopeField: + case ast.ScopeField: scope, err := gen.irMDField(oldField.Scope()) if err != nil { return nil, errors.WithStack(err) } md.Scope = scope - case *ast.FileField: + case ast.FileField: file, err := gen.irMDField(oldField.File()) if err != nil { return nil, errors.WithStack(err) } md.File = file - case *ast.LineField: + case ast.LineField: md.Line = intLit(oldField.Line()) - case *ast.BaseTypeField: + case ast.BaseTypeField: baseType, err := gen.irMDField(oldField.BaseType()) if err != nil { return nil, errors.WithStack(err) } md.BaseType = baseType - case *ast.SizeField: + case ast.SizeField: md.Size = uintLit(oldField.Size()) - case *ast.AlignField: + case ast.AlignField: md.Align = uintLit(oldField.Align()) - case *ast.OffsetField: + case ast.OffsetField: md.Offset = uintLit(oldField.OffsetField()) - case *ast.FlagsField: + case ast.FlagsField: md.Flags = irDIFlags(oldField.Flags()) - case *ast.ElementsField: + case ast.ElementsField: elements, err := gen.irMDField(oldField.Elements()) if err != nil { return nil, errors.WithStack(err) } md.Elements = elements - case *ast.RuntimeLangField: + case ast.RuntimeLangField: md.RuntimeLang = irDwarfLang(oldField.RuntimeLang()) - case *ast.VtableHolderField: + case ast.VtableHolderField: vtableHolder, err := gen.irMDField(oldField.VtableHolder()) if err != nil { return nil, errors.WithStack(err) } md.VtableHolder = vtableHolder - case *ast.TemplateParamsField: + case ast.TemplateParamsField: templateParams, err := gen.irMDField(oldField.TemplateParams()) if err != nil { return nil, errors.WithStack(err) } md.TemplateParams = templateParams - case *ast.IdentifierField: + case ast.IdentifierField: md.Identifier = stringLit(oldField.Identifier()) - case *ast.DiscriminatorField: + case ast.DiscriminatorField: discriminator, err := gen.irMDField(oldField.Discriminator()) if err != nil { return nil, errors.WithStack(err) @@ -243,50 +243,50 @@ func (gen *generator) irDICompositeType(old *ast.DICompositeType) (*metadata.DIC // --- [ DIDerivedType ] ------------------------------------------------------- -func (gen *generator) irDIDerivedType(old *ast.DIDerivedType) (*metadata.DIDerivedType, error) { +func (gen *generator) irDIDerivedType(old ast.DIDerivedType) (*metadata.DIDerivedType, error) { md := &metadata.DIDerivedType{} for _, oldField := range old.Fields() { switch oldField := oldField.(type) { - case *ast.TagField: + case ast.TagField: md.Tag = irDwarfTag(oldField.Tag()) - case *ast.NameField: + case ast.NameField: md.Name = stringLit(oldField.Name()) - case *ast.ScopeField: + case ast.ScopeField: scope, err := gen.irMDField(oldField.Scope()) if err != nil { return nil, errors.WithStack(err) } md.Scope = scope - case *ast.FileField: + case ast.FileField: file, err := gen.irMDField(oldField.File()) if err != nil { return nil, errors.WithStack(err) } md.File = file - case *ast.LineField: + case ast.LineField: md.Line = intLit(oldField.Line()) - case *ast.BaseTypeField: + case ast.BaseTypeField: baseType, err := gen.irMDField(oldField.BaseType()) if err != nil { return nil, errors.WithStack(err) } md.BaseType = baseType - case *ast.SizeField: + case ast.SizeField: md.Size = uintLit(oldField.Size()) - case *ast.AlignField: + case ast.AlignField: md.Align = uintLit(oldField.Align()) - case *ast.OffsetField: + case ast.OffsetField: // TODO: rename OffsetField method to Offset once https://github.com/inspirer/textmapper/issues/13 is resolved. md.Offset = uintLit(oldField.OffsetField()) - case *ast.FlagsField: + case ast.FlagsField: md.Flags = irDIFlags(oldField.Flags()) - case *ast.ExtraDataField: + case ast.ExtraDataField: extraData, err := gen.irMDField(oldField.ExtraData()) if err != nil { return nil, errors.WithStack(err) } md.ExtraData = extraData - case *ast.DwarfAddressSpaceField: + case ast.DwarfAddressSpaceField: md.DwarfAddressSpace = uintLit(oldField.DwarfAddressSpace()) default: panic(fmt.Errorf("support for DIDerivedType field %T not yet implemented", old)) @@ -297,20 +297,20 @@ func (gen *generator) irDIDerivedType(old *ast.DIDerivedType) (*metadata.DIDeriv // --- [ DIEnumerator ] -------------------------------------------------------- -func (gen *generator) irDIEnumerator(old *ast.DIEnumerator) (*metadata.DIEnumerator, error) { +func (gen *generator) irDIEnumerator(old ast.DIEnumerator) (*metadata.DIEnumerator, error) { md := &metadata.DIEnumerator{} isUnsigned := false for _, oldField := range old.Fields() { - if oldField, ok := oldField.(*ast.IsUnsignedField); ok { + if oldField, ok := oldField.(ast.IsUnsignedField); ok { isUnsigned = boolLit(oldField.IsUnsigned()) break } } for _, oldField := range old.Fields() { switch oldField := oldField.(type) { - case *ast.NameField: + case ast.NameField: md.Name = stringLit(oldField.Name()) - case *ast.ValueIntField: + case ast.ValueIntField: if isUnsigned { text := oldField.Value().Text() x, err := strconv.ParseUint(text, 10, 64) @@ -321,7 +321,7 @@ func (gen *generator) irDIEnumerator(old *ast.DIEnumerator) (*metadata.DIEnumera } else { md.Value = intLit(oldField.Value()) } - case *ast.IsUnsignedField: + case ast.IsUnsignedField: md.IsUnsigned = boolLit(oldField.IsUnsigned()) default: panic(fmt.Errorf("support for DIEnumerator field %T not yet implemented", old)) @@ -332,7 +332,7 @@ func (gen *generator) irDIEnumerator(old *ast.DIEnumerator) (*metadata.DIEnumera // --- [ DIExpression ] -------------------------------------------------------- -func (gen *generator) irDIExpression(old *ast.DIExpression) (*metadata.DIExpression, error) { +func (gen *generator) irDIExpression(old ast.DIExpression) (*metadata.DIExpression, error) { md := &metadata.DIExpression{} for _, oldField := range old.Fields() { field, err := gen.irDIExpressionField(oldField) @@ -348,9 +348,9 @@ func (gen *generator) irDIExpression(old *ast.DIExpression) (*metadata.DIExpress func (gen *generator) irDIExpressionField(old ast.DIExpressionField) (metadata.DIExpressionField, error) { switch old := old.(type) { - case *ast.UintLit: - return metadata.UintLit(uintLit(*old)), nil - case *ast.DwarfOp: + case ast.UintLit: + return metadata.UintLit(uintLit(old)), nil + case ast.DwarfOp: return asmenum.DwarfOpFromString(old.Text()), nil default: panic(fmt.Errorf("support for DIExpression field %T not yet implemented", old)) @@ -359,19 +359,19 @@ func (gen *generator) irDIExpressionField(old ast.DIExpressionField) (metadata.D // --- [ DIFile ] -------------------------------------------------------------- -func (gen *generator) irDIFile(old *ast.DIFile) (*metadata.DIFile, error) { +func (gen *generator) irDIFile(old ast.DIFile) (*metadata.DIFile, error) { md := &metadata.DIFile{} for _, oldField := range old.Fields() { switch oldField := oldField.(type) { - case *ast.FilenameField: + case ast.FilenameField: md.Filename = stringLit(oldField.Filename()) - case *ast.DirectoryField: + case ast.DirectoryField: md.Directory = stringLit(oldField.Directory()) - case *ast.ChecksumkindField: + case ast.ChecksumkindField: md.Checksumkind = asmenum.ChecksumKindFromString(oldField.Checksumkind().Text()) - case *ast.ChecksumField: + case ast.ChecksumField: md.Checksum = stringLit(oldField.Checksum()) - case *ast.SourceField: + case ast.SourceField: md.Source = stringLit(oldField.Source()) default: panic(fmt.Errorf("support for DIFile field %T not yet implemented", old)) @@ -382,51 +382,51 @@ func (gen *generator) irDIFile(old *ast.DIFile) (*metadata.DIFile, error) { // --- [ DIGlobalVariable ] ---------------------------------------------------- -func (gen *generator) irDIGlobalVariable(old *ast.DIGlobalVariable) (*metadata.DIGlobalVariable, error) { +func (gen *generator) irDIGlobalVariable(old ast.DIGlobalVariable) (*metadata.DIGlobalVariable, error) { md := &metadata.DIGlobalVariable{} for _, oldField := range old.Fields() { switch oldField := oldField.(type) { - case *ast.NameField: + case ast.NameField: md.Name = stringLit(oldField.Name()) - case *ast.ScopeField: + case ast.ScopeField: scope, err := gen.irMDField(oldField.Scope()) if err != nil { return nil, errors.WithStack(err) } md.Scope = scope - case *ast.LinkageNameField: + case ast.LinkageNameField: md.LinkageName = stringLit(oldField.LinkageName()) - case *ast.FileField: + case ast.FileField: file, err := gen.irMDField(oldField.File()) if err != nil { return nil, errors.WithStack(err) } md.File = file - case *ast.LineField: + case ast.LineField: md.Line = intLit(oldField.Line()) - case *ast.TypeField: + case ast.TypeField: typ, err := gen.irMDField(oldField.Typ()) if err != nil { return nil, errors.WithStack(err) } md.Type = typ - case *ast.IsLocalField: + case ast.IsLocalField: md.IsLocal = boolLit(oldField.IsLocal()) - case *ast.IsDefinitionField: + case ast.IsDefinitionField: md.IsDefinition = boolLit(oldField.IsDefinition()) - case *ast.TemplateParamsField: + case ast.TemplateParamsField: templateParams, err := gen.irMDField(oldField.TemplateParams()) if err != nil { return nil, errors.WithStack(err) } md.TemplateParams = templateParams - case *ast.DeclarationField: + case ast.DeclarationField: declaration, err := gen.irMDField(oldField.Declaration()) if err != nil { return nil, errors.WithStack(err) } md.Declaration = declaration - case *ast.AlignField: + case ast.AlignField: md.Align = uintLit(oldField.Align()) default: panic(fmt.Errorf("support for DIGlobalVariable field %T not yet implemented", old)) @@ -437,17 +437,17 @@ func (gen *generator) irDIGlobalVariable(old *ast.DIGlobalVariable) (*metadata.D // --- [ DIGlobalVariableExpression ] ------------------------------------------ -func (gen *generator) irDIGlobalVariableExpression(old *ast.DIGlobalVariableExpression) (*metadata.DIGlobalVariableExpression, error) { +func (gen *generator) irDIGlobalVariableExpression(old ast.DIGlobalVariableExpression) (*metadata.DIGlobalVariableExpression, error) { md := &metadata.DIGlobalVariableExpression{} for _, oldField := range old.Fields() { switch oldField := oldField.(type) { - case *ast.VarField: + case ast.VarField: v, err := gen.irMDField(oldField.Var()) if err != nil { return nil, errors.WithStack(err) } md.Var = v - case *ast.ExprField: + case ast.ExprField: expr, err := gen.irMDField(oldField.Expr()) if err != nil { return nil, errors.WithStack(err) @@ -462,33 +462,33 @@ func (gen *generator) irDIGlobalVariableExpression(old *ast.DIGlobalVariableExpr // --- [ DIImportedEntity ] ---------------------------------------------------- -func (gen *generator) irDIImportedEntity(old *ast.DIImportedEntity) (*metadata.DIImportedEntity, error) { +func (gen *generator) irDIImportedEntity(old ast.DIImportedEntity) (*metadata.DIImportedEntity, error) { md := &metadata.DIImportedEntity{} for _, oldField := range old.Fields() { switch oldField := oldField.(type) { - case *ast.TagField: + case ast.TagField: md.Tag = irDwarfTag(oldField.Tag()) - case *ast.ScopeField: + case ast.ScopeField: scope, err := gen.irMDField(oldField.Scope()) if err != nil { return nil, errors.WithStack(err) } md.Scope = scope - case *ast.EntityField: + case ast.EntityField: entity, err := gen.irMDField(oldField.Entity()) if err != nil { return nil, errors.WithStack(err) } md.Entity = entity - case *ast.FileField: + case ast.FileField: file, err := gen.irMDField(oldField.File()) if err != nil { return nil, errors.WithStack(err) } md.File = file - case *ast.LineField: + case ast.LineField: md.Line = intLit(oldField.Line()) - case *ast.NameField: + case ast.NameField: md.Name = stringLit(oldField.Name()) default: panic(fmt.Errorf("support for DIImportedEntity field %T not yet implemented", old)) @@ -499,25 +499,25 @@ func (gen *generator) irDIImportedEntity(old *ast.DIImportedEntity) (*metadata.D // --- [ DILabel ] ------------------------------------------------------------- -func (gen *generator) irDILabel(old *ast.DILabel) (*metadata.DILabel, error) { +func (gen *generator) irDILabel(old ast.DILabel) (*metadata.DILabel, error) { md := &metadata.DILabel{} for _, oldField := range old.Fields() { switch oldField := oldField.(type) { - case *ast.ScopeField: + case ast.ScopeField: scope, err := gen.irMDField(oldField.Scope()) if err != nil { return nil, errors.WithStack(err) } md.Scope = scope - case *ast.NameField: + case ast.NameField: md.Name = stringLit(oldField.Name()) - case *ast.FileField: + case ast.FileField: file, err := gen.irMDField(oldField.File()) if err != nil { return nil, errors.WithStack(err) } md.File = file - case *ast.LineField: + case ast.LineField: md.Line = intLit(oldField.Line()) default: panic(fmt.Errorf("support for DILabel field %T not yet implemented", old)) @@ -528,25 +528,25 @@ func (gen *generator) irDILabel(old *ast.DILabel) (*metadata.DILabel, error) { // --- [ DILexicalBlock ] ------------------------------------------------------ -func (gen *generator) irDILexicalBlock(old *ast.DILexicalBlock) (*metadata.DILexicalBlock, error) { +func (gen *generator) irDILexicalBlock(old ast.DILexicalBlock) (*metadata.DILexicalBlock, error) { md := &metadata.DILexicalBlock{} for _, oldField := range old.Fields() { switch oldField := oldField.(type) { - case *ast.ScopeField: + case ast.ScopeField: scope, err := gen.irMDField(oldField.Scope()) if err != nil { return nil, errors.WithStack(err) } md.Scope = scope - case *ast.FileField: + case ast.FileField: file, err := gen.irMDField(oldField.File()) if err != nil { return nil, errors.WithStack(err) } md.File = file - case *ast.LineField: + case ast.LineField: md.Line = intLit(oldField.Line()) - case *ast.ColumnField: + case ast.ColumnField: md.Column = intLit(oldField.Column()) default: panic(fmt.Errorf("support for DILexicalBlock field %T not yet implemented", old)) @@ -557,23 +557,23 @@ func (gen *generator) irDILexicalBlock(old *ast.DILexicalBlock) (*metadata.DILex // --- [ DILexicalBlockFile ] -------------------------------------------------- -func (gen *generator) irDILexicalBlockFile(old *ast.DILexicalBlockFile) (*metadata.DILexicalBlockFile, error) { +func (gen *generator) irDILexicalBlockFile(old ast.DILexicalBlockFile) (*metadata.DILexicalBlockFile, error) { md := &metadata.DILexicalBlockFile{} for _, oldField := range old.Fields() { switch oldField := oldField.(type) { - case *ast.ScopeField: + case ast.ScopeField: scope, err := gen.irMDField(oldField.Scope()) if err != nil { return nil, errors.WithStack(err) } md.Scope = scope - case *ast.FileField: + case ast.FileField: file, err := gen.irMDField(oldField.File()) if err != nil { return nil, errors.WithStack(err) } md.File = file - case *ast.DiscriminatorIntField: + case ast.DiscriminatorIntField: md.Discriminator = uintLit(oldField.Discriminator()) default: panic(fmt.Errorf("support for DILexicalBlockFile field %T not yet implemented", old)) @@ -584,37 +584,37 @@ func (gen *generator) irDILexicalBlockFile(old *ast.DILexicalBlockFile) (*metada // --- [ DILocalVariable ] ----------------------------------------------------- -func (gen *generator) irDILocalVariable(old *ast.DILocalVariable) (*metadata.DILocalVariable, error) { +func (gen *generator) irDILocalVariable(old ast.DILocalVariable) (*metadata.DILocalVariable, error) { md := &metadata.DILocalVariable{} for _, oldField := range old.Fields() { switch oldField := oldField.(type) { - case *ast.NameField: + case ast.NameField: md.Name = stringLit(oldField.Name()) - case *ast.ArgField: + case ast.ArgField: md.Arg = uintLit(oldField.Arg()) - case *ast.ScopeField: + case ast.ScopeField: scope, err := gen.irMDField(oldField.Scope()) if err != nil { return nil, errors.WithStack(err) } md.Scope = scope - case *ast.FileField: + case ast.FileField: file, err := gen.irMDField(oldField.File()) if err != nil { return nil, errors.WithStack(err) } md.File = file - case *ast.LineField: + case ast.LineField: md.Line = intLit(oldField.Line()) - case *ast.TypeField: + case ast.TypeField: typ, err := gen.irMDField(oldField.Typ()) if err != nil { return nil, errors.WithStack(err) } md.Type = typ - case *ast.FlagsField: + case ast.FlagsField: md.Flags = irDIFlags(oldField.Flags()) - case *ast.AlignField: + case ast.AlignField: md.Align = uintLit(oldField.Align()) default: panic(fmt.Errorf("support for DILocalVariable field %T not yet implemented", old)) @@ -625,27 +625,27 @@ func (gen *generator) irDILocalVariable(old *ast.DILocalVariable) (*metadata.DIL // --- [ DILocation ] ---------------------------------------------------------- -func (gen *generator) irDILocation(old *ast.DILocation) (*metadata.DILocation, error) { +func (gen *generator) irDILocation(old ast.DILocation) (*metadata.DILocation, error) { md := &metadata.DILocation{} for _, oldField := range old.Fields() { switch oldField := oldField.(type) { - case *ast.LineField: + case ast.LineField: md.Line = intLit(oldField.Line()) - case *ast.ColumnField: + case ast.ColumnField: md.Column = intLit(oldField.Column()) - case *ast.ScopeField: + case ast.ScopeField: scope, err := gen.irMDField(oldField.Scope()) if err != nil { return nil, errors.WithStack(err) } md.Scope = scope - case *ast.InlinedAtField: + case ast.InlinedAtField: inlinedAt, err := gen.irMDField(oldField.InlinedAt()) if err != nil { return nil, errors.WithStack(err) } md.InlinedAt = inlinedAt - case *ast.IsImplicitCodeField: + case ast.IsImplicitCodeField: md.IsImplicitCode = boolLit(oldField.IsImplicitCode()) default: panic(fmt.Errorf("support for DILocation field %T not yet implemented", old)) @@ -656,17 +656,17 @@ func (gen *generator) irDILocation(old *ast.DILocation) (*metadata.DILocation, e // --- [ DIMacro ] ------------------------------------------------------------- -func (gen *generator) irDIMacro(old *ast.DIMacro) (*metadata.DIMacro, error) { +func (gen *generator) irDIMacro(old ast.DIMacro) (*metadata.DIMacro, error) { md := &metadata.DIMacro{} for _, oldField := range old.Fields() { switch oldField := oldField.(type) { - case *ast.TypeMacinfoField: + case ast.TypeMacinfoField: md.Type = irDwarfMacinfo(oldField.Typ()) - case *ast.LineField: + case ast.LineField: md.Line = intLit(oldField.Line()) - case *ast.NameField: + case ast.NameField: md.Name = stringLit(oldField.Name()) - case *ast.ValueStringField: + case ast.ValueStringField: md.Value = stringLit(oldField.Value()) default: panic(fmt.Errorf("support for DIMacro field %T not yet implemented", old)) @@ -677,21 +677,21 @@ func (gen *generator) irDIMacro(old *ast.DIMacro) (*metadata.DIMacro, error) { // --- [ DIMacroFile ] --------------------------------------------------------- -func (gen *generator) irDIMacroFile(old *ast.DIMacroFile) (*metadata.DIMacroFile, error) { +func (gen *generator) irDIMacroFile(old ast.DIMacroFile) (*metadata.DIMacroFile, error) { md := &metadata.DIMacroFile{} for _, oldField := range old.Fields() { switch oldField := oldField.(type) { - case *ast.TypeMacinfoField: + case ast.TypeMacinfoField: md.Type = irDwarfMacinfo(oldField.Typ()) - case *ast.LineField: + case ast.LineField: md.Line = intLit(oldField.Line()) - case *ast.FileField: + case ast.FileField: file, err := gen.irMDField(oldField.File()) if err != nil { return nil, errors.WithStack(err) } md.File = file - case *ast.NodesField: + case ast.NodesField: nodes, err := gen.irMDField(oldField.Nodes()) if err != nil { return nil, errors.WithStack(err) @@ -706,23 +706,23 @@ func (gen *generator) irDIMacroFile(old *ast.DIMacroFile) (*metadata.DIMacroFile // --- [ DIModule ] ------------------------------------------------------------ -func (gen *generator) irDIModule(old *ast.DIModule) (*metadata.DIModule, error) { +func (gen *generator) irDIModule(old ast.DIModule) (*metadata.DIModule, error) { md := &metadata.DIModule{} for _, oldField := range old.Fields() { switch oldField := oldField.(type) { - case *ast.ScopeField: + case ast.ScopeField: scope, err := gen.irMDField(oldField.Scope()) if err != nil { return nil, errors.WithStack(err) } md.Scope = scope - case *ast.NameField: + case ast.NameField: md.Name = stringLit(oldField.Name()) - case *ast.ConfigMacrosField: + case ast.ConfigMacrosField: md.ConfigMacros = stringLit(oldField.ConfigMacros()) - case *ast.IncludePathField: + case ast.IncludePathField: md.IncludePath = stringLit(oldField.IncludePath()) - case *ast.IsysrootField: + case ast.IsysrootField: md.Isysroot = stringLit(oldField.Isysroot()) default: panic(fmt.Errorf("support for DIModule field %T not yet implemented", old)) @@ -733,19 +733,19 @@ func (gen *generator) irDIModule(old *ast.DIModule) (*metadata.DIModule, error) // --- [ DINamespace ] --------------------------------------------------------- -func (gen *generator) irDINamespace(old *ast.DINamespace) (*metadata.DINamespace, error) { +func (gen *generator) irDINamespace(old ast.DINamespace) (*metadata.DINamespace, error) { md := &metadata.DINamespace{} for _, oldField := range old.Fields() { switch oldField := oldField.(type) { - case *ast.ScopeField: + case ast.ScopeField: scope, err := gen.irMDField(oldField.Scope()) if err != nil { return nil, errors.WithStack(err) } md.Scope = scope - case *ast.NameField: + case ast.NameField: md.Name = stringLit(oldField.Name()) - case *ast.ExportSymbolsField: + case ast.ExportSymbolsField: md.ExportSymbols = boolLit(oldField.ExportSymbols()) default: panic(fmt.Errorf("support for DINamespace field %T not yet implemented", old)) @@ -756,27 +756,27 @@ func (gen *generator) irDINamespace(old *ast.DINamespace) (*metadata.DINamespace // --- [ DIObjCProperty ] ------------------------------------------------------ -func (gen *generator) irDIObjCProperty(old *ast.DIObjCProperty) (*metadata.DIObjCProperty, error) { +func (gen *generator) irDIObjCProperty(old ast.DIObjCProperty) (*metadata.DIObjCProperty, error) { md := &metadata.DIObjCProperty{} for _, oldField := range old.Fields() { switch oldField := oldField.(type) { - case *ast.NameField: + case ast.NameField: md.Name = stringLit(oldField.Name()) - case *ast.FileField: + case ast.FileField: file, err := gen.irMDField(oldField.File()) if err != nil { return nil, errors.WithStack(err) } md.File = file - case *ast.LineField: + case ast.LineField: md.Line = intLit(oldField.Line()) - case *ast.SetterField: + case ast.SetterField: md.Setter = stringLit(oldField.Setter()) - case *ast.GetterField: + case ast.GetterField: md.Getter = stringLit(oldField.Getter()) - case *ast.AttributesField: + case ast.AttributesField: md.Attributes = uintLit(oldField.Attributes()) - case *ast.TypeField: + case ast.TypeField: typ, err := gen.irMDField(oldField.Typ()) if err != nil { return nil, errors.WithStack(err) @@ -791,81 +791,81 @@ func (gen *generator) irDIObjCProperty(old *ast.DIObjCProperty) (*metadata.DIObj // --- [ DISubprogram ] -------------------------------------------------------- -func (gen *generator) irDISubprogram(old *ast.DISubprogram) (*metadata.DISubprogram, error) { +func (gen *generator) irDISubprogram(old ast.DISubprogram) (*metadata.DISubprogram, error) { md := &metadata.DISubprogram{} for _, oldField := range old.Fields() { switch oldField := oldField.(type) { - case *ast.ScopeField: + case ast.ScopeField: scope, err := gen.irMDField(oldField.Scope()) if err != nil { return nil, errors.WithStack(err) } md.Scope = scope - case *ast.NameField: + case ast.NameField: md.Name = stringLit(oldField.Name()) - case *ast.LinkageNameField: + case ast.LinkageNameField: md.LinkageName = stringLit(oldField.LinkageName()) - case *ast.FileField: + case ast.FileField: file, err := gen.irMDField(oldField.File()) if err != nil { return nil, errors.WithStack(err) } md.File = file - case *ast.LineField: + case ast.LineField: md.Line = intLit(oldField.Line()) - case *ast.TypeField: + case ast.TypeField: typ, err := gen.irMDField(oldField.Typ()) if err != nil { return nil, errors.WithStack(err) } md.Type = typ - case *ast.IsLocalField: + case ast.IsLocalField: md.IsLocal = boolLit(oldField.IsLocal()) - case *ast.IsDefinitionField: + case ast.IsDefinitionField: md.IsDefinition = boolLit(oldField.IsDefinition()) - case *ast.ScopeLineField: + case ast.ScopeLineField: md.ScopeLine = intLit(oldField.ScopeLine()) - case *ast.ContainingTypeField: + case ast.ContainingTypeField: containingType, err := gen.irMDField(oldField.ContainingType()) if err != nil { return nil, errors.WithStack(err) } md.ContainingType = containingType - case *ast.VirtualityField: + case ast.VirtualityField: md.Virtuality = irDwarfVirtuality(oldField.Virtuality()) - case *ast.VirtualIndexField: + case ast.VirtualIndexField: md.VirtualIndex = uintLit(oldField.VirtualIndex()) - case *ast.ThisAdjustmentField: + case ast.ThisAdjustmentField: md.ThisAdjustment = intLit(oldField.ThisAdjustment()) - case *ast.FlagsField: + case ast.FlagsField: md.Flags = irDIFlags(oldField.Flags()) - case *ast.IsOptimizedField: + case ast.IsOptimizedField: md.IsOptimized = boolLit(oldField.IsOptimized()) - case *ast.UnitField: + case ast.UnitField: unit, err := gen.irMDField(oldField.Unit()) if err != nil { return nil, errors.WithStack(err) } md.Unit = unit - case *ast.TemplateParamsField: + case ast.TemplateParamsField: templateParams, err := gen.irMDField(oldField.TemplateParams()) if err != nil { return nil, errors.WithStack(err) } md.TemplateParams = templateParams - case *ast.DeclarationField: + case ast.DeclarationField: declaration, err := gen.irMDField(oldField.Declaration()) if err != nil { return nil, errors.WithStack(err) } md.Declaration = declaration - case *ast.RetainedNodesField: + case ast.RetainedNodesField: retainedNodes, err := gen.irMDField(oldField.RetainedNodes()) if err != nil { return nil, errors.WithStack(err) } md.RetainedNodes = retainedNodes - case *ast.ThrownTypesField: + case ast.ThrownTypesField: thrownTypes, err := gen.irMDField(oldField.ThrownTypes()) if err != nil { return nil, errors.WithStack(err) @@ -880,17 +880,17 @@ func (gen *generator) irDISubprogram(old *ast.DISubprogram) (*metadata.DISubprog // --- [ DISubrange ] ---------------------------------------------------------- -func (gen *generator) irDISubrange(old *ast.DISubrange) (*metadata.DISubrange, error) { +func (gen *generator) irDISubrange(old ast.DISubrange) (*metadata.DISubrange, error) { md := &metadata.DISubrange{} for _, oldField := range old.Fields() { switch oldField := oldField.(type) { - case *ast.CountField: + case ast.CountField: count, err := gen.irMDFieldOrInt(oldField.Count()) if err != nil { return nil, errors.WithStack(err) } md.Count = count - case *ast.LowerBoundField: + case ast.LowerBoundField: md.LowerBound = intLit(oldField.LowerBound()) default: panic(fmt.Errorf("support for DISubrange field %T not yet implemented", old)) @@ -901,15 +901,15 @@ func (gen *generator) irDISubrange(old *ast.DISubrange) (*metadata.DISubrange, e // --- [ DISubroutineType ] ---------------------------------------------------- -func (gen *generator) irDISubroutineType(old *ast.DISubroutineType) (*metadata.DISubroutineType, error) { +func (gen *generator) irDISubroutineType(old ast.DISubroutineType) (*metadata.DISubroutineType, error) { md := &metadata.DISubroutineType{} for _, oldField := range old.Fields() { switch oldField := oldField.(type) { - case *ast.FlagsField: + case ast.FlagsField: md.Flags = irDIFlags(oldField.Flags()) - case *ast.CCField: + case ast.CCField: md.CC = irDwarfCC(oldField.CC()) - case *ast.TypesField: + case ast.TypesField: ts, err := gen.irMDField(oldField.Types()) if err != nil { return nil, errors.WithStack(err) @@ -924,13 +924,13 @@ func (gen *generator) irDISubroutineType(old *ast.DISubroutineType) (*metadata.D // --- [ DITemplateTypeParameter ] --------------------------------------------- -func (gen *generator) irDITemplateTypeParameter(old *ast.DITemplateTypeParameter) (*metadata.DITemplateTypeParameter, error) { +func (gen *generator) irDITemplateTypeParameter(old ast.DITemplateTypeParameter) (*metadata.DITemplateTypeParameter, error) { md := &metadata.DITemplateTypeParameter{} for _, oldField := range old.Fields() { switch oldField := oldField.(type) { - case *ast.NameField: + case ast.NameField: md.Name = stringLit(oldField.Name()) - case *ast.TypeField: + case ast.TypeField: typ, err := gen.irMDField(oldField.Typ()) if err != nil { return nil, errors.WithStack(err) @@ -945,21 +945,21 @@ func (gen *generator) irDITemplateTypeParameter(old *ast.DITemplateTypeParameter // --- [ DITemplateValueParameter ] -------------------------------------------- -func (gen *generator) irDITemplateValueParameter(old *ast.DITemplateValueParameter) (*metadata.DITemplateValueParameter, error) { +func (gen *generator) irDITemplateValueParameter(old ast.DITemplateValueParameter) (*metadata.DITemplateValueParameter, error) { md := &metadata.DITemplateValueParameter{} for _, oldField := range old.Fields() { switch oldField := oldField.(type) { - case *ast.TagField: + case ast.TagField: md.Tag = irDwarfTag(oldField.Tag()) - case *ast.NameField: + case ast.NameField: md.Name = stringLit(oldField.Name()) - case *ast.TypeField: + case ast.TypeField: typ, err := gen.irMDField(oldField.Typ()) if err != nil { return nil, errors.WithStack(err) } md.Type = typ - case *ast.ValueField: + case ast.ValueField: value, err := gen.irMDField(oldField.Value()) if err != nil { return nil, errors.WithStack(err) @@ -974,15 +974,15 @@ func (gen *generator) irDITemplateValueParameter(old *ast.DITemplateValueParamet // --- [ GenericDINode ] ------------------------------------------------------- -func (gen *generator) irGenericDINode(old *ast.GenericDINode) (*metadata.GenericDINode, error) { +func (gen *generator) irGenericDINode(old ast.GenericDINode) (*metadata.GenericDINode, error) { md := &metadata.GenericDINode{} for _, oldField := range old.Fields() { switch oldField := oldField.(type) { - case *ast.TagField: + case ast.TagField: md.Tag = irDwarfTag(oldField.Tag()) - case *ast.HeaderField: + case ast.HeaderField: md.Header = stringLit(oldField.Header()) - case *ast.OperandsField: + case ast.OperandsField: for _, field := range oldField.Operands().MDFields() { operand, err := gen.irMDField(field) if err != nil { @@ -1003,8 +1003,8 @@ func (gen *generator) irMDFieldOrInt(old ast.MDFieldOrInt) (metadata.MDFieldOrIn switch old := old.(type) { case ast.MDField: return gen.irMDField(old) - case *ast.IntLit: - return metadata.IntLit(intLit(*old)), nil + case ast.IntLit: + return metadata.IntLit(intLit(old)), nil default: panic(fmt.Errorf("support for metadata field %T not yet implemented", old)) } @@ -1025,9 +1025,9 @@ func irDIFlags(old ast.DIFlags) enum.DIFlag { // info flag. func irDIFlag(old ast.DIFlag) enum.DIFlag { switch old := old.(type) { - case *ast.DIFlagEnum: + case ast.DIFlagEnum: return asmenum.DIFlagFromString(old.Text()) - case *ast.DIFlagInt: + case ast.DIFlagInt: return enum.DIFlag(uintLit(old.UintLit())) default: panic(fmt.Errorf("support for debug info flag %T not yet implemented", old)) @@ -1038,9 +1038,9 @@ func irDIFlag(old ast.DIFlag) enum.DIFlag { // the given AST Dwarf attribute encoding. func irDwarfAttEncoding(old ast.DwarfAttEncoding) enum.DwarfAttEncoding { switch old := old.(type) { - case *ast.DwarfAttEncodingEnum: + case ast.DwarfAttEncodingEnum: return asmenum.DwarfAttEncodingFromString(old.Text()) - case *ast.DwarfAttEncodingInt: + case ast.DwarfAttEncodingInt: return enum.DwarfAttEncoding(uintLit(old.UintLit())) default: panic(fmt.Errorf("support for Dwarf attribute encoding %T not yet implemented", old)) @@ -1051,9 +1051,9 @@ func irDwarfAttEncoding(old ast.DwarfAttEncoding) enum.DwarfAttEncoding { // AST Dwarf calling convention. func irDwarfCC(old ast.DwarfCC) enum.DwarfCC { switch old := old.(type) { - case *ast.DwarfCCEnum: + case ast.DwarfCCEnum: return asmenum.DwarfCCFromString(old.Text()) - case *ast.DwarfCCInt: + case ast.DwarfCCInt: return enum.DwarfCC(uintLit(old.UintLit())) default: panic(fmt.Errorf("support for Dwarf calling convention %T not yet implemented", old)) @@ -1064,9 +1064,9 @@ func irDwarfCC(old ast.DwarfCC) enum.DwarfCC { // Dwarf language. func irDwarfLang(old ast.DwarfLang) enum.DwarfLang { switch old := old.(type) { - case *ast.DwarfLangEnum: + case ast.DwarfLangEnum: return asmenum.DwarfLangFromString(old.Text()) - case *ast.DwarfLangInt: + case ast.DwarfLangInt: return enum.DwarfLang(uintLit(old.UintLit())) default: panic(fmt.Errorf("support for Dwarf language %T not yet implemented", old)) @@ -1077,9 +1077,9 @@ func irDwarfLang(old ast.DwarfLang) enum.DwarfLang { // Dwarf Macinfo. func irDwarfMacinfo(old ast.DwarfMacinfo) enum.DwarfMacinfo { switch old := old.(type) { - case *ast.DwarfMacinfoEnum: + case ast.DwarfMacinfoEnum: return asmenum.DwarfMacinfoFromString(old.Text()) - case *ast.DwarfMacinfoInt: + case ast.DwarfMacinfoInt: return enum.DwarfMacinfo(uintLit(old.UintLit())) default: panic(fmt.Errorf("support for Dwarf Macinfo %T not yet implemented", old)) @@ -1089,9 +1089,9 @@ func irDwarfMacinfo(old ast.DwarfMacinfo) enum.DwarfMacinfo { // irDwarfTag returns the IR Dwarf tag corresponding to the given AST Dwarf tag. func irDwarfTag(old ast.DwarfTag) enum.DwarfTag { switch old := old.(type) { - case *ast.DwarfTagEnum: + case ast.DwarfTagEnum: return asmenum.DwarfTagFromString(old.Text()) - case *ast.DwarfTagInt: + case ast.DwarfTagInt: return enum.DwarfTag(uintLit(old.UintLit())) default: panic(fmt.Errorf("support for Dwarf tag %T not yet implemented", old)) @@ -1102,9 +1102,9 @@ func irDwarfTag(old ast.DwarfTag) enum.DwarfTag { // AST Dwarf virtuality. func irDwarfVirtuality(old ast.DwarfVirtuality) enum.DwarfVirtuality { switch old := old.(type) { - case *ast.DwarfVirtualityEnum: + case ast.DwarfVirtualityEnum: return asmenum.DwarfVirtualityFromString(old.Text()) - case *ast.DwarfVirtualityInt: + case ast.DwarfVirtualityInt: return enum.DwarfVirtuality(uintLit(old.UintLit())) default: panic(fmt.Errorf("support for Dwarf virtuality %T not yet implemented", old)) @@ -1115,9 +1115,9 @@ func irDwarfVirtuality(old ast.DwarfVirtuality) enum.DwarfVirtuality { // emission kind. func irEmissionKind(old ast.EmissionKind) enum.EmissionKind { switch old := old.(type) { - case *ast.EmissionKindEnum: + case ast.EmissionKindEnum: return asmenum.EmissionKindFromString(old.Text()) - case *ast.EmissionKindInt: + case ast.EmissionKindInt: return enum.EmissionKind(uintLit(old.UintLit())) default: panic(fmt.Errorf("support for emission kind %T not yet implemented", old)) @@ -1128,9 +1128,9 @@ func irEmissionKind(old ast.EmissionKind) enum.EmissionKind { // name table kind. func irNameTableKind(old ast.NameTableKind) enum.NameTableKind { switch old := old.(type) { - case *ast.NameTableKindEnum: + case ast.NameTableKindEnum: return asmenum.NameTableKindFromString(old.Text()) - case *ast.NameTableKindInt: + case ast.NameTableKindInt: return enum.NameTableKind(uintLit(old.UintLit())) default: panic(fmt.Errorf("support for name table kind %T not yet implemented", old)) diff --git a/asm/terminator.go b/asm/terminator.go index f5aa7190..50cc068b 100644 --- a/asm/terminator.go +++ b/asm/terminator.go @@ -18,29 +18,29 @@ import ( func (fgen *funcGen) newIRTerm(old ast.Terminator) (ir.Terminator, error) { switch old := old.(type) { // Value terminators. - case *ast.LocalDefTerm: + case ast.LocalDefTerm: ident := localIdent(old.Name()) return fgen.newIRValueTerm(ident, old.Term()) case ast.ValueTerminator: return fgen.newIRValueTerm(ir.LocalIdent{}, old) // Non-value terminators. - case *ast.RetTerm: + case ast.RetTerm: return &ir.TermRet{}, nil - case *ast.BrTerm: + case ast.BrTerm: return &ir.TermBr{}, nil - case *ast.CondBrTerm: + case ast.CondBrTerm: return &ir.TermCondBr{}, nil - case *ast.SwitchTerm: + case ast.SwitchTerm: return &ir.TermSwitch{}, nil - case *ast.IndirectBrTerm: + case ast.IndirectBrTerm: return &ir.TermIndirectBr{}, nil - case *ast.ResumeTerm: + case ast.ResumeTerm: return &ir.TermResume{}, nil - case *ast.CatchRetTerm: + case ast.CatchRetTerm: return &ir.TermCatchRet{}, nil - case *ast.CleanupRetTerm: + case ast.CleanupRetTerm: return &ir.TermCleanupRet{}, nil - case *ast.UnreachableTerm: + case ast.UnreachableTerm: return &ir.TermUnreachable{}, nil default: panic(fmt.Errorf("support for terminator %T not yet implemented", old)) @@ -51,14 +51,14 @@ func (fgen *funcGen) newIRTerm(old ast.Terminator) (ir.Terminator, error) { // based on the given AST value terminator. func (fgen *funcGen) newIRValueTerm(ident ir.LocalIdent, old ast.ValueTerminator) (ir.Terminator, error) { switch old := old.(type) { - case *ast.InvokeTerm: + case ast.InvokeTerm: // Invokee type. typ, err := fgen.gen.irType(old.Typ()) if err != nil { return nil, errors.WithStack(err) } return &ir.TermInvoke{LocalIdent: ident, Typ: typ}, nil - case *ast.CatchSwitchTerm: + case ast.CatchSwitchTerm: // Result type is always token. return &ir.TermCatchSwitch{LocalIdent: ident}, nil default: @@ -73,7 +73,7 @@ func (fgen *funcGen) newIRValueTerm(ident ir.LocalIdent, old ast.ValueTerminator func (fgen *funcGen) astToIRTerm(term ir.Terminator, old ast.Terminator) error { switch old := old.(type) { // Value terminators. - case *ast.LocalDefTerm: + case ast.LocalDefTerm: ident := localIdent(old.Name()) v, ok := fgen.ls[ident] if !ok { @@ -87,23 +87,23 @@ func (fgen *funcGen) astToIRTerm(term ir.Terminator, old ast.Terminator) error { case ast.ValueTerminator: return fgen.astToIRValueTerm(term, old) // Non-value terminators. - case *ast.RetTerm: + case ast.RetTerm: return fgen.astToIRTermRet(term, old) - case *ast.BrTerm: + case ast.BrTerm: return fgen.astToIRTermBr(term, old) - case *ast.CondBrTerm: + case ast.CondBrTerm: return fgen.astToIRTermCondBr(term, old) - case *ast.SwitchTerm: + case ast.SwitchTerm: return fgen.astToIRTermSwitch(term, old) - case *ast.IndirectBrTerm: + case ast.IndirectBrTerm: return fgen.astToIRTermIndirectBr(term, old) - case *ast.ResumeTerm: + case ast.ResumeTerm: return fgen.astToIRTermResume(term, old) - case *ast.CatchRetTerm: + case ast.CatchRetTerm: return fgen.astToIRTermCatchRet(term, old) - case *ast.CleanupRetTerm: + case ast.CleanupRetTerm: return fgen.astToIRTermCleanupRet(term, old) - case *ast.UnreachableTerm: + case ast.UnreachableTerm: return fgen.astToIRTermUnreachable(term, old) default: panic(fmt.Errorf("support for terminator %T not yet implemented", old)) @@ -114,9 +114,9 @@ func (fgen *funcGen) astToIRTerm(term ir.Terminator, old ast.Terminator) error { // IR terminator. func (fgen *funcGen) astToIRValueTerm(term ir.Terminator, old ast.ValueTerminator) error { switch old := old.(type) { - case *ast.InvokeTerm: + case ast.InvokeTerm: return fgen.astToIRTermInvoke(term, old) - case *ast.CatchSwitchTerm: + case ast.CatchSwitchTerm: return fgen.astToIRTermCatchSwitch(term, old) default: panic(fmt.Errorf("support for value terminator %T not yet implemented", old)) @@ -127,7 +127,7 @@ func (fgen *funcGen) astToIRValueTerm(term ir.Terminator, old ast.ValueTerminato // astToIRTermRet translates the given AST ret terminator into an equivalent IR // terminator. -func (fgen *funcGen) astToIRTermRet(term ir.Terminator, old *ast.RetTerm) error { +func (fgen *funcGen) astToIRTermRet(term ir.Terminator, old ast.RetTerm) error { t, ok := term.(*ir.TermRet) if !ok { panic(fmt.Errorf("invalid IR terminator for AST terminator; expected *ir.TermRet, got %T", term)) @@ -159,7 +159,7 @@ func (fgen *funcGen) astToIRTermRet(term ir.Terminator, old *ast.RetTerm) error // astToIRTermBr translates the given AST br terminator into an equivalent IR // terminator. -func (fgen *funcGen) astToIRTermBr(term ir.Terminator, old *ast.BrTerm) error { +func (fgen *funcGen) astToIRTermBr(term ir.Terminator, old ast.BrTerm) error { t, ok := term.(*ir.TermBr) if !ok { panic(fmt.Errorf("invalid IR terminator for AST terminator; expected *ir.TermBr, got %T", term)) @@ -183,14 +183,14 @@ func (fgen *funcGen) astToIRTermBr(term ir.Terminator, old *ast.BrTerm) error { // astToIRTermCondBr translates the given AST condbr terminator into an // equivalent IR terminator. -func (fgen *funcGen) astToIRTermCondBr(term ir.Terminator, old *ast.CondBrTerm) error { +func (fgen *funcGen) astToIRTermCondBr(term ir.Terminator, old ast.CondBrTerm) error { t, ok := term.(*ir.TermCondBr) if !ok { panic(fmt.Errorf("invalid IR terminator for AST terminator; expected *ir.TermCondBr, got %T", term)) } // Branching condition. ct := old.CondTyp() - condType, err := fgen.gen.irType(&ct) + condType, err := fgen.gen.irType(ct) if err != nil { return errors.WithStack(err) } @@ -224,7 +224,7 @@ func (fgen *funcGen) astToIRTermCondBr(term ir.Terminator, old *ast.CondBrTerm) // astToIRTermSwitch translates the given AST switch terminator into an // equivalent IR terminator. -func (fgen *funcGen) astToIRTermSwitch(term ir.Terminator, old *ast.SwitchTerm) error { +func (fgen *funcGen) astToIRTermSwitch(term ir.Terminator, old ast.SwitchTerm) error { t, ok := term.(*ir.TermSwitch) if !ok { panic(fmt.Errorf("invalid IR terminator for AST terminator; expected *ir.TermSwitch, got %T", term)) @@ -262,7 +262,7 @@ func (fgen *funcGen) astToIRTermSwitch(term ir.Terminator, old *ast.SwitchTerm) // astToIRTermIndirectBr translates the given AST indirectbr terminator into an // equivalent IR terminator. -func (fgen *funcGen) astToIRTermIndirectBr(term ir.Terminator, old *ast.IndirectBrTerm) error { +func (fgen *funcGen) astToIRTermIndirectBr(term ir.Terminator, old ast.IndirectBrTerm) error { t, ok := term.(*ir.TermIndirectBr) if !ok { panic(fmt.Errorf("invalid IR terminator for AST terminator; expected *ir.TermIndirectBr, got %T", term)) @@ -294,7 +294,7 @@ func (fgen *funcGen) astToIRTermIndirectBr(term ir.Terminator, old *ast.Indirect // astToIRTermInvoke translates the given AST invoke terminator into an // equivalent IR terminator. -func (fgen *funcGen) astToIRTermInvoke(term ir.Terminator, old *ast.InvokeTerm) error { +func (fgen *funcGen) astToIRTermInvoke(term ir.Terminator, old ast.InvokeTerm) error { t, ok := term.(*ir.TermInvoke) if !ok { panic(fmt.Errorf("invalid IR terminator for AST terminator; expected *ir.TermInvoke, got %T", term)) @@ -375,7 +375,7 @@ func (fgen *funcGen) astToIRTermInvoke(term ir.Terminator, old *ast.InvokeTerm) // astToIRTermResume translates the given AST resume terminator into an // equivalent IR terminator. -func (fgen *funcGen) astToIRTermResume(term ir.Terminator, old *ast.ResumeTerm) error { +func (fgen *funcGen) astToIRTermResume(term ir.Terminator, old ast.ResumeTerm) error { t, ok := term.(*ir.TermResume) if !ok { panic(fmt.Errorf("invalid IR terminator for AST terminator; expected *ir.TermResume, got %T", term)) @@ -399,7 +399,7 @@ func (fgen *funcGen) astToIRTermResume(term ir.Terminator, old *ast.ResumeTerm) // astToIRTermCatchSwitch translates the given AST catchswitch terminator into // an equivalent IR terminator. -func (fgen *funcGen) astToIRTermCatchSwitch(term ir.Terminator, old *ast.CatchSwitchTerm) error { +func (fgen *funcGen) astToIRTermCatchSwitch(term ir.Terminator, old ast.CatchSwitchTerm) error { t, ok := term.(*ir.TermCatchSwitch) if !ok { panic(fmt.Errorf("invalid IR terminator for AST terminator; expected *ir.TermCatchSwitch, got %T", term)) @@ -437,7 +437,7 @@ func (fgen *funcGen) astToIRTermCatchSwitch(term ir.Terminator, old *ast.CatchSw // astToIRTermCatchRet translates the given AST catchret terminator into an // equivalent IR terminator. -func (fgen *funcGen) astToIRTermCatchRet(term ir.Terminator, old *ast.CatchRetTerm) error { +func (fgen *funcGen) astToIRTermCatchRet(term ir.Terminator, old ast.CatchRetTerm) error { t, ok := term.(*ir.TermCatchRet) if !ok { panic(fmt.Errorf("invalid IR terminator for AST terminator; expected *ir.TermCatchRet, got %T", term)) @@ -471,7 +471,7 @@ func (fgen *funcGen) astToIRTermCatchRet(term ir.Terminator, old *ast.CatchRetTe // astToIRTermCleanupRet translates the given AST cleanupret terminator into an // equivalent IR terminator. -func (fgen *funcGen) astToIRTermCleanupRet(term ir.Terminator, old *ast.CleanupRetTerm) error { +func (fgen *funcGen) astToIRTermCleanupRet(term ir.Terminator, old ast.CleanupRetTerm) error { t, ok := term.(*ir.TermCleanupRet) if !ok { panic(fmt.Errorf("invalid IR terminator for AST terminator; expected *ir.TermCleanupRet, got %T", term)) @@ -505,7 +505,7 @@ func (fgen *funcGen) astToIRTermCleanupRet(term ir.Terminator, old *ast.CleanupR // astToIRTermUnreachable translates the given AST unreachable terminator into // an equivalent IR terminator. -func (fgen *funcGen) astToIRTermUnreachable(term ir.Terminator, old *ast.UnreachableTerm) error { +func (fgen *funcGen) astToIRTermUnreachable(term ir.Terminator, old ast.UnreachableTerm) error { t, ok := term.(*ir.TermUnreachable) if !ok { panic(fmt.Errorf("invalid IR terminator for AST terminator; expected *ir.TermUnreachable, got %T", term)) diff --git a/asm/translate.go b/asm/translate.go index 02e6458a..84df1e86 100644 --- a/asm/translate.go +++ b/asm/translate.go @@ -70,7 +70,7 @@ import ( ) // translate translates the given AST module into an equivalent IR module. -func translate(old *ast.Module) (*ir.Module, error) { +func translate(old ast.Module) (*ir.Module, error) { gen := newGenerator() // 1. Index AST top-level entities. indexStart := time.Now() @@ -105,7 +105,7 @@ func translate(old *ast.Module) (*ir.Module, error) { // NOTE: step 5-7 can be done concurrenty. // 5. Translate use-list orders. for _, oldUseListOrder := range gen.old.useListOrders { - useListOrder, err := gen.irUseListOrder(*oldUseListOrder) + useListOrder, err := gen.irUseListOrder(oldUseListOrder) if err != nil { return nil, errors.WithStack(err) } @@ -113,7 +113,7 @@ func translate(old *ast.Module) (*ir.Module, error) { } // 6. Translate basic block specific use-list orders. for _, oldUseListOrderBB := range gen.old.useListOrderBBs { - useListOrderBB, err := gen.irUseListOrderBB(*oldUseListOrderBB) + useListOrderBB, err := gen.irUseListOrderBB(oldUseListOrderBB) if err != nil { return nil, errors.WithStack(err) } diff --git a/asm/type.go b/asm/type.go index 41f39a9e..44387f55 100644 --- a/asm/type.go +++ b/asm/type.go @@ -57,25 +57,25 @@ func (gen *generator) resolveTypeDefs() error { // // ; struct type containing pointer to itself. // %d = type { %d* } -func newIRType(typeName string, old ast.LlvmNode, index map[string]*ast.TypeDef, track map[string]bool) (types.Type, error) { +func newIRType(typeName string, old ast.LlvmNode, index map[string]ast.TypeDef, track map[string]bool) (types.Type, error) { switch old := old.(type) { - case *ast.OpaqueType: + case ast.OpaqueType: return &types.StructType{TypeName: typeName}, nil - case *ast.ArrayType: + case ast.ArrayType: return &types.ArrayType{TypeName: typeName}, nil - case *ast.FloatType: + case ast.FloatType: return &types.FloatType{TypeName: typeName}, nil - case *ast.FuncType: + case ast.FuncType: return &types.FuncType{TypeName: typeName}, nil - case *ast.IntType: + case ast.IntType: return &types.IntType{TypeName: typeName}, nil - case *ast.LabelType: + case ast.LabelType: return &types.LabelType{TypeName: typeName}, nil - case *ast.MMXType: + case ast.MMXType: return &types.MMXType{TypeName: typeName}, nil - case *ast.MetadataType: + case ast.MetadataType: return &types.MetadataType{TypeName: typeName}, nil - case *ast.NamedType: + case ast.NamedType: if track[typeName] { var names []string for name := range track { @@ -89,17 +89,17 @@ func newIRType(typeName string, old ast.LlvmNode, index map[string]*ast.TypeDef, newName := getTypeName(newIdent) newTyp := index[newName].Typ() return newIRType(newName, newTyp, index, track) - case *ast.PointerType: + case ast.PointerType: return &types.PointerType{TypeName: typeName}, nil - case *ast.StructType: + case ast.StructType: return &types.StructType{TypeName: typeName}, nil - case *ast.PackedStructType: + case ast.PackedStructType: return &types.StructType{TypeName: typeName}, nil - case *ast.TokenType: + case ast.TokenType: return &types.TokenType{TypeName: typeName}, nil - case *ast.VectorType: + case ast.VectorType: return &types.VectorType{TypeName: typeName}, nil - case *ast.VoidType: + case ast.VoidType: return &types.VoidType{TypeName: typeName}, nil default: panic(fmt.Errorf("support for type %T not yet implemented", old)) @@ -113,35 +113,35 @@ func newIRType(typeName string, old ast.LlvmNode, index map[string]*ast.TypeDef, // of t is populated. Named types are resolved through ts. func (gen *generator) astToIRTypeDef(t types.Type, old ast.LlvmNode) (types.Type, error) { switch old := old.(type) { - case *ast.OpaqueType: + case ast.OpaqueType: return gen.astToIROpaqueType(t, old) - case *ast.ArrayType: + case ast.ArrayType: return gen.astToIRArrayType(t, old) - case *ast.FloatType: + case ast.FloatType: return gen.astToIRFloatType(t, old) - case *ast.FuncType: + case ast.FuncType: return gen.astToIRFuncType(t, old) - case *ast.IntType: + case ast.IntType: return gen.astToIRIntType(t, old) - case *ast.LabelType: + case ast.LabelType: return gen.astToIRLabelType(t, old) - case *ast.MMXType: + case ast.MMXType: return gen.astToIRMMXType(t, old) - case *ast.MetadataType: + case ast.MetadataType: return gen.astToIRMetadataType(t, old) - case *ast.NamedType: + case ast.NamedType: return gen.astToIRNamedType(t, old) - case *ast.PointerType: + case ast.PointerType: return gen.astToIRPointerType(t, old) - case *ast.StructType: + case ast.StructType: return gen.astToIRStructType(t, old) - case *ast.PackedStructType: + case ast.PackedStructType: return gen.astToIRPackedStructType(t, old) - case *ast.TokenType: + case ast.TokenType: return gen.astToIRTokenType(t, old) - case *ast.VectorType: + case ast.VectorType: return gen.astToIRVectorType(t, old) - case *ast.VoidType: + case ast.VoidType: return gen.astToIRVoidType(t, old) default: panic(fmt.Errorf("support for type %T not yet implemented", old)) @@ -150,7 +150,7 @@ func (gen *generator) astToIRTypeDef(t types.Type, old ast.LlvmNode) (types.Type // --- [ Void Types ] ---------------------------------------------------------- -func (gen *generator) astToIRVoidType(t types.Type, old *ast.VoidType) (types.Type, error) { +func (gen *generator) astToIRVoidType(t types.Type, old ast.VoidType) (types.Type, error) { typ, ok := t.(*types.VoidType) if t == nil { typ = &types.VoidType{} @@ -165,7 +165,7 @@ func (gen *generator) astToIRVoidType(t types.Type, old *ast.VoidType) (types.Ty // --- [ Function Types ] ------------------------------------------------------ -func (gen *generator) astToIRFuncType(t types.Type, old *ast.FuncType) (types.Type, error) { +func (gen *generator) astToIRFuncType(t types.Type, old ast.FuncType) (types.Type, error) { typ, ok := t.(*types.FuncType) if t == nil { typ = &types.FuncType{} @@ -196,7 +196,7 @@ func (gen *generator) astToIRFuncType(t types.Type, old *ast.FuncType) (types.Ty // --- [ Integer Types ] ------------------------------------------------------- -func (gen *generator) astToIRIntType(t types.Type, old *ast.IntType) (types.Type, error) { +func (gen *generator) astToIRIntType(t types.Type, old ast.IntType) (types.Type, error) { typ, ok := t.(*types.IntType) if t == nil { typ = &types.IntType{} @@ -212,7 +212,7 @@ func (gen *generator) astToIRIntType(t types.Type, old *ast.IntType) (types.Type // irIntTypeBitSize returns the integer type bit size corresponding to the given // AST integer type. -func irIntTypeBitSize(n *ast.IntType) int64 { +func irIntTypeBitSize(n ast.IntType) int64 { text := n.Text() const prefix = "i" if !strings.HasPrefix(text, prefix) { @@ -232,7 +232,7 @@ func irIntTypeBitSize(n *ast.IntType) int64 { // --- [ Floating-point Types ] ------------------------------------------------ -func (gen *generator) astToIRFloatType(t types.Type, old *ast.FloatType) (types.Type, error) { +func (gen *generator) astToIRFloatType(t types.Type, old ast.FloatType) (types.Type, error) { typ, ok := t.(*types.FloatType) if t == nil { typ = &types.FloatType{} @@ -268,7 +268,7 @@ func irFloatKind(kind ast.FloatKind) types.FloatKind { // --- [ MMX Types ] ----------------------------------------------------------- -func (gen *generator) astToIRMMXType(t types.Type, old *ast.MMXType) (types.Type, error) { +func (gen *generator) astToIRMMXType(t types.Type, old ast.MMXType) (types.Type, error) { typ, ok := t.(*types.MMXType) if t == nil { typ = &types.MMXType{} @@ -283,7 +283,7 @@ func (gen *generator) astToIRMMXType(t types.Type, old *ast.MMXType) (types.Type // --- [ Pointer Types ] ------------------------------------------------------- -func (gen *generator) astToIRPointerType(t types.Type, old *ast.PointerType) (types.Type, error) { +func (gen *generator) astToIRPointerType(t types.Type, old ast.PointerType) (types.Type, error) { typ, ok := t.(*types.PointerType) if t == nil { typ = &types.PointerType{} @@ -307,7 +307,7 @@ func (gen *generator) astToIRPointerType(t types.Type, old *ast.PointerType) (ty // --- [ Vector Types ] -------------------------------------------------------- -func (gen *generator) astToIRVectorType(t types.Type, old *ast.VectorType) (types.Type, error) { +func (gen *generator) astToIRVectorType(t types.Type, old ast.VectorType) (types.Type, error) { typ, ok := t.(*types.VectorType) if t == nil { typ = &types.VectorType{} @@ -330,7 +330,7 @@ func (gen *generator) astToIRVectorType(t types.Type, old *ast.VectorType) (type // --- [ Label Types ] --------------------------------------------------------- -func (gen *generator) astToIRLabelType(t types.Type, old *ast.LabelType) (types.Type, error) { +func (gen *generator) astToIRLabelType(t types.Type, old ast.LabelType) (types.Type, error) { typ, ok := t.(*types.LabelType) if t == nil { typ = &types.LabelType{} @@ -345,7 +345,7 @@ func (gen *generator) astToIRLabelType(t types.Type, old *ast.LabelType) (types. // --- [ Token Types ] --------------------------------------------------------- -func (gen *generator) astToIRTokenType(t types.Type, old *ast.TokenType) (types.Type, error) { +func (gen *generator) astToIRTokenType(t types.Type, old ast.TokenType) (types.Type, error) { typ, ok := t.(*types.TokenType) if t == nil { typ = &types.TokenType{} @@ -360,7 +360,7 @@ func (gen *generator) astToIRTokenType(t types.Type, old *ast.TokenType) (types. // --- [ Metadata Types ] ------------------------------------------------------ -func (gen *generator) astToIRMetadataType(t types.Type, old *ast.MetadataType) (types.Type, error) { +func (gen *generator) astToIRMetadataType(t types.Type, old ast.MetadataType) (types.Type, error) { typ, ok := t.(*types.MetadataType) if t == nil { typ = &types.MetadataType{} @@ -375,7 +375,7 @@ func (gen *generator) astToIRMetadataType(t types.Type, old *ast.MetadataType) ( // --- [ Array Types ] --------------------------------------------------------- -func (gen *generator) astToIRArrayType(t types.Type, old *ast.ArrayType) (types.Type, error) { +func (gen *generator) astToIRArrayType(t types.Type, old ast.ArrayType) (types.Type, error) { typ, ok := t.(*types.ArrayType) if t == nil { typ = &types.ArrayType{} @@ -398,7 +398,7 @@ func (gen *generator) astToIRArrayType(t types.Type, old *ast.ArrayType) (types. // --- [ Structure Types ] ----------------------------------------------------- -func (gen *generator) astToIROpaqueType(t types.Type, old *ast.OpaqueType) (types.Type, error) { +func (gen *generator) astToIROpaqueType(t types.Type, old ast.OpaqueType) (types.Type, error) { typ, ok := t.(*types.StructType) if t == nil { // NOTE: Panic instead of returning error as this case should not be @@ -414,7 +414,7 @@ func (gen *generator) astToIROpaqueType(t types.Type, old *ast.OpaqueType) (type return typ, nil } -func (gen *generator) astToIRStructType(t types.Type, old *ast.StructType) (types.Type, error) { +func (gen *generator) astToIRStructType(t types.Type, old ast.StructType) (types.Type, error) { typ, ok := t.(*types.StructType) if t == nil { typ = &types.StructType{} @@ -437,7 +437,7 @@ func (gen *generator) astToIRStructType(t types.Type, old *ast.StructType) (type return typ, nil } -func (gen *generator) astToIRPackedStructType(t types.Type, old *ast.PackedStructType) (types.Type, error) { +func (gen *generator) astToIRPackedStructType(t types.Type, old ast.PackedStructType) (types.Type, error) { typ, ok := t.(*types.StructType) if t == nil { typ = &types.StructType{} @@ -463,7 +463,7 @@ func (gen *generator) astToIRPackedStructType(t types.Type, old *ast.PackedStruc // --- [ Named Types ] --------------------------------------------------------- -func (gen *generator) astToIRNamedType(t types.Type, old *ast.NamedType) (types.Type, error) { +func (gen *generator) astToIRNamedType(t types.Type, old ast.NamedType) (types.Type, error) { // Resolve named type. ident := localIdent(old.Name()) name := getTypeName(ident) diff --git a/asm/value.go b/asm/value.go index 0ff0b832..7a4f8c8e 100644 --- a/asm/value.go +++ b/asm/value.go @@ -12,21 +12,21 @@ import ( func (fgen *funcGen) astToIRValue(typ types.Type, old ast.Value) (value.Value, error) { switch old := old.(type) { - case *ast.GlobalIdent: - ident := globalIdent(*old) + case ast.GlobalIdent: + ident := globalIdent(old) v, ok := fgen.gen.new.globals[ident] if !ok { return nil, errors.Errorf("unable to locate global identifier %q", ident) } return v, nil - case *ast.LocalIdent: - ident := localIdent(*old) + case ast.LocalIdent: + ident := localIdent(old) v, ok := fgen.ls[ident] if !ok { return nil, errors.Errorf("unable to locate local identifier %q", ident.Ident()) } return v, nil - case *ast.InlineAsm: + case ast.InlineAsm: asm := &ir.InlineAsm{} // (optional) Side effect. asm.SideEffect = old.SideEffect().IsValid()