X Tutup
Skip to content

Commit 382b44e

Browse files
rscrsc
committed
[dev.cc] cmd/5g etc: code cleanup: delay var decls and eliminate dead code
Ran rsc.io/grind rev 6f0e601 on the source files. The cleanups move var declarations as close to the use as possible, splitting disjoint uses of the var into separate variables. They also remove dead code (especially in func sudoaddable), which helps with the var moving. There's more cleanup to come, but this alone cuts the time spent compiling html/template on my 2013 MacBook Pro from 3.1 seconds to 2.3 seconds. Change-Id: I4de499f47b1dd47a560c310bbcde6b08d425cfd6 Reviewed-on: https://go-review.googlesource.com/5637 Reviewed-by: Rob Pike <r@golang.org>
1 parent 3af0d79 commit 382b44e

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

65 files changed

+4093
-6826
lines changed

‎src/cmd/5g/cgen.go‎

Lines changed: 158 additions & 155 deletions
Large diffs are not rendered by default.

‎src/cmd/5g/cgen64.go‎

Lines changed: 66 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -16,61 +16,43 @@ import "cmd/internal/gc"
1616
* return 1 on success, 0 if op not handled.
1717
*/
1818
func cgen64(n *gc.Node, res *gc.Node) {
19-
var t1 gc.Node
20-
var t2 gc.Node
21-
var l *gc.Node
22-
var r *gc.Node
23-
var lo1 gc.Node
24-
var lo2 gc.Node
25-
var hi1 gc.Node
26-
var hi2 gc.Node
27-
var al gc.Node
28-
var ah gc.Node
29-
var bl gc.Node
30-
var bh gc.Node
31-
var cl gc.Node
32-
var ch gc.Node
33-
var s gc.Node
34-
var n1 gc.Node
35-
var creg gc.Node
36-
var p1 *obj.Prog
37-
var p2 *obj.Prog
38-
var p3 *obj.Prog
39-
var p4 *obj.Prog
40-
var p5 *obj.Prog
41-
var p6 *obj.Prog
42-
var v uint64
43-
4419
if res.Op != gc.OINDREG && res.Op != gc.ONAME {
4520
gc.Dump("n", n)
4621
gc.Dump("res", res)
4722
gc.Fatal("cgen64 %v of %v", gc.Oconv(int(n.Op), 0), gc.Oconv(int(res.Op), 0))
4823
}
4924

50-
l = n.Left
25+
l := n.Left
26+
var t1 gc.Node
5127
if l.Addable == 0 {
5228
gc.Tempname(&t1, l.Type)
5329
cgen(l, &t1)
5430
l = &t1
5531
}
5632

33+
var hi1 gc.Node
34+
var lo1 gc.Node
5735
split64(l, &lo1, &hi1)
5836
switch n.Op {
5937
default:
6038
gc.Fatal("cgen64 %v", gc.Oconv(int(n.Op), 0))
6139

6240
case gc.OMINUS:
41+
var lo2 gc.Node
42+
var hi2 gc.Node
6343
split64(res, &lo2, &hi2)
6444

6545
regalloc(&t1, lo1.Type, nil)
46+
var al gc.Node
6647
regalloc(&al, lo1.Type, nil)
48+
var ah gc.Node
6749
regalloc(&ah, hi1.Type, nil)
6850

6951
gins(arm.AMOVW, &lo1, &al)
7052
gins(arm.AMOVW, &hi1, &ah)
7153

7254
gmove(ncon(0), &t1)
73-
p1 = gins(arm.ASUB, &al, &t1)
55+
p1 := gins(arm.ASUB, &al, &t1)
7456
p1.Scond |= arm.C_SBIT
7557
gins(arm.AMOVW, &t1, &lo2)
7658

@@ -89,7 +71,10 @@ func cgen64(n *gc.Node, res *gc.Node) {
8971
regalloc(&t1, lo1.Type, nil)
9072
gmove(ncon(^uint32(0)), &t1)
9173

74+
var lo2 gc.Node
75+
var hi2 gc.Node
9276
split64(res, &lo2, &hi2)
77+
var n1 gc.Node
9378
regalloc(&n1, lo1.Type, nil)
9479

9580
gins(arm.AMOVW, &lo1, &n1)
@@ -121,19 +106,24 @@ func cgen64(n *gc.Node, res *gc.Node) {
121106
}
122107

123108
// setup for binary operators
124-
r = n.Right
109+
r := n.Right
125110

126111
if r != nil && r.Addable == 0 {
112+
var t2 gc.Node
127113
gc.Tempname(&t2, r.Type)
128114
cgen(r, &t2)
129115
r = &t2
130116
}
131117

118+
var hi2 gc.Node
119+
var lo2 gc.Node
132120
if gc.Is64(r.Type) {
133121
split64(r, &lo2, &hi2)
134122
}
135123

124+
var al gc.Node
136125
regalloc(&al, lo1.Type, nil)
126+
var ah gc.Node
137127
regalloc(&ah, hi1.Type, nil)
138128

139129
// Do op. Leave result in ah:al.
@@ -143,40 +133,48 @@ func cgen64(n *gc.Node, res *gc.Node) {
143133

144134
// TODO: Constants
145135
case gc.OADD:
136+
var bl gc.Node
146137
regalloc(&bl, gc.Types[gc.TPTR32], nil)
147138

139+
var bh gc.Node
148140
regalloc(&bh, gc.Types[gc.TPTR32], nil)
149141
gins(arm.AMOVW, &hi1, &ah)
150142
gins(arm.AMOVW, &lo1, &al)
151143
gins(arm.AMOVW, &hi2, &bh)
152144
gins(arm.AMOVW, &lo2, &bl)
153-
p1 = gins(arm.AADD, &bl, &al)
145+
p1 := gins(arm.AADD, &bl, &al)
154146
p1.Scond |= arm.C_SBIT
155147
gins(arm.AADC, &bh, &ah)
156148
regfree(&bl)
157149
regfree(&bh)
158150

159151
// TODO: Constants.
160152
case gc.OSUB:
153+
var bl gc.Node
161154
regalloc(&bl, gc.Types[gc.TPTR32], nil)
162155

156+
var bh gc.Node
163157
regalloc(&bh, gc.Types[gc.TPTR32], nil)
164158
gins(arm.AMOVW, &lo1, &al)
165159
gins(arm.AMOVW, &hi1, &ah)
166160
gins(arm.AMOVW, &lo2, &bl)
167161
gins(arm.AMOVW, &hi2, &bh)
168-
p1 = gins(arm.ASUB, &bl, &al)
162+
p1 := gins(arm.ASUB, &bl, &al)
169163
p1.Scond |= arm.C_SBIT
170164
gins(arm.ASBC, &bh, &ah)
171165
regfree(&bl)
172166
regfree(&bh)
173167

174168
// TODO(kaib): this can be done with 4 regs and does not need 6
175169
case gc.OMUL:
170+
var bl gc.Node
176171
regalloc(&bl, gc.Types[gc.TPTR32], nil)
177172

173+
var bh gc.Node
178174
regalloc(&bh, gc.Types[gc.TPTR32], nil)
175+
var cl gc.Node
179176
regalloc(&cl, gc.Types[gc.TPTR32], nil)
177+
var ch gc.Node
180178
regalloc(&ch, gc.Types[gc.TPTR32], nil)
181179

182180
// load args into bh:bl and bh:bl.
@@ -187,7 +185,7 @@ func cgen64(n *gc.Node, res *gc.Node) {
187185
gins(arm.AMOVW, &lo2, &cl)
188186

189187
// bl * cl -> ah al
190-
p1 = gins(arm.AMULLU, nil, nil)
188+
p1 := gins(arm.AMULLU, nil, nil)
191189

192190
p1.From.Type = obj.TYPE_REG
193191
p1.From.Reg = bl.Val.U.Reg
@@ -239,9 +237,11 @@ func cgen64(n *gc.Node, res *gc.Node) {
239237
// shld hi:lo, c
240238
// shld lo:t, c
241239
case gc.OLROT:
242-
v = uint64(gc.Mpgetfix(r.Val.U.Xval))
240+
v := uint64(gc.Mpgetfix(r.Val.U.Xval))
243241

242+
var bl gc.Node
244243
regalloc(&bl, lo1.Type, nil)
244+
var bh gc.Node
245245
regalloc(&bh, hi1.Type, nil)
246246
if v >= 32 {
247247
// reverse during load to do the first 32 bits of rotate
@@ -274,13 +274,24 @@ func cgen64(n *gc.Node, res *gc.Node) {
274274
regfree(&bh)
275275

276276
case gc.OLSH:
277+
var bl gc.Node
277278
regalloc(&bl, lo1.Type, nil)
279+
var bh gc.Node
278280
regalloc(&bh, hi1.Type, nil)
279281
gins(arm.AMOVW, &hi1, &bh)
280282
gins(arm.AMOVW, &lo1, &bl)
281283

284+
var p6 *obj.Prog
285+
var s gc.Node
286+
var n1 gc.Node
287+
var creg gc.Node
288+
var p1 *obj.Prog
289+
var p2 *obj.Prog
290+
var p3 *obj.Prog
291+
var p4 *obj.Prog
292+
var p5 *obj.Prog
282293
if r.Op == gc.OLITERAL {
283-
v = uint64(gc.Mpgetfix(r.Val.U.Xval))
294+
v := uint64(gc.Mpgetfix(r.Val.U.Xval))
284295
if v >= 64 {
285296
// TODO(kaib): replace with gins(AMOVW, nodintconst(0), &al)
286297
// here and below (verify it optimizes to EOR)
@@ -316,6 +327,8 @@ func cgen64(n *gc.Node, res *gc.Node) {
316327
regalloc(&creg, gc.Types[gc.TUINT32], nil)
317328
if gc.Is64(r.Type) {
318329
// shift is >= 1<<32
330+
var cl gc.Node
331+
var ch gc.Node
319332
split64(r, &cl, &ch)
320333

321334
gmove(&ch, &s)
@@ -422,13 +435,24 @@ func cgen64(n *gc.Node, res *gc.Node) {
422435
regfree(&bh)
423436

424437
case gc.ORSH:
438+
var bl gc.Node
425439
regalloc(&bl, lo1.Type, nil)
440+
var bh gc.Node
426441
regalloc(&bh, hi1.Type, nil)
427442
gins(arm.AMOVW, &hi1, &bh)
428443
gins(arm.AMOVW, &lo1, &bl)
429444

445+
var p4 *obj.Prog
446+
var p5 *obj.Prog
447+
var n1 gc.Node
448+
var p6 *obj.Prog
449+
var s gc.Node
450+
var p1 *obj.Prog
451+
var p2 *obj.Prog
452+
var creg gc.Node
453+
var p3 *obj.Prog
430454
if r.Op == gc.OLITERAL {
431-
v = uint64(gc.Mpgetfix(r.Val.U.Xval))
455+
v := uint64(gc.Mpgetfix(r.Val.U.Xval))
432456
if v >= 64 {
433457
if bh.Type.Etype == gc.TINT32 {
434458
// MOVW bh->31, al
@@ -487,10 +511,13 @@ func cgen64(n *gc.Node, res *gc.Node) {
487511
regalloc(&creg, gc.Types[gc.TUINT32], nil)
488512
if gc.Is64(r.Type) {
489513
// shift is >= 1<<32
514+
var ch gc.Node
515+
var cl gc.Node
490516
split64(r, &cl, &ch)
491517

492518
gmove(&ch, &s)
493519
gins(arm.ATST, &s, nil)
520+
var p1 *obj.Prog
494521
if bh.Type.Etype == gc.TINT32 {
495522
p1 = gshift(arm.AMOVW, &bh, arm.SHIFT_AR, 31, &ah)
496523
} else {
@@ -578,12 +605,12 @@ func cgen64(n *gc.Node, res *gc.Node) {
578605

579606
if bh.Type.Etype == gc.TINT32 {
580607
// MOVW bh->(s-32), al
581-
p1 = gregshift(arm.AMOVW, &bh, arm.SHIFT_AR, &s, &al)
608+
p1 := gregshift(arm.AMOVW, &bh, arm.SHIFT_AR, &s, &al)
582609

583610
p1.Scond = arm.C_SCOND_LO
584611
} else {
585612
// MOVW bh>>(v-32), al
586-
p1 = gregshift(arm.AMOVW, &bh, arm.SHIFT_LR, &s, &al)
613+
p1 := gregshift(arm.AMOVW, &bh, arm.SHIFT_LR, &s, &al)
587614

588615
p1.Scond = arm.C_SCOND_LO
589616
}
@@ -708,6 +735,7 @@ func cgen64(n *gc.Node, res *gc.Node) {
708735
case gc.OXOR,
709736
gc.OAND,
710737
gc.OOR:
738+
var n1 gc.Node
711739
regalloc(&n1, lo1.Type, nil)
712740

713741
gins(arm.AMOVW, &lo1, &al)
@@ -746,15 +774,13 @@ func cmp64(nl *gc.Node, nr *gc.Node, op int, likely int, to *obj.Prog) {
746774
var hi2 gc.Node
747775
var r1 gc.Node
748776
var r2 gc.Node
749-
var br *obj.Prog
750-
var t *gc.Type
751777

752778
split64(nl, &lo1, &hi1)
753779
split64(nr, &lo2, &hi2)
754780

755781
// compare most significant word;
756782
// if they differ, we're done.
757-
t = hi1.Type
783+
t := hi1.Type
758784

759785
regalloc(&r1, gc.Types[gc.TINT32], nil)
760786
regalloc(&r2, gc.Types[gc.TINT32], nil)
@@ -764,7 +790,7 @@ func cmp64(nl *gc.Node, nr *gc.Node, op int, likely int, to *obj.Prog) {
764790
regfree(&r1)
765791
regfree(&r2)
766792

767-
br = nil
793+
br := (*obj.Prog)(nil)
768794
switch op {
769795
default:
770796
gc.Fatal("cmp64 %v %v", gc.Oconv(int(op), 0), gc.Tconv(t, 0))

0 commit comments

Comments
 (0)
X Tutup