--- /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