Stowage/go
2
0
Fork 0
mirror of https://github.com/golang/go.git synced 2025-12-08 06:10:04 +00:00
Code Issues Projects Releases Packages Wiki Activity

cmd/compile: use int32 for line numbers consistently

Browse source 
- removed lots of unnecessary int(x) casts
- removed parserline() - was inconsistently used anyway
- minor simplifications in dcl.go

Change-Id: Ibf7de679eea528a31c9692ef1c76a1d9b3239211
Reviewed-on: https://go-review.googlesource.com/20131
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
This commit is contained in:
Robert Griesemer 2016-03-02 11:01:25 -08:00
parent 053aef4f1b
commit b83f3972fe
20 changed files with 87 additions and 105 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/cmd/compile/internal/amd64/ggen.go
View file

@ -728,7 +728,7 @@ func expandchecks(firstp *obj.Prog) {
continue
}
if gc.Debug_checknil != 0 && p.Lineno > 1 { // p->lineno==1 in generated wrappers
gc.Warnl(int(p.Lineno), "generated nil check")
gc.Warnl(p.Lineno, "generated nil check")
}
// check is

2
src/cmd/compile/internal/arm/ggen.go
View file

@ -421,7 +421,7 @@ func expandchecks(firstp *obj.Prog) {
continue
}
if gc.Debug_checknil != 0 && p.Lineno > 1 { // p->lineno==1 in generated wrappers
gc.Warnl(int(p.Lineno), "generated nil check")
gc.Warnl(p.Lineno, "generated nil check")
}
if p.From.Type != obj.TYPE_REG {
gc.Fatalf("invalid nil check %v", p)

2
src/cmd/compile/internal/arm64/ggen.go
View file

@ -491,7 +491,7 @@ func expandchecks(firstp *obj.Prog) {
continue
}
if gc.Debug_checknil != 0 && p.Lineno > 1 { // p->lineno==1 in generated wrappers
gc.Warnl(int(p.Lineno), "generated nil check")
gc.Warnl(p.Lineno, "generated nil check")
}
if p.From.Type != obj.TYPE_REG {
gc.Fatalf("invalid nil check %v\n", p)

2
src/cmd/compile/internal/gc/closure.go
View file

@ -261,7 +261,7 @@ func capturevars(xfunc *Node) {
if v.Name.Byval {
how = "value"
}
Warnl(int(v.Lineno), "%v capturing by %s: %v (addr=%v assign=%v width=%d)", name, how, v.Sym, v.Name.Param.Closure.Addrtaken, v.Name.Param.Closure.Assigned, int32(v.Type.Width))
Warnl(v.Lineno, "%v capturing by %s: %v (addr=%v assign=%v width=%d)", name, how, v.Sym, v.Name.Param.Closure.Addrtaken, v.Name.Param.Closure.Assigned, int32(v.Type.Width))
}
typecheck(&outer, Erv)

50
src/cmd/compile/internal/gc/dcl.go
View file

@ -50,21 +50,12 @@ func pushdcl(s *Sym) *Sym {
}
func popdcl() {
var d *Sym
var s *Sym
var lno int
// if(dflag())
// print("revert\n");
for d = dclstack; d != nil; d = d.Link {
if d.Name == "" {
break
}
s = Pkglookup(d.Name, d.Pkg)
lno = int(s.Lastlineno)
d := dclstack
for ; d != nil && d.Name != ""; d = d.Link {
s := Pkglookup(d.Name, d.Pkg)
lno := s.Lastlineno
dcopy(s, d)
d.Lastlineno = int32(lno)
d.Lastlineno = lno
if dflag() {
fmt.Printf("\t%v pop %v %p\n", Ctxt.Line(int(lineno)), s, s.Def)
}
@ -73,7 +64,8 @@ func popdcl() {
if d == nil {
Fatalf("popdcl: no mark")
}
dclstack = d.Link
dclstack = d.Link // pop mark
block = d.Block
}
@ -86,11 +78,7 @@ func markdcl() {
block = blockgen
}
// if(dflag())
// print("markdcl\n");
func dumpdcl(st string) {
var s *Sym
i := 0
for d := dclstack; d != nil; d = d.Link {
i++
@ -101,8 +89,7 @@ func dumpdcl(st string) {
}
fmt.Printf(" '%s'", d.Name)
s = Pkglookup(d.Name, d.Pkg)
fmt.Printf(" %v\n", s)
fmt.Printf(" %v\n", Pkglookup(d.Name, d.Pkg))
}
}
@ -113,7 +100,6 @@ func testdclstack() {
errorexit()
}
Yyerror("mark left on the stack")
continue
}
}
}
@ -129,8 +115,8 @@ func redeclare(s *Sym, where string) {
pkgstr := tmp
Yyerror("%v redeclared %s\n"+"\tprevious declaration during import %q", s, where, pkgstr)
} else {
line1 := parserline()
line2 := int(s.Lastlineno)
line1 := lineno
line2 := s.Lastlineno
// When an import and a declaration collide in separate files,
// present the import as the "redeclared", because the declaration
@ -138,10 +124,10 @@ func redeclare(s *Sym, where string) {
// See issue 4510.
if s.Def == nil {
line2 = line1
line1 = int(s.Lastlineno)
line1 = s.Lastlineno
}
yyerrorl(int(line1), "%v redeclared %s\n"+"\tprevious declaration at %v", s, where, Ctxt.Line(line2))
yyerrorl(line1, "%v redeclared %s\n"+"\tprevious declaration at %v", s, where, Ctxt.Line(int(line2)))
}
}
@ -164,7 +150,7 @@ func declare(n *Node, ctxt Class) {
// named OLITERAL needs Name; most OLITERALs don't.
n.Name = new(Name)
}
n.Lineno = int32(parserline())
n.Lineno = lineno
s := n.Sym
// kludgy: typecheckok means we're past parsing. Eg genwrapper may declare out of package names later.
@ -213,7 +199,7 @@ func declare(n *Node, ctxt Class) {
}
s.Block = block
s.Lastlineno = int32(parserline())
s.Lastlineno = lineno
s.Def = n
n.Name.Vargen = int32(gen)
n.Name.Funcdepth = Funcdepth
@ -466,13 +452,13 @@ func colasdefn(left *NodeList, defn *Node) {
continue
}
if !colasname(n) {
yyerrorl(int(defn.Lineno), "non-name %v on left side of :=", n)
yyerrorl(defn.Lineno, "non-name %v on left side of :=", n)
nerr++
continue
}
if n.Sym.Flags&SymUniq == 0 {
yyerrorl(int(defn.Lineno), "%v repeated on left side of :=", n.Sym)
yyerrorl(defn.Lineno, "%v repeated on left side of :=", n.Sym)
n.Diag++
nerr++
continue
@ -492,7 +478,7 @@ func colasdefn(left *NodeList, defn *Node) {
}
if nnew == 0 && nerr == 0 {
yyerrorl(int(defn.Lineno), "no new variables on left side of :=")
yyerrorl(defn.Lineno, "no new variables on left side of :=")
}
}
@ -1546,7 +1532,7 @@ func checknowritebarrierrec() {
call = c.best[n]
}
err = fmt.Sprintf("write barrier prohibited by caller; %v%s", n.Func.Nname, err)
yyerrorl(int(n.Func.WBLineno), err)
yyerrorl(n.Func.WBLineno, err)
}
})
}

34
src/cmd/compile/internal/gc/esc.go
View file

@ -462,7 +462,7 @@ func escAnalyze(all []*Node, recursive bool) {
if Debug['m'] != 0 {
for l := e.noesc; l != nil; l = l.Next {
if l.N.Esc == EscNone {
Warnl(int(l.N.Lineno), "%v %v does not escape", e.curfnSym(l.N), Nconv(l.N, obj.FmtShort))
Warnl(l.N.Lineno, "%v %v does not escape", e.curfnSym(l.N), Nconv(l.N, obj.FmtShort))
}
}
}
@ -632,7 +632,7 @@ func esc(e *EscState, n *Node, up *Node) {
n.Op == ONEW && n.Type.Type.Width >= 1<<16 ||
n.Op == OMAKESLICE && !isSmallMakeSlice(n)) {
if Debug['m'] > 1 {
Warnl(int(n.Lineno), "%v is too large for stack", n)
Warnl(n.Lineno, "%v is too large for stack", n)
}
n.Esc = EscHeap
addrescapes(n)
@ -732,7 +732,7 @@ func esc(e *EscState, n *Node, up *Node) {
// b escapes as well. If we ignore such OSLICEARR, we will conclude
// that b does not escape when b contents do.
if Debug['m'] != 0 {
Warnl(int(n.Lineno), "%v ignoring self-assignment to %v", e.curfnSym(n), Nconv(n.Left, obj.FmtShort))
Warnl(n.Lineno, "%v ignoring self-assignment to %v", e.curfnSym(n), Nconv(n.Left, obj.FmtShort))
}
break
@ -827,7 +827,7 @@ func esc(e *EscState, n *Node, up *Node) {
slice2 := n.List.Next.N
escassignDereference(e, &e.theSink, slice2) // lose track of assign of dereference
if Debug['m'] > 2 {
Warnl(int(n.Lineno), "%v special treatment of append(slice1, slice2...) %v", e.curfnSym(n), Nconv(n, obj.FmtShort))
Warnl(n.Lineno, "%v special treatment of append(slice1, slice2...) %v", e.curfnSym(n), Nconv(n, obj.FmtShort))
}
}
escassignDereference(e, &e.theSink, n.List.N) // The original elements are now leaked, too
@ -1667,9 +1667,9 @@ func escwalkBody(e *EscState, level Level, dst *Node, src *Node, extraloopdepth
// 4. return *in
if Debug['m'] != 0 {
if Debug['m'] == 1 {
Warnl(int(src.Lineno), "leaking param: %v to result %v level=%v", Nconv(src, obj.FmtShort), dst.Sym, level.int())
Warnl(src.Lineno, "leaking param: %v to result %v level=%v", Nconv(src, obj.FmtShort), dst.Sym, level.int())
} else {
Warnl(int(src.Lineno), "leaking param: %v to result %v level=%v", Nconv(src, obj.FmtShort), dst.Sym, level)
Warnl(src.Lineno, "leaking param: %v to result %v level=%v", Nconv(src, obj.FmtShort), dst.Sym, level)
}
}
if src.Esc&EscMask != EscReturn {
@ -1686,7 +1686,7 @@ func escwalkBody(e *EscState, level Level, dst *Node, src *Node, extraloopdepth
level.int() > 0 {
src.Esc = escMax(EscContentEscapes|src.Esc, EscNone)
if Debug['m'] != 0 {
Warnl(int(src.Lineno), "mark escaped content: %v", Nconv(src, obj.FmtShort))
Warnl(src.Lineno, "mark escaped content: %v", Nconv(src, obj.FmtShort))
}
}
@ -1699,9 +1699,9 @@ func escwalkBody(e *EscState, level Level, dst *Node, src *Node, extraloopdepth
src.Esc = escMax(EscContentEscapes|src.Esc, EscNone)
if Debug['m'] != 0 {
if Debug['m'] == 1 {
Warnl(int(src.Lineno), "leaking param content: %v", Nconv(src, obj.FmtShort))
Warnl(src.Lineno, "leaking param content: %v", Nconv(src, obj.FmtShort))
} else {
Warnl(int(src.Lineno), "leaking param content: %v level=%v dst.eld=%v src.eld=%v dst=%v",
Warnl(src.Lineno, "leaking param content: %v level=%v dst.eld=%v src.eld=%v dst=%v",
Nconv(src, obj.FmtShort), level, dstE.Escloopdepth, modSrcLoopdepth, Nconv(dst, obj.FmtShort))
}
}
@ -1709,9 +1709,9 @@ func escwalkBody(e *EscState, level Level, dst *Node, src *Node, extraloopdepth
src.Esc = EscScope
if Debug['m'] != 0 {
if Debug['m'] == 1 {
Warnl(int(src.Lineno), "leaking param: %v", Nconv(src, obj.FmtShort))
Warnl(src.Lineno, "leaking param: %v", Nconv(src, obj.FmtShort))
} else {
Warnl(int(src.Lineno), "leaking param: %v level=%v dst.eld=%v src.eld=%v dst=%v",
Warnl(src.Lineno, "leaking param: %v level=%v dst.eld=%v src.eld=%v dst=%v",
Nconv(src, obj.FmtShort), level, dstE.Escloopdepth, modSrcLoopdepth, Nconv(dst, obj.FmtShort))
}
}
@ -1722,7 +1722,7 @@ func escwalkBody(e *EscState, level Level, dst *Node, src *Node, extraloopdepth
// original variable.
if src.Class == PPARAMREF {
if leaks && Debug['m'] != 0 {
Warnl(int(src.Lineno), "leaking closure reference %v", Nconv(src, obj.FmtShort))
Warnl(src.Lineno, "leaking closure reference %v", Nconv(src, obj.FmtShort))
}
escwalk(e, level, dst, src.Name.Param.Closure)
}
@ -1737,10 +1737,10 @@ func escwalkBody(e *EscState, level Level, dst *Node, src *Node, extraloopdepth
p = p.Left // merely to satisfy error messages in tests
}
if Debug['m'] > 1 {
Warnl(int(src.Lineno), "%v escapes to heap, level=%v, dst.eld=%v, src.eld=%v",
Warnl(src.Lineno, "%v escapes to heap, level=%v, dst.eld=%v, src.eld=%v",
Nconv(p, obj.FmtShort), level, dstE.Escloopdepth, modSrcLoopdepth)
} else {
Warnl(int(src.Lineno), "%v escapes to heap", Nconv(p, obj.FmtShort))
Warnl(src.Lineno, "%v escapes to heap", Nconv(p, obj.FmtShort))
}
}
escwalkBody(e, level.dec(), dst, src.Left, modSrcLoopdepth)
@ -1756,7 +1756,7 @@ func escwalkBody(e *EscState, level Level, dst *Node, src *Node, extraloopdepth
if leaks {
src.Esc = EscHeap
if Debug['m'] != 0 {
Warnl(int(src.Lineno), "%v escapes to heap", Nconv(src, obj.FmtShort))
Warnl(src.Lineno, "%v escapes to heap", Nconv(src, obj.FmtShort))
}
extraloopdepth = modSrcLoopdepth
}
@ -1790,7 +1790,7 @@ func escwalkBody(e *EscState, level Level, dst *Node, src *Node, extraloopdepth
if leaks {
src.Esc = EscHeap
if Debug['m'] != 0 {
Warnl(int(src.Lineno), "%v escapes to heap", Nconv(src, obj.FmtShort))
Warnl(src.Lineno, "%v escapes to heap", Nconv(src, obj.FmtShort))
}
extraloopdepth = modSrcLoopdepth
}
@ -1878,7 +1878,7 @@ func esctag(e *EscState, func_ *Node) {
} else {
name = fmt.Sprintf("arg#%d", narg)
}
Warnl(int(func_.Lineno), "%v assuming %v is unsafe uintptr", funcSym(func_), name)
Warnl(func_.Lineno, "%v assuming %v is unsafe uintptr", funcSym(func_), name)
}
t.Note = &unsafeUintptrTag
}

2
src/cmd/compile/internal/gc/export.go
View file

@ -558,7 +558,7 @@ func importtype(pt *Type, t *Type) {
copytype(pt.Nod, t)
pt.Nod = n // unzero nod
pt.Sym.Importdef = importpkg
pt.Sym.Lastlineno = int32(parserline())
pt.Sym.Lastlineno = lineno
declare(n, PEXTERN)
checkwidth(pt)
} else if !Eqtype(pt.Orig, t) {

4
src/cmd/compile/internal/gc/gen.go
View file

@ -983,13 +983,13 @@ func checklabels() {
for lab := labellist; lab != nil; lab = lab.Link {
if lab.Def == nil {
for _, n := range lab.Use {
yyerrorl(int(n.Lineno), "label %v not defined", lab.Sym)
yyerrorl(n.Lineno, "label %v not defined", lab.Sym)
}
continue
}
if lab.Use == nil && !lab.Used {
yyerrorl(int(lab.Def.Lineno), "label %v defined and not used", lab.Sym)
yyerrorl(lab.Def.Lineno, "label %v defined and not used", lab.Sym)
continue
}

16
src/cmd/compile/internal/gc/lex.go
View file

@ -1900,7 +1900,7 @@ redo:
c := obj.Bgetc(l.bin)
if c < utf8.RuneSelf {
if c == 0 {
yyerrorl(int(lexlineno), "illegal NUL byte")
yyerrorl(lexlineno, "illegal NUL byte")
return 0
}
if c == '\n' && importpkg == nil {
@ -1924,11 +1924,11 @@ redo:
// The string conversion here makes a copy for passing
// to fmt.Printf, so that buf itself does not escape and
// can be allocated on the stack.
yyerrorl(int(lexlineno), "illegal UTF-8 sequence % x", string(buf[:i]))
yyerrorl(lexlineno, "illegal UTF-8 sequence % x", string(buf[:i]))
}
if r == BOM {
yyerrorl(int(lexlineno), "Unicode (UTF-8) BOM in middle of file")
yyerrorl(lexlineno, "Unicode (UTF-8) BOM in middle of file")
goto redo
}
@ -2299,7 +2299,7 @@ func lexname(lex rune) string {
return fmt.Sprintf("LEX-%d", lex)
}
func pkgnotused(lineno int, path string, name string) {
func pkgnotused(lineno int32, path string, name string) {
// If the package was imported with a name other than the final
// import path element, show it explicitly in the error message.
// Note that this handles both renamed imports and imports of
@ -2311,9 +2311,9 @@ func pkgnotused(lineno int, path string, name string) {
elem = elem[i+1:]
}
if name == "" || elem == name {
yyerrorl(int(lineno), "imported and not used: %q", path)
yyerrorl(lineno, "imported and not used: %q", path)
} else {
yyerrorl(int(lineno), "imported and not used: %q as %s", path, name)
yyerrorl(lineno, "imported and not used: %q as %s", path, name)
}
}
@ -2338,7 +2338,7 @@ func mkpackage(pkgname string) {
// errors if a conflicting top-level name is
// introduced by a different file.
if !s.Def.Used && nsyntaxerrors == 0 {
pkgnotused(int(s.Def.Lineno), s.Def.Name.Pkg.Path, s.Name)
pkgnotused(s.Def.Lineno, s.Def.Name.Pkg.Path, s.Name)
}
s.Def = nil
continue
@ -2348,7 +2348,7 @@ func mkpackage(pkgname string) {
// throw away top-level name left over
// from previous import . "x"
if s.Def.Name != nil && s.Def.Name.Pack != nil && !s.Def.Name.Pack.Used && nsyntaxerrors == 0 {
pkgnotused(int(s.Def.Name.Pack.Lineno), s.Def.Name.Pack.Name.Pkg.Path, "")
pkgnotused(s.Def.Name.Pack.Lineno, s.Def.Name.Pack.Name.Pkg.Path, "")
s.Def.Name.Pack.Used = true
}

4
src/cmd/compile/internal/gc/parser.go
View file

@ -327,7 +327,7 @@ func (p *parser) importdcl() {
return
}
line := int32(parserline())
line := lineno
// We need to clear importpkg before calling p.next(),
// otherwise it will affect lexlineno.
@ -1568,7 +1568,7 @@ func (p *parser) dcl_name() *Node {
symlineno := lineno
sym := p.sym()
if sym == nil {
yyerrorl(int(symlineno), "invalid declaration")
yyerrorl(symlineno, "invalid declaration")
return nil
}
return dclname(sym)

4
src/cmd/compile/internal/gc/plive.go
View file

@ -1270,7 +1270,7 @@ func livenessepilogue(lv *Liveness) {
if !n.Name.Needzero {
n.Name.Needzero = true
if debuglive >= 1 {
Warnl(int(p.Lineno), "%v: %v is ambiguously live", Curfn.Func.Nname, Nconv(n, obj.FmtLong))
Warnl(p.Lineno, "%v: %v is ambiguously live", Curfn.Func.Nname, Nconv(n, obj.FmtLong))
}
// Record in 'ambiguous' bitmap.
@ -1367,7 +1367,7 @@ func livenessepilogue(lv *Liveness) {
}
n = lv.vars[j]
if n.Class != PPARAM {
yyerrorl(int(p.Lineno), "internal error: %v %v recorded as live on entry, p.Pc=%v", Curfn.Func.Nname, Nconv(n, obj.FmtLong), p.Pc)
yyerrorl(p.Lineno, "internal error: %v %v recorded as live on entry, p.Pc=%v", Curfn.Func.Nname, Nconv(n, obj.FmtLong), p.Pc)
}
}
}

6
src/cmd/compile/internal/gc/popt.go
View file

@ -927,7 +927,7 @@ func nilopt(firstp *obj.Prog) {
ncheck++
if Thearch.Stackaddr(&p.From) {
if Debug_checknil != 0 && p.Lineno > 1 {
Warnl(int(p.Lineno), "removed nil check of SP address")
Warnl(p.Lineno, "removed nil check of SP address")
}
f.Data = &killed
continue
@ -936,7 +936,7 @@ func nilopt(firstp *obj.Prog) {
nilwalkfwd(f)
if f.Data != nil {
if Debug_checknil != 0 && p.Lineno > 1 {
Warnl(int(p.Lineno), "removed nil check before indirect")
Warnl(p.Lineno, "removed nil check before indirect")
}
continue
}
@ -944,7 +944,7 @@ func nilopt(firstp *obj.Prog) {
nilwalkback(f)
if f.Data != nil {
if Debug_checknil != 0 && p.Lineno > 1 {
Warnl(int(p.Lineno), "removed repeated nil check")
Warnl(p.Lineno, "removed repeated nil check")
}
continue
}

22
src/cmd/compile/internal/gc/ssa.go
View file

@ -182,11 +182,11 @@ func buildssa(fn *Node) *ssa.Func {
// Check that we used all labels
for name, lab := range s.labels {
if !lab.used() && !lab.reported {
yyerrorl(int(lab.defNode.Lineno), "label %v defined and not used", name)
yyerrorl(lab.defNode.Lineno, "label %v defined and not used", name)
lab.reported = true
}
if lab.used() && !lab.defined() && !lab.reported {
yyerrorl(int(lab.useNode.Lineno), "label %v not defined", name)
yyerrorl(lab.useNode.Lineno, "label %v not defined", name)
lab.reported = true
}
}
@ -372,7 +372,7 @@ func (s *state) peekLine() int32 {
}
func (s *state) Error(msg string, args ...interface{}) {
yyerrorl(int(s.peekLine()), msg, args...)
yyerrorl(s.peekLine(), msg, args...)
}
// newValue0 adds a new value with no arguments to the current block.
@ -2796,7 +2796,7 @@ func (s *state) insertWBmove(t *Type, left, right *ssa.Value, line int32) {
s.startBlock(bEnd)
if Debug_wb > 0 {
Warnl(int(line), "write barrier")
Warnl(line, "write barrier")
}
}
@ -2842,7 +2842,7 @@ func (s *state) insertWBstore(t *Type, left, right *ssa.Value, line int32) {
s.startBlock(bEnd)
if Debug_wb > 0 {
Warnl(int(line), "write barrier")
Warnl(line, "write barrier")
}
}
@ -3339,7 +3339,7 @@ func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) {
}
if Debug_typeassert > 0 {
Warnl(int(n.Lineno), "type assertion inlined")
Warnl(n.Lineno, "type assertion inlined")
}
// TODO: If we have a nonempty interface and its itab field is nil,
@ -3444,7 +3444,7 @@ func (s *state) checkgoto(from *Node, to *Node) {
fs = fs.Link
}
lno := int(from.Left.Lineno)
lno := from.Left.Lineno
if block != nil {
yyerrorl(lno, "goto %v jumps into block starting at %v", from.Left.Sym, Ctxt.Line(int(block.Lastlineno)))
} else {
@ -4658,7 +4658,7 @@ func (s *genState) genValue(v *ssa.Value) {
ssa.OpAMD64MOVSSstore, ssa.OpAMD64MOVSDstore, ssa.OpAMD64MOVOstore:
if w.Args[0] == v.Args[0] && w.Aux == nil && w.AuxInt >= 0 && w.AuxInt < minZeroPage {
if Debug_checknil != 0 && int(v.Line) > 1 {
Warnl(int(v.Line), "removed nil check")
Warnl(v.Line, "removed nil check")
}
return
}
@ -4666,7 +4666,7 @@ func (s *genState) genValue(v *ssa.Value) {
off := ssa.ValAndOff(v.AuxInt).Off()
if w.Args[0] == v.Args[0] && w.Aux == nil && off >= 0 && off < minZeroPage {
if Debug_checknil != 0 && int(v.Line) > 1 {
Warnl(int(v.Line), "removed nil check")
Warnl(v.Line, "removed nil check")
}
return
}
@ -4694,7 +4694,7 @@ func (s *genState) genValue(v *ssa.Value) {
p.To.Reg = regnum(v.Args[0])
addAux(&p.To, v)
if Debug_checknil != 0 && v.Line > 1 { // v.Line==1 in generated wrappers
Warnl(int(v.Line), "generated nil check")
Warnl(v.Line, "generated nil check")
}
default:
v.Unimplementedf("genValue not implemented: %s", v.LongString())
@ -5223,7 +5223,7 @@ func (e *ssaExport) Unimplementedf(line int32, msg string, args ...interface{})
// Warnl reports a "warning", which is usually flag-triggered
// logging output for the benefit of tests.
func (e *ssaExport) Warnl(line int, fmt_ string, args ...interface{}) {
Warnl(line, fmt_, args...)
Warnl(int32(line), fmt_, args...)
}
func (e *ssaExport) Debug_checknil() bool {

28
src/cmd/compile/internal/gc/subr.go
View file

@ -18,7 +18,7 @@ import (
)
type Error struct {
lineno int
lineno int32
msg string
}
@ -32,10 +32,6 @@ func errorexit() {
os.Exit(2)
}
func parserline() int {
return int(lineno)
}
func adderrorname(n *Node) {
if n.Op != ODOT {
return
@ -46,10 +42,10 @@ func adderrorname(n *Node) {
}
}
func adderr(line int, format string, args ...interface{}) {
func adderr(line int32, format string, args ...interface{}) {
errors = append(errors, Error{
lineno: line,
msg: fmt.Sprintf("%v: %s\n", Ctxt.Line(line), fmt.Sprintf(format, args...)),
msg: fmt.Sprintf("%v: %s\n", Ctxt.Line(int(line)), fmt.Sprintf(format, args...)),
})
}
@ -85,14 +81,14 @@ func hcrash() {
}
}
func yyerrorl(line int, format string, args ...interface{}) {
func yyerrorl(line int32, format string, args ...interface{}) {
adderr(line, format, args...)
hcrash()
nerrors++
if nsavederrors+nerrors >= 10 && Debug['e'] == 0 {
Flusherrors()
fmt.Printf("%v: too many errors\n", Ctxt.Line(line))
fmt.Printf("%v: too many errors\n", Ctxt.Line(int(line)))
errorexit()
}
}
@ -110,28 +106,28 @@ func Yyerror(format string, args ...interface{}) {
}
yyerror_lastsyntax = lineno
yyerrorl(int(lineno), "%s", msg)
yyerrorl(lineno, "%s", msg)
return
}
adderr(parserline(), "%s", msg)
adderr(lineno, "%s", msg)
hcrash()
nerrors++
if nsavederrors+nerrors >= 10 && Debug['e'] == 0 {
Flusherrors()
fmt.Printf("%v: too many errors\n", Ctxt.Line(parserline()))
fmt.Printf("%v: too many errors\n", Ctxt.Line(int(lineno)))
errorexit()
}
}
func Warn(fmt_ string, args ...interface{}) {
adderr(parserline(), fmt_, args...)
adderr(lineno, fmt_, args...)
hcrash()
}
func Warnl(line int, fmt_ string, args ...interface{}) {
func Warnl(line int32, fmt_ string, args ...interface{}) {
adderr(line, fmt_, args...)
if Debug['m'] != 0 {
Flusherrors()
@ -304,7 +300,7 @@ func importdot(opkg *Pkg, pack *Node) {
if n == 0 {
// can't possibly be used - there were no symbols
yyerrorl(int(pack.Lineno), "imported and not used: %q", opkg.Path)
yyerrorl(pack.Lineno, "imported and not used: %q", opkg.Path)
}
}
@ -313,7 +309,7 @@ func Nod(op Op, nleft *Node, nright *Node) *Node {
n.Op = op
n.Left = nleft
n.Right = nright
n.Lineno = int32(parserline())
n.Lineno = lineno
n.Xoffset = BADWIDTH
n.Orig = n
switch op {

2
src/cmd/compile/internal/gc/swt.go
View file

@ -483,7 +483,7 @@ func caseClauses(sw *Node, kind int) []*caseClause {
break
}
if Eqtype(c1.node.Left.Type, c2.node.Left.Type) {
yyerrorl(int(c2.node.Lineno), "duplicate case %v in type switch\n\tprevious case at %v", c2.node.Left.Type, c1.node.Line())
yyerrorl(c2.node.Lineno, "duplicate case %v in type switch\n\tprevious case at %v", c2.node.Left.Type, c1.node.Line())
}
}
}

4
src/cmd/compile/internal/gc/typecheck.go
View file

@ -164,7 +164,7 @@ func typecheck(np **Node, top int) *Node {
break
}
sprint_depchain(&fmt_, typecheck_tcstack, n, n)
yyerrorl(int(n.Lineno), "constant definition loop%s", fmt_)
yyerrorl(n.Lineno, "constant definition loop%s", fmt_)
}
if nsavederrors+nerrors == 0 {
@ -4013,7 +4013,7 @@ func checkreturn(fn *Node) {
if fn.Type.Outtuple != 0 && len(fn.Nbody.Slice()) != 0 {
markbreakslice(fn.Nbody.Slice(), nil)
if !fn.Nbody.isterminating() {
yyerrorl(int(fn.Func.Endlineno), "missing return at end of function")
yyerrorl(fn.Func.Endlineno, "missing return at end of function")
}
}
}

2
src/cmd/compile/internal/gc/walk.go
View file

@ -2142,7 +2142,7 @@ func needwritebarrier(l *Node, r *Node) bool {
func applywritebarrier(n *Node) *Node {
if n.Left != nil && n.Right != nil && needwritebarrier(n.Left, n.Right) {
if Debug_wb > 1 {
Warnl(int(n.Lineno), "marking %v for barrier", Nconv(n.Left, 0))
Warnl(n.Lineno, "marking %v for barrier", Nconv(n.Left, 0))
}
n.Op = OASWB
return n

2
src/cmd/compile/internal/mips64/ggen.go
View file

@ -453,7 +453,7 @@ func expandchecks(firstp *obj.Prog) {
continue
}
if gc.Debug_checknil != 0 && p.Lineno > 1 { // p->lineno==1 in generated wrappers
gc.Warnl(int(p.Lineno), "generated nil check")
gc.Warnl(p.Lineno, "generated nil check")
}
if p.From.Type != obj.TYPE_REG {
gc.Fatalf("invalid nil check %v\n", p)

2
src/cmd/compile/internal/ppc64/ggen.go
View file

@ -485,7 +485,7 @@ func expandchecks(firstp *obj.Prog) {
continue
}
if gc.Debug_checknil != 0 && p.Lineno > 1 { // p->lineno==1 in generated wrappers
gc.Warnl(int(p.Lineno), "generated nil check")
gc.Warnl(p.Lineno, "generated nil check")
}
if p.From.Type != obj.TYPE_REG {
gc.Fatalf("invalid nil check %v\n", p)

2
src/cmd/compile/internal/x86/ggen.go
View file

@ -843,7 +843,7 @@ func expandchecks(firstp *obj.Prog) {
continue
}
if gc.Debug_checknil != 0 && p.Lineno > 1 { // p->lineno==1 in generated wrappers
gc.Warnl(int(p.Lineno), "generated nil check")
gc.Warnl(p.Lineno, "generated nil check")
}
// check is