func (w *Walker) emitStructType(name string, typ *types.Struct) {
typeStruct := fmt.Sprintf("type %s struct", name)
- w.emitf(typeStruct)
+ w.emitf("%s", typeStruct)
defer w.pushScope(typeStruct)()
for i := 0; i < typ.NumFields(); i++ {
if p.arch.Family == sys.ARM64 {
off, err := arch.ARM64RegisterShift(r1, op, count)
if err != nil {
- p.errorf(err.Error())
+ p.errorf("%v", err)
}
return off
} else {
case sys.ARM64:
err := arch.ARM64RegisterExtension(a, ext, reg, num, isAmount, isIndex)
if err != nil {
- p.errorf(err.Error())
+ p.errorf("%v", err)
}
default:
p.errorf("register extension not supported on this architecture")
ext := tok.String()
curArrangement, err := arch.ARM64RegisterArrangement(reg, name, ext)
if err != nil {
- p.errorf(err.Error())
+ p.errorf("%v", err)
}
if firstReg == -1 {
// only record the first register and arrangement
case sys.ARM64:
offset, err := arch.ARM64RegisterListOffset(firstReg, regCnt, arrangement)
if err != nil {
- p.errorf(err.Error())
+ p.errorf("%v", err)
}
a.Offset = offset
default:
}
if !gotMatch {
- v.t.Errorf(errorMessage.String())
+ v.t.Error(errorMessage.String())
}
}
}
var sb strings.Builder
sep := ""
base.Ctxt.AllPos(p, func(pos src.Pos) {
- fmt.Fprintf(&sb, sep)
+ sb.WriteString(sep)
sep = "|"
file := filepath.Base(pos.Filename())
fmt.Fprintf(&sb, "%s:%d:%d", file, pos.Line(), pos.Col())
var sb strings.Builder
sep := ""
base.Ctxt.AllPos(p, func(pos src.Pos) {
- fmt.Fprintf(&sb, sep)
+ sb.WriteString(sep)
sep = "|"
file := filepath.Base(pos.Filename())
fmt.Fprintf(&sb, "%s:%d:%d", file, pos.Line(), pos.Col())
var sb strings.Builder
sep := ""
base.Ctxt.AllPos(p, func(pos src.Pos) {
- fmt.Fprintf(&sb, sep)
+ sb.WriteString(sep)
sep = "|"
file := filepath.Base(pos.Filename())
fmt.Fprintf(&sb, "%s:%d:%d", file, pos.Line(), pos.Col())
s += " " + v
}
- base.WarnfAt(pos, s)
+ base.WarnfAt(pos, "%s", s)
}
func (lv *liveness) printbvec(printed bool, name string, live bitvec.BitVec) bool {
func checkLogPath(destination string) string {
path, complaint := parseLogPath(destination)
if complaint != "" {
- log.Fatalf(complaint)
+ log.Fatal(complaint)
}
err := os.MkdirAll(path, 0755)
if err != nil {
c := f(root + "/c")
m := f(root)
- t.Logf(a)
- t.Logf(b)
- t.Logf(c)
- t.Logf(m)
+ t.Log(a)
+ t.Log(b)
+ t.Log(c)
+ t.Log(m)
if !strings.Contains(a, "f, af, bf, abf, cf sums = 100, 45, 100, 100, 100") {
t.Errorf("Did not see expected value of a")
for _, arg := range []string{"v001100110110110010100100", "vx336ca4"} {
m := f(arg)
- t.Logf(m)
+ t.Log(m)
mCount := countMatches(m, "loopvarhash triggered cmd/compile/internal/loopvar/testdata/inlines/main.go:27:6: .* 001100110110110010100100")
otherCount := strings.Count(m, "loopvarhash")
b, err := cmd.CombinedOutput()
m := string(b)
- t.Logf(m)
+ t.Log(m)
yCount := strings.Count(m, "opt.go:16:6: loop variable private now per-iteration, heap-allocated (loop inlined into ./opt.go:29)")
nCount := strings.Count(m, "shared")
b, err := cmd.CombinedOutput()
m := string(b)
- t.Logf(m)
+ t.Log(m)
yCount := strings.Count(m, "opt-122.go:18:6: loop variable private now per-iteration, heap-allocated (loop inlined into ./opt-122.go:31)")
nCount := strings.Count(m, "shared")
b, err := cmd.CombinedOutput()
m := string(b)
- t.Logf(m) // expect error
+ t.Log(m) // expect error
yCount := strings.Count(m, "opt.go:16:6: loop variable private now per-iteration, heap-allocated (loop inlined into ./opt.go:29)")
nCount := strings.Count(m, "shared")
b, err := cmd.CombinedOutput()
m := string(b)
- t.Logf(m) // expect error
+ t.Log(m) // expect error
yCount := strings.Count(m, "opt-121.go:18:6: loop variable private now per-iteration, heap-allocated (loop inlined into ./opt-121.go:31)")
nCount := strings.Count(m, "shared")
fun := c.Fun("entry", bg(size)...)
CheckFunc(fun.f)
if size == 4 {
- t.Logf(fun.f.String())
+ t.Log(fun.f.String())
}
lca1 := makeLCArange(fun.f)
lca2 := makeLCAeasy(fun.f)
name := fwd.Label.Value
if l := ls.labels[name]; l != nil {
l.used = true // avoid "defined and not used" error
- ls.err(fwd.Label.Pos(), "goto %s jumps into block starting at %s", name, l.parent.start)
+ ls.errf(fwd.Label.Pos(), "goto %s jumps into block starting at %s", name, l.parent.start)
} else {
- ls.err(fwd.Label.Pos(), "label %s not defined", name)
+ ls.errf(fwd.Label.Pos(), "label %s not defined", name)
}
}
for _, l := range ls.labels {
if !l.used {
l := l.lstmt.Label
- ls.err(l.Pos(), "label %s defined and not used", l.Value)
+ ls.errf(l.Pos(), "label %s defined and not used", l.Value)
}
}
}
lstmt *LabeledStmt // labeled statement associated with this block, or nil
}
-func (ls *labelScope) err(pos Pos, format string, args ...interface{}) {
+func (ls *labelScope) errf(pos Pos, format string, args ...interface{}) {
ls.errh(Error{pos, fmt.Sprintf(format, args...)})
}
labels = make(map[string]*label)
ls.labels = labels
} else if alt := labels[name]; alt != nil {
- ls.err(s.Label.Pos(), "label %s already defined at %s", name, alt.lstmt.Label.Pos().String())
+ ls.errf(s.Label.Pos(), "label %s already defined at %s", name, alt.lstmt.Label.Pos().String())
return alt
}
l := &label{b, s, false}
fwd.Target = s
l.used = true
if jumpsOverVarDecl(fwd) {
- ls.err(
+ ls.errf(
fwd.Label.Pos(),
"goto %s jumps over declaration of %s at %s",
name, String(varName), varPos,
if t := ctxt.breaks; t != nil {
s.Target = t
} else {
- ls.err(s.Pos(), "break is not in a loop, switch, or select")
+ ls.errf(s.Pos(), "break is not in a loop, switch, or select")
}
case _Continue:
if t := ctxt.continues; t != nil {
s.Target = t
} else {
- ls.err(s.Pos(), "continue is not in a loop")
+ ls.errf(s.Pos(), "continue is not in a loop")
}
case _Fallthrough:
msg := "fallthrough statement out of place"
break // fallthrough ok
}
}
- ls.err(s.Pos(), msg)
+ ls.errf(s.Pos(), "%s", msg)
case _Goto:
fallthrough // should always have a label
default:
case *SwitchStmt, *SelectStmt, *ForStmt:
s.Target = t
default:
- ls.err(s.Label.Pos(), "invalid break label %s", name)
+ ls.errf(s.Label.Pos(), "invalid break label %s", name)
}
} else {
- ls.err(s.Label.Pos(), "break label not defined: %s", name)
+ ls.errf(s.Label.Pos(), "break label not defined: %s", name)
}
case _Continue:
if t, ok := t.Stmt.(*ForStmt); ok {
s.Target = t
} else {
- ls.err(s.Label.Pos(), "invalid continue label %s", name)
+ ls.errf(s.Label.Pos(), "invalid continue label %s", name)
}
} else {
- ls.err(s.Label.Pos(), "continue label not defined: %s", name)
+ ls.errf(s.Label.Pos(), "continue label not defined: %s", name)
}
case _Goto:
fields := strings.Fields(line)
wantFields := 9
if len(fields) != wantFields {
- t.Logf(string(out))
+ t.Log(string(out))
t.Fatalf("bad trace output line, wanted %d fields got %d: %s",
wantFields, len(fields), line)
}
wantvnum := 8
gotvnum := len(vars)
if wantvnum != gotvnum {
- t.Logf(string(out))
+ t.Log(string(out))
t.Fatalf("expected trace output on %d vars got %d\n", wantvnum, gotvnum)
}
rungo := filepath.Join(t.TempDir(), "run.go")
ok := os.WriteFile(rungo, stdout.Bytes(), 0600)
if ok != nil {
- t.Fatalf("Failed to create temporary file " + rungo)
+ t.Fatalf("Failed to create temporary file %s", rungo)
}
stdout.Reset()
var output string
func mypanic(t *testing.T, s string) {
- t.Fatalf(s + "\n" + output)
+ t.Fatal(s + "\n" + output)
}
perr := &PackageError{
alwaysPrintStack: true,
ImportStack: stk.Copy(),
- Err: ImportErrorf(p.ImportPath, "use of internal package "+p.ImportPath+" not allowed"),
+ Err: ImportErrorf(p.ImportPath, "use of internal package %s not allowed", p.ImportPath),
}
return perr
}
}
}
} else {
- cfg.BuildModReason = fmt.Sprintf("Go version in " + versionSource + " is unspecified, so vendor directory was not used.")
+ cfg.BuildModReason = fmt.Sprintf("Go version in %s is unspecified, so vendor directory was not used.", versionSource)
}
}
}
// Emit testcase.
var w bytes.Buffer
- fmt.Fprintf(&w, issue41621prolog)
+ w.WriteString(issue41621prolog)
for i := 0; i < 1048576+13; i++ {
fmt.Fprintf(&w, "\t\"%d\",\n", i)
}
- fmt.Fprintf(&w, issue41621epilog)
+ w.WriteString(issue41621epilog)
err = os.WriteFile(tmpdir+"/large.go", w.Bytes(), 0666)
if err != nil {
t.Fatalf("can't write output: %v\n", err)
}
err := f.debugSSA(phase, flag, val, valstring)
if err != "" {
- log.Fatalf(err)
+ log.Fatal(err)
}
// Setting this false for -d=ssa/... preserves old behavior
// of turning off concurrency for any debug flags.
name := fmt.Sprintf("new%d", k+1)
mi := ldr.LookupOrCreateSym(name, 0)
if mi == 0 {
- t.Fatalf("LookupOrCreateSym failed for '" + name + "'")
+ t.Fatalf("LookupOrCreateSym failed for %q", name)
}
mi = tp.addDataFunc(ldr, mi, pmi)
if ldr.SymType(mi) != tp.expKind {
testname := fmt.Sprintf("bigfn%d", j)
fmt.Fprintf(&w, "TEXT ยท%s(SB),$0\n", testname)
for i := 0; i < 2200000; i++ {
- fmt.Fprintf(&w, inst)
+ w.WriteString(inst)
}
fmt.Fprintf(&w, "\tRET\n")
err := os.WriteFile(tmpdir+"/"+testname+".s", w.Bytes(), 0666)