Commits · d4cc51d4118027464f61034179908abd0005fab6 · Kirill Smelkov / go

15 Aug, 2015 1 commit

[dev.ssa] cmd/compile/internal/ssa: Use explicit size for store ops · d4cc51d4

Keith Randall authored Aug 14, 2015

Using the type of the store argument is not safe, it may change
during rewriting, giving us the wrong store width.

(Store ptr (Trunc32to16 val) mem)

This should be a 2-byte store.  But we have the rule:

(Trunc32to16 x) -> x

So if the Trunc rewrite happens before the Store -> MOVW rewrite,
then the Store thinks that the value it is storing is 4 bytes
in size and uses a MOVL.  Bad things ensue.

Fix this by encoding the store width explicitly in the auxint field.

In general, we can't rely on the type of arguments, as they may
change during rewrites.  The type of the op itself (as used by
the Load rules) is still ok to use.

Change-Id: I9e2359e4f657bb0ea0e40038969628bf0f84e584
Reviewed-on: https://go-review.googlesource.com/13636Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>

d4cc51d4

14 Aug, 2015 2 commits

[dev.ssa] cmd/compile/internal/ssa/gen: more simplifications and foldings. · 198fc9a9

Alexandru Moșoi authored Aug 14, 2015

Change-Id: I74d1267dbfced2663072b4f091732c0fb328690f
Reviewed-on: https://go-review.googlesource.com/13641Reviewed-by: Keith Randall <khr@golang.org>

198fc9a9

[dev.ssa] cmd/compile/internal/ssa/gen: fold Mul8 properly. · 7a6de6d5

Alexandru Moșoi authored Aug 14, 2015

Mul8 is lowered to MULW, but the rules for constant
folding do not handle the fact that the operands
are int8.

Change-Id: I2c336686d86249393a8079a471c6ff74e6228f3d
Reviewed-on: https://go-review.googlesource.com/13642Reviewed-by: Keith Randall <khr@golang.org>

7a6de6d5

13 Aug, 2015 6 commits

[dev.ssa] cmd/compile/internal/gc: handle all inputs for shifts. · c55870a5

Alexandru Moșoi authored Aug 07, 2015

Disable CX as output for shift operations.

Change-Id: I85e6b22d09009b38847082dc375b6108c2dee80a
Reviewed-on: https://go-review.googlesource.com/13370Reviewed-by: Keith Randall <khr@golang.org>

c55870a5

[dev.ssa] cmd/compile: add HTML SSA printer · 35fb5145

Josh Bleecher Snyder authored Aug 10, 2015

This is an initial implementation.
There are many rough edges and TODOs,
which will hopefully be polished out
with use.

Fixes #12071.

Change-Id: I1d6fd5a343063b5200623bceef2c2cfcc885794e
Reviewed-on: https://go-review.googlesource.com/13472Reviewed-by: Keith Randall <khr@golang.org>

35fb5145

[dev.ssa] cmd/compile: improve inBounds rewrite rules · 3e7904b6

Josh Bleecher Snyder authored Aug 12, 2015

Change-Id: Ia238187a89f820cd1620ab5acdbf1c8f003569b1
Reviewed-on: https://go-review.googlesource.com/13587Reviewed-by: Keith Randall <khr@golang.org>

3e7904b6

[dev.ssa] cmd/compile: add register spec to getg · bc1f5768

Keith Randall authored Aug 13, 2015

This omission was causing the new regalloc to fail.

Change-Id: If7ba7be38a436dbd0dd443828ddd7ebf6e35be0e
Reviewed-on: https://go-review.googlesource.com/13632Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>

bc1f5768

[dev.ssa] cmd/compile: fix constant subtraction rules · 3b705824

Keith Randall authored Aug 13, 2015

(SUBQconst [x] y) computes y-x, not x-y.

Fixes #12137

Change-Id: Idbd0554eee051102f562240d1756647843666ee6
Reviewed-on: https://go-review.googlesource.com/13631Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>

3b705824

[dev.ssa] cmd/compile: move rewrite logging behind codegen flag · f85faefa

Josh Bleecher Snyder authored Aug 12, 2015

Generating logging code every time causes large
diffs for small changes.

Since the intent is to use this for debugging only,
generate logging code only when requested.
Committed generated code will be logging free.

Change-Id: I9ef9e29c88b76c2557bad4c6b424b9db1255ec8b
Reviewed-on: https://go-review.googlesource.com/13623Reviewed-by: Keith Randall <khr@golang.org>

f85faefa

12 Aug, 2015 8 commits

[dev.ssa] cmd/compile: make sure entry block has no predecessors · 867662da

Keith Randall authored Aug 12, 2015

Fix one test that build a violating CFG.

Change-Id: Ie0296ced602984d914a70461c76559c507ce2510
Reviewed-on: https://go-review.googlesource.com/13621Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>

867662da

[dev.ssa] cmd/compile: log line numbers in generated rewrite rules · 514ab7c3

Josh Bleecher Snyder authored Aug 12, 2015

This makes it easier to investigate and
understand rewrite behavior.

Change-Id: I790e8964922caf98362ce8a6d6972f52d83eefa8
Reviewed-on: https://go-review.googlesource.com/13588Reviewed-by: Keith Randall <khr@golang.org>

514ab7c3

[dev.ssa] cmd/compile: implement OGETG · 3d23afb9

Josh Bleecher Snyder authored Aug 12, 2015

Change-Id: I7ecf62cf399c710b4a617803c43e83fce09b8a7d
Reviewed-on: https://go-review.googlesource.com/13585Reviewed-by: Keith Randall <khr@golang.org>

3d23afb9

[dev.ssa] cmd/compile: initial implementation of likely direction · bbf8c5ce

Josh Bleecher Snyder authored Aug 11, 2015

Change-Id: Id8457b18c07bf717d13c9423d8f314f253eee64f
Reviewed-on: https://go-review.googlesource.com/13580Reviewed-by: Keith Randall <khr@golang.org>

bbf8c5ce

[dev.ssa] cmd/compile: update opnames · 212a1763

Josh Bleecher Snyder authored Aug 12, 2015

This claims to be autogenerated from go tool dist,
but I don't see where.

In any case, the update is trivial.

Change-Id: I58daaba755f3d34a0396005046b89411a02ada7e
Reviewed-on: https://go-review.googlesource.com/13584Reviewed-by: Keith Randall <khr@golang.org>

212a1763

[dev.ssa] cmd/compile: implement OSPTR · a2d1580f

Josh Bleecher Snyder authored Aug 12, 2015

Change-Id: Iaa40f14a1e3e4393af3c446953ffc315e79a3762
Reviewed-on: https://go-review.googlesource.com/13581Reviewed-by: Keith Randall <khr@golang.org>

a2d1580f

[dev.ssa] cmd/compile: fix function call memory · d56d2fa2

Keith Randall authored Aug 12, 2015

We need to move the memory variable update back to before endBlock
so that all successors use the right memory value.

See https://go-review.googlesource.com/13560

Change-Id: Id72e5526c56e5e070b933d3b28dc503a5a2978dc
Reviewed-on: https://go-review.googlesource.com/13586Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>

d56d2fa2

[dev.ssa] cmd/compile/ssa: fix test for dse · ce977889

Todd Neal authored Aug 11, 2015

Fix the test broken with dee1f2 by implementing Elem()

Change-Id: I7a4a487885267c24fdc52d79fb7d450231328812
Reviewed-on: https://go-review.googlesource.com/13551Reviewed-by: Keith Randall <khr@golang.org>

ce977889

11 Aug, 2015 5 commits

[dev.ssa] cmd/compile/ssa: eliminate Zero with dse · dee1f275

Todd Neal authored Aug 10, 2015

Consider OpZero to be a store so it can be eliminated by dse.

Change-Id: Idebb6a190657b76966f0c5b20f2ec9f52fe47499
Reviewed-on: https://go-review.googlesource.com/13447Reviewed-by: Keith Randall <khr@golang.org>

dee1f275

[dev.ssa] cmd/compile: make failed nil checks panic · 463858e6

Josh Bleecher Snyder authored Aug 11, 2015

Introduce pseudo-ops PanicMem and LoweredPanicMem.
PanicMem could be rewritten directly into MOVL
during lowering, but then we couldn't log nil checks.

With this change, runnable nil check tests pass:

GOSSAPKG=main go run run.go -- nil*.go

Compiler output nil check tests fail:

GOSSAPKG=p go run run.go -- nil*.go

This is due to several factors:

* SSA has improved elimination of unnecessary nil checks.
* SSA is missing elimination of implicit nil checks.
* SSA is missing extra logging about why nil checks were removed.

I'm not sure how best to resolve these failures,
particularly in a world in which the two backends
will live side by side for some time.
For now, punt on the problem.

Change-Id: Ib2ca6824551671f92e0e1800b036f5ca0905e2a3
Reviewed-on: https://go-review.googlesource.com/13474Reviewed-by: Keith Randall <khr@golang.org>

463858e6

[dev.ssa] cmd/compile: fix function call memory accounting · 2af06480

Josh Bleecher Snyder authored Aug 11, 2015

We were not recording function calls as
changing the state of memory.

As a result, the scheduler was not aware that
storing values to the stack in order to make a
function call must happen *after* retrieving
results from the stack from a just-completed
function call.

This fixes the container/ring tests.

This was my first experience debugging an issue
using the HTML output. I'm feeling quite
pleased with it.

Change-Id: I9e8276846be9fd7a60422911b11816c5175e3d0a
Reviewed-on: https://go-review.googlesource.com/13560Reviewed-by: Keith Randall <khr@golang.org>

2af06480

[dev.ssa] cmd/compile: add support for LROT, and tests · 40aba8c4

David Chase authored Aug 05, 2015

Hardcoded the limit on constants only allowed.

Change-Id: Idb9b07b4871db7a752a79e492671e9b41207b956
Reviewed-on: https://go-review.googlesource.com/13257Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>

40aba8c4

[dev.ssa] cmd/compile/ssa: don't nil check phis with non-nil arguments · e0e55662

Todd Neal authored Aug 06, 2015

Move the known-non-nil scan outside the work loop to resolve an issue
with values that were declared outside the block being operated on.
Also consider phis whose arguments are all non-nil, as non-nil.

Change-Id: I4d5b840042de9eb181f2cb918f36913fb5d517a2
Reviewed-on: https://go-review.googlesource.com/13441Reviewed-by: Keith Randall <khr@golang.org>

e0e55662

10 Aug, 2015 3 commits

[dev.ssa] cmd/compile/internal/ssa: Update TODO list · 9787ba43

Keith Randall authored Aug 10, 2015

Change-Id: Ibcd4c6984c8728fd9ab76e0c7df555984deaf281
Reviewed-on: https://go-review.googlesource.com/13471Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>

9787ba43

[dev.ssa] cmd/compile: detect rewrite loops of length > 1 · baf2c3ec

Josh Bleecher Snyder authored Aug 10, 2015

Use a version of Floyd's cycle finding algorithm,
but advance by 1 and 1/2 steps per cycle rather
than by 1 and 2. It is simpler and should be cheaper
in the normal, acyclic case.

This should fix the 386 and arm builds,
which are currently hung.

Change-Id: If8bd443011b28a5ecb004a549239991d3dfc862b
Reviewed-on: https://go-review.googlesource.com/13473Reviewed-by: Keith Randall <khr@golang.org>

baf2c3ec

[dev.ssa] cmd/compile/internal/ssa: enforce load-store ordering in scheduler · e98edc88

Keith Randall authored Aug 10, 2015

We must make sure that all loads that use a store are scheduled
before the next store. Add additional dependency edges to the
value graph to enforce this constraint.

Change-Id: Iab83644f68bc4c30637085b82ca7467b9d5513a5
Reviewed-on: https://go-review.googlesource.com/13470Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>

e98edc88

07 Aug, 2015 1 commit

[dev.ssa] cmd/compile: add simplifying block rewrite rules · 0d910180

Josh Bleecher Snyder authored Aug 07, 2015

Change-Id: Ia946c259628f84dc7031171456563975d2ad5ea9
Reviewed-on: https://go-review.googlesource.com/13381Reviewed-by: Keith Randall <khr@golang.org>

0d910180

06 Aug, 2015 12 commits

[dev.ssa] cmd/compile/ssa: don't perform nilcheck on OpAddr/OpAddPtr values · b14b8d6b

Todd Neal authored Aug 03, 2015

Don't nilcheck values that were constructed as a result of OpAddr or
OpAddPtr.

Change-Id: I38053e905d1b76a2a64e77f84e444d38a5217108
Reviewed-on: https://go-review.googlesource.com/13256Reviewed-by: David Chase <drchase@google.com>

b14b8d6b

[dev.ssa] cmd/compile: copy values during rewrites · 0fb818a4

Josh Bleecher Snyder authored Aug 05, 2015

Rather than require an explicit Copy on the RHS of rewrite rules,
use rulegen magic to add it.

The advantages to handling this in rulegen are:

* simpler rules
* harder to accidentally miss a Copy

Change-Id: I46853bade83bdf517eee9495bf5a553175277b53
Reviewed-on: https://go-review.googlesource.com/13242Reviewed-by: Keith Randall <khr@golang.org>

0fb818a4

[dev.ssa] cmd/compile/internal/ssa/gen: generate better code when right-shifting with a constant. · d2150c83

Alexandru Moșoi authored Aug 06, 2015

The lowering rules were missing the non-64 bit case.

SBBLcarrymask can be folded to a int32 integer whose
type has a smaller bit size. Without the new AND rules
the following would be generated:

    v19 = MOVLconst <uint8> [-1] : SI
    v20 = ANDB <uint8> v18 v19 : DI

which is obviously a NOP.

Fixes #12022

Change-Id: I5f4209f78edc0f118e5b9b2908739f09cefebca4
Reviewed-on: https://go-review.googlesource.com/13301Reviewed-by: Keith Randall <khr@golang.org>

d2150c83

[dev.ssa] cmd/compile: handle phi control values · ca088cf4

Josh Bleecher Snyder authored Aug 05, 2015

Tests courtesy of Todd Neal.

Change-Id: If657c7c7d3cd1ce01e9d9ad79eb6b2110230c0f9
Reviewed-on: https://go-review.googlesource.com/13267Reviewed-by: Todd Neal <todd@tneal.org>
Reviewed-by: Keith Randall <khr@golang.org>

ca088cf4

[dev.ssa] cmd/compile/internal/ssa: more checks on ssa structure · cfd8dfaa

Keith Randall authored Aug 04, 2015

Make sure all referenced Blocks and Values are really there.
Fix deadcode to generate SSA graphs that pass this new test.

Change-Id: Ib002ce20e33490eb8c919bd189d209f769d61517
Reviewed-on: https://go-review.googlesource.com/13147Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>

cfd8dfaa

[dev.ssa] cmd/compile: enforce that all phis are first during regalloc · ddeee0ee

Josh Bleecher Snyder authored Aug 05, 2015

Change-Id: I035708f5d0659b3deef00808d35e1cc8a80215e0
Reviewed-on: https://go-review.googlesource.com/13243Reviewed-by: Keith Randall <khr@golang.org>

ddeee0ee

[dev.ssa] cmd/compile: schedule phi control values first · f1401f1a

Josh Bleecher Snyder authored Aug 05, 2015

Change-Id: I684440dc316625d5572cc12179adbc206e306429
Reviewed-on: https://go-review.googlesource.com/13263Reviewed-by: Keith Randall <khr@golang.org>

f1401f1a

[dev.ssa] cmd/compile: tidy up register setup · cd0cb0a9

Josh Bleecher Snyder authored Aug 06, 2015

No functional changes.
The intent is just to make this
easier to read and maintain.

Change-Id: Iec207546482cd62bcb22eaae8efe5be6c4f15378
Reviewed-on: https://go-review.googlesource.com/13284Reviewed-by: Keith Randall <khr@golang.org>

cd0cb0a9

[dev.ssa] cmd/compile: improve error message for phi location mismatch · 55845232

Josh Bleecher Snyder authored Aug 05, 2015

Change-Id: I402841743fcdc287631646039eb149f5cfdf886c
Reviewed-on: https://go-review.googlesource.com/13269Reviewed-by: Keith Randall <khr@golang.org>

55845232

[dev.ssa] cmd/compile: don't move OpSP and OpSB values · 6548b63d

Josh Bleecher Snyder authored Aug 05, 2015

regalloc expects to find all OpSP and OpSB values
in the entry block.

There is no value to moving them; don't.

Change-Id: I775198f03ce7420348721ffc5e7d2bab065465b1
Reviewed-on: https://go-review.googlesource.com/13266Reviewed-by: Keith Randall <khr@golang.org>

6548b63d

[dev.ssa] cmd/compile: provide better errors for regnum and localOffset failures · e1395498

Josh Bleecher Snyder authored Aug 05, 2015

Change-Id: I2667b0923e17df7cbf08e34ebec1b69a0f2f02b2
Reviewed-on: https://go-review.googlesource.com/13265Reviewed-by: Keith Randall <khr@golang.org>

e1395498

[dev.ssa] cmd/compile: respect phi values in tighten · e5fe33e5

Josh Bleecher Snyder authored Aug 05, 2015

Given (say)

b1: <- b2 b3
  v1 = Phi <t> v2 v3
b2:
  v2 = ...
b3:
  ...

tighten will move v2 to b1, since it is only used in b1.

This is wrong; v2 needs to be evaluated before entering b1.
Fix it.

Change-Id: I2cc3b30e3ffd221cf594e36cec534dfd9cf3c6a7
Reviewed-on: https://go-review.googlesource.com/13264Reviewed-by: Keith Randall <khr@golang.org>

e5fe33e5

05 Aug, 2015 1 commit

[dev.ssa] cmd/compile: add SSA pass to move values closer to uses · f91ff1a5

Josh Bleecher Snyder authored Aug 04, 2015

Even this very simple, restricted initial implementation helps.

While running make.bash, it moves 84437 values
to new, closer homes.

As a concrete example:

func f_ssa(i, j int, b bool) int {
	if !b {
		return 0
	}
	return i + j
}

It cuts off one stack slot and two instructions:

Before:

"".f_ssa t=1 size=96 value=0 args=0x20 locals=0x18
	0x0000 00000 (x.go:3)	TEXT	"".f_ssa(SB), $24-32
	0x0000 00000 (x.go:3)	SUBQ	$24, SP
	0x0004 00004 (x.go:3)	FUNCDATA	$0, "".gcargs·0(SB)
	0x0004 00004 (x.go:3)	FUNCDATA	$1, "".gclocals·1(SB)
	0x0004 00004 (x.go:5)	MOVQ	$0, AX
	0x0006 00006 (x.go:3)	MOVQ	32(SP), CX
	0x000b 00011 (x.go:3)	MOVQ	40(SP), DX
	0x0010 00016 (x.go:3)	LEAQ	48(SP), BX
	0x0015 00021 (x.go:3)	MOVB	(BX), BPB
	0x0018 00024 (x.go:3)	MOVQ	$0, SI
	0x001a 00026 (x.go:3)	MOVQ	SI, 56(SP)
	0x001f 00031 (x.go:3)	TESTB	BPB, BPB
	0x0022 00034 (x.go:5)	MOVQ	AX, (SP)
	0x0026 00038 (x.go:3)	MOVQ	CX, 8(SP)
	0x002b 00043 (x.go:3)	MOVQ	DX, 16(SP)
	0x0030 00048 (x.go:4)	JEQ	74
	0x0032 00050 (x.go:3)	MOVQ	8(SP), AX
	0x0037 00055 (x.go:3)	MOVQ	16(SP), CX
	0x003c 00060 (x.go:7)	LEAQ	(AX)(CX*1), DX
	0x0040 00064 (x.go:7)	MOVQ	DX, 56(SP)
	0x0045 00069 (x.go:3)	ADDQ	$24, SP
	0x0049 00073 (x.go:3)	RET
	0x004a 00074 (x.go:5)	MOVQ	(SP), AX
	0x004e 00078 (x.go:5)	MOVQ	AX, 56(SP)
	0x0053 00083 (x.go:3)	JMP	69

After:

"".f_ssa t=1 size=80 value=0 args=0x20 locals=0x10
	0x0000 00000 (x.go:3)	TEXT	"".f_ssa(SB), $16-32
	0x0000 00000 (x.go:3)	SUBQ	$16, SP
	0x0004 00004 (x.go:3)	FUNCDATA	$0, "".gcargs·0(SB)
	0x0004 00004 (x.go:3)	FUNCDATA	$1, "".gclocals·1(SB)
	0x0004 00004 (x.go:3)	MOVQ	32(SP), AX
	0x0009 00009 (x.go:3)	MOVQ	24(SP), CX
	0x000e 00014 (x.go:3)	LEAQ	40(SP), DX
	0x0013 00019 (x.go:3)	MOVB	(DX), BL
	0x0015 00021 (x.go:3)	MOVQ	$0, BP
	0x0017 00023 (x.go:3)	MOVQ	BP, 48(SP)
	0x001c 00028 (x.go:3)	TESTB	BL, BL
	0x001e 00030 (x.go:3)	MOVQ	AX, (SP)
	0x0022 00034 (x.go:3)	MOVQ	CX, 8(SP)
	0x0027 00039 (x.go:4)	JEQ	64
	0x0029 00041 (x.go:3)	MOVQ	8(SP), AX
	0x002e 00046 (x.go:3)	MOVQ	(SP), CX
	0x0032 00050 (x.go:7)	LEAQ	(AX)(CX*1), DX
	0x0036 00054 (x.go:7)	MOVQ	DX, 48(SP)
	0x003b 00059 (x.go:3)	ADDQ	$16, SP
	0x003f 00063 (x.go:3)	RET
	0x0040 00064 (x.go:5)	MOVQ	$0, AX
	0x0042 00066 (x.go:5)	MOVQ	AX, 48(SP)
	0x0047 00071 (x.go:3)	JMP	59

Of course, the old backend is still well ahead:

"".f_ssa t=1 size=48 value=0 args=0x20 locals=0x0
	0x0000 00000 (x.go:3)	TEXT	"".f_ssa(SB), $0-32
	0x0000 00000 (x.go:3)	NOP
	0x0000 00000 (x.go:3)	NOP
	0x0000 00000 (x.go:3)	FUNCDATA	$0, gclocals·a8eabfc4a4514ed6b3b0c61e9680e440(SB)
	0x0000 00000 (x.go:3)	FUNCDATA	$1, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
	0x0000 00000 (x.go:4)	CMPB	"".b+24(FP), $0
	0x0005 00005 (x.go:4)	JNE	17
	0x0007 00007 (x.go:5)	MOVQ	$0, "".~r3+32(FP)
	0x0010 00016 (x.go:5)	RET
	0x0011 00017 (x.go:7)	MOVQ	"".i+8(FP), BX
	0x0016 00022 (x.go:7)	MOVQ	"".j+16(FP), BP
	0x001b 00027 (x.go:7)	ADDQ	BP, BX
	0x001e 00030 (x.go:7)	MOVQ	BX, "".~r3+32(FP)
	0x0023 00035 (x.go:7)	RET

Some regalloc improvements should help considerably.

Change-Id: I95bb5dd83e56afd70ae4e983f1d32dffd0c3d46a
Reviewed-on: https://go-review.googlesource.com/13142Reviewed-by: Keith Randall <khr@golang.org>

f91ff1a5

04 Aug, 2015 1 commit

[dev.ssa] cmd/compile/internal/ssa: implement ITAB · d1c15a0e

Keith Randall authored Aug 04, 2015

Implement ITAB, selecting the itable field of an interface.

Soften the lowering check to allow lowerings that leave
generic but dead ops behind. (The ITAB lowering does this.)

Change-Id: Icc84961dd4060d143602f001311aa1d8be0d7fc0
Reviewed-on: https://go-review.googlesource.com/13144Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>

d1c15a0e