The Lengauer-Tarjan dominator/dominance frontier algorithm needs to
visit the blocks in reverse preorder (in the first pass) and preorder
(in the second). Compute that at the same time as postorder (e.g.,
using the same spanning tree).
Take this chance to make the flow graph visitors always operate on a
forward block ordering.
R=srdjan@google.com
BUG=
TEST=
Review URL: https://chromiumcodereview.appspot.com//9719003
git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@5598 260f80e4-7a28-3924-810f-c04153c831b5
and the constructor case, as suggested in my review of
https://chromiumcodereview.appspot.com/9700003/
Examples of generated IL (first factory, second non-factory).
foo() { return new List<T>(); }
moo() { return new A<T>(); }
==== file:///home/regis/test.dart_A_foo
0: [target]
t0 <- LoadLocal(this)
t0 <- NativeLoadField(t0, 16)
t0 <- ExtractFactoryTypeArguments(t0)
t0 <- StaticCall(List., t0)
return t0
==== file:///home/regis/test.dart_A_moo
0: [target]
t0 <- #null
t1 <- LoadLocal(this)
t1 <- NativeLoadField(t1, 16)
t2 <- Pick(t1)
t2 <- ExtractConstructorTypeArguments(t2)
t0 := t2
t1 <- ExtractConstructorInstantiator(t1, t2)
t0 <- AllocateObject(Library:'file:///home/regis/test.dart' Class: A, t0, t1)
t1 <- Pick(t0)
t2 <- #3
StaticCall(A., t1, t2)
return t0
This change removes the computation that previously returned two values at the
cost of a some small code duplication. We could address this duplication by
exposing the computation recognizing the identity vector at the IL level and
implement a branch.
Review URL: https://chromiumcodereview.appspot.com//9703080
git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@5537 260f80e4-7a28-3924-810f-c04153c831b5
Chosen because of its wartiness. A pair of new computations are introduced
to allow the IL to express duplication of temporaries and storing to
temporaries. These will be translated away by the optimizing compiler, but
allow the instruction stream to represent exactly the deoptimization state
we are intereseted in (with at most one deopt point per instruction).
Translation of:
test(a, i) {
return a[i]++;
}
is
0: [target]
t0 <-#0
t1 <-LoadLocal(a)
t2 <-LoadLocal(i)
t3 <-CopyTemp(-1)
t4 <-CopyTemp(-1)
t3 <-InstanceCall([], t3, t4)
SetTemp(-3)
t4 <-#1
t3 <-InstanceCall(+, t3, t4)
InstanceCall([]=, t1, t2, t3)
return t0
R=srdjan@google.com
BUG=
TEST=
Review URL: https://chromiumcodereview.appspot.com//9601011
git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@5012 260f80e4-7a28-3924-810f-c04153c831b5
Implement a simple compilation visitor for the intermediate language. Copy
code from the x64 code generator to support compilation of functions with no
arguments, no locals, and that return a literal.
Compiled code is not used, but it can be disassembled and visually checked
against the code from the old code generator.
R=srdjan@google.com
BUG=
TEST=expected to pass all tests on x64
Review URL: https://chromiumcodereview.appspot.com//9464009
git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@4601 260f80e4-7a28-3924-810f-c04153c831b5
This keeps the IL simple for the benefit of the optimizing compiler.
It intentionally relies on a particular temporary allocation strategy
for the non-optimizing compiler.
For the dart function
main() {
var x = 2;
hukairs(1, x, 3);
}
The flow graph is:
0: [target]
StoreLocal(x, #2)
t0 <-#1
t1 <-LoadLocal(x)
t2 <-#3
StaticCall(hukairs, t0, t1, t2)
return #null
R=srdjan@google.com
BUG=
TEST=
Review URL: https://chromiumcodereview.appspot.com//9463007
git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@4600 260f80e4-7a28-3924-810f-c04153c831b5
Also, instead of keeping a list of all instructions, keep a list of only
block entries. The printing implementation is changed (for the better) to
use the new representation. With --use_new_compiler and --print_flow_graph
the function:
main() {
var f = 1;
var n = 5;
while (n > 0) {
f = f * n;
n = n - 1;
}
print(f);
}
prints as:
0: [target]
StoreLocal(f, #1)
StoreLocal(n, #5) goto 1
1: [join]
t0 <-LoadLocal(n)
t0 <-InstanceCall(>, t0, #0)
if t0 goto(2, 3)
2: [target]
t0 <-LoadLocal(f)
t1 <-LoadLocal(n)
t0 <-InstanceCall(*, t0, t1)
StoreLocal(f, t0)
t0 <-LoadLocal(n)
t0 <-InstanceCall(-, t0, #1)
StoreLocal(n, t0) goto 1
3: [target]
t0 <-LoadLocal(f)
StaticCall(print, t0)
return #null
R=srdjan@google.com
BUG=
TEST=
Review URL: https://chromiumcodereview.appspot.com//9429056
git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@4515 260f80e4-7a28-3924-810f-c04153c831b5
regis@google.com