stmt.go

Documentation: cmd/compile/internal/ir

     1  // Copyright 2020 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package ir
     6  
     7  import (
     8  	"cmd/compile/internal/base"
     9  	"cmd/compile/internal/types"
    10  	"cmd/internal/obj"
    11  	"cmd/internal/src"
    12  	"go/constant"
    13  )
    14  
    15  // A Decl is a declaration of a const, type, or var. (A declared func is a Func.)
    16  type Decl struct {
    17  	miniNode
    18  	X *Name // the thing being declared
    19  }
    20  
    21  func NewDecl(pos src.XPos, op Op, x *Name) *Decl {
    22  	n := &Decl{X: x}
    23  	n.pos = pos
    24  	switch op {
    25  	default:
    26  		panic("invalid Decl op " + op.String())
    27  	case ODCL:
    28  		n.op = op
    29  	}
    30  	return n
    31  }
    32  
    33  func (*Decl) isStmt() {}
    34  
    35  // A Stmt is a Node that can appear as a statement.
    36  // This includes statement-like expressions such as f().
    37  //
    38  // (It's possible it should include <-c, but that would require
    39  // splitting ORECV out of UnaryExpr, which hasn't yet been
    40  // necessary. Maybe instead we will introduce ExprStmt at
    41  // some point.)
    42  type Stmt interface {
    43  	Node
    44  	isStmt()
    45  }
    46  
    47  // A miniStmt is a miniNode with extra fields common to statements.
    48  type miniStmt struct {
    49  	miniNode
    50  	init Nodes
    51  }
    52  
    53  func (*miniStmt) isStmt() {}
    54  
    55  func (n *miniStmt) Init() Nodes     { return n.init }
    56  func (n *miniStmt) SetInit(x Nodes) { n.init = x }
    57  func (n *miniStmt) PtrInit() *Nodes { return &n.init }
    58  
    59  // An AssignListStmt is an assignment statement with
    60  // more than one item on at least one side: Lhs = Rhs.
    61  // If Def is true, the assignment is a :=.
    62  type AssignListStmt struct {
    63  	miniStmt
    64  	Lhs Nodes
    65  	Def bool
    66  	Rhs Nodes
    67  }
    68  
    69  func NewAssignListStmt(pos src.XPos, op Op, lhs, rhs []Node) *AssignListStmt {
    70  	n := &AssignListStmt{}
    71  	n.pos = pos
    72  	n.SetOp(op)
    73  	n.Lhs = lhs
    74  	n.Rhs = rhs
    75  	return n
    76  }
    77  
    78  func (n *AssignListStmt) SetOp(op Op) {
    79  	switch op {
    80  	default:
    81  		panic(n.no("SetOp " + op.String()))
    82  	case OAS2, OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV, OSELRECV2:
    83  		n.op = op
    84  	}
    85  }
    86  
    87  // An AssignStmt is a simple assignment statement: X = Y.
    88  // If Def is true, the assignment is a :=.
    89  type AssignStmt struct {
    90  	miniStmt
    91  	X   Node
    92  	Def bool
    93  	Y   Node
    94  }
    95  
    96  func NewAssignStmt(pos src.XPos, x, y Node) *AssignStmt {
    97  	n := &AssignStmt{X: x, Y: y}
    98  	n.pos = pos
    99  	n.op = OAS
   100  	return n
   101  }
   102  
   103  func (n *AssignStmt) SetOp(op Op) {
   104  	switch op {
   105  	default:
   106  		panic(n.no("SetOp " + op.String()))
   107  	case OAS:
   108  		n.op = op
   109  	}
   110  }
   111  
   112  // An AssignOpStmt is an AsOp= assignment statement: X AsOp= Y.
   113  type AssignOpStmt struct {
   114  	miniStmt
   115  	X      Node
   116  	AsOp   Op // OADD etc
   117  	Y      Node
   118  	IncDec bool // actually ++ or --
   119  }
   120  
   121  func NewAssignOpStmt(pos src.XPos, asOp Op, x, y Node) *AssignOpStmt {
   122  	n := &AssignOpStmt{AsOp: asOp, X: x, Y: y}
   123  	n.pos = pos
   124  	n.op = OASOP
   125  	return n
   126  }
   127  
   128  // A BlockStmt is a block: { List }.
   129  type BlockStmt struct {
   130  	miniStmt
   131  	List Nodes
   132  }
   133  
   134  func NewBlockStmt(pos src.XPos, list []Node) *BlockStmt {
   135  	n := &BlockStmt{}
   136  	n.pos = pos
   137  	if !pos.IsKnown() {
   138  		n.pos = base.Pos
   139  		if len(list) > 0 {
   140  			n.pos = list[0].Pos()
   141  		}
   142  	}
   143  	n.op = OBLOCK
   144  	n.List = list
   145  	return n
   146  }
   147  
   148  // A BranchStmt is a break, continue, fallthrough, or goto statement.
   149  type BranchStmt struct {
   150  	miniStmt
   151  	Label *types.Sym // label if present
   152  }
   153  
   154  func NewBranchStmt(pos src.XPos, op Op, label *types.Sym) *BranchStmt {
   155  	switch op {
   156  	case OBREAK, OCONTINUE, OFALL, OGOTO:
   157  		// ok
   158  	default:
   159  		panic("NewBranch " + op.String())
   160  	}
   161  	n := &BranchStmt{Label: label}
   162  	n.pos = pos
   163  	n.op = op
   164  	return n
   165  }
   166  
   167  func (n *BranchStmt) SetOp(op Op) {
   168  	switch op {
   169  	default:
   170  		panic(n.no("SetOp " + op.String()))
   171  	case OBREAK, OCONTINUE, OFALL, OGOTO:
   172  		n.op = op
   173  	}
   174  }
   175  
   176  func (n *BranchStmt) Sym() *types.Sym { return n.Label }
   177  
   178  // A CaseClause is a case statement in a switch or select: case List: Body.
   179  type CaseClause struct {
   180  	miniStmt
   181  	Var  *Name // declared variable for this case in type switch
   182  	List Nodes // list of expressions for switch, early select
   183  
   184  	// RTypes is a list of RType expressions, which are copied to the
   185  	// corresponding OEQ nodes that are emitted when switch statements
   186  	// are desugared. RTypes[i] must be non-nil if the emitted
   187  	// comparison for List[i] will be a mixed interface/concrete
   188  	// comparison; see reflectdata.CompareRType for details.
   189  	//
   190  	// Because mixed interface/concrete switch cases are rare, we allow
   191  	// len(RTypes) < len(List). Missing entries are implicitly nil.
   192  	RTypes Nodes
   193  
   194  	Body Nodes
   195  }
   196  
   197  func NewCaseStmt(pos src.XPos, list, body []Node) *CaseClause {
   198  	n := &CaseClause{List: list, Body: body}
   199  	n.pos = pos
   200  	n.op = OCASE
   201  	return n
   202  }
   203  
   204  type CommClause struct {
   205  	miniStmt
   206  	Comm Node // communication case
   207  	Body Nodes
   208  }
   209  
   210  func NewCommStmt(pos src.XPos, comm Node, body []Node) *CommClause {
   211  	n := &CommClause{Comm: comm, Body: body}
   212  	n.pos = pos
   213  	n.op = OCASE
   214  	return n
   215  }
   216  
   217  // A ForStmt is a non-range for loop: for Init; Cond; Post { Body }
   218  type ForStmt struct {
   219  	miniStmt
   220  	Label        *types.Sym
   221  	Cond         Node
   222  	Post         Node
   223  	Body         Nodes
   224  	DistinctVars bool
   225  }
   226  
   227  func NewForStmt(pos src.XPos, init Node, cond, post Node, body []Node, distinctVars bool) *ForStmt {
   228  	n := &ForStmt{Cond: cond, Post: post}
   229  	n.pos = pos
   230  	n.op = OFOR
   231  	if init != nil {
   232  		n.init = []Node{init}
   233  	}
   234  	n.Body = body
   235  	n.DistinctVars = distinctVars
   236  	return n
   237  }
   238  
   239  // A GoDeferStmt is a go or defer statement: go Call / defer Call.
   240  //
   241  // The two opcodes use a single syntax because the implementations
   242  // are very similar: both are concerned with saving Call and running it
   243  // in a different context (a separate goroutine or a later time).
   244  type GoDeferStmt struct {
   245  	miniStmt
   246  	Call    Node
   247  	DeferAt Expr
   248  }
   249  
   250  func NewGoDeferStmt(pos src.XPos, op Op, call Node) *GoDeferStmt {
   251  	n := &GoDeferStmt{Call: call}
   252  	n.pos = pos
   253  	switch op {
   254  	case ODEFER, OGO:
   255  		n.op = op
   256  	default:
   257  		panic("NewGoDeferStmt " + op.String())
   258  	}
   259  	return n
   260  }
   261  
   262  // An IfStmt is a return statement: if Init; Cond { Body } else { Else }.
   263  type IfStmt struct {
   264  	miniStmt
   265  	Cond   Node
   266  	Body   Nodes
   267  	Else   Nodes
   268  	Likely bool // code layout hint
   269  }
   270  
   271  func NewIfStmt(pos src.XPos, cond Node, body, els []Node) *IfStmt {
   272  	n := &IfStmt{Cond: cond}
   273  	n.pos = pos
   274  	n.op = OIF
   275  	n.Body = body
   276  	n.Else = els
   277  	return n
   278  }
   279  
   280  // A JumpTableStmt is used to implement switches. Its semantics are:
   281  //
   282  //	tmp := jt.Idx
   283  //	if tmp == Cases[0] goto Targets[0]
   284  //	if tmp == Cases[1] goto Targets[1]
   285  //	...
   286  //	if tmp == Cases[n] goto Targets[n]
   287  //
   288  // Note that a JumpTableStmt is more like a multiway-goto than
   289  // a multiway-if. In particular, the case bodies are just
   290  // labels to jump to, not full Nodes lists.
   291  type JumpTableStmt struct {
   292  	miniStmt
   293  
   294  	// Value used to index the jump table.
   295  	// We support only integer types that
   296  	// are at most the size of a uintptr.
   297  	Idx Node
   298  
   299  	// If Idx is equal to Cases[i], jump to Targets[i].
   300  	// Cases entries must be distinct and in increasing order.
   301  	// The length of Cases and Targets must be equal.
   302  	Cases   []constant.Value
   303  	Targets []*types.Sym
   304  }
   305  
   306  func NewJumpTableStmt(pos src.XPos, idx Node) *JumpTableStmt {
   307  	n := &JumpTableStmt{Idx: idx}
   308  	n.pos = pos
   309  	n.op = OJUMPTABLE
   310  	return n
   311  }
   312  
   313  // An InterfaceSwitchStmt is used to implement type switches.
   314  // Its semantics are:
   315  //
   316  //	if RuntimeType implements Descriptor.Cases[0] {
   317  //	    Case, Itab = 0, itab<RuntimeType, Descriptor.Cases[0]>
   318  //	} else if RuntimeType implements Descriptor.Cases[1] {
   319  //	    Case, Itab = 1, itab<RuntimeType, Descriptor.Cases[1]>
   320  //	...
   321  //	} else if RuntimeType implements Descriptor.Cases[N-1] {
   322  //	    Case, Itab = N-1, itab<RuntimeType, Descriptor.Cases[N-1]>
   323  //	} else {
   324  //	    Case, Itab = len(cases), nil
   325  //	}
   326  //
   327  // RuntimeType must be a non-nil *runtime._type.
   328  // Hash must be the hash field of RuntimeType (or its copy loaded from an itab).
   329  // Descriptor must represent an abi.InterfaceSwitch global variable.
   330  type InterfaceSwitchStmt struct {
   331  	miniStmt
   332  
   333  	Case        Node
   334  	Itab        Node
   335  	RuntimeType Node
   336  	Hash        Node
   337  	Descriptor  *obj.LSym
   338  }
   339  
   340  func NewInterfaceSwitchStmt(pos src.XPos, case_, itab, runtimeType, hash Node, descriptor *obj.LSym) *InterfaceSwitchStmt {
   341  	n := &InterfaceSwitchStmt{
   342  		Case:        case_,
   343  		Itab:        itab,
   344  		RuntimeType: runtimeType,
   345  		Hash:        hash,
   346  		Descriptor:  descriptor,
   347  	}
   348  	n.pos = pos
   349  	n.op = OINTERFACESWITCH
   350  	return n
   351  }
   352  
   353  // An InlineMarkStmt is a marker placed just before an inlined body.
   354  type InlineMarkStmt struct {
   355  	miniStmt
   356  	Index int64
   357  }
   358  
   359  func NewInlineMarkStmt(pos src.XPos, index int64) *InlineMarkStmt {
   360  	n := &InlineMarkStmt{Index: index}
   361  	n.pos = pos
   362  	n.op = OINLMARK
   363  	return n
   364  }
   365  
   366  func (n *InlineMarkStmt) Offset() int64     { return n.Index }
   367  func (n *InlineMarkStmt) SetOffset(x int64) { n.Index = x }
   368  
   369  // A LabelStmt is a label statement (just the label, not including the statement it labels).
   370  type LabelStmt struct {
   371  	miniStmt
   372  	Label *types.Sym // "Label:"
   373  }
   374  
   375  func NewLabelStmt(pos src.XPos, label *types.Sym) *LabelStmt {
   376  	n := &LabelStmt{Label: label}
   377  	n.pos = pos
   378  	n.op = OLABEL
   379  	return n
   380  }
   381  
   382  func (n *LabelStmt) Sym() *types.Sym { return n.Label }
   383  
   384  // A RangeStmt is a range loop: for Key, Value = range X { Body }
   385  type RangeStmt struct {
   386  	miniStmt
   387  	Label        *types.Sym
   388  	Def          bool
   389  	X            Node
   390  	RType        Node `mknode:"-"` // see reflectdata/helpers.go
   391  	Key          Node
   392  	Value        Node
   393  	Body         Nodes
   394  	DistinctVars bool
   395  	Prealloc     *Name
   396  
   397  	// When desugaring the RangeStmt during walk, the assignments to Key
   398  	// and Value may require OCONVIFACE operations. If so, these fields
   399  	// will be copied to their respective ConvExpr fields.
   400  	KeyTypeWord   Node `mknode:"-"`
   401  	KeySrcRType   Node `mknode:"-"`
   402  	ValueTypeWord Node `mknode:"-"`
   403  	ValueSrcRType Node `mknode:"-"`
   404  }
   405  
   406  func NewRangeStmt(pos src.XPos, key, value, x Node, body []Node, distinctVars bool) *RangeStmt {
   407  	n := &RangeStmt{X: x, Key: key, Value: value}
   408  	n.pos = pos
   409  	n.op = ORANGE
   410  	n.Body = body
   411  	n.DistinctVars = distinctVars
   412  	return n
   413  }
   414  
   415  // A ReturnStmt is a return statement.
   416  type ReturnStmt struct {
   417  	miniStmt
   418  	Results Nodes // return list
   419  }
   420  
   421  func NewReturnStmt(pos src.XPos, results []Node) *ReturnStmt {
   422  	n := &ReturnStmt{}
   423  	n.pos = pos
   424  	n.op = ORETURN
   425  	n.Results = results
   426  	return n
   427  }
   428  
   429  // A SelectStmt is a block: { Cases }.
   430  type SelectStmt struct {
   431  	miniStmt
   432  	Label *types.Sym
   433  	Cases []*CommClause
   434  
   435  	// TODO(rsc): Instead of recording here, replace with a block?
   436  	Compiled Nodes // compiled form, after walkSelect
   437  }
   438  
   439  func NewSelectStmt(pos src.XPos, cases []*CommClause) *SelectStmt {
   440  	n := &SelectStmt{Cases: cases}
   441  	n.pos = pos
   442  	n.op = OSELECT
   443  	return n
   444  }
   445  
   446  // A SendStmt is a send statement: X <- Y.
   447  type SendStmt struct {
   448  	miniStmt
   449  	Chan  Node
   450  	Value Node
   451  }
   452  
   453  func NewSendStmt(pos src.XPos, ch, value Node) *SendStmt {
   454  	n := &SendStmt{Chan: ch, Value: value}
   455  	n.pos = pos
   456  	n.op = OSEND
   457  	return n
   458  }
   459  
   460  // A SwitchStmt is a switch statement: switch Init; Tag { Cases }.
   461  type SwitchStmt struct {
   462  	miniStmt
   463  	Tag   Node
   464  	Cases []*CaseClause
   465  	Label *types.Sym
   466  
   467  	// TODO(rsc): Instead of recording here, replace with a block?
   468  	Compiled Nodes // compiled form, after walkSwitch
   469  }
   470  
   471  func NewSwitchStmt(pos src.XPos, tag Node, cases []*CaseClause) *SwitchStmt {
   472  	n := &SwitchStmt{Tag: tag, Cases: cases}
   473  	n.pos = pos
   474  	n.op = OSWITCH
   475  	return n
   476  }
   477  
   478  // A TailCallStmt is a tail call statement, which is used for back-end
   479  // code generation to jump directly to another function entirely.
   480  type TailCallStmt struct {
   481  	miniStmt
   482  	Call *CallExpr // the underlying call
   483  }
   484  
   485  func NewTailCallStmt(pos src.XPos, call *CallExpr) *TailCallStmt {
   486  	n := &TailCallStmt{Call: call}
   487  	n.pos = pos
   488  	n.op = OTAILCALL
   489  	return n
   490  }
   491  
   492  // A TypeSwitchGuard is the [Name :=] X.(type) in a type switch.
   493  type TypeSwitchGuard struct {
   494  	miniNode
   495  	Tag  *Ident
   496  	X    Node
   497  	Used bool
   498  }
   499  
   500  func NewTypeSwitchGuard(pos src.XPos, tag *Ident, x Node) *TypeSwitchGuard {
   501  	n := &TypeSwitchGuard{Tag: tag, X: x}
   502  	n.pos = pos
   503  	n.op = OTYPESW
   504  	return n
   505  }
   506
View as plain text