proc,dwarf/line: support is_stmt and prologue_end flags

Go1.11 uses the is_stmt flag of .debug_line to communicate which
assembly instructions are good places for breakpoints, we should
respect this flag.

These changes were introduced by:
* https://go-review.googlesource.com/c/go/+/102435/

Additionally when setting next breakpoints ignore all PC addresses that
belong to the same line as the one currently under at the cursor. This
matches the behavior of gdb and avoids stopping multiple times at the
heading line of a for statement with go1.11.

Change: https://go-review.googlesource.com/c/go/+/110416 adds the
prologue_end flag to the .debug_line section to communicate the end of
the stack-split prologue. We should use it instead of pattern matching
the disassembly when available.

Fixes #550

type of interfaces
'c7cde8b'.

pkg/proc/proc.go

@@ -328,7 +328,7 @@ func StepOut(dbp Process) error {
 		if selg != nil {
 			deferPCEntry := selg.DeferPC()
 			if deferPCEntry != 0 {
-				_, _, deferfn := dbp.BinInfo().PCToLine(deferPCEntry)
+				deferfn := dbp.BinInfo().PCToFunc(deferPCEntry)
 				deferpc, err = FirstPCAfterPrologue(dbp, deferfn, false)
 				if err != nil {
 					return err
@@ -565,3 +565,38 @@ func CreateUnrecoveredPanicBreakpoint(p Process, writeBreakpoint writeBreakpoint
 	}
 
 }
+
+// FirstPCAfterPrologue returns the address of the first
+// instruction after the prologue for function fn.
+// If sameline is set FirstPCAfterPrologue will always return an
+// address associated with the same line as fn.Entry.
+func FirstPCAfterPrologue(p Process, fn *Function, sameline bool) (uint64, error) {
+	pc, _, line, ok := fn.cu.lineInfo.PrologueEndPC(fn.Entry, fn.End)
+	if ok {
+		if !sameline {
+			return pc, nil
+		} else {
+			_, entryLine := fn.cu.lineInfo.PCToLine(fn.Entry, fn.Entry)
+			if entryLine == line {
+				return pc, nil
+			}
+		}
+	}
+
+	pc, err := firstPCAfterPrologueDisassembly(p, fn, sameline)
+	if err != nil {
+		return fn.Entry, err
+	}
+
+	if pc == fn.Entry {
+		// Look for the first instruction with the stmt flag set, so that setting a
+		// breakpoint with file:line and with the function name always result on
+		// the same instruction being selected.
+		entryFile, entryLine := fn.cu.lineInfo.PCToLine(fn.Entry, fn.Entry)
+		if pc, _, err := p.BinInfo().LineToPC(entryFile, entryLine); err == nil {
+			return pc, nil
+		}
+	}
+
+	return pc, nil
+}