[turbofan] Add FixedArray peephole optimizations to CodeStubAssembler

[turbofan] Add FixedArray peephole optimizations to CodeStubAssembler

Previously, CodeStubAssembler macros performing FixedArray element accesses had
to compute offsets to elements explicitly with a fair amount of duplicated
code. Furthermore, any peephole optimizations that could produce better code--
like recognizing constant indices or combining array index computation with Smi
untagging--were also duplicated.

This change factors the code to compute FixedArray index offsets into a common
routine in the CodeStubAssembler that applies standard peephole optimizations to
all accesses. In order to do this, it also introduces limited introspection into
the up-until-now opaque Node* type exported from code-assembler.h, allowing
Nodes to be queried whether they are constant and extracting their constant
value in that case.

Committed: https://crrev.com/cbdb373804585d18351e9b5c25a1cad33a4058c7
Cr-Commit-Position: refs/heads/master@{#36370}

[danno, 2016-05-19 09:38:05]

Description was changed from

==========
[turbofan] Add array peephole optimizations to CodeStubAssembler

Previously, CodeStubAssembler macros performing FixedArray element accesses had
to compute offsets to elements explicitly with a fair amount of duplicated
code. Furthermore, any peephole optimizations that could produce better code--
like recognizing constant indices or combining array index computation with Smi
untagging--were also duplicated.

This change factors the code to compute FixedArray index offsets into a common
routine in the CodeStubAssembler that applies standard peephole optimizations to
all accesses. In order to do this, it also introduces limited introspection into
the up-until-now opaque Node* type exported from code-assembler.h, allowing
Nodes to be queried whether they are constant and extracting their constant
value in that case.
==========

to

==========
[turbofan] Add FixedArray peephole optimizations to CodeStubAssembler

Previously, CodeStubAssembler macros performing FixedArray element accesses had
to compute offsets to elements explicitly with a fair amount of duplicated
code. Furthermore, any peephole optimizations that could produce better code--
like recognizing constant indices or combining array index computation with Smi
untagging--were also duplicated.

This change factors the code to compute FixedArray index offsets into a common
routine in the CodeStubAssembler that applies standard peephole optimizations to
all accesses. In order to do this, it also introduces limited introspection into
the up-until-now opaque Node* type exported from code-assembler.h, allowing
Nodes to be queried whether they are constant and extracting their constant
value in that case.
==========

[danno, 2016-05-19 09:38:51]

danno@chromium.org changed reviewers:
+ mstarzinger@chromium.org

[danno, 2016-05-19 09:38:52]

PTAL

[Michael Starzinger, 2016-05-19 10:54:21]

https://codereview.chromium.org/1989363004/diff/40001/src/compiler/code-assem...
File src/compiler/code-assembler.cc (right):

https://codereview.chromium.org/1989363004/diff/40001/src/compiler/code-assem...
src/compiler/code-assembler.cc:131: if (node->opcode() ==
IrOpcode::kInt32Constant) {
Can we use an Int32Matcher to do this kind of matching?

https://codereview.chromium.org/1989363004/diff/40001/src/compiler/code-assem...
src/compiler/code-assembler.cc:136: if (node->opcode() ==
IrOpcode::kInt64Constant) {
Can we use an Int64Matcher (and the IsInRange method) here?

https://codereview.chromium.org/1989363004/diff/40001/src/compiler/code-assem...
src/compiler/code-assembler.cc:149: if (node->opcode() ==
IrOpcode::kInt32Constant) {
Can we use an Int64Matcher to do this kind of matching?

Int64Matcher m(node);
if (m.HasValue()) out_value = m.Value();
return m.HasValue();

https://codereview.chromium.org/1989363004/diff/40001/src/compiler/code-assem...
src/compiler/code-assembler.cc:161: if (kPointerSize == 8) {
Can we use an IntPtrMatcher to do this kind of matching?

[danno, 2016-05-19 11:10:18]

thanks for the feedback, great suggestions. please take another look.

https://codereview.chromium.org/1989363004/diff/40001/src/compiler/code-assem...
File src/compiler/code-assembler.cc (right):

https://codereview.chromium.org/1989363004/diff/40001/src/compiler/code-assem...
src/compiler/code-assembler.cc:131: if (node->opcode() ==
IrOpcode::kInt32Constant) {
On 2016/05/19 10:54:21, Michael Starzinger wrote:
> Can we use an Int32Matcher to do this kind of matching?

Done.

https://codereview.chromium.org/1989363004/diff/40001/src/compiler/code-assem...
src/compiler/code-assembler.cc:136: if (node->opcode() ==
IrOpcode::kInt64Constant) {
On 2016/05/19 10:54:21, Michael Starzinger wrote:
> Can we use an Int64Matcher (and the IsInRange method) here?

Done.

https://codereview.chromium.org/1989363004/diff/40001/src/compiler/code-assem...
src/compiler/code-assembler.cc:149: if (node->opcode() ==
IrOpcode::kInt32Constant) {
On 2016/05/19 10:54:21, Michael Starzinger wrote:
> Can we use an Int64Matcher to do this kind of matching?
> 
> Int64Matcher m(node);
> if (m.HasValue()) out_value = m.Value();
> return m.HasValue();

Done.

https://codereview.chromium.org/1989363004/diff/40001/src/compiler/code-assem...
src/compiler/code-assembler.cc:161: if (kPointerSize == 8) {
On 2016/05/19 10:54:21, Michael Starzinger wrote:
> Can we use an IntPtrMatcher to do this kind of matching?

Done.

[Michael Starzinger, 2016-05-19 11:19:17]

LGTM. Just nits left.

https://codereview.chromium.org/1989363004/diff/60001/src/code-stub-assembler.cc
File src/code-stub-assembler.cc (right):

https://codereview.chromium.org/1989363004/diff/60001/src/code-stub-assembler...
src/code-stub-assembler.cc:249: constant_value <= Smi::kMaxValue);
nit: DCHECK(Smi::IsValid(constant_value))

https://codereview.chromium.org/1989363004/diff/60001/src/code-stub-assembler...
src/code-stub-assembler.cc:1526: intptr_t temp;
nit: Better initialize "temp" here, because it is used unconditionally two lines
below. I am sure some compilers out there will get unhappy about this.

[danno, 2016-05-19 14:25:49]

Thanks for the feedback, which I addressed. Landing.

https://codereview.chromium.org/1989363004/diff/60001/src/code-stub-assembler.cc
File src/code-stub-assembler.cc (right):

https://codereview.chromium.org/1989363004/diff/60001/src/code-stub-assembler...
src/code-stub-assembler.cc:249: constant_value <= Smi::kMaxValue);
On 2016/05/19 11:19:17, Michael Starzinger wrote:
> nit: DCHECK(Smi::IsValid(constant_value))

Done.

https://codereview.chromium.org/1989363004/diff/60001/src/code-stub-assembler...
src/code-stub-assembler.cc:1526: intptr_t temp;
On 2016/05/19 11:19:17, Michael Starzinger wrote:
> nit: Better initialize "temp" here, because it is used unconditionally two
lines
> below. I am sure some compilers out there will get unhappy about this.

Done.

[danno, 2016-05-19 14:25:54]

The CQ bit was checked by danno@chromium.org

[danno, 2016-05-19 14:25:55]

The patchset sent to the CQ was uploaded after l-g-t-m from
mstarzinger@chromium.org
Link to the patchset: https://codereview.chromium.org/1989363004/#ps120001
(title: "Final review feedback")

[commit-bot: I haz the power, 2016-05-19 14:26:00]

CQ is trying da patch. Follow status at
 https://chromium-cq-status.appspot.com/patch-status/1989363004/120001
View timeline at
 https://chromium-cq-status.appspot.com/patch-timeline/1989363004/120001

[commit-bot: I haz the power, 2016-05-19 15:49:10]

Description was changed from

==========
[turbofan] Add FixedArray peephole optimizations to CodeStubAssembler

Previously, CodeStubAssembler macros performing FixedArray element accesses had
to compute offsets to elements explicitly with a fair amount of duplicated
code. Furthermore, any peephole optimizations that could produce better code--
like recognizing constant indices or combining array index computation with Smi
untagging--were also duplicated.

This change factors the code to compute FixedArray index offsets into a common
routine in the CodeStubAssembler that applies standard peephole optimizations to
all accesses. In order to do this, it also introduces limited introspection into
the up-until-now opaque Node* type exported from code-assembler.h, allowing
Nodes to be queried whether they are constant and extracting their constant
value in that case.
==========

to

==========
[turbofan] Add FixedArray peephole optimizations to CodeStubAssembler

Previously, CodeStubAssembler macros performing FixedArray element accesses had
to compute offsets to elements explicitly with a fair amount of duplicated
code. Furthermore, any peephole optimizations that could produce better code--
like recognizing constant indices or combining array index computation with Smi
untagging--were also duplicated.

This change factors the code to compute FixedArray index offsets into a common
routine in the CodeStubAssembler that applies standard peephole optimizations to
all accesses. In order to do this, it also introduces limited introspection into
the up-until-now opaque Node* type exported from code-assembler.h, allowing
Nodes to be queried whether they are constant and extracting their constant
value in that case.
==========

[commit-bot: I haz the power, 2016-05-19 15:49:10]

Committed patchset #7 (id:120001)

[commit-bot: I haz the power, 2016-05-19 15:50:43]

Description was changed from

==========
[turbofan] Add FixedArray peephole optimizations to CodeStubAssembler

Previously, CodeStubAssembler macros performing FixedArray element accesses had
to compute offsets to elements explicitly with a fair amount of duplicated
code. Furthermore, any peephole optimizations that could produce better code--
like recognizing constant indices or combining array index computation with Smi
untagging--were also duplicated.

This change factors the code to compute FixedArray index offsets into a common
routine in the CodeStubAssembler that applies standard peephole optimizations to
all accesses. In order to do this, it also introduces limited introspection into
the up-until-now opaque Node* type exported from code-assembler.h, allowing
Nodes to be queried whether they are constant and extracting their constant
value in that case.
==========

to

==========
[turbofan] Add FixedArray peephole optimizations to CodeStubAssembler

Previously, CodeStubAssembler macros performing FixedArray element accesses had
to compute offsets to elements explicitly with a fair amount of duplicated
code. Furthermore, any peephole optimizations that could produce better code--
like recognizing constant indices or combining array index computation with Smi
untagging--were also duplicated.

This change factors the code to compute FixedArray index offsets into a common
routine in the CodeStubAssembler that applies standard peephole optimizations to
all accesses. In order to do this, it also introduces limited introspection into
the up-until-now opaque Node* type exported from code-assembler.h, allowing
Nodes to be queried whether they are constant and extracting their constant
value in that case.

Committed: https://crrev.com/cbdb373804585d18351e9b5c25a1cad33a4058c7
Cr-Commit-Position: refs/heads/master@{#36370}
==========

[commit-bot: I haz the power, 2016-05-19 15:50:44]

Patchset 7 (id:??) landed as
https://crrev.com/cbdb373804585d18351e9b5c25a1cad33a4058c7
Cr-Commit-Position: refs/heads/master@{#36370}