cmd/toolstash/cmp.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
}