158 lines
3.9 KiB
Go
158 lines
3.9 KiB
Go
// Copyright 2015 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 main
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"os"
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
var (
|
|
hexDumpRE = regexp.MustCompile(`^\t(0x[0-9a-f]{4,})(( ([0-9a-f]{2}| )){16}) [ -\x7F]{1,16}\n`)
|
|
listingRE = regexp.MustCompile(`^\t(0x[0-9a-f]{4,}) ([0-9]{4,}) \(.*:[0-9]+\)\t`)
|
|
)
|
|
|
|
// okdiffs lists regular expressions for lines to consider minor mismatches.
|
|
// If one of these regexps matches both of a pair of unequal lines, the mismatch
|
|
// is reported but not treated as the one worth looking for.
|
|
// For example, differences in the TEXT line are typically frame size
|
|
// changes due to optimization decisions made in the body of the function.
|
|
// Better to keep looking for the actual difference.
|
|
// Similarly, forward jumps might have different offsets due to a
|
|
// change in instruction encoding later on.
|
|
// Better to find that change.
|
|
var okdiffs = []*regexp.Regexp{
|
|
regexp.MustCompile(`\) TEXT[ ].*,\$`),
|
|
regexp.MustCompile(`\) WORD[ ].*,\$`),
|
|
regexp.MustCompile(`\) (B|BR|JMP) `),
|
|
regexp.MustCompile(`\) FUNCDATA `),
|
|
regexp.MustCompile(`\\(z|x00)`),
|
|
regexp.MustCompile(`\$\([0-9]\.[0-9]+e[+\-][0-9]+\)`),
|
|
regexp.MustCompile(`size=.*value=.*args=.*locals=`),
|
|
}
|
|
|
|
func compareLogs(outfile string) string {
|
|
f1, err := os.Open(outfile + ".log")
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
defer f1.Close()
|
|
|
|
f2, err := os.Open(outfile + ".stash.log")
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
defer f2.Close()
|
|
|
|
b1 := bufio.NewReader(f1)
|
|
b2 := bufio.NewReader(f2)
|
|
|
|
offset := int64(0)
|
|
textOffset := offset
|
|
textLineno := 0
|
|
lineno := 0
|
|
var line1, line2 string
|
|
var prefix bytes.Buffer
|
|
Reading:
|
|
for {
|
|
var err1, err2 error
|
|
line1, err1 = b1.ReadString('\n')
|
|
line2, err2 = b2.ReadString('\n')
|
|
if strings.Contains(line1, ")\tTEXT\t") {
|
|
textOffset = offset
|
|
textLineno = lineno
|
|
}
|
|
offset += int64(len(line1))
|
|
lineno++
|
|
if err1 == io.EOF && err2 == io.EOF {
|
|
return "no differences in debugging output"
|
|
}
|
|
|
|
if lineno == 1 || line1 == line2 && err1 == nil && err2 == nil {
|
|
continue
|
|
}
|
|
// Lines are inconsistent. Worth stopping?
|
|
for _, re := range okdiffs {
|
|
if re.MatchString(line1) && re.MatchString(line2) {
|
|
fmt.Fprintf(&prefix, "inconsistent log line:\n%s:%d:\n\t%s\n%s:%d:\n\t%s\n\n",
|
|
f1.Name(), lineno, strings.TrimSuffix(line1, "\n"),
|
|
f2.Name(), lineno, strings.TrimSuffix(line2, "\n"))
|
|
continue Reading
|
|
}
|
|
}
|
|
|
|
if err1 != nil {
|
|
line1 = err1.Error()
|
|
}
|
|
if err2 != nil {
|
|
line2 = err2.Error()
|
|
}
|
|
break
|
|
}
|
|
|
|
msg := fmt.Sprintf("inconsistent log line:\n%s:%d:\n\t%s\n%s:%d:\n\t%s",
|
|
f1.Name(), lineno, strings.TrimSuffix(line1, "\n"),
|
|
f2.Name(), lineno, strings.TrimSuffix(line2, "\n"))
|
|
|
|
if m := hexDumpRE.FindStringSubmatch(line1); m != nil {
|
|
target, err := strconv.ParseUint(m[1], 0, 64)
|
|
if err != nil {
|
|
goto Skip
|
|
}
|
|
|
|
m2 := hexDumpRE.FindStringSubmatch(line2)
|
|
if m2 == nil {
|
|
goto Skip
|
|
}
|
|
|
|
fields1 := strings.Fields(m[2])
|
|
fields2 := strings.Fields(m2[2])
|
|
i := 0
|
|
for i < len(fields1) && i < len(fields2) && fields1[i] == fields2[i] {
|
|
i++
|
|
}
|
|
target += uint64(i)
|
|
|
|
f1.Seek(textOffset, 0)
|
|
b1 = bufio.NewReader(f1)
|
|
last := ""
|
|
lineno := textLineno
|
|
limitAddr := uint64(0)
|
|
lastAddr := uint64(0)
|
|
for {
|
|
line1, err1 := b1.ReadString('\n')
|
|
if err1 != nil {
|
|
break
|
|
}
|
|
lineno++
|
|
if m := listingRE.FindStringSubmatch(line1); m != nil {
|
|
addr, _ := strconv.ParseUint(m[1], 0, 64)
|
|
if addr > target {
|
|
limitAddr = addr
|
|
break
|
|
}
|
|
last = line1
|
|
lastAddr = addr
|
|
} else if hexDumpRE.FindStringSubmatch(line1) != nil {
|
|
break
|
|
}
|
|
}
|
|
if last != "" {
|
|
msg = fmt.Sprintf("assembly instruction at %#04x-%#04x:\n%s:%d\n\t%s\n\n%s",
|
|
lastAddr, limitAddr, f1.Name(), lineno-1, strings.TrimSuffix(last, "\n"), msg)
|
|
}
|
|
}
|
|
Skip:
|
|
|
|
return prefix.String() + msg
|
|
}
|