// Copyright 2013 The Go Authors. All rights reserved.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

package ir

// This file implements the Function and BasicBlock types.

import (

"bytes"

"fmt"

"go/ast"

"go/format"

"go/token"

"go/types"

"io"

"os"

"sort"

"strings"

"honnef.co/go/tools/go/types/typeutil"

)

// addEdge adds a control-flow graph edge from from to to.

func addEdge(from, to *BasicBlock) {

from.Succs = append(from.Succs, to)

to.Preds = append(to.Preds, from)

}

// Control returns the last instruction in the block.

func (b *BasicBlock) Control() Instruction {

if len(b.Instrs) == 0 {

return nil

}

return b.Instrs[len(b.Instrs)-1]

}

// SigmaFor returns the sigma node for v coming from pred.

func (b *BasicBlock) SigmaFor(v Value, pred *BasicBlock) *Sigma {

for _, instr := range b.Instrs {

sigma, ok := instr.(*Sigma)

if !ok {

// no more sigmas

return nil

}

if sigma.From == pred && sigma.X == v {

return sigma

}

}

return nil

}

func unsigma(v Value) Value {

for {

s, ok := v.(*Sigma)

if !ok {

return v

}

v = s.X

}

}

// SigmaForRecursive returns the sigma node for v, or a sigma node of v, coming from pred.

func (b *BasicBlock) SigmaForRecursive(v Value, pred *BasicBlock) *Sigma {

for _, instr := range b.Instrs {

sigma, ok := instr.(*Sigma)

if !ok {

// no more sigmas

return nil

}

if sigma.From == pred && sigma.X == v || unsigma(sigma.X) == v {

return sigma

}

}

return nil

}

// Parent returns the function that contains block b.

func (b *BasicBlock) Parent() *Function { return b.parent }

// String returns a human-readable label of this block.

// It is not guaranteed unique within the function.

//

func (b *BasicBlock) String() string {

return fmt.Sprintf("%d", b.Index)

}

// emit appends an instruction to the current basic block.

// If the instruction defines a Value, it is returned.

//

func (b *BasicBlock) emit(i Instruction, source ast.Node) Value {

i.setSource(source)

i.setBlock(b)

b.Instrs = append(b.Instrs, i)

v, _ := i.(Value)

return v

}

// predIndex returns the i such that b.Preds[i] == c or panics if

// there is none.

func (b *BasicBlock) predIndex(c *BasicBlock) int {

for i, pred := range b.Preds {

if pred == c {

return i

}

}

panic(fmt.Sprintf("no edge %s -> %s", c, b))

}

// succIndex returns the i such that b.Succs[i] == c or -1 if there is none.

func (b *BasicBlock) succIndex(c *BasicBlock) int {

for i, succ := range b.Succs {

if succ == c {

return i

}

}

return -1

}

// hasPhi returns true if b.Instrs contains φ-nodes.

func (b *BasicBlock) hasPhi() bool {

// XXX have we broken this when we added sigmas?

_, ok := b.Instrs[0].(*Phi)

return ok

}

func (b *BasicBlock) Phis() []Instruction {

return b.phis()

}

// phis returns the prefix of b.Instrs containing all the block's φ-nodes.

func (b *BasicBlock) phis() []Instruction {

// XXX have we broken this when we added sigmas?

for i, instr := range b.Instrs {

if _, ok := instr.(*Phi); !ok {

return b.Instrs[:i]

}

}

return nil // unreachable in well-formed blocks

}

func (b *BasicBlock) Sigmas() []Instruction {

for i, instr := range b.Instrs {

if _, ok := instr.(*Sigma); !ok {

return b.Instrs[:i]

}

}

return nil // unreachable in well-formed blocks

}

// replacePred replaces all occurrences of p in b's predecessor list with q.

// Ordinarily there should be at most one.

//

func (b *BasicBlock) replacePred(p, q *BasicBlock) {

for i, pred := range b.Preds {

if pred == p {

b.Preds[i] = q

}

}

}

// replaceSucc replaces all occurrences of p in b's successor list with q.

// Ordinarily there should be at most one.

//

func (b *BasicBlock) replaceSucc(p, q *BasicBlock) {

for i, succ := range b.Succs {

if succ == p {

b.Succs[i] = q

}

}

}

// removePred removes all occurrences of p in b's

// predecessor list and φ-nodes.

// Ordinarily there should be at most one.

//

func (b *BasicBlock) removePred(p *BasicBlock) {

phis := b.phis()

// We must preserve edge order for φ-nodes.

j := 0

for i, pred := range b.Preds {

if pred != p {

b.Preds[j] = b.Preds[i]

// Strike out φ-edge too.

for _, instr := range phis {

phi := instr.(*Phi)

phi.Edges[j] = phi.Edges[i]

}

j++

}

}

// Nil out b.Preds[j:] and φ-edges[j:] to aid GC.

for i := j; i < len(b.Preds); i++ {

b.Preds[i] = nil

for _, instr := range phis {

instr.(*Phi).Edges[i] = nil

}

}

b.Preds = b.Preds[:j]

for _, instr := range phis {

phi := instr.(*Phi)

phi.Edges = phi.Edges[:j]

}

}

// Destinations associated with unlabelled for/switch/select stmts.

// We push/pop one of these as we enter/leave each construct and for

// each BranchStmt we scan for the innermost target of the right type.

//

type targets struct {

tail *targets // rest of stack

_break *BasicBlock

_continue *BasicBlock

_fallthrough *BasicBlock

}

// Destinations associated with a labelled block.

// We populate these as labels are encountered in forward gotos or

// labelled statements.

//

type lblock struct {

_goto *BasicBlock

_break *BasicBlock

_continue *BasicBlock

}

// labelledBlock returns the branch target associated with the

// specified label, creating it if needed.

//

func (f *Function) labelledBlock(label *ast.Ident) *lblock {

obj := f.Pkg.objectOf(label)

lb := f.lblocks[obj]

if lb == nil {

lb = &lblock{_goto: f.newBasicBlock(label.Name)}

if f.lblocks == nil {

f.lblocks = make(map[types.Object]*lblock)

}

f.lblocks[obj] = lb

}

return lb

}

// addParam adds a (non-escaping) parameter to f.Params of the

// specified name, type and source position.

//

func (f *Function) addParam(name string, typ types.Type, source ast.Node) *Parameter {

var b *BasicBlock

if len(f.Blocks) > 0 {

b = f.Blocks[0]

}

v := &Parameter{

name: name,

}

v.setBlock(b)

v.setType(typ)

v.setSource(source)

f.Params = append(f.Params, v)

if b != nil {

// There may be no blocks if this function has no body. We

// still create params, but aren't interested in the

// instruction.

f.Blocks[0].Instrs = append(f.Blocks[0].Instrs, v)

}

return v

}

func (f *Function) addParamObj(obj types.Object, source ast.Node) *Parameter {

name := obj.Name()

if name == "" {

name = fmt.Sprintf("arg%d", len(f.Params))

}

param := f.addParam(name, obj.Type(), source)

param.object = obj

return param

}

// addSpilledParam declares a parameter that is pre-spilled to the

// stack; the function body will load/store the spilled location.

// Subsequent lifting will eliminate spills where possible.

//

func (f *Function) addSpilledParam(obj types.Object, source ast.Node) {

param := f.addParamObj(obj, source)

spill := &Alloc{}

spill.setType(types.NewPointer(obj.Type()))

spill.source = source

f.objects[obj] = spill

f.Locals = append(f.Locals, spill)

f.emit(spill, source)

emitStore(f, spill, param, source)

// f.emit(&Store{Addr: spill, Val: param})

}

// startBody initializes the function prior to generating IR code for its body.

// Precondition: f.Type() already set.

//

func (f *Function) startBody() {

entry := f.newBasicBlock("entry")

f.currentBlock = entry

f.objects = make(map[types.Object]Value) // needed for some synthetics, e.g. init

}

func (f *Function) blockset(i int) *BlockSet {

bs := &f.blocksets[i]

if len(bs.values) != len(f.Blocks) {

if cap(bs.values) >= len(f.Blocks) {

bs.values = bs.values[:len(f.Blocks)]

bs.Clear()

} else {

bs.values = make([]bool, len(f.Blocks))

}

} else {

bs.Clear()

}

return bs

}

func (f *Function) exitBlock() {

old := f.currentBlock

f.Exit = f.newBasicBlock("exit")

f.currentBlock = f.Exit

ret := f.results()

results := make([]Value, len(ret))

// Run function calls deferred in this

// function when explicitly returning from it.

f.emit(new(RunDefers), nil)

for i, r := range ret {

results[i] = emitLoad(f, r, nil)

}

f.emit(&Return{Results: results}, nil)

f.currentBlock = old

}

// createSyntacticParams populates f.Params and generates code (spills

// and named result locals) for all the parameters declared in the

// syntax. In addition it populates the f.objects mapping.

//

// Preconditions:

// f.startBody() was called.

// Postcondition:

// len(f.Params) == len(f.Signature.Params) + (f.Signature.Recv() ? 1 : 0)

//

func (f *Function) createSyntacticParams(recv *ast.FieldList, functype *ast.FuncType) {

// Receiver (at most one inner iteration).

if recv != nil {

for _, field := range recv.List {

for _, n := range field.Names {

f.addSpilledParam(f.Pkg.info.Defs[n], n)

}

// Anonymous receiver? No need to spill.

if field.Names == nil {

f.addParamObj(f.Signature.Recv(), field)

}

}

}

// Parameters.

if functype.Params != nil {

n := len(f.Params) // 1 if has recv, 0 otherwise

for _, field := range functype.Params.List {

for _, n := range field.Names {

f.addSpilledParam(f.Pkg.info.Defs[n], n)

}

// Anonymous parameter? No need to spill.

if field.Names == nil {

f.addParamObj(f.Signature.Params().At(len(f.Params)-n), field)

}

}

}

// Named results.

if functype.Results != nil {

for _, field := range functype.Results.List {

// Implicit "var" decl of locals for named results.

for _, n := range field.Names {

f.namedResults = append(f.namedResults, f.addLocalForIdent(n))

}

}

if len(f.namedResults) == 0 {

sig := f.Signature.Results()

for i := 0; i < sig.Len(); i++ {

// XXX position information

v := f.addLocal(sig.At(i).Type(), nil)

f.implicitResults = append(f.implicitResults, v)

}

}

}

}

func numberNodes(f *Function) {

var base ID

for _, b := range f.Blocks {

for _, instr := range b.Instrs {

if instr == nil {

continue

}

base++

instr.setID(base)

}

}

}

func updateOperandsReferrers(instr Instruction, ops []*Value) {

for _, op := range ops {

if r := *op; r != nil {

if refs := (*op).Referrers(); refs != nil {

if len(*refs) == 0 {

// per median, each value has two referrers, so we can avoid one call into growslice

//

// Note: we experimented with allocating

// sequential scratch space, but we

// couldn't find a value that gave better

// performance than making many individual

// allocations

*refs = make([]Instruction, 1, 2)

(*refs)[0] = instr

} else {

*refs = append(*refs, instr)

}

}

}

}

}

// buildReferrers populates the def/use information in all non-nil

// Value.Referrers slice.

// Precondition: all such slices are initially empty.

func buildReferrers(f *Function) {

var rands []*Value

for _, b := range f.Blocks {

for _, instr := range b.Instrs {

rands = instr.Operands(rands[:0]) // recycle storage

updateOperandsReferrers(instr, rands)

}

}

for _, c := range f.consts {

rands = c.c.Operands(rands[:0])

updateOperandsReferrers(c.c, rands)

}

}

func (f *Function) emitConsts() {

defer func() {

f.consts = nil

f.aggregateConsts = typeutil.Map[[]*AggregateConst]{}

}()

if len(f.Blocks) == 0 {

return

}

// TODO(dh): our deduplication only works on booleans and

// integers. other constants are represented as pointers to

// things.

head := make([]constValue, 0, len(f.consts))

for _, c := range f.consts {

if len(*c.c.Referrers()) == 0 {

// TODO(dh): killing a const may make other consts dead, too

killInstruction(c.c)

} else {

head = append(head, c)

}

}

sort.Slice(head, func(i, j int) bool {

return head[i].idx < head[j].idx

})

entry := f.Blocks[0]

instrs := make([]Instruction, 0, len(entry.Instrs)+len(head))

for _, c := range head {

instrs = append(instrs, c.c)

}

f.aggregateConsts.Iterate(func(key types.Type, value []*AggregateConst) {

for _, c := range value {

instrs = append(instrs, c)

}

})

instrs = append(instrs, entry.Instrs...)

entry.Instrs = instrs

}

// buildFakeExits ensures that every block in the function is

// reachable in reverse from the Exit block. This is required to build

// a full post-dominator tree, and to ensure the exit block's

// inclusion in the dominator tree.

func buildFakeExits(fn *Function) {

// Find back-edges via forward DFS

fn.fakeExits = BlockSet{values: make([]bool, len(fn.Blocks))}

seen := fn.blockset(0)

backEdges := fn.blockset(1)

var dfs func(b *BasicBlock)

dfs = func(b *BasicBlock) {

if !seen.Add(b) {

backEdges.Add(b)

return

}

for _, pred := range b.Succs {

dfs(pred)

}

}

dfs(fn.Blocks[0])

buildLoop:

for {

seen := fn.blockset(2)

var dfs func(b *BasicBlock)

dfs = func(b *BasicBlock) {

if !seen.Add(b) {

return

}

for _, pred := range b.Preds {

dfs(pred)

}

if b == fn.Exit {

for _, b := range fn.Blocks {

if fn.fakeExits.Has(b) {

dfs(b)

}

}

}

}

dfs(fn.Exit)

for _, b := range fn.Blocks {

if !seen.Has(b) && backEdges.Has(b) {

// Block b is not reachable from the exit block. Add a

// fake jump from b to exit, then try again. Note that we

// only add one fake edge at a time, as it may make

// multiple blocks reachable.

//

// We only consider those blocks that have back edges.

// Any unreachable block that doesn't have a back edge

// must flow into a loop, which by definition has a

// back edge. Thus, by looking for loops, we should

// need fewer fake edges overall.

fn.fakeExits.Add(b)

continue buildLoop

}

}

break

}

}

// finishBody() finalizes the function after IR code generation of its body.

func (f *Function) finishBody() {

f.objects = nil

f.currentBlock = nil

f.lblocks = nil

// Remove from f.Locals any Allocs that escape to the heap.

j := 0

for _, l := range f.Locals {

if !l.Heap {

f.Locals[j] = l

j++

}

}

// Nil out f.Locals[j:] to aid GC.

for i := j; i < len(f.Locals); i++ {

f.Locals[i] = nil

}

f.Locals = f.Locals[:j]

optimizeBlocks(f)

buildFakeExits(f)

buildReferrers(f)

buildDomTree(f)

buildPostDomTree(f)

if f.Prog.mode&NaiveForm == 0 {

lift(f)

}

// emit constants after lifting, because lifting may produce new constants, but before other variable splitting,

// because it expects constants to have been deduplicated.

f.emitConsts()

if f.Prog.mode&SplitAfterNewInformation != 0 {

splitOnNewInformation(f.Blocks[0], &StackMap{})

}

f.namedResults = nil // (used by lifting)

f.implicitResults = nil

numberNodes(f)

defer f.wr.Close()

f.wr.WriteFunc("start", "start", f)

if f.Prog.mode&PrintFunctions != 0 {

printMu.Lock()

f.WriteTo(os.Stdout)

printMu.Unlock()

}

if f.Prog.mode&SanityCheckFunctions != 0 {

mustSanityCheck(f, nil)

}

}

func isUselessPhi(phi *Phi) (Value, bool) {

var v0 Value

for _, e := range phi.Edges {

if e == phi {

continue

}

if v0 == nil {

v0 = e

}

if v0 != e {

if v0, ok := v0.(*Const); ok {

if e, ok := e.(*Const); ok {

if v0.typ == e.typ && v0.Value == e.Value {

continue

}

}

}

return nil, false

}

}

return v0, true

}

func (f *Function) RemoveNilBlocks() {

f.removeNilBlocks()

}

// removeNilBlocks eliminates nils from f.Blocks and updates each

// BasicBlock.Index. Use this after any pass that may delete blocks.

//

func (f *Function) removeNilBlocks() {

j := 0

for _, b := range f.Blocks {

if b != nil {

b.Index = j

f.Blocks[j] = b

j++

}

}

// Nil out f.Blocks[j:] to aid GC.

for i := j; i < len(f.Blocks); i++ {

f.Blocks[i] = nil

}

f.Blocks = f.Blocks[:j]

}

// SetDebugMode sets the debug mode for package pkg. If true, all its

// functions will include full debug info. This greatly increases the

// size of the instruction stream, and causes Functions to depend upon

// the ASTs, potentially keeping them live in memory for longer.

//

func (pkg *Package) SetDebugMode(debug bool) {

// TODO(adonovan): do we want ast.File granularity?

pkg.debug = debug

}

// debugInfo reports whether debug info is wanted for this function.

func (f *Function) debugInfo() bool {

return f.Pkg != nil && f.Pkg.debug

}

// addNamedLocal creates a local variable, adds it to function f and

// returns it. Its name and type are taken from obj. Subsequent

// calls to f.lookup(obj) will return the same local.

//

func (f *Function) addNamedLocal(obj types.Object, source ast.Node) *Alloc {

l := f.addLocal(obj.Type(), source)

f.objects[obj] = l

return l

}

func (f *Function) addLocalForIdent(id *ast.Ident) *Alloc {

return f.addNamedLocal(f.Pkg.info.Defs[id], id)

}

// addLocal creates an anonymous local variable of type typ, adds it

// to function f and returns it. pos is the optional source location.

//

func (f *Function) addLocal(typ types.Type, source ast.Node) *Alloc {

v := &Alloc{}

v.setType(types.NewPointer(typ))

f.Locals = append(f.Locals, v)

f.emit(v, source)

return v

}

// lookup returns the address of the named variable identified by obj

// that is local to function f or one of its enclosing functions.

// If escaping, the reference comes from a potentially escaping pointer

// expression and the referent must be heap-allocated.

//

func (f *Function) lookup(obj types.Object, escaping bool) Value {

if v, ok := f.objects[obj]; ok {

if alloc, ok := v.(*Alloc); ok && escaping {

alloc.Heap = true

}

return v // function-local var (address)

}

// Definition must be in an enclosing function;

// plumb it through intervening closures.

if f.parent == nil {

panic("no ir.Value for " + obj.String())

}

outer := f.parent.lookup(obj, true) // escaping

v := &FreeVar{

name: obj.Name(),

typ: outer.Type(),

outer: outer,

parent: f,

}

f.objects[obj] = v

f.FreeVars = append(f.FreeVars, v)

return v

}

// emit emits the specified instruction to function f.

func (f *Function) emit(instr Instruction, source ast.Node) Value {

return f.currentBlock.emit(instr, source)

}

// RelString returns the full name of this function, qualified by

// package name, receiver type, etc.

//

// The specific formatting rules are not guaranteed and may change.

//

// Examples:

// "math.IsNaN" // a package-level function

// "(*bytes.Buffer).Bytes" // a declared method or a wrapper

// "(*bytes.Buffer).Bytes$thunk" // thunk (func wrapping method; receiver is param 0)

// "(*bytes.Buffer).Bytes$bound" // bound (func wrapping method; receiver supplied by closure)

// "main.main$1" // an anonymous function in main

// "main.init#1" // a declared init function

// "main.init" // the synthesized package initializer

//

// When these functions are referred to from within the same package

// (i.e. from == f.Pkg.Object), they are rendered without the package path.

// For example: "IsNaN", "(*Buffer).Bytes", etc.

//

// All non-synthetic functions have distinct package-qualified names.

// (But two methods may have the same name "(T).f" if one is a synthetic

// wrapper promoting a non-exported method "f" from another package; in

// that case, the strings are equal but the identifiers "f" are distinct.)

//

func (f *Function) RelString(from *types.Package) string {

// Anonymous?

if f.parent != nil {

// An anonymous function's Name() looks like "parentName$1",

// but its String() should include the type/package/etc.

parent := f.parent.RelString(from)

for i, anon := range f.parent.AnonFuncs {

if anon == f {

return fmt.Sprintf("%s$%d", parent, 1+i)

}

}

return f.name // should never happen

}

// Method (declared or wrapper)?

if recv := f.Signature.Recv(); recv != nil {

return f.relMethod(from, recv.Type())

}

// Thunk?

if f.method != nil {

return f.relMethod(from, f.method.Recv())

}

// Bound?

if len(f.FreeVars) == 1 && strings.HasSuffix(f.name, "$bound") {

return f.relMethod(from, f.FreeVars[0].Type())

}

// Package-level function?

// Prefix with package name for cross-package references only.

if p := f.pkg(); p != nil && p != from {

return fmt.Sprintf("%s.%s", p.Path(), f.name)

}

// Unknown.

return f.name

}

func (f *Function) relMethod(from *types.Package, recv types.Type) string {

return fmt.Sprintf("(%s).%s", relType(recv, from), f.name)

}

// writeSignature writes to buf the signature sig in declaration syntax.

func writeSignature(buf *bytes.Buffer, from *types.Package, name string, sig *types.Signature, params []*Parameter) {

buf.WriteString("func ")

if recv := sig.Recv(); recv != nil {

buf.WriteString("(")

if n := params[0].Name(); n != "" {

buf.WriteString(n)

buf.WriteString(" ")

}

types.WriteType(buf, params[0].Type(), types.RelativeTo(from))

buf.WriteString(") ")

}

buf.WriteString(name)

types.WriteSignature(buf, sig, types.RelativeTo(from))

}

func (f *Function) pkg() *types.Package {

if f.Pkg != nil {

return f.Pkg.Pkg

}

return nil

}

var _ io.WriterTo = (*Function)(nil) // *Function implements io.Writer

func (f *Function) WriteTo(w io.Writer) (int64, error) {

var buf bytes.Buffer

WriteFunction(&buf, f)

n, err := w.Write(buf.Bytes())

return int64(n), err

}

// WriteFunction writes to buf a human-readable "disassembly" of f.

func WriteFunction(buf *bytes.Buffer, f *Function) {

fmt.Fprintf(buf, "# Name: %s\n", f.String())

if f.Pkg != nil {

fmt.Fprintf(buf, "# Package: %s\n", f.Pkg.Pkg.Path())

}

if syn := f.Synthetic; syn != 0 {

fmt.Fprintln(buf, "# Synthetic:", syn)

}

if pos := f.Pos(); pos.IsValid() {

fmt.Fprintf(buf, "# Location: %s\n", f.Prog.Fset.Position(pos))

}

if f.parent != nil {

fmt.Fprintf(buf, "# Parent: %s\n", f.parent.Name())

}

from := f.pkg()

if f.FreeVars != nil {

buf.WriteString("# Free variables:\n")

for i, fv := range f.FreeVars {

fmt.Fprintf(buf, "# % 3d:\t%s %s\n", i, fv.Name(), relType(fv.Type(), from))

}

}

if len(f.Locals) > 0 {

buf.WriteString("# Locals:\n")

for i, l := range f.Locals {

fmt.Fprintf(buf, "# % 3d:\t%s %s\n", i, l.Name(), relType(deref(l.Type()), from))

}

}

writeSignature(buf, from, f.Name(), f.Signature, f.Params)

buf.WriteString(":\n")

if f.Blocks == nil {

buf.WriteString("\t(external)\n")

}

for _, b := range f.Blocks {

if b == nil {

// Corrupt CFG.

fmt.Fprintf(buf, ".nil:\n")

continue

}

fmt.Fprintf(buf, "b%d:", b.Index)

if len(b.Preds) > 0 {

fmt.Fprint(buf, " ←")

for _, pred := range b.Preds {

fmt.Fprintf(buf, " b%d", pred.Index)

}

}

if b.Comment != "" {

fmt.Fprintf(buf, " # %s", b.Comment)

}

buf.WriteByte('\n')

if false { // CFG debugging

fmt.Fprintf(buf, "\t# CFG: %s --> %s --> %s\n", b.Preds, b, b.Succs)

}

buf2 := &bytes.Buffer{}

for _, instr := range b.Instrs {

buf.WriteString("\t")

switch v := instr.(type) {

case Value:

// Left-align the instruction.

if name := v.Name(); name != "" {

fmt.Fprintf(buf, "%s = ", name)

}

buf.WriteString(instr.String())

case nil:

// Be robust against bad transforms.

buf.WriteString("<deleted>")

default:

buf.WriteString(instr.String())

}

buf.WriteString("\n")

if f.Prog.mode&PrintSource != 0 {

if s := instr.Source(); s != nil {

buf2.Reset()

format.Node(buf2, f.Prog.Fset, s)

for {

line, err := buf2.ReadString('\n')

if len(line) == 0 {

break

}

buf.WriteString("\t\t> ")

buf.WriteString(line)

if line[len(line)-1] != '\n' {

buf.WriteString("\n")

}

if err != nil {

break

}

}

}

}

}

buf.WriteString("\n")

}

}

// newBasicBlock adds to f a new basic block and returns it. It does

// not automatically become the current block for subsequent calls to emit.

// comment is an optional string for more readable debugging output.

//

func (f *Function) newBasicBlock(comment string) *BasicBlock {

var instrs []Instruction

if len(f.functionBody.scratchInstructions) > 0 {

instrs = f.functionBody.scratchInstructions[0:0:avgInstructionsPerBlock]

f.functionBody.scratchInstructions = f.functionBody.scratchInstructions[avgInstructionsPerBlock:]

} else {

instrs = make([]Instruction, 0, avgInstructionsPerBlock)

}

b := &BasicBlock{

Index: len(f.Blocks),

Comment: comment,

parent: f,

Instrs: instrs,

}

b.Succs = b.succs2[:0]

f.Blocks = append(f.Blocks, b)

return b

}

// NewFunction returns a new synthetic Function instance belonging to

// prog, with its name and signature fields set as specified.

//

// The caller is responsible for initializing the remaining fields of

// the function object, e.g. Pkg, Params, Blocks.

//

// It is practically impossible for clients to construct well-formed

// IR functions/packages/programs directly, so we assume this is the

// job of the Builder alone. NewFunction exists to provide clients a

// little flexibility. For example, analysis tools may wish to

// construct fake Functions for the root of the callgraph, a fake

// "reflect" package, etc.

//

// TODO(adonovan): think harder about the API here.

//

func (prog *Program) NewFunction(name string, sig *types.Signature, provenance Synthetic) *Function {

return &Function{Prog: prog, name: name, Signature: sig, Synthetic: provenance}

}

//lint:ignore U1000 we may make use of this for functions loaded from export data

type extentNode [2]token.Pos

func (n extentNode) Pos() token.Pos { return n[0] }

func (n extentNode) End() token.Pos { return n[1] }

func (f *Function) initHTML(name string) {

if name == "" {

return

}

if rel := f.RelString(nil); rel == name {

f.wr = NewHTMLWriter("ir.html", rel, "")

}

}

func killInstruction(instr Instruction) {

ops := instr.Operands(nil)

for _, op := range ops {

if refs := (*op).Referrers(); refs != nil {

*refs = removeInstr(*refs, instr)

}

}

}