From b32217a2730b322f4bdc2a00ff9159bae853b939 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 17 Sep 2015 16:45:10 -0700 Subject: [PATCH] [dev.ssa] cmd/compile: consistent naming of temporary vars ptrvar -> ptrVar, etc. Change-Id: Id38bed0e145711dfe3bdc9541ab4741da6a570a2 Reviewed-on: https://go-review.googlesource.com/14725 Reviewed-by: Todd Neal --- src/cmd/compile/internal/gc/ssa.go | 80 +++++++++++++++--------------- 1 file changed, 40 insertions(+), 40 deletions(-) diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 7268a34a12..186c1a2996 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -261,11 +261,11 @@ func (s *state) Unimplementedf(msg string, args ...interface{}) { s.config.Unimp var ( // dummy node for the memory variable - memvar = Node{Op: ONAME, Sym: &Sym{Name: "mem"}} + memVar = Node{Op: ONAME, Sym: &Sym{Name: "mem"}} // dummy nodes for temporary variables - ptrvar = Node{Op: ONAME, Sym: &Sym{Name: "ptr"}} - capvar = Node{Op: ONAME, Sym: &Sym{Name: "cap"}} + ptrVar = Node{Op: ONAME, Sym: &Sym{Name: "ptr"}} + capVar = Node{Op: ONAME, Sym: &Sym{Name: "cap"}} typVar = Node{Op: ONAME, Sym: &Sym{Name: "typ"}} idataVar = Node{Op: ONAME, Sym: &Sym{Name: "idata"}} okVar = Node{Op: ONAME, Sym: &Sym{Name: "ok"}} @@ -785,7 +785,7 @@ func (s *state) stmt(n *Node) { // We only care about liveness info at call sites, so putting the // varkill in the store chain is enough to keep it correctly ordered // with respect to call ops. - s.vars[&memvar] = s.newValue1A(ssa.OpVarKill, ssa.TypeMem, n.Left, s.mem()) + s.vars[&memVar] = s.newValue1A(ssa.OpVarKill, ssa.TypeMem, n.Left, s.mem()) case OCHECKNIL: p := s.expr(n.Left) @@ -1840,8 +1840,8 @@ func (s *state) expr(n *Node) *ssa.Value { c := s.newValue1(ssa.OpSliceCap, Types[TINT], slice) nl := s.newValue2(s.ssaOp(OADD, Types[TINT]), Types[TINT], l, s.constInt(Types[TINT], nargs)) cmp := s.newValue2(s.ssaOp(OGT, Types[TINT]), Types[TBOOL], nl, c) - s.vars[&ptrvar] = p - s.vars[&capvar] = c + s.vars[&ptrVar] = p + s.vars[&capVar] = c b := s.endBlock() b.Kind = ssa.BlockIf b.Likely = ssa.BranchUnlikely @@ -1857,14 +1857,14 @@ func (s *state) expr(n *Node) *ssa.Value { spplus2 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(2*Widthptr), s.sp) spplus3 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(3*Widthptr), s.sp) spplus4 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(4*Widthptr), s.sp) - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), s.sp, taddr, s.mem()) - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus1, p, s.mem()) - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus2, l, s.mem()) - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus3, c, s.mem()) - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus4, nl, s.mem()) + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), s.sp, taddr, s.mem()) + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus1, p, s.mem()) + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus2, l, s.mem()) + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus3, c, s.mem()) + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus4, nl, s.mem()) call := s.newValue1A(ssa.OpStaticCall, ssa.TypeMem, syslook("growslice", 0).Sym, s.mem()) call.AuxInt = int64(8 * Widthptr) - s.vars[&memvar] = call + s.vars[&memVar] = call b = s.endBlock() b.Kind = ssa.BlockCall b.Control = call @@ -1875,19 +1875,19 @@ func (s *state) expr(n *Node) *ssa.Value { spplus5 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(5*Widthptr), s.sp) // Note: we don't need to read the result's length. spplus7 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(7*Widthptr), s.sp) - s.vars[&ptrvar] = s.newValue2(ssa.OpLoad, pt, spplus5, s.mem()) - s.vars[&capvar] = s.newValue2(ssa.OpLoad, Types[TINT], spplus7, s.mem()) + s.vars[&ptrVar] = s.newValue2(ssa.OpLoad, pt, spplus5, s.mem()) + s.vars[&capVar] = s.newValue2(ssa.OpLoad, Types[TINT], spplus7, s.mem()) b = s.endBlock() b.AddEdgeTo(assign) // assign new elements to slots s.startBlock(assign) - p = s.variable(&ptrvar, pt) // generates phi for ptr - c = s.variable(&capvar, Types[TINT]) // generates phi for cap + p = s.variable(&ptrVar, pt) // generates phi for ptr + c = s.variable(&capVar, Types[TINT]) // generates phi for cap p2 := s.newValue2(ssa.OpPtrIndex, pt, p, l) for i, arg := range args { addr := s.newValue2(ssa.OpPtrIndex, pt, p2, s.constInt(Types[TUINTPTR], int64(i))) - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, et.Size(), addr, arg, s.mem()) + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, et.Size(), addr, arg, s.mem()) if haspointers(et) { // TODO: just one write barrier call for all of these writes? // TODO: maybe just one writeBarrierEnabled check? @@ -1897,8 +1897,8 @@ func (s *state) expr(n *Node) *ssa.Value { // make result r := s.newValue3(ssa.OpSliceMake, n.Type, p, nl, c) - delete(s.vars, &ptrvar) - delete(s.vars, &capvar) + delete(s.vars, &ptrVar) + delete(s.vars, &capVar) return r default: @@ -1919,9 +1919,9 @@ func (s *state) assign(left *Node, right *ssa.Value, wb bool) { // if we can't ssa this memory, treat it as just zeroing out the backing memory addr := s.addr(left) if left.Op == ONAME { - s.vars[&memvar] = s.newValue1A(ssa.OpVarDef, ssa.TypeMem, left, s.mem()) + s.vars[&memVar] = s.newValue1A(ssa.OpVarDef, ssa.TypeMem, left, s.mem()) } - s.vars[&memvar] = s.newValue2I(ssa.OpZero, ssa.TypeMem, t.Size(), addr, s.mem()) + s.vars[&memVar] = s.newValue2I(ssa.OpZero, ssa.TypeMem, t.Size(), addr, s.mem()) return } right = s.zeroVal(t) @@ -1934,9 +1934,9 @@ func (s *state) assign(left *Node, right *ssa.Value, wb bool) { // not ssa-able. Treat as a store. addr := s.addr(left) if left.Op == ONAME { - s.vars[&memvar] = s.newValue1A(ssa.OpVarDef, ssa.TypeMem, left, s.mem()) + s.vars[&memVar] = s.newValue1A(ssa.OpVarDef, ssa.TypeMem, left, s.mem()) } - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, t.Size(), addr, right, s.mem()) + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, t.Size(), addr, right, s.mem()) if wb { s.insertWB(left.Type, addr) } @@ -2068,16 +2068,16 @@ func (s *state) call(n *Node, k callKind) *ssa.Value { argStart += int64(2 * Widthptr) } addr := s.entryNewValue1I(ssa.OpOffPtr, Types[TUINTPTR], argStart, s.sp) - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), addr, rcvr, s.mem()) + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), addr, rcvr, s.mem()) } // Defer/go args if k != callNormal { // Write argsize and closure (args to Newproc/Deferproc). argsize := s.constInt32(Types[TUINT32], int32(stksize)) - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, 4, s.sp, argsize, s.mem()) + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, 4, s.sp, argsize, s.mem()) addr := s.entryNewValue1I(ssa.OpOffPtr, Ptrto(Types[TUINTPTR]), int64(Widthptr), s.sp) - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), addr, closure, s.mem()) + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), addr, closure, s.mem()) stksize += 2 * int64(Widthptr) } @@ -2102,7 +2102,7 @@ func (s *state) call(n *Node, k callKind) *ssa.Value { call.AuxInt = stksize // Call operations carry the argsize of the callee along with them // Finish call block - s.vars[&memvar] = call + s.vars[&memVar] = call b := s.endBlock() b.Kind = ssa.BlockCall b.Control = call @@ -2382,12 +2382,12 @@ func (s *state) insertWB(t *Type, p *ssa.Value) { s.startBlock(bThen) // TODO: writebarrierptr_nostore if just one pointer word (or a few?) taddr := s.newValue1A(ssa.OpAddr, Types[TUINTPTR], &ssa.ExternSymbol{Types[TUINTPTR], typenamesym(t)}, s.sb) - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), s.sp, taddr, s.mem()) + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), s.sp, taddr, s.mem()) spplus8 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(Widthptr), s.sp) - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus8, p, s.mem()) + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus8, p, s.mem()) call := s.newValue1A(ssa.OpStaticCall, ssa.TypeMem, syslook("typedmemmove_nostore", 0).Sym, s.mem()) call.AuxInt = int64(2 * Widthptr) - s.vars[&memvar] = call + s.vars[&memVar] = call c := s.endBlock() c.Kind = ssa.BlockCall c.Control = call @@ -2477,7 +2477,7 @@ func (s *state) slice(t *Type, v, i, j, k *ssa.Value) (p, l, c *ssa.Value) { rcap = s.newValue2(ssa.OpSubPtr, Types[TINT], k, i) } - s.vars[&ptrvar] = ptr + s.vars[&ptrVar] = ptr // Generate code to test the resulting slice length. var cmp *ssa.Value @@ -2502,7 +2502,7 @@ func (s *state) slice(t *Type, v, i, j, k *ssa.Value) (p, l, c *ssa.Value) { } else { inc = s.newValue2(ssa.OpMulPtr, Types[TUINTPTR], i, s.constInt(Types[TINT], elemtype.Width)) } - s.vars[&ptrvar] = s.newValue2(ssa.OpAddPtr, ptrtype, ptr, inc) + s.vars[&ptrVar] = s.newValue2(ssa.OpAddPtr, ptrtype, ptr, inc) s.endBlock() // All done. @@ -2510,8 +2510,8 @@ func (s *state) slice(t *Type, v, i, j, k *ssa.Value) (p, l, c *ssa.Value) { b.AddEdgeTo(merge) nz.AddEdgeTo(merge) s.startBlock(merge) - rptr := s.variable(&ptrvar, ptrtype) - delete(s.vars, &ptrvar) + rptr := s.variable(&ptrVar, ptrtype) + delete(s.vars, &ptrVar) return rptr, rlen, rcap } @@ -2814,9 +2814,9 @@ func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) { spplus1 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(Widthptr), s.sp) spplus2 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(2*Widthptr), s.sp) taddr := s.newValue1A(ssa.OpAddr, byteptr, &ssa.ExternSymbol{byteptr, typenamesym(n.Left.Type)}, s.sb) - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), s.sp, typ, s.mem()) // actual dynamic type - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus1, target, s.mem()) // type we're casting to - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus2, taddr, s.mem()) // static source type + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), s.sp, typ, s.mem()) // actual dynamic type + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus1, target, s.mem()) // type we're casting to + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus2, taddr, s.mem()) // static source type call := s.newValue1A(ssa.OpStaticCall, ssa.TypeMem, syslook("panicdottype", 0).Sym, s.mem()) s.endBlock() bFail.Kind = ssa.BlockExit @@ -2924,7 +2924,7 @@ func (s *state) variable(name *Node, t ssa.Type) *ssa.Value { } func (s *state) mem() *ssa.Value { - return s.variable(&memvar, ssa.TypeMem) + return s.variable(&memVar, ssa.TypeMem) } func (s *state) linkForwardReferences() { @@ -2952,7 +2952,7 @@ func (s *state) lookupVarIncoming(b *ssa.Block, t ssa.Type, name *Node) *ssa.Val // TODO(khr): have lookupVarIncoming overwrite the fwdRef or copy it // will be used in, instead of having the result used in a copy value. if b == s.f.Entry { - if name == &memvar { + if name == &memVar { return s.startmem } // variable is live at the entry block. Load it. @@ -2974,7 +2974,7 @@ func (s *state) lookupVarIncoming(b *ssa.Block, t ssa.Type, name *Node) *ssa.Val // This block is dead; we have no predecessors and we're not the entry block. // It doesn't matter what we use here as long as it is well-formed, // so use the default/zero value. - if name == &memvar { + if name == &memVar { return s.startmem } return s.zeroVal(name.Type)