ShiftAmountsAllowReplaceByRotate Extension

In the case of shift amounts with two constants and if their sum is equal 32, then shift can also be replaced with bit rotate.

R=svenpanne@chromium.org

Committed: http://code.google.com/p/v8/source/detail?r=16735

[Sven Panne, 2013-09-13 12:54:49]

Can we have an explicit test case for this?

[Bangfu, 2013-09-16 13:32:06]

On 2013/09/13 12:54:49, Sven Panne wrote:
> Can we have an explicit test case for this?

test case added, thank you for review.

[Sven Panne, 2013-09-16 13:39:54]

LGTM, although it would be nice to know if there is some real-world example
which benefits from this or if there is some follow-up CL building on this.

Landing this for you...

[Sven Panne, 2013-09-16 13:51:48]

Committed patchset #2 manually as r16735.

[Bangfu, 2013-09-16 14:54:24]

On 2013/09/16 13:51:48, Sven Panne wrote:
> Committed patchset #2 manually as r16735.

for example:

var b = 0x1234;
function rol(num, cnt)
{
  return (num << cnt) | (num >>> (32 - cnt));
}
var c;
for(var i = 0; i < 1000; i++)
{
  c = rol(b, 30);
}

In the above example, V8 compiler would replace cnt and (32-cnt) with two
constants operands if function rol() is inlined during optimization. Therefore,
the old logic failed to detect it's a rotation.

[Sven Panne, 2013-09-17 05:58:31]

On 2013/09/16 14:54:24, Bangfu wrote:
> On 2013/09/16 13:51:48, Sven Panne wrote:
> > Committed patchset #2 manually as r16735.
> 
> for example:
> 
> var b = 0x1234;
> function rol(num, cnt)
> {
>   return (num << cnt) | (num >>> (32 - cnt));
> }
> var c;
> for(var i = 0; i < 1000; i++)
> {
>   c = rol(b, 30);
> }
> 
> In the above example, V8 compiler would replace cnt and (32-cnt) with two
> constants operands if function rol() is inlined during optimization.
Therefore,
> the old logic failed to detect it's a rotation.

Well, that's a nano-benchmark again, we would be interested in something
non-synthetic: Is there a real-world application or some other motivation for
this patch?

[Bangfu, 2013-09-17 07:27:32]

On 2013/09/17 05:58:31, Sven Panne wrote:
> On 2013/09/16 14:54:24, Bangfu wrote:
> > On 2013/09/16 13:51:48, Sven Panne wrote:
> > > Committed patchset #2 manually as r16735.
> > 
> > for example:
> > 
> > var b = 0x1234;
> > function rol(num, cnt)
> > {
> >   return (num << cnt) | (num >>> (32 - cnt));
> > }
> > var c;
> > for(var i = 0; i < 1000; i++)
> > {
> >   c = rol(b, 30);
> > }
> > 
> > In the above example, V8 compiler would replace cnt and (32-cnt) with two
> > constants operands if function rol() is inlined during optimization.
> Therefore,
> > the old logic failed to detect it's a rotation.
> 
> Well, that's a nano-benchmark again, we would be interested in something
> non-synthetic: Is there a real-world application or some other motivation for
> this patch?

The motivations are:
1. To improve current function working properly without adding extra complexity.
2. Rotation is often used in encryption application such as, secure hash
algorithm. Rotation is much faster than "two shifts OR".   
Thanks.