1 // Copyright 2015 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.
12 // Block represents a basic block in the control flow graph of a function.
14 // A unique identifier for the block. The system will attempt to allocate
15 // these IDs densely, but no guarantees.
18 // Source position for block's control operation
21 // The kind of block this is.
24 // Likely direction for branches.
25 // If BranchLikely, Succs[0] is the most likely branch taken.
26 // If BranchUnlikely, Succs[1] is the most likely branch taken.
27 // Ignored if len(Succs) < 2.
28 // Fatal if not BranchUnknown and len(Succs) > 2.
29 Likely BranchPrediction
31 // After flagalloc, records whether flags are live at the end of the block.
34 // Subsequent blocks, if any. The number and order depend on the block kind.
37 // Inverse of successors.
38 // The order is significant to Phi nodes in the block.
39 // TODO: predecessors is a pain to maintain. Can we somehow order phi
40 // arguments by block id and have this field computed explicitly when needed?
43 // A list of values that determine how the block is exited. The number
44 // and type of control values depends on the Kind of the block. For
45 // instance, a BlockIf has a single boolean control value and BlockExit
46 // has a single memory control value.
48 // The ControlValues() method may be used to get a slice with the non-nil
49 // control values that can be ranged over.
51 // Controls[1] must be nil if Controls[0] is nil.
54 // Auxiliary info for the block. Its value depends on the Kind.
58 // The unordered set of Values that define the operation of this block.
59 // After the scheduling pass, this list is ordered.
62 // The containing function
65 // Storage for Succs, Preds and Values.
71 // Edge represents a CFG edge.
72 // Example edges for b branching to either c or d.
73 // (c and d have other predecessors.)
75 // b.Succs = [{c,3}, {d,1}]
76 // c.Preds = [?, ?, ?, {b,0}]
77 // d.Preds = [?, {b,1}, ?]
79 // These indexes allow us to edit the CFG in constant time.
80 // In addition, it informs phi ops in degenerate cases like:
87 // Then the indexes tell you whether x is chosen from
88 // the if or else branch from b.
90 // b.Succs = [{c,0},{c,1}]
91 // c.Preds = [{b,0},{b,1}]
93 // means x is chosen if k is true.
95 // block edge goes to (in a Succs list) or from (in a Preds list)
97 // index of reverse edge. Invariant:
99 // e.b.Preds[e.i] = Edge{x,idx}
100 // and similarly for predecessors.
104 func (e Edge) Block() *Block {
107 func (e Edge) Index() int {
110 func (e Edge) String() string {
111 return fmt.Sprintf("{%v,%d}", e.b, e.i)
114 // BlockKind is the kind of SSA block.
116 // kind controls successors
117 // ------------------------------------------
118 // Exit [return mem] []
120 // If [boolean Value] [then, else]
121 // Defer [mem] [nopanic, panic] (control opcode should be OpStaticCall to runtime.deferproc)
125 func (b *Block) String() string {
126 return fmt.Sprintf("b%d", b.ID)
130 func (b *Block) LongString() string {
133 s += fmt.Sprintf(" {%s}", b.Aux)
135 if t := b.AuxIntString(); t != "" {
136 s += fmt.Sprintf(" [%s]", t)
138 for _, c := range b.ControlValues() {
139 s += fmt.Sprintf(" %s", c)
141 if len(b.Succs) > 0 {
143 for _, c := range b.Succs {
144 s += " " + c.b.String()
156 // NumControls returns the number of non-nil control values the
158 func (b *Block) NumControls() int {
159 if b.Controls[0] == nil {
162 if b.Controls[1] == nil {
168 // ControlValues returns a slice containing the non-nil control
169 // values of the block. The index of each control value will be
170 // the same as it is in the Controls property and can be used
171 // in ReplaceControl calls.
172 func (b *Block) ControlValues() []*Value {
173 if b.Controls[0] == nil {
174 return b.Controls[:0]
176 if b.Controls[1] == nil {
177 return b.Controls[:1]
179 return b.Controls[:2]
182 // SetControl removes all existing control values and then adds
183 // the control value provided. The number of control values after
184 // a call to SetControl will always be 1.
185 func (b *Block) SetControl(v *Value) {
191 // ResetControls sets the number of controls for the block to 0.
192 func (b *Block) ResetControls() {
193 if b.Controls[0] != nil {
196 if b.Controls[1] != nil {
199 b.Controls = [2]*Value{} // reset both controls to nil
202 // AddControl appends a control value to the existing list of control values.
203 func (b *Block) AddControl(v *Value) {
205 b.Controls[i] = v // panics if array is full
209 // ReplaceControl exchanges the existing control value at the index provided
210 // for the new value. The index must refer to a valid control value.
211 func (b *Block) ReplaceControl(i int, v *Value) {
217 // CopyControls replaces the controls for this block with those from the
218 // provided block. The provided block is not modified.
219 func (b *Block) CopyControls(from *Block) {
224 for _, c := range from.ControlValues() {
229 // Reset sets the block to the provided kind and clears all the blocks control
230 // and auxiliary values. Other properties of the block, such as its successors,
231 // predecessors and values are left unmodified.
232 func (b *Block) Reset(kind BlockKind) {
239 // resetWithControl resets b and adds control v.
240 // It is equivalent to b.Reset(kind); b.AddControl(v),
241 // except that it is one call instead of two and avoids a bounds check.
242 // It is intended for use by rewrite rules, where this matters.
243 func (b *Block) resetWithControl(kind BlockKind, v *Value) {
252 // resetWithControl2 resets b and adds controls v and w.
253 // It is equivalent to b.Reset(kind); b.AddControl(v); b.AddControl(w),
254 // except that it is one call instead of three and avoids two bounds checks.
255 // It is intended for use by rewrite rules, where this matters.
256 func (b *Block) resetWithControl2(kind BlockKind, v, w *Value) {
267 // truncateValues truncates b.Values at the ith element, zeroing subsequent elements.
268 // The values in b.Values after i must already have had their args reset,
269 // to maintain correct value uses counts.
270 func (b *Block) truncateValues(i int) {
272 for j := range tail {
275 b.Values = b.Values[:i]
278 // AddEdgeTo adds an edge from block b to block c. Used during building of the
279 // SSA graph; do not use on an already-completed SSA graph.
280 func (b *Block) AddEdgeTo(c *Block) {
283 b.Succs = append(b.Succs, Edge{c, j})
284 c.Preds = append(c.Preds, Edge{b, i})
285 b.Func.invalidateCFG()
288 // removePred removes the ith input edge from b.
289 // It is the responsibility of the caller to remove
290 // the corresponding successor edge, and adjust any
291 // phi values by calling b.removePhiArg(v, i).
292 func (b *Block) removePred(i int) {
293 n := len(b.Preds) - 1
297 // Update the other end of the edge we moved.
301 b.Preds = b.Preds[:n]
302 b.Func.invalidateCFG()
305 // removeSucc removes the ith output edge from b.
306 // It is the responsibility of the caller to remove
307 // the corresponding predecessor edge.
308 func (b *Block) removeSucc(i int) {
309 n := len(b.Succs) - 1
313 // Update the other end of the edge we moved.
317 b.Succs = b.Succs[:n]
318 b.Func.invalidateCFG()
321 func (b *Block) swapSuccessors() {
322 if len(b.Succs) != 2 {
323 b.Fatalf("swapSuccessors with len(Succs)=%d", len(b.Succs))
329 e0.b.Preds[e0.i].i = 1
330 e1.b.Preds[e1.i].i = 0
334 // removePhiArg removes the ith arg from phi.
335 // It must be called after calling b.removePred(i) to
336 // adjust the corresponding phi value of the block:
339 // for _, v := range b.Values {
341 // if v.Op != OpPhi {
344 // b.removePhiArg(v, i)
347 func (b *Block) removePhiArg(phi *Value, i int) {
349 if numPhiArgs := len(phi.Args); numPhiArgs-1 != n {
350 b.Fatalf("inconsistent state, num predecessors: %d, num phi args: %d", n, numPhiArgs)
353 phi.Args[i] = phi.Args[n]
355 phi.Args = phi.Args[:n]
359 // LackingPos indicates whether b is a block whose position should be inherited
360 // from its successors. This is true if all the values within it have unreliable positions
361 // and if it is "plain", meaning that there is no control flow that is also very likely
362 // to correspond to a well-understood source position.
363 func (b *Block) LackingPos() bool {
364 // Non-plain predecessors are If or Defer, which both (1) have two successors,
365 // which might have different line numbers and (2) correspond to statements
366 // in the source code that have positions, so this case ought not occur anyway.
367 if b.Kind != BlockPlain {
370 if b.Pos != src.NoXPos {
373 for _, v := range b.Values {
382 func (b *Block) AuxIntString() string {
383 switch b.Kind.AuxIntType() {
385 return fmt.Sprintf("%v", int8(b.AuxInt))
387 return fmt.Sprintf("%v", uint8(b.AuxInt))
388 default: // type specified but not implemented - print as int64
389 return fmt.Sprintf("%v", b.AuxInt)
390 case "": // no aux int type
395 // likelyBranch reports whether block b is the likely branch of all of its predecessors.
396 func (b *Block) likelyBranch() bool {
397 if len(b.Preds) == 0 {
400 for _, e := range b.Preds {
402 if len(p.Succs) == 1 || len(p.Succs) == 2 && (p.Likely == BranchLikely && p.Succs[0].b == b ||
403 p.Likely == BranchUnlikely && p.Succs[1].b == b) {
411 func (b *Block) Logf(msg string, args ...interface{}) { b.Func.Logf(msg, args...) }
412 func (b *Block) Log() bool { return b.Func.Log() }
413 func (b *Block) Fatalf(msg string, args ...interface{}) { b.Func.Fatalf(msg, args...) }
415 type BranchPrediction int8
418 BranchUnlikely = BranchPrediction(-1)
419 BranchUnknown = BranchPrediction(0)
420 BranchLikely = BranchPrediction(+1)