github.com/shogo82148/std@v1.22.1-0.20240327122250-4e474527810c/cmd/internal/obj/inl.go (about)

     1  // Copyright 2017 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 obj
     6  
     7  import "github.com/shogo82148/std/cmd/internal/src"
     8  
     9  // InlTree is a collection of inlined calls. The Parent field of an
    10  // InlinedCall is the index of another InlinedCall in InlTree.
    11  //
    12  // The compiler maintains a global inlining tree and adds a node to it
    13  // every time a function is inlined. For example, suppose f() calls g()
    14  // and g has two calls to h(), and that f, g, and h are inlineable:
    15  //
    16  //	 1 func main() {
    17  //	 2     f()
    18  //	 3 }
    19  //	 4 func f() {
    20  //	 5     g()
    21  //	 6 }
    22  //	 7 func g() {
    23  //	 8     h()
    24  //	 9     h()
    25  //	10 }
    26  //	11 func h() {
    27  //	12     println("H")
    28  //	13 }
    29  //
    30  // Assuming the global tree starts empty, inlining will produce the
    31  // following tree:
    32  //
    33  //	[]InlinedCall{
    34  //	  {Parent: -1, Func: "f", Pos: <line 2>},
    35  //	  {Parent:  0, Func: "g", Pos: <line 5>},
    36  //	  {Parent:  1, Func: "h", Pos: <line 8>},
    37  //	  {Parent:  1, Func: "h", Pos: <line 9>},
    38  //	}
    39  //
    40  // The nodes of h inlined into main will have inlining indexes 2 and 3.
    41  //
    42  // Eventually, the compiler extracts a per-function inlining tree from
    43  // the global inlining tree (see pcln.go).
    44  type InlTree struct {
    45  	nodes []InlinedCall
    46  }
    47  
    48  // InlinedCall is a node in an InlTree.
    49  type InlinedCall struct {
    50  	Parent   int
    51  	Pos      src.XPos
    52  	Func     *LSym
    53  	Name     string
    54  	ParentPC int32
    55  }
    56  
    57  // Add adds a new call to the tree, returning its index.
    58  func (tree *InlTree) Add(parent int, pos src.XPos, func_ *LSym, name string) int
    59  
    60  // AllParents invokes do on each InlinedCall in the inlining call
    61  // stack, from outermost to innermost.
    62  //
    63  // That is, if inlIndex corresponds to f inlining g inlining h,
    64  // AllParents invokes do with the call for inlining g into f, and then
    65  // inlining h into g.
    66  func (tree *InlTree) AllParents(inlIndex int, do func(InlinedCall))
    67  
    68  func (tree *InlTree) Parent(inlIndex int) int
    69  
    70  func (tree *InlTree) InlinedFunction(inlIndex int) *LSym
    71  
    72  func (tree *InlTree) CallPos(inlIndex int) src.XPos
    73  
    74  // OutermostPos returns the outermost position corresponding to xpos,
    75  // which is where xpos was ultimately inlined to. In the example for
    76  // InlTree, main() contains inlined AST nodes from h(), but the
    77  // outermost position for those nodes is line 2.
    78  func (ctxt *Link) OutermostPos(xpos src.XPos) src.Pos
    79  
    80  // InnermostPos returns the innermost position corresponding to xpos,
    81  // that is, the code that is inlined and that inlines nothing else.
    82  // In the example for InlTree above, the code for println within h
    83  // would have an innermost position with line number 12, whether
    84  // h was not inlined, inlined into g, g-then-f, or g-then-f-then-main.
    85  // This corresponds to what someone debugging main, f, g, or h might
    86  // expect to see while single-stepping.
    87  func (ctxt *Link) InnermostPos(xpos src.XPos) src.Pos
    88  
    89  // AllPos invokes do with every position in the inlining call stack for xpos,
    90  // from outermost to innermost. That is, xpos corresponds to f inlining g inlining h,
    91  // AllPos invokes do with the position in f, then the position in g, then the position in h.
    92  func (ctxt *Link) AllPos(xpos src.XPos, do func(src.Pos))