[turbofan] Byte and word memory operands in x64 cmp/test. Fixes arithmetic_op_8 in assembler-x64.cc

[turbofan] Byte and word memory operands in x64 cmp/test. Fixes arithmetic_op_8 in assembler-x64.cc

Currently, if the size of two cmp or test operands is a byte or a word, we sign-extend or zero-extend each of them into a 32-bit register before doing the comparison, even when the conditions for the use of a memory operand are met.

This CL makes it possible to load only one of them into a register and address the other as a memory operand.

Meanwhile, comparisons between Uint8 values in the string relational comparison stubs are done with Uint32LessThan (previously we were always zero-extending the byte to a 32-bit value, so signed comparison was alright).

Found that Assembler::arithmetic_op_8(byte, Register, const Operand&) wasn't taking the Operand's rex_ field into account, so I fixed that too.

BUG=

Committed: https://crrev.com/165b68e227cebe664c9bb8d1faf9357ce22d0a0f
Cr-Commit-Position: refs/heads/master@{#34862}

[epertoso, 2016-03-10 15:23:34]

epertoso@chromium.org changed reviewers:
+ jarin@chromium.org

[epertoso, 2016-03-10 15:26:01]

I'll port this to ia32 if you think it's OK.

[Jarin, 2016-03-14 14:54:09]

lgtm with a nit.

https://codereview.chromium.org/1780193003/diff/20001/src/compiler/x64/instru...
File src/compiler/x64/instruction-selector-x64.cc (right):

https://codereview.chromium.org/1780193003/diff/20001/src/compiler/x64/instru...
src/compiler/x64/instruction-selector-x64.cc:1437: if (left->opcode() !=
IrOpcode::kLoad || right->opcode() != IrOpcode::kLoad) {
Could you add a comment explaining why you only consider loads?

[epertoso, 2016-03-15 14:38:40]

The CQ bit was checked by epertoso@chromium.org

[epertoso, 2016-03-15 14:38:41]

The patchset sent to the CQ was uploaded after l-g-t-m from jarin@chromium.org
Link to the patchset: https://codereview.chromium.org/1780193003/#ps40001
(title: "Update.")

[commit-bot: I haz the power, 2016-03-15 14:38:43]

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

[epertoso, 2016-03-15 14:38:46]

https://codereview.chromium.org/1780193003/diff/20001/src/compiler/x64/instru...
File src/compiler/x64/instruction-selector-x64.cc (right):

https://codereview.chromium.org/1780193003/diff/20001/src/compiler/x64/instru...
src/compiler/x64/instruction-selector-x64.cc:1437: if (left->opcode() !=
IrOpcode::kLoad || right->opcode() != IrOpcode::kLoad) {
On 2016/03/14 at 14:54:08, Jarin wrote:
> Could you add a comment explaining why you only consider loads?

Done.

[commit-bot: I haz the power, 2016-03-15 14:54:10]

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

[commit-bot: I haz the power, 2016-03-15 14:54:11]

Try jobs failed on following builders:
  v8_linux64_avx2_rel on tryserver.v8 (JOB_FAILED,
http://build.chromium.org/p/tryserver.v8/builders/v8_linux64_avx2_rel/builds/...)

[epertoso, 2016-03-17 13:56:03]

Description was changed from

==========
[turbofan] Emit cmp, test with a memory operand even when the size is 8 or 16
bits.

Currently, if the size of two cmp or test operands is a byte or a word, we
sign-extend or zero-extend each of them into a 32-bit register before doing the
comparison, even when the conditions for the use of a memory operand are met.

This CL makes it possible to load only one of them into a register and address
the other as a memory operand.

BUG=
==========

to

==========
[turbofan] Byte and word memory operands in x64 cmp/test. Fixes arithmetic_op_8
in assembler-x64.cc

Currently, if the size of two cmp or test operands is a byte or a word, we
sign-extend or zero-extend each of them into a 32-bit register before doing the
comparison, even when the conditions for the use of a memory operand are met.

This CL makes it possible to load only one of them into a register and address
the other as a memory operand.

Meanwhile, comparisons between Uint8 values in the string relational comparison
stubs are done with Uint32LessThan (previously we were always zero-extending the
byte to a 32-bit value, so signed comparison was alright).

Found that Assembler::arithmetic_op_8(Register, Operand) wasn't taking the
operand rex_ field into account, so I fixed that too.

BUG=
==========

[epertoso, 2016-03-17 13:56:27]

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

[commit-bot: I haz the power, 2016-03-17 13:56:32]

Dry run: CQ is trying da patch. Follow status at
 https://chromium-cq-status.appspot.com/patch-status/1780193003/60001
View timeline at
 https://chromium-cq-status.appspot.com/patch-timeline/1780193003/60001

[Jarin, 2016-03-17 14:13:30]

lgtm. Thanks!

[commit-bot: I haz the power, 2016-03-17 14:17:31]

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

[commit-bot: I haz the power, 2016-03-17 14:17:32]

Dry run: This issue passed the CQ dry run.

[epertoso, 2016-03-17 14:21:05]

Description was changed from

==========
[turbofan] Byte and word memory operands in x64 cmp/test. Fixes arithmetic_op_8
in assembler-x64.cc

Currently, if the size of two cmp or test operands is a byte or a word, we
sign-extend or zero-extend each of them into a 32-bit register before doing the
comparison, even when the conditions for the use of a memory operand are met.

This CL makes it possible to load only one of them into a register and address
the other as a memory operand.

Meanwhile, comparisons between Uint8 values in the string relational comparison
stubs are done with Uint32LessThan (previously we were always zero-extending the
byte to a 32-bit value, so signed comparison was alright).

Found that Assembler::arithmetic_op_8(Register, Operand) wasn't taking the
operand rex_ field into account, so I fixed that too.

BUG=
==========

to

==========
[turbofan] Byte and word memory operands in x64 cmp/test. Fixes arithmetic_op_8
in assembler-x64.cc

Currently, if the size of two cmp or test operands is a byte or a word, we
sign-extend or zero-extend each of them into a 32-bit register before doing the
comparison, even when the conditions for the use of a memory operand are met.

This CL makes it possible to load only one of them into a register and address
the other as a memory operand.

Meanwhile, comparisons between Uint8 values in the string relational comparison
stubs are done with Uint32LessThan (previously we were always zero-extending the
byte to a 32-bit value, so signed comparison was alright).

Found that Assembler::arithmetic_op_8(byte, Register, const Operand&) wasn't
taking the Operand's rex_ field into account, so I fixed that too.

BUG=
==========

[epertoso, 2016-03-17 14:21:35]

The CQ bit was checked by epertoso@chromium.org

[commit-bot: I haz the power, 2016-03-17 14:21:38]

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

[commit-bot: I haz the power, 2016-03-17 14:23:16]

Description was changed from

==========
[turbofan] Byte and word memory operands in x64 cmp/test. Fixes arithmetic_op_8
in assembler-x64.cc

Currently, if the size of two cmp or test operands is a byte or a word, we
sign-extend or zero-extend each of them into a 32-bit register before doing the
comparison, even when the conditions for the use of a memory operand are met.

This CL makes it possible to load only one of them into a register and address
the other as a memory operand.

Meanwhile, comparisons between Uint8 values in the string relational comparison
stubs are done with Uint32LessThan (previously we were always zero-extending the
byte to a 32-bit value, so signed comparison was alright).

Found that Assembler::arithmetic_op_8(byte, Register, const Operand&) wasn't
taking the Operand's rex_ field into account, so I fixed that too.

BUG=
==========

to

==========
[turbofan] Byte and word memory operands in x64 cmp/test. Fixes arithmetic_op_8
in assembler-x64.cc

Currently, if the size of two cmp or test operands is a byte or a word, we
sign-extend or zero-extend each of them into a 32-bit register before doing the
comparison, even when the conditions for the use of a memory operand are met.

This CL makes it possible to load only one of them into a register and address
the other as a memory operand.

Meanwhile, comparisons between Uint8 values in the string relational comparison
stubs are done with Uint32LessThan (previously we were always zero-extending the
byte to a 32-bit value, so signed comparison was alright).

Found that Assembler::arithmetic_op_8(byte, Register, const Operand&) wasn't
taking the Operand's rex_ field into account, so I fixed that too.

BUG=
==========

[commit-bot: I haz the power, 2016-03-17 14:23:17]

Committed patchset #4 (id:60001)

[commit-bot: I haz the power, 2016-03-17 14:23:58]

Description was changed from

==========
[turbofan] Byte and word memory operands in x64 cmp/test. Fixes arithmetic_op_8
in assembler-x64.cc

Currently, if the size of two cmp or test operands is a byte or a word, we
sign-extend or zero-extend each of them into a 32-bit register before doing the
comparison, even when the conditions for the use of a memory operand are met.

This CL makes it possible to load only one of them into a register and address
the other as a memory operand.

Meanwhile, comparisons between Uint8 values in the string relational comparison
stubs are done with Uint32LessThan (previously we were always zero-extending the
byte to a 32-bit value, so signed comparison was alright).

Found that Assembler::arithmetic_op_8(byte, Register, const Operand&) wasn't
taking the Operand's rex_ field into account, so I fixed that too.

BUG=
==========

to

==========
[turbofan] Byte and word memory operands in x64 cmp/test. Fixes arithmetic_op_8
in assembler-x64.cc

Currently, if the size of two cmp or test operands is a byte or a word, we
sign-extend or zero-extend each of them into a 32-bit register before doing the
comparison, even when the conditions for the use of a memory operand are met.

This CL makes it possible to load only one of them into a register and address
the other as a memory operand.

Meanwhile, comparisons between Uint8 values in the string relational comparison
stubs are done with Uint32LessThan (previously we were always zero-extending the
byte to a 32-bit value, so signed comparison was alright).

Found that Assembler::arithmetic_op_8(byte, Register, const Operand&) wasn't
taking the Operand's rex_ field into account, so I fixed that too.

BUG=

Committed: https://crrev.com/165b68e227cebe664c9bb8d1faf9357ce22d0a0f
Cr-Commit-Position: refs/heads/master@{#34862}
==========

[commit-bot: I haz the power, 2016-03-17 14:23:59]

Patchset 4 (id:??) landed as
https://crrev.com/165b68e227cebe664c9bb8d1faf9357ce22d0a0f
Cr-Commit-Position: refs/heads/master@{#34862}