qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-19 15:05:00 -07:00
Code Releases Activity

cmd/compile: teach front-end deadcode about && and ||

Browse Source 
The front-end dead code elimination is very simple. Currently, it just
looks for if statements with constant boolean conditions. Its main
purpose is to reduce load on the compiler and shrink code before
inlining computes hairiness.

This CL teaches front-end dead code elimination about short-circuiting
boolean expressions && and ||, since they're essentially the same as
if statements.

This also teaches the inliner that the constant 'if' form left behind
by deadcode is free.

These changes will help with runtime modifications in the next CL that
would otherwise inhibit inlining in some hot code paths. Currently,
however, they have no significant impact on benchmarks.

Change-Id: I886203b3c4acdbfef08148fddd7f3a7af5afc7c1
Reviewed-on: https://go-review.googlesource.com/96778
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
This commit is contained in:
Austin Clements 2018-02-22 19:58:59 -05:00
parent 33b76920ec
commit 2dbf15e88e
2 changed files with 43 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/cmd/compile/internal/gc/inl.go
View File

@ -344,6 +344,12 @@ func (v *hairyVisitor) visit(n *Node) bool {
case ODCLCONST, OEMPTY, OFALL, OLABEL: case ODCLCONST, OEMPTY, OFALL, OLABEL:
// These nodes don't produce code; omit from inlining budget. // These nodes don't produce code; omit from inlining budget.
return false return false
case OIF:
if Isconst(n.Left, CTBOOL) {
// This if and the condition cost nothing.
return v.visitList(n.Nbody) || v.visitList(n.Rlist)
}
} }
v.budget-- v.budget--

42
src/cmd/compile/internal/gc/typecheck.go
View File

@ -3919,11 +3919,14 @@ func deadcodeslice(nn Nodes) {
if n == nil { if n == nil {
continue continue
} }
if n.Op == OIF && Isconst(n.Left, CTBOOL) { if n.Op == OIF {
if n.Left.Bool() { n.Left = deadcodeexpr(n.Left)
n.Rlist = Nodes{} if Isconst(n.Left, CTBOOL) {
} else { if n.Left.Bool() {
n.Nbody = Nodes{} n.Rlist = Nodes{}
} else {
n.Nbody = Nodes{}
}
} }
} }
deadcodeslice(n.Ninit) deadcodeslice(n.Ninit)
@ -3932,3 +3935,32 @@ func deadcodeslice(nn Nodes) {
deadcodeslice(n.Rlist) deadcodeslice(n.Rlist)
} }
} }
func deadcodeexpr(n *Node) *Node {
// Perform dead-code elimination on short-circuited boolean
// expressions involving constants with the intent of
// producing a constant 'if' condition.
switch n.Op {
case OANDAND:
n.Left = deadcodeexpr(n.Left)
n.Right = deadcodeexpr(n.Right)
if Isconst(n.Left, CTBOOL) {
if n.Left.Bool() {
return n.Right // true && x => x
} else {
return n.Left // false && x => false
}
}
case OOROR:
n.Left = deadcodeexpr(n.Left)
n.Right = deadcodeexpr(n.Right)
if Isconst(n.Left, CTBOOL) {
if n.Left.Bool() {
return n.Left // true || x => true
} else {
return n.Right // false || x => x
}
}
}
return n
}