1403 // The passed offset is relative to address of the branch.
1404 // On 86 a branch displacement is calculated relative to address
1405 // of a next instruction.
1406 offset -= br_size;
1407
1408 // the short version of jmpConUCF2 contains multiple branches,
1409 // making the reach slightly less
1410 if (rule == jmpConUCF2_rule)
1411 return (-126 <= offset && offset <= 125);
1412 return (-128 <= offset && offset <= 127);
1413 }
1414
1415 const bool Matcher::isSimpleConstant64(jlong value) {
1416 // Will one (StoreL ConL) be cheaper than two (StoreI ConI)?.
1417 return false;
1418 }
1419
1420 // The ecx parameter to rep stos for the ClearArray node is in dwords.
1421 const bool Matcher::init_array_count_is_in_bytes = false;
1422
1423 // Threshold size for cleararray.
1424 const int Matcher::init_array_short_size = 8 * BytesPerLong;
1425
1426 // Needs 2 CMOV's for longs.
1427 const int Matcher::long_cmove_cost() { return 1; }
1428
1429 // No CMOVF/CMOVD with SSE/SSE2
1430 const int Matcher::float_cmove_cost() { return (UseSSE>=1) ? ConditionalMoveLimit : 0; }
1431
1432 // Does the CPU require late expand (see block.cpp for description of late expand)?
1433 const bool Matcher::require_postalloc_expand = false;
1434
1435 // Should the Matcher clone shifts on addressing modes, expecting them to
1436 // be subsumed into complex addressing expressions or compute them into
1437 // registers? True for Intel but false for most RISCs
1438 const bool Matcher::clone_shift_expressions = true;
1439
1440 // Do we need to mask the count passed to shift instructions or does
1441 // the cpu only look at the lower 5/6 bits anyway?
1442 const bool Matcher::need_masked_shift_count = false;
1443
1444 bool Matcher::narrow_oop_use_complex_address() {
1445 ShouldNotCallThis();
11352 instruct MoveL2D_reg_reg_sse(regD dst, eRegL src, regD tmp) %{
11353 predicate(UseSSE>=2);
11354 match(Set dst (MoveL2D src));
11355 effect(TEMP dst, USE src, TEMP tmp);
11356 ins_cost(85);
11357 format %{ "MOVD $dst,$src.lo\n\t"
11358 "MOVD $tmp,$src.hi\n\t"
11359 "PUNPCKLDQ $dst,$tmp\t# MoveL2D_reg_reg_sse" %}
11360 ins_encode %{
11361 __ movdl($dst$$XMMRegister, $src$$Register);
11362 __ movdl($tmp$$XMMRegister, HIGH_FROM_LOW($src$$Register));
11363 __ punpckldq($dst$$XMMRegister, $tmp$$XMMRegister);
11364 %}
11365 ins_pipe( pipe_slow );
11366 %}
11367
11368
11369 // =======================================================================
11370 // fast clearing of an array
11371 instruct rep_stos(eCXRegI cnt, eDIRegP base, eAXRegI zero, Universe dummy, eFlagsReg cr) %{
11372 predicate(!UseFastStosb);
11373 match(Set dummy (ClearArray cnt base));
11374 effect(USE_KILL cnt, USE_KILL base, KILL zero, KILL cr);
11375 format %{ "XOR EAX,EAX\t# ClearArray:\n\t"
11376 "SHL ECX,1\t# Convert doublewords to words\n\t"
11377 "REP STOS\t# store EAX into [EDI++] while ECX--" %}
11378 ins_encode %{
11379 __ clear_mem($base$$Register, $cnt$$Register, $zero$$Register);
11380 %}
11381 ins_pipe( pipe_slow );
11382 %}
11383
11384 instruct rep_fast_stosb(eCXRegI cnt, eDIRegP base, eAXRegI zero, Universe dummy, eFlagsReg cr) %{
11385 predicate(UseFastStosb);
11386 match(Set dummy (ClearArray cnt base));
11387 effect(USE_KILL cnt, USE_KILL base, KILL zero, KILL cr);
11388 format %{ "XOR EAX,EAX\t# ClearArray:\n\t"
11389 "SHL ECX,3\t# Convert doublewords to bytes\n\t"
11390 "REP STOSB\t# store EAX into [EDI++] while ECX--" %}
11391 ins_encode %{
11392 __ clear_mem($base$$Register, $cnt$$Register, $zero$$Register);
11393 %}
11394 ins_pipe( pipe_slow );
11395 %}
11396
11397 instruct string_compareL(eDIRegP str1, eCXRegI cnt1, eSIRegP str2, eDXRegI cnt2,
11398 eAXRegI result, regD tmp1, eFlagsReg cr) %{
11399 predicate(((StrCompNode*)n)->encoding() == StrIntrinsicNode::LL);
11400 match(Set result (StrComp (Binary str1 cnt1) (Binary str2 cnt2)));
11401 effect(TEMP tmp1, USE_KILL str1, USE_KILL str2, USE_KILL cnt1, USE_KILL cnt2, KILL cr);
11402
11403 format %{ "String Compare byte[] $str1,$cnt1,$str2,$cnt2 -> $result // KILL $tmp1" %}
11404 ins_encode %{
11405 __ string_compare($str1$$Register, $str2$$Register,
11406 $cnt1$$Register, $cnt2$$Register, $result$$Register,
11407 $tmp1$$XMMRegister, StrIntrinsicNode::LL);
11408 %}
11409 ins_pipe( pipe_slow );
11410 %}
11411
11412 instruct string_compareU(eDIRegP str1, eCXRegI cnt1, eSIRegP str2, eDXRegI cnt2,
|
1403 // The passed offset is relative to address of the branch.
1404 // On 86 a branch displacement is calculated relative to address
1405 // of a next instruction.
1406 offset -= br_size;
1407
1408 // the short version of jmpConUCF2 contains multiple branches,
1409 // making the reach slightly less
1410 if (rule == jmpConUCF2_rule)
1411 return (-126 <= offset && offset <= 125);
1412 return (-128 <= offset && offset <= 127);
1413 }
1414
1415 const bool Matcher::isSimpleConstant64(jlong value) {
1416 // Will one (StoreL ConL) be cheaper than two (StoreI ConI)?.
1417 return false;
1418 }
1419
1420 // The ecx parameter to rep stos for the ClearArray node is in dwords.
1421 const bool Matcher::init_array_count_is_in_bytes = false;
1422
1423 // Needs 2 CMOV's for longs.
1424 const int Matcher::long_cmove_cost() { return 1; }
1425
1426 // No CMOVF/CMOVD with SSE/SSE2
1427 const int Matcher::float_cmove_cost() { return (UseSSE>=1) ? ConditionalMoveLimit : 0; }
1428
1429 // Does the CPU require late expand (see block.cpp for description of late expand)?
1430 const bool Matcher::require_postalloc_expand = false;
1431
1432 // Should the Matcher clone shifts on addressing modes, expecting them to
1433 // be subsumed into complex addressing expressions or compute them into
1434 // registers? True for Intel but false for most RISCs
1435 const bool Matcher::clone_shift_expressions = true;
1436
1437 // Do we need to mask the count passed to shift instructions or does
1438 // the cpu only look at the lower 5/6 bits anyway?
1439 const bool Matcher::need_masked_shift_count = false;
1440
1441 bool Matcher::narrow_oop_use_complex_address() {
1442 ShouldNotCallThis();
11349 instruct MoveL2D_reg_reg_sse(regD dst, eRegL src, regD tmp) %{
11350 predicate(UseSSE>=2);
11351 match(Set dst (MoveL2D src));
11352 effect(TEMP dst, USE src, TEMP tmp);
11353 ins_cost(85);
11354 format %{ "MOVD $dst,$src.lo\n\t"
11355 "MOVD $tmp,$src.hi\n\t"
11356 "PUNPCKLDQ $dst,$tmp\t# MoveL2D_reg_reg_sse" %}
11357 ins_encode %{
11358 __ movdl($dst$$XMMRegister, $src$$Register);
11359 __ movdl($tmp$$XMMRegister, HIGH_FROM_LOW($src$$Register));
11360 __ punpckldq($dst$$XMMRegister, $tmp$$XMMRegister);
11361 %}
11362 ins_pipe( pipe_slow );
11363 %}
11364
11365
11366 // =======================================================================
11367 // fast clearing of an array
11368 instruct rep_stos(eCXRegI cnt, eDIRegP base, eAXRegI zero, Universe dummy, eFlagsReg cr) %{
11369 predicate(!UseFastStosb && !((ClearArrayNode*)n)->is_large());
11370 match(Set dummy (ClearArray cnt base));
11371 effect(USE_KILL cnt, USE_KILL base, KILL zero, KILL cr);
11372 format %{ "XOR EAX,EAX\t# ClearArray:\n\t"
11373 "SHL ECX,1\t# Convert doublewords to words\n\t"
11374 "REP STOS\t# store EAX into [EDI++] while ECX--" %}
11375 ins_encode %{
11376 __ clear_mem($base$$Register, $cnt$$Register, $zero$$Register, false);
11377 %}
11378 ins_pipe( pipe_slow );
11379 %}
11380
11381 instruct rep_stos_large(eCXRegI cnt, eDIRegP base, eAXRegI zero, Universe dummy, eFlagsReg cr) %{
11382 predicate(!UseFastStosb && ((ClearArrayNode*)n)->is_large());
11383 match(Set dummy (ClearArray cnt base));
11384 effect(USE_KILL cnt, USE_KILL base, KILL zero, KILL cr);
11385 format %{ "XOR EAX,EAX\t# ClearArray:\n\t"
11386 "SHL ECX,1\t# Convert doublewords to words\n\t"
11387 "REP STOS\t# store EAX into [EDI++] while ECX--" %}
11388 ins_encode %{
11389 __ clear_mem($base$$Register, $cnt$$Register, $zero$$Register, true);
11390 %}
11391 ins_pipe( pipe_slow );
11392 %}
11393
11394 instruct rep_fast_stosb(eCXRegI cnt, eDIRegP base, eAXRegI zero, Universe dummy, eFlagsReg cr) %{
11395 predicate(UseFastStosb && !((ClearArrayNode*)n)->is_large());
11396 match(Set dummy (ClearArray cnt base));
11397 effect(USE_KILL cnt, USE_KILL base, KILL zero, KILL cr);
11398 format %{ "XOR EAX,EAX\t# ClearArray:\n\t"
11399 "SHL ECX,3\t# Convert doublewords to bytes\n\t"
11400 "REP STOSB\t# store EAX into [EDI++] while ECX--" %}
11401 ins_encode %{
11402 __ clear_mem($base$$Register, $cnt$$Register, $zero$$Register, false);
11403 %}
11404 ins_pipe( pipe_slow );
11405 %}
11406
11407 instruct rep_fast_stosb_large(eCXRegI cnt, eDIRegP base, eAXRegI zero, Universe dummy, eFlagsReg cr) %{
11408 predicate(UseFastStosb && ((ClearArrayNode*)n)->is_large());
11409 match(Set dummy (ClearArray cnt base));
11410 effect(USE_KILL cnt, USE_KILL base, KILL zero, KILL cr);
11411 format %{ "XOR EAX,EAX\t# ClearArray:\n\t"
11412 "SHL ECX,3\t# Convert doublewords to bytes\n\t"
11413 "REP STOSB\t# store EAX into [EDI++] while ECX--" %}
11414 ins_encode %{
11415 __ clear_mem($base$$Register, $cnt$$Register, $zero$$Register, true);
11416 %}
11417 ins_pipe( pipe_slow );
11418 %}
11419
11420 instruct string_compareL(eDIRegP str1, eCXRegI cnt1, eSIRegP str2, eDXRegI cnt2,
11421 eAXRegI result, regD tmp1, eFlagsReg cr) %{
11422 predicate(((StrCompNode*)n)->encoding() == StrIntrinsicNode::LL);
11423 match(Set result (StrComp (Binary str1 cnt1) (Binary str2 cnt2)));
11424 effect(TEMP tmp1, USE_KILL str1, USE_KILL str2, USE_KILL cnt1, USE_KILL cnt2, KILL cr);
11425
11426 format %{ "String Compare byte[] $str1,$cnt1,$str2,$cnt2 -> $result // KILL $tmp1" %}
11427 ins_encode %{
11428 __ string_compare($str1$$Register, $str2$$Register,
11429 $cnt1$$Register, $cnt2$$Register, $result$$Register,
11430 $tmp1$$XMMRegister, StrIntrinsicNode::LL);
11431 %}
11432 ins_pipe( pipe_slow );
11433 %}
11434
11435 instruct string_compareU(eDIRegP str1, eCXRegI cnt1, eSIRegP str2, eDXRegI cnt2,
|