[turbofan] Ensure monotonicity for induction variable typing.

[turbofan] Ensure monotonicity for induction variable typing.

The trouble here is that the type of the induction variable might be
a bit ahead of the increment (JSAdd) operation's type. When we update
the type of the increment, we might only update the induction variable
type while the JSAdd type might be stale. If the induction variable typing
needs to fall back to normal phi typing (e.g., when the increment is not
an integer anymore), it might use the stale type.

To get around this, we fake monotonicity if we fallback to normal phi
typing. Another option would be to force re-typing of the increment
operation, but that seems to be harder to maintain.

BUG=chromium:644633
Committed: https://crrev.com/b4f8a7c9006fb99f17217027e56d8e8113193636
Cr-Commit-Position: refs/heads/master@{#39261}

[Jarin, 2016-09-07 19:11:10]

Description was changed from

==========
[turbofan] Ensure monotonicity for induction variable typing.
==========

to

==========
[turbofan] Ensure monotonicity for induction variable typing.

The trouble here is that the type of the induction variable might be
a bit ahead of the increment (JSAdd) operation's type. When we update the type
of the increment, we might only update the induction variable
type while the JSAdd type might be stale. If the induction variable typing
needs to fall back to normal phi typing (e.g., when the increment is not
an integer anymore), it might use the stale type.

To get around this, we fake monotonicity if we fallback to normal phi
typing. Another option would be to force re-typing of the increment
operation, but that seems to be harder to maintain.

BUG=chromium:644633
==========

[Jarin, 2016-09-07 19:11:25]

Description was changed from

==========
[turbofan] Ensure monotonicity for induction variable typing.

The trouble here is that the type of the induction variable might be
a bit ahead of the increment (JSAdd) operation's type. When we update the type
of the increment, we might only update the induction variable
type while the JSAdd type might be stale. If the induction variable typing
needs to fall back to normal phi typing (e.g., when the increment is not
an integer anymore), it might use the stale type.

To get around this, we fake monotonicity if we fallback to normal phi
typing. Another option would be to force re-typing of the increment
operation, but that seems to be harder to maintain.

BUG=chromium:644633
==========

to

==========
[turbofan] Ensure monotonicity for induction variable typing.

The trouble here is that the type of the induction variable might be
a bit ahead of the increment (JSAdd) operation's type. When we update 
the type of the increment, we might only update the induction variable
type while the JSAdd type might be stale. If the induction variable typing
needs to fall back to normal phi typing (e.g., when the increment is not
an integer anymore), it might use the stale type.

To get around this, we fake monotonicity if we fallback to normal phi
typing. Another option would be to force re-typing of the increment
operation, but that seems to be harder to maintain.

BUG=chromium:644633
==========

[Jarin, 2016-09-07 19:11:59]

The CQ bit was checked by jarin@chromium.org to run a CQ dry run

[commit-bot: I haz the power, 2016-09-07 19:12:05]

Dry run: CQ is trying da patch. Follow status at
 
https://chromium-cq-status.appspot.com/v2/patch-status/codereview.chromium.or...

[Jarin, 2016-09-07 19:37:08]

jarin@chromium.org changed reviewers:
+ bmeurer@chromium.org, mstarzinger@chromium.org

[Jarin, 2016-09-07 19:37:09]

Could you take a look, please?

[commit-bot: I haz the power, 2016-09-07 19:43:01]

The CQ bit was unchecked by commit-bot@chromium.org

[commit-bot: I haz the power, 2016-09-07 19:43:02]

Dry run: This issue passed the CQ dry run.

[Benedikt Meurer, 2016-09-08 03:48:58]

LGTM, thanks.

[Benedikt Meurer, 2016-09-08 03:49:03]

The CQ bit was checked by bmeurer@chromium.org

[commit-bot: I haz the power, 2016-09-08 03:49:09]

CQ is trying da patch. Follow status at
 
https://chromium-cq-status.appspot.com/v2/patch-status/codereview.chromium.or...

[commit-bot: I haz the power, 2016-09-08 03:50:51]

Description was changed from

==========
[turbofan] Ensure monotonicity for induction variable typing.

The trouble here is that the type of the induction variable might be
a bit ahead of the increment (JSAdd) operation's type. When we update 
the type of the increment, we might only update the induction variable
type while the JSAdd type might be stale. If the induction variable typing
needs to fall back to normal phi typing (e.g., when the increment is not
an integer anymore), it might use the stale type.

To get around this, we fake monotonicity if we fallback to normal phi
typing. Another option would be to force re-typing of the increment
operation, but that seems to be harder to maintain.

BUG=chromium:644633
==========

to

==========
[turbofan] Ensure monotonicity for induction variable typing.

The trouble here is that the type of the induction variable might be
a bit ahead of the increment (JSAdd) operation's type. When we update 
the type of the increment, we might only update the induction variable
type while the JSAdd type might be stale. If the induction variable typing
needs to fall back to normal phi typing (e.g., when the increment is not
an integer anymore), it might use the stale type.

To get around this, we fake monotonicity if we fallback to normal phi
typing. Another option would be to force re-typing of the increment
operation, but that seems to be harder to maintain.

BUG=chromium:644633
==========

[commit-bot: I haz the power, 2016-09-08 03:50:52]

Committed patchset #2 (id:20001)

[commit-bot: I haz the power, 2016-09-08 03:51:18]

Description was changed from

==========
[turbofan] Ensure monotonicity for induction variable typing.

The trouble here is that the type of the induction variable might be
a bit ahead of the increment (JSAdd) operation's type. When we update 
the type of the increment, we might only update the induction variable
type while the JSAdd type might be stale. If the induction variable typing
needs to fall back to normal phi typing (e.g., when the increment is not
an integer anymore), it might use the stale type.

To get around this, we fake monotonicity if we fallback to normal phi
typing. Another option would be to force re-typing of the increment
operation, but that seems to be harder to maintain.

BUG=chromium:644633
==========

to

==========
[turbofan] Ensure monotonicity for induction variable typing.

The trouble here is that the type of the induction variable might be
a bit ahead of the increment (JSAdd) operation's type. When we update
the type of the increment, we might only update the induction variable
type while the JSAdd type might be stale. If the induction variable typing
needs to fall back to normal phi typing (e.g., when the increment is not
an integer anymore), it might use the stale type.

To get around this, we fake monotonicity if we fallback to normal phi
typing. Another option would be to force re-typing of the increment
operation, but that seems to be harder to maintain.

BUG=chromium:644633

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

[commit-bot: I haz the power, 2016-09-08 03:51:19]

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