+++ /dev/null
-package ir
-
-import (
- "go/types"
-)
-
-func (b *builder) buildExits(fn *Function) {
- if obj := fn.Object(); obj != nil {
- switch obj.Pkg().Path() {
- case "runtime":
- switch obj.Name() {
- case "exit":
- fn.WillExit = true
- return
- case "throw":
- fn.WillExit = true
- return
- case "Goexit":
- fn.WillUnwind = true
- return
- }
- case "github.com/sirupsen/logrus":
- switch obj.(*types.Func).FullName() {
- case "(*github.com/sirupsen/logrus.Logger).Exit":
- // Technically, this method does not unconditionally exit
- // the process. It dynamically calls a function stored in
- // the logger. If the function is nil, it defaults to
- // os.Exit.
- //
- // The main intent of this method is to terminate the
- // process, and that's what the vast majority of people
- // will use it for. We'll happily accept some false
- // negatives to avoid a lot of false positives.
- fn.WillExit = true
- return
- case "(*github.com/sirupsen/logrus.Logger).Panic",
- "(*github.com/sirupsen/logrus.Logger).Panicf",
- "(*github.com/sirupsen/logrus.Logger).Panicln":
-
- // These methods will always panic, but that's not
- // statically known from the code alone, because they
- // take a detour through the generic Log methods.
- fn.WillUnwind = true
- return
- case "(*github.com/sirupsen/logrus.Entry).Panicf",
- "(*github.com/sirupsen/logrus.Entry).Panicln":
-
- // Entry.Panic has an explicit panic, but Panicf and
- // Panicln do not, relying fully on the generic Log
- // method.
- fn.WillUnwind = true
- return
- case "(*github.com/sirupsen/logrus.Logger).Log",
- "(*github.com/sirupsen/logrus.Logger).Logf",
- "(*github.com/sirupsen/logrus.Logger).Logln":
- // TODO(dh): we cannot handle these case. Whether they
- // exit or unwind depends on the level, which is set
- // via the first argument. We don't currently support
- // call-site-specific exit information.
- }
- }
- }
-
- buildDomTree(fn)
-
- isRecoverCall := func(instr Instruction) bool {
- if instr, ok := instr.(*Call); ok {
- if builtin, ok := instr.Call.Value.(*Builtin); ok {
- if builtin.Name() == "recover" {
- return true
- }
- }
- }
- return false
- }
-
- // All panics branch to the exit block, which means that if every
- // possible path through the function panics, then all
- // predecessors of the exit block must panic.
- willPanic := true
- for _, pred := range fn.Exit.Preds {
- if _, ok := pred.Control().(*Panic); !ok {
- willPanic = false
- }
- }
- if willPanic {
- recovers := false
- recoverLoop:
- for _, u := range fn.Blocks {
- for _, instr := range u.Instrs {
- if instr, ok := instr.(*Defer); ok {
- call := instr.Call.StaticCallee()
- if call == nil {
- // not a static call, so we can't be sure the
- // deferred call isn't calling recover
- recovers = true
- break recoverLoop
- }
- if len(call.Blocks) == 0 {
- // external function, we don't know what's
- // happening inside it
- //
- // TODO(dh): this includes functions from
- // imported packages, due to how go/analysis
- // works. We could introduce another fact,
- // like we've done for exiting and unwinding,
- // but it doesn't seem worth it. Virtually all
- // uses of recover will be in closures.
- recovers = true
- break recoverLoop
- }
- for _, y := range call.Blocks {
- for _, instr2 := range y.Instrs {
- if isRecoverCall(instr2) {
- recovers = true
- break recoverLoop
- }
- }
- }
- }
- }
- }
- if !recovers {
- fn.WillUnwind = true
- return
- }
- }
-
- // TODO(dh): don't check that any specific call dominates the exit
- // block. instead, check that all calls combined cover every
- // possible path through the function.
- exits := NewBlockSet(len(fn.Blocks))
- unwinds := NewBlockSet(len(fn.Blocks))
- for _, u := range fn.Blocks {
- for _, instr := range u.Instrs {
- if instr, ok := instr.(CallInstruction); ok {
- switch instr.(type) {
- case *Defer, *Call:
- default:
- continue
- }
- if instr.Common().IsInvoke() {
- // give up
- return
- }
- var call *Function
- switch instr.Common().Value.(type) {
- case *Function, *MakeClosure:
- call = instr.Common().StaticCallee()
- case *Builtin:
- // the only builtins that affect control flow are
- // panic and recover, and we've already handled
- // those
- continue
- default:
- // dynamic dispatch
- return
- }
- // buildFunction is idempotent. if we're part of a
- // (mutually) recursive call chain, then buildFunction
- // will immediately return, and fn.WillExit will be false.
- if call.Package() == fn.Package() {
- b.buildFunction(call)
- }
- dom := u.Dominates(fn.Exit)
- if call.WillExit {
- if dom {
- fn.WillExit = true
- return
- }
- exits.Add(u)
- } else if call.WillUnwind {
- if dom {
- fn.WillUnwind = true
- return
- }
- unwinds.Add(u)
- }
- }
- }
- }
-
- // depth-first search trying to find a path to the exit block that
- // doesn't cross any of the blacklisted blocks
- seen := NewBlockSet(len(fn.Blocks))
- var findPath func(root *BasicBlock, bl *BlockSet) bool
- findPath = func(root *BasicBlock, bl *BlockSet) bool {
- if root == fn.Exit {
- return true
- }
- if seen.Has(root) {
- return false
- }
- if bl.Has(root) {
- return false
- }
- seen.Add(root)
- for _, succ := range root.Succs {
- if findPath(succ, bl) {
- return true
- }
- }
- return false
- }
-
- if exits.Num() > 0 {
- if !findPath(fn.Blocks[0], exits) {
- fn.WillExit = true
- return
- }
- }
- if unwinds.Num() > 0 {
- seen.Clear()
- if !findPath(fn.Blocks[0], unwinds) {
- fn.WillUnwind = true
- return
- }
- }
-}
-
-func (b *builder) addUnreachables(fn *Function) {
- for _, bb := range fn.Blocks {
- for i, instr := range bb.Instrs {
- if instr, ok := instr.(*Call); ok {
- var call *Function
- switch v := instr.Common().Value.(type) {
- case *Function:
- call = v
- case *MakeClosure:
- call = v.Fn.(*Function)
- }
- if call == nil {
- continue
- }
- if call.Package() == fn.Package() {
- // make sure we have information on all functions in this package
- b.buildFunction(call)
- }
- if call.WillExit {
- // This call will cause the process to terminate.
- // Remove remaining instructions in the block and
- // replace any control flow with Unreachable.
- for _, succ := range bb.Succs {
- succ.removePred(bb)
- }
- bb.Succs = bb.Succs[:0]
-
- bb.Instrs = bb.Instrs[:i+1]
- bb.emit(new(Unreachable), instr.Source())
- addEdge(bb, fn.Exit)
- break
- } else if call.WillUnwind {
- // This call will cause the goroutine to terminate
- // and defers to run (i.e. a panic or
- // runtime.Goexit). Remove remaining instructions
- // in the block and replace any control flow with
- // an unconditional jump to the exit block.
- for _, succ := range bb.Succs {
- succ.removePred(bb)
- }
- bb.Succs = bb.Succs[:0]
-
- bb.Instrs = bb.Instrs[:i+1]
- bb.emit(new(Jump), instr.Source())
- addEdge(bb, fn.Exit)
- break
- }
- }
- }
- }
-}
projects / dotfiles / .git / blobdiff