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/internal/gc: cleaning; use range when appropriate

Browse source 
Made use of range statement in for loops.
Cleaning along the way:
-remove unnecessary variable declarations
-rename variables
-remove dead code

This change passes go build -toolexec 'toolstash -cmp' -a std.

Change-Id: Ife8c2a98482a81ba91f5bbb65142d9f3dc46d6ee
Reviewed-on: https://go-review.googlesource.com/14379
Run-TryBot: Dave Cheney <dave@cheney.net>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Dave Cheney <dave@cheney.net>
This commit is contained in:
Marvin Stenger 2015-09-08 22:22:44 +02:00 • committed by Dave Cheney
parent a326c3e1ad
commit 2dc63d1544
6 changed files with 172 additions and 247 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -2162,32 +2162,22 @@ var syms = []struct {
{"insofaras", LIGNORE, Txxx, OXXX}, {"insofaras", LIGNORE, Txxx, OXXX},
} }
// lexinit initializes known symbols and the basic types.
func lexinit() { func lexinit() {
var lex int for _, s := range syms {
var s *Sym lex := s.lexical
var s1 *Sym s1 := Lookup(s.name)
var t *Type s1.Lexical = uint16(lex)
var etype int
/* if etype := s.etype; etype != Txxx {
* initialize basic types array
* initialize known symbols
*/
for i := 0; i < len(syms); i++ {
lex = syms[i].lexical
s = Lookup(syms[i].name)
s.Lexical = uint16(lex)
etype = syms[i].etype
if etype != Txxx {
if etype < 0 || etype >= len(Types) { if etype < 0 || etype >= len(Types) {
Fatalf("lexinit: %s bad etype", s.Name) Fatalf("lexinit: %s bad etype", s.name)
} }
s1 = Pkglookup(syms[i].name, builtinpkg) s2 := Pkglookup(s.name, builtinpkg)
t = Types[etype] t := Types[etype]
if t == nil { if t == nil {
t = typ(etype) t = typ(etype)
t.Sym = s1 t.Sym = s2
if etype != TANY && etype != TSTRING { if etype != TANY && etype != TSTRING {
dowidth(t) dowidth(t)
@ -2195,19 +2185,18 @@ func lexinit() {
Types[etype] = t Types[etype] = t
} }
s1.Lexical = LNAME s2.Lexical = LNAME
s1.Def = typenod(t) s2.Def = typenod(t)
s1.Def.Name = new(Name) s2.Def.Name = new(Name)
continue continue
} }
etype = syms[i].op if etype := s.op; etype != OXXX {
if etype != OXXX { s2 := Pkglookup(s.name, builtinpkg)
s1 = Pkglookup(syms[i].name, builtinpkg) s2.Lexical = LNAME
s1.Lexical = LNAME s2.Def = Nod(ONAME, nil, nil)
s1.Def = Nod(ONAME, nil, nil) s2.Def.Sym = s2
s1.Def.Sym = s1 s2.Def.Etype = uint8(etype)
s1.Def.Etype = uint8(etype)
} }
} }
@ -2220,7 +2209,7 @@ func lexinit() {
idealbool = typ(TBOOL) idealbool = typ(TBOOL)
s = Pkglookup("true", builtinpkg) s := Pkglookup("true", builtinpkg)
s.Def = Nodbool(true) s.Def = Nodbool(true)
s.Def.Sym = Lookup("true") s.Def.Sym = Lookup("true")
s.Def.Name = new(Name) s.Def.Name = new(Name)
@ -2419,61 +2408,56 @@ func lexfini() {
nodfp.Sym = Lookup(".fp") nodfp.Sym = Lookup(".fp")
} }
var lexn = []struct { var lexn = map[int]string{
lex int LANDAND: "ANDAND",
name string LANDNOT: "ANDNOT",
}{ LASOP: "ASOP",
{LANDAND, "ANDAND"}, LBREAK: "BREAK",
{LANDNOT, "ANDNOT"}, LCASE: "CASE",
{LASOP, "ASOP"}, LCHAN: "CHAN",
{LBREAK, "BREAK"}, LCOLAS: "COLAS",
{LCASE, "CASE"}, LCOMM: "<-",
{LCHAN, "CHAN"}, LCONST: "CONST",
{LCOLAS, "COLAS"}, LCONTINUE: "CONTINUE",
{LCOMM, "<-"}, LDDD: "...",
{LCONST, "CONST"}, LDEC: "DEC",
{LCONTINUE, "CONTINUE"}, LDEFAULT: "DEFAULT",
{LDDD, "..."}, LDEFER: "DEFER",
{LDEC, "DEC"}, LELSE: "ELSE",
{LDEFAULT, "DEFAULT"}, LEQ: "EQ",
{LDEFER, "DEFER"}, LFALL: "FALL",
{LELSE, "ELSE"}, LFOR: "FOR",
{LEQ, "EQ"}, LFUNC: "FUNC",
{LFALL, "FALL"}, LGE: "GE",
{LFOR, "FOR"}, LGO: "GO",
{LFUNC, "FUNC"}, LGOTO: "GOTO",
{LGE, "GE"}, LGT: "GT",
{LGO, "GO"}, LIF: "IF",
{LGOTO, "GOTO"}, LIMPORT: "IMPORT",
{LGT, "GT"}, LINC: "INC",
{LIF, "IF"}, LINTERFACE: "INTERFACE",
{LIMPORT, "IMPORT"}, LLE: "LE",
{LINC, "INC"}, LLITERAL: "LITERAL",
{LINTERFACE, "INTERFACE"}, LLSH: "LSH",
{LLE, "LE"}, LLT: "LT",
{LLITERAL, "LITERAL"}, LMAP: "MAP",
{LLSH, "LSH"}, LNAME: "NAME",
{LLT, "LT"}, LNE: "NE",
{LMAP, "MAP"}, LOROR: "OROR",
{LNAME, "NAME"}, LPACKAGE: "PACKAGE",
{LNE, "NE"}, LRANGE: "RANGE",
{LOROR, "OROR"}, LRETURN: "RETURN",
{LPACKAGE, "PACKAGE"}, LRSH: "RSH",
{LRANGE, "RANGE"}, LSELECT: "SELECT",
{LRETURN, "RETURN"}, LSTRUCT: "STRUCT",
{LRSH, "RSH"}, LSWITCH: "SWITCH",
{LSELECT, "SELECT"}, LTYPE: "TYPE",
{LSTRUCT, "STRUCT"}, LVAR: "VAR",
{LSWITCH, "SWITCH"},
{LTYPE, "TYPE"},
{LVAR, "VAR"},
} }
func lexname(lex int) string { func lexname(lex int) string {
for i := 0; i < len(lexn); i++ { if s, ok := lexn[lex]; ok {
if lexn[i].lex == lex { return s
return lexn[i].name
}
} }
return fmt.Sprintf("LEX-%d", lex) return fmt.Sprintf("LEX-%d", lex)
} }

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

@ -572,22 +572,11 @@ func mergetemp(firstp *obj.Prog) {
} }
// Build list of all mergeable variables. // Build list of all mergeable variables.
nvar := 0 var vars []*TempVar
for l := Curfn.Func.Dcl; l != nil; l = l.Next { for l := Curfn.Func.Dcl; l != nil; l = l.Next {
if canmerge(l.N) { if n := l.N; canmerge(n) {
nvar++ v := &TempVar{}
} vars = append(vars, v)
}
var_ := make([]TempVar, nvar)
nvar = 0
var n *Node
var v *TempVar
for l := Curfn.Func.Dcl; l != nil; l = l.Next {
n = l.N
if canmerge(n) {
v = &var_[nvar]
nvar++
n.SetOpt(v) n.SetOpt(v)
v.node = n v.node = n
} }
@ -602,8 +591,8 @@ func mergetemp(firstp *obj.Prog) {
if p.From.Node != nil && ((p.From.Node).(*Node)).Opt() != nil && p.To.Node != nil && ((p.To.Node).(*Node)).Opt() != nil { if p.From.Node != nil && ((p.From.Node).(*Node)).Opt() != nil && p.To.Node != nil && ((p.To.Node).(*Node)).Opt() != nil {
Fatalf("double node %v", p) Fatalf("double node %v", p)
} }
v = nil var v *TempVar
n, _ = p.From.Node.(*Node) n, _ := p.From.Node.(*Node)
if n != nil { if n != nil {
v, _ = n.Opt().(*TempVar) v, _ = n.Opt().(*TempVar)
} }
@ -632,8 +621,7 @@ func mergetemp(firstp *obj.Prog) {
nkill := 0 nkill := 0
// Special case. // Special case.
for i := 0; i < len(var_); i++ { for _, v := range vars {
v = &var_[i]
if v.addr { if v.addr {
continue continue
} }
@ -682,28 +670,24 @@ func mergetemp(firstp *obj.Prog) {
// Traverse live range of each variable to set start, end. // Traverse live range of each variable to set start, end.
// Each flood uses a new value of gen so that we don't have // Each flood uses a new value of gen so that we don't have
// to clear all the r->active words after each variable. // to clear all the r->active words after each variable.
gen := int32(0) gen := uint32(0)
for i := 0; i < len(var_); i++ { for _, v := range vars {
v = &var_[i]
gen++ gen++
for f := v.use; f != nil; f = f.Data.(*Flow) { for f := v.use; f != nil; f = f.Data.(*Flow) {
mergewalk(v, f, uint32(gen)) mergewalk(v, f, gen)
} }
if v.addr { if v.addr {
gen++ gen++
for f := v.use; f != nil; f = f.Data.(*Flow) { for f := v.use; f != nil; f = f.Data.(*Flow) {
varkillwalk(v, f, uint32(gen)) varkillwalk(v, f, gen)
} }
} }
} }
// Sort variables by start. // Sort variables by start.
bystart := make([]*TempVar, len(var_)) bystart := make([]*TempVar, len(vars))
copy(bystart, vars)
for i := 0; i < len(var_); i++ {
bystart[i] = &var_[i]
}
sort.Sort(startcmp(bystart)) sort.Sort(startcmp(bystart))
// List of in-use variables, sorted by end, so that the ones that // List of in-use variables, sorted by end, so that the ones that
@ -712,15 +696,11 @@ func mergetemp(firstp *obj.Prog) {
// In theory we should use a sorted tree so that insertions are // In theory we should use a sorted tree so that insertions are
// guaranteed O(log n) and then the loop is guaranteed O(n log n). // guaranteed O(log n) and then the loop is guaranteed O(n log n).
// In practice, it doesn't really matter. // In practice, it doesn't really matter.
inuse := make([]*TempVar, len(var_)) inuse := make([]*TempVar, len(bystart))
ninuse := 0 ninuse := 0
nfree := len(var_) nfree := len(bystart)
var t *Type for _, v := range bystart {
var v1 *TempVar
var j int
for i := 0; i < len(var_); i++ {
v = bystart[i]
if debugmerge > 0 && Debug['v'] != 0 { if debugmerge > 0 && Debug['v'] != 0 {
fmt.Printf("consider %v: removed=%t\n", Nconv(v.node, obj.FmtSharp), v.removed) fmt.Printf("consider %v: removed=%t\n", Nconv(v.node, obj.FmtSharp), v.removed)
} }
@ -732,20 +712,19 @@ func mergetemp(firstp *obj.Prog) {
// Expire no longer in use. // Expire no longer in use.
for ninuse > 0 && inuse[ninuse-1].end < v.start { for ninuse > 0 && inuse[ninuse-1].end < v.start {
ninuse-- ninuse--
v1 = inuse[ninuse]
nfree-- nfree--
inuse[nfree] = v1 inuse[nfree] = inuse[ninuse]
} }
if debugmerge > 0 && Debug['v'] != 0 { if debugmerge > 0 && Debug['v'] != 0 {
fmt.Printf("consider %v: removed=%t nfree=%d nvar=%d\n", Nconv(v.node, obj.FmtSharp), v.removed, nfree, len(var_)) fmt.Printf("consider %v: removed=%t nfree=%d nvar=%d\n", Nconv(v.node, obj.FmtSharp), v.removed, nfree, len(bystart))
} }
// Find old temp to reuse if possible. // Find old temp to reuse if possible.
t = v.node.Type t := v.node.Type
for j = nfree; j < len(var_); j++ { for j := nfree; j < len(inuse); j++ {
v1 = inuse[j] v1 := inuse[j]
if debugmerge > 0 && Debug['v'] != 0 { if debugmerge > 0 && Debug['v'] != 0 {
fmt.Printf("consider %v: maybe %v: type=%v,%v addrtaken=%v,%v\n", Nconv(v.node, obj.FmtSharp), Nconv(v1.node, obj.FmtSharp), t, v1.node.Type, v.node.Addrtaken, v1.node.Addrtaken) fmt.Printf("consider %v: maybe %v: type=%v,%v addrtaken=%v,%v\n", Nconv(v.node, obj.FmtSharp), Nconv(v1.node, obj.FmtSharp), t, v1.node.Type, v.node.Addrtaken, v1.node.Addrtaken)
} }
@ -769,7 +748,7 @@ func mergetemp(firstp *obj.Prog) {
} }
// Sort v into inuse. // Sort v into inuse.
j = ninuse j := ninuse
ninuse++ ninuse++
for j > 0 && inuse[j-1].end < v.end { for j > 0 && inuse[j-1].end < v.end {
@ -781,10 +760,8 @@ func mergetemp(firstp *obj.Prog) {
} }
if debugmerge > 0 && Debug['v'] != 0 { if debugmerge > 0 && Debug['v'] != 0 {
fmt.Printf("%v [%d - %d]\n", Curfn.Func.Nname.Sym, len(var_), nkill) fmt.Printf("%v [%d - %d]\n", Curfn.Func.Nname.Sym, len(vars), nkill)
var v *TempVar for _, v := range vars {
for i := 0; i < len(var_); i++ {
v = &var_[i]
fmt.Printf("var %v %v %d-%d", Nconv(v.node, obj.FmtSharp), v.node.Type, v.start, v.end) fmt.Printf("var %v %v %d-%d", Nconv(v.node, obj.FmtSharp), v.node.Type, v.start, v.end)
if v.addr { if v.addr {
fmt.Printf(" addr=true") fmt.Printf(" addr=true")
@ -809,16 +786,16 @@ func mergetemp(firstp *obj.Prog) {
// Update node references to use merged temporaries. // Update node references to use merged temporaries.
for f := g.Start; f != nil; f = f.Link { for f := g.Start; f != nil; f = f.Link {
p := f.Prog p := f.Prog
n, _ = p.From.Node.(*Node) n, _ := p.From.Node.(*Node)
if n != nil { if n != nil {
v, _ = n.Opt().(*TempVar) v, _ := n.Opt().(*TempVar)
if v != nil && v.merge != nil { if v != nil && v.merge != nil {
p.From.Node = v.merge.node p.From.Node = v.merge.node
} }
} }
n, _ = p.To.Node.(*Node) n, _ = p.To.Node.(*Node)
if n != nil { if n != nil {
v, _ = n.Opt().(*TempVar) v, _ := n.Opt().(*TempVar)
if v != nil && v.merge != nil { if v != nil && v.merge != nil {
p.To.Node = v.merge.node p.To.Node = v.merge.node
} }
@ -826,16 +803,15 @@ func mergetemp(firstp *obj.Prog) {
} }
// Delete merged nodes from declaration list. // Delete merged nodes from declaration list.
var l *NodeList
for lp := &Curfn.Func.Dcl; ; { for lp := &Curfn.Func.Dcl; ; {
l = *lp l := *lp
if l == nil { if l == nil {
break break
} }
Curfn.Func.Dcl.End = l Curfn.Func.Dcl.End = l
n = l.N n := l.N
v, _ = n.Opt().(*TempVar) v, _ := n.Opt().(*TempVar)
if v != nil && (v.merge != nil || v.removed) { if v != nil && (v.merge != nil || v.removed) {
*lp = l.Next *lp = l.Next
continue continue
@ -845,8 +821,8 @@ func mergetemp(firstp *obj.Prog) {
} }
// Clear aux structures. // Clear aux structures.
for i := 0; i < len(var_); i++ { for _, v := range vars {
var_[i].node.SetOpt(nil) v.node.SetOpt(nil)
} }
Flowend(g) Flowend(g)

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

@ -32,8 +32,8 @@ var noinst_pkgs = []string{"sync", "sync/atomic"}
func ispkgin(pkgs []string) bool { func ispkgin(pkgs []string) bool {
if myimportpath != "" { if myimportpath != "" {
for i := 0; i < len(pkgs); i++ { for _, p := range pkgs {
if myimportpath == pkgs[i] { if myimportpath == p {
return true return true
} }
} }

162
src/cmd/compile/internal/gc/sinit.go
View file

@ -329,13 +329,13 @@ func staticcopy(l *Node, r *Node, out **NodeList) bool {
// copy slice // copy slice
a := inittemps[r] a := inittemps[r]
n1 := *l n := *l
n1.Xoffset = l.Xoffset + int64(Array_array) n.Xoffset = l.Xoffset + int64(Array_array)
gdata(&n1, Nod(OADDR, a, nil), Widthptr) gdata(&n, Nod(OADDR, a, nil), Widthptr)
n1.Xoffset = l.Xoffset + int64(Array_nel) n.Xoffset = l.Xoffset + int64(Array_nel)
gdata(&n1, r.Right, Widthint) gdata(&n, r.Right, Widthint)
n1.Xoffset = l.Xoffset + int64(Array_cap) n.Xoffset = l.Xoffset + int64(Array_cap)
gdata(&n1, r.Right, Widthint) gdata(&n, r.Right, Widthint)
return true return true
} }
fallthrough fallthrough
@ -344,24 +344,21 @@ func staticcopy(l *Node, r *Node, out **NodeList) bool {
case OSTRUCTLIT: case OSTRUCTLIT:
p := initplans[r] p := initplans[r]
n1 := *l n := *l
var e *InitEntry for i := range p.E {
var ll *Node e := &p.E[i]
var rr *Node n.Xoffset = l.Xoffset + e.Xoffset
for i := 0; i < len(p.E); i++ { n.Type = e.Expr.Type
e = &p.E[i]
n1.Xoffset = l.Xoffset + e.Xoffset
n1.Type = e.Expr.Type
if e.Expr.Op == OLITERAL { if e.Expr.Op == OLITERAL {
gdata(&n1, e.Expr, int(n1.Type.Width)) gdata(&n, e.Expr, int(n.Type.Width))
} else { } else {
ll = Nod(OXXX, nil, nil) ll := Nod(OXXX, nil, nil)
*ll = n1 *ll = n
ll.Orig = ll // completely separate copy ll.Orig = ll // completely separate copy
if !staticassign(ll, e.Expr, out) { if !staticassign(ll, e.Expr, out) {
// Requires computation, but we're // Requires computation, but we're
// copying someone else's computation. // copying someone else's computation.
rr = Nod(OXXX, nil, nil) rr := Nod(OXXX, nil, nil)
*rr = *orig *rr = *orig
rr.Orig = rr // completely separate copy rr.Orig = rr // completely separate copy
@ -380,8 +377,6 @@ func staticcopy(l *Node, r *Node, out **NodeList) bool {
} }
func staticassign(l *Node, r *Node, out **NodeList) bool { func staticassign(l *Node, r *Node, out **NodeList) bool {
var n1 Node
for r.Op == OCONVNOP { for r.Op == OCONVNOP {
r = r.Left r = r.Left
} }
@ -404,9 +399,9 @@ func staticassign(l *Node, r *Node, out **NodeList) bool {
case OADDR: case OADDR:
var nam Node var nam Node
if stataddr(&nam, r.Left) { if stataddr(&nam, r.Left) {
n1 := *r n := *r
n1.Left = &nam n.Left = &nam
gdata(l, &n1, int(l.Type.Width)) gdata(l, &n, int(l.Type.Width))
return true return true
} }
fallthrough fallthrough
@ -448,13 +443,13 @@ func staticassign(l *Node, r *Node, out **NodeList) bool {
ta.Bound = Mpgetfix(r.Right.Val().U.(*Mpint)) ta.Bound = Mpgetfix(r.Right.Val().U.(*Mpint))
a := staticname(ta, 1) a := staticname(ta, 1)
inittemps[r] = a inittemps[r] = a
n1 = *l n := *l
n1.Xoffset = l.Xoffset + int64(Array_array) n.Xoffset = l.Xoffset + int64(Array_array)
gdata(&n1, Nod(OADDR, a, nil), Widthptr) gdata(&n, Nod(OADDR, a, nil), Widthptr)
n1.Xoffset = l.Xoffset + int64(Array_nel) n.Xoffset = l.Xoffset + int64(Array_nel)
gdata(&n1, r.Right, Widthint) gdata(&n, r.Right, Widthint)
n1.Xoffset = l.Xoffset + int64(Array_cap) n.Xoffset = l.Xoffset + int64(Array_cap)
gdata(&n1, r.Right, Widthint) gdata(&n, r.Right, Widthint)
// Fall through to init underlying array. // Fall through to init underlying array.
l = a l = a
@ -466,19 +461,17 @@ func staticassign(l *Node, r *Node, out **NodeList) bool {
initplan(r) initplan(r)
p := initplans[r] p := initplans[r]
n1 = *l n := *l
var e *InitEntry for i := range p.E {
var a *Node e := &p.E[i]
for i := 0; i < len(p.E); i++ { n.Xoffset = l.Xoffset + e.Xoffset
e = &p.E[i] n.Type = e.Expr.Type
n1.Xoffset = l.Xoffset + e.Xoffset
n1.Type = e.Expr.Type
if e.Expr.Op == OLITERAL { if e.Expr.Op == OLITERAL {
gdata(&n1, e.Expr, int(n1.Type.Width)) gdata(&n, e.Expr, int(n.Type.Width))
} else { } else {
setlineno(e.Expr) setlineno(e.Expr)
a = Nod(OXXX, nil, nil) a := Nod(OXXX, nil, nil)
*a = n1 *a = n
a.Orig = a // completely separate copy a.Orig = a // completely separate copy
if !staticassign(a, e.Expr, out) { if !staticassign(a, e.Expr, out) {
*out = list(*out, Nod(OAS, a, e.Expr)) *out = list(*out, Nod(OAS, a, e.Expr))
@ -569,9 +562,8 @@ func getdyn(n *Node, top int) int {
break break
} }
var value *Node
for nl := n.List; nl != nil; nl = nl.Next { for nl := n.List; nl != nil; nl = nl.Next {
value = nl.N.Right value := nl.N.Right
mode |= getdyn(value, 0) mode |= getdyn(value, 0)
if mode == MODEDYNAM|MODECONST { if mode == MODEDYNAM|MODECONST {
break break
@ -582,18 +574,15 @@ func getdyn(n *Node, top int) int {
} }
func structlit(ctxt int, pass int, n *Node, var_ *Node, init **NodeList) { func structlit(ctxt int, pass int, n *Node, var_ *Node, init **NodeList) {
var r *Node
var a *Node
var index *Node
var value *Node
for nl := n.List; nl != nil; nl = nl.Next { for nl := n.List; nl != nil; nl = nl.Next {
r = nl.N r := nl.N
if r.Op != OKEY { if r.Op != OKEY {
Fatalf("structlit: rhs not OKEY: %v", r) Fatalf("structlit: rhs not OKEY: %v", r)
} }
index = r.Left index := r.Left
value = r.Right value := r.Right
var a *Node
switch value.Op { switch value.Op {
case OARRAYLIT: case OARRAYLIT:
@ -650,18 +639,15 @@ func structlit(ctxt int, pass int, n *Node, var_ *Node, init **NodeList) {
} }
func arraylit(ctxt int, pass int, n *Node, var_ *Node, init **NodeList) { func arraylit(ctxt int, pass int, n *Node, var_ *Node, init **NodeList) {
var r *Node
var a *Node
var index *Node
var value *Node
for l := n.List; l != nil; l = l.Next { for l := n.List; l != nil; l = l.Next {
r = l.N r := l.N
if r.Op != OKEY { if r.Op != OKEY {
Fatalf("arraylit: rhs not OKEY: %v", r) Fatalf("arraylit: rhs not OKEY: %v", r)
} }
index = r.Left index := r.Left
value = r.Right value := r.Right
var a *Node
switch value.Op { switch value.Op {
case OARRAYLIT: case OARRAYLIT:
@ -828,17 +814,14 @@ func slicelit(ctxt int, n *Node, var_ *Node, init **NodeList) {
*init = list(*init, a) *init = list(*init, a)
// put dynamics into slice (6) // put dynamics into slice (6)
var value *Node
var r *Node
var index *Node
for l := n.List; l != nil; l = l.Next { for l := n.List; l != nil; l = l.Next {
r = l.N r := l.N
if r.Op != OKEY { if r.Op != OKEY {
Fatalf("slicelit: rhs not OKEY: %v", r) Fatalf("slicelit: rhs not OKEY: %v", r)
} }
index = r.Left index := r.Left
value = r.Right value := r.Right
a = Nod(OINDEX, var_, index) a := Nod(OINDEX, var_, index)
a.Bounded = true a.Bounded = true
// TODO need to check bounds? // TODO need to check bounds?
@ -872,10 +855,6 @@ func slicelit(ctxt int, n *Node, var_ *Node, init **NodeList) {
} }
func maplit(ctxt int, n *Node, var_ *Node, init **NodeList) { func maplit(ctxt int, n *Node, var_ *Node, init **NodeList) {
var r *Node
var index *Node
var value *Node
ctxt = 0 ctxt = 0
// make the map var // make the map var
@ -889,13 +868,12 @@ func maplit(ctxt int, n *Node, var_ *Node, init **NodeList) {
b := int64(0) b := int64(0)
for l := n.List; l != nil; l = l.Next { for l := n.List; l != nil; l = l.Next {
r = l.N r := l.N
if r.Op != OKEY { if r.Op != OKEY {
Fatalf("maplit: rhs not OKEY: %v", r) Fatalf("maplit: rhs not OKEY: %v", r)
} }
index = r.Left index := r.Left
value = r.Right value := r.Right
if isliteral(index) && isliteral(value) { if isliteral(index) && isliteral(value) {
b++ b++
@ -936,17 +914,14 @@ func maplit(ctxt int, n *Node, var_ *Node, init **NodeList) {
vstat := staticname(t, ctxt) vstat := staticname(t, ctxt)
b := int64(0) b := int64(0)
var index *Node
var r *Node
var value *Node
for l := n.List; l != nil; l = l.Next { for l := n.List; l != nil; l = l.Next {
r = l.N r := l.N
if r.Op != OKEY { if r.Op != OKEY {
Fatalf("maplit: rhs not OKEY: %v", r) Fatalf("maplit: rhs not OKEY: %v", r)
} }
index = r.Left index := r.Left
value = r.Right value := r.Right
if isliteral(index) && isliteral(value) { if isliteral(index) && isliteral(value) {
// build vstat[b].a = key; // build vstat[b].a = key;
@ -981,13 +956,13 @@ func maplit(ctxt int, n *Node, var_ *Node, init **NodeList) {
// for i = 0; i < len(vstat); i++ { // for i = 0; i < len(vstat); i++ {
// map[vstat[i].a] = vstat[i].b // map[vstat[i].a] = vstat[i].b
// } // }
index = temp(Types[TINT]) index := temp(Types[TINT])
a = Nod(OINDEX, vstat, index) a = Nod(OINDEX, vstat, index)
a.Bounded = true a.Bounded = true
a = Nod(ODOT, a, newname(symb)) a = Nod(ODOT, a, newname(symb))
r = Nod(OINDEX, vstat, index) r := Nod(OINDEX, vstat, index)
r.Bounded = true r.Bounded = true
r = Nod(ODOT, r, newname(syma)) r = Nod(ODOT, r, newname(syma))
r = Nod(OINDEX, var_, r) r = Nod(OINDEX, var_, r)
@ -1011,13 +986,13 @@ func maplit(ctxt int, n *Node, var_ *Node, init **NodeList) {
var val *Node var val *Node
for l := n.List; l != nil; l = l.Next { for l := n.List; l != nil; l = l.Next {
r = l.N r := l.N
if r.Op != OKEY { if r.Op != OKEY {
Fatalf("maplit: rhs not OKEY: %v", r) Fatalf("maplit: rhs not OKEY: %v", r)
} }
index = r.Left index := r.Left
value = r.Right value := r.Right
if isliteral(index) && isliteral(value) { if isliteral(index) && isliteral(value) {
continue continue
@ -1290,9 +1265,8 @@ func initplan(n *Node) {
Fatalf("initplan") Fatalf("initplan")
case OARRAYLIT: case OARRAYLIT:
var a *Node
for l := n.List; l != nil; l = l.Next { for l := n.List; l != nil; l = l.Next {
a = l.N a := l.N
if a.Op != OKEY || !Smallintconst(a.Left) { if a.Op != OKEY || !Smallintconst(a.Left) {
Fatalf("initplan arraylit") Fatalf("initplan arraylit")
} }
@ -1300,9 +1274,8 @@ func initplan(n *Node) {
} }
case OSTRUCTLIT: case OSTRUCTLIT:
var a *Node
for l := n.List; l != nil; l = l.Next { for l := n.List; l != nil; l = l.Next {
a = l.N a := l.N
if a.Op != OKEY || a.Left.Type == nil { if a.Op != OKEY || a.Left.Type == nil {
Fatalf("initplan structlit") Fatalf("initplan structlit")
} }
@ -1310,9 +1283,8 @@ func initplan(n *Node) {
} }
case OMAPLIT: case OMAPLIT:
var a *Node
for l := n.List; l != nil; l = l.Next { for l := n.List; l != nil; l = l.Next {
a = l.N a := l.N
if a.Op != OKEY { if a.Op != OKEY {
Fatalf("initplan maplit") Fatalf("initplan maplit")
} }
@ -1332,13 +1304,11 @@ func addvalue(p *InitPlan, xoffset int64, key *Node, n *Node) {
if isvaluelit(n) { if isvaluelit(n) {
initplan(n) initplan(n)
q := initplans[n] q := initplans[n]
var e *InitEntry for _, qe := range q.E {
for i := 0; i < len(q.E); i++ { e := entry(p)
e = entry(p) *e = qe
*e = q.E[i]
e.Xoffset += xoffset e.Xoffset += xoffset
} }
return return
} }

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

@ -3358,7 +3358,6 @@ func ngotype(n *Node) *Sym {
* only in the last segment of the path, and it makes for happier * only in the last segment of the path, and it makes for happier
* users if we escape that as little as possible. * users if we escape that as little as possible.
* *
* If you edit this, edit ../ld/lib.c:/^pathtoprefix too.
* If you edit this, edit ../../debug/goobj/read.go:/importPathToPrefix too. * If you edit this, edit ../../debug/goobj/read.go:/importPathToPrefix too.
*/ */
func pathtoprefix(s string) string { func pathtoprefix(s string) string {
@ -3430,17 +3429,13 @@ func isbadimport(path string) bool {
return true return true
} }
for i := 0; i < len(reservedimports); i++ { for _, ri := range reservedimports {
if path == reservedimports[i] { if path == ri {
Yyerror("import path %q is reserved and cannot be used", path) Yyerror("import path %q is reserved and cannot be used", path)
return true return true
} }
} }
var s string
_ = s
var r uint
_ = r
for _, r := range path { for _, r := range path {
if r == utf8.RuneError { if r == utf8.RuneError {
Yyerror("import path contains invalid UTF-8 sequence: %q", path) Yyerror("import path contains invalid UTF-8 sequence: %q", path)

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

@ -36,10 +36,10 @@ func isDigit(c int) bool {
func plan9quote(s string) string { func plan9quote(s string) string {
if s == "" { if s == "" {
return "'" + strings.Replace(s, "'", "''", -1) + "'" return "''"
} }
for i := 0; i < len(s); i++ { for _, c := range s {
if s[i] <= ' ' || s[i] == '\'' { if c <= ' ' || c == '\'' {
return "'" + strings.Replace(s, "'", "''", -1) + "'" return "'" + strings.Replace(s, "'", "''", -1) + "'"
} }
} }