1360 return (-126 <= offset && offset <= 125);
1361 return (-128 <= offset && offset <= 127);
1362 }
1363
1364 const bool Matcher::isSimpleConstant64(jlong value) {
1365 // Will one (StoreL ConL) be cheaper than two (StoreI ConI)?.
1366 return false;
1367 }
1368
1369 // The ecx parameter to rep stos for the ClearArray node is in dwords.
1370 const bool Matcher::init_array_count_is_in_bytes = false;
1371
1372 // Threshold size for cleararray.
1373 const int Matcher::init_array_short_size = 8 * BytesPerLong;
1374
1375 // Should the Matcher clone shifts on addressing modes, expecting them to
1376 // be subsumed into complex addressing expressions or compute them into
1377 // registers? True for Intel but false for most RISCs
1378 const bool Matcher::clone_shift_expressions = true;
1379
1380 // Is it better to copy float constants, or load them directly from memory?
1381 // Intel can load a float constant from a direct address, requiring no
1382 // extra registers. Most RISCs will have to materialize an address into a
1383 // register first, so they would do better to copy the constant from stack.
1384 const bool Matcher::rematerialize_float_constants = true;
1385
1386 // If CPU can load and store mis-aligned doubles directly then no fixup is
1387 // needed. Else we split the double into 2 integer pieces and move it
1388 // piece-by-piece. Only happens when passing doubles into C code as the
1389 // Java calling convention forces doubles to be aligned.
1390 const bool Matcher::misaligned_doubles_ok = true;
1391
1392
1393 void Matcher::pd_implicit_null_fixup(MachNode *node, uint idx) {
1394 // Get the memory operand from the node
1395 uint numopnds = node->num_opnds(); // Virtual call for number of operands
1396 uint skipped = node->oper_input_base(); // Sum of leaves skipped so far
1397 assert( idx >= skipped, "idx too low in pd_implicit_null_fixup" );
1398 uint opcnt = 1; // First operand
1399 uint num_edges = node->_opnds[1]->num_edges(); // leaves for first operand
|
1360 return (-126 <= offset && offset <= 125);
1361 return (-128 <= offset && offset <= 127);
1362 }
1363
1364 const bool Matcher::isSimpleConstant64(jlong value) {
1365 // Will one (StoreL ConL) be cheaper than two (StoreI ConI)?.
1366 return false;
1367 }
1368
1369 // The ecx parameter to rep stos for the ClearArray node is in dwords.
1370 const bool Matcher::init_array_count_is_in_bytes = false;
1371
1372 // Threshold size for cleararray.
1373 const int Matcher::init_array_short_size = 8 * BytesPerLong;
1374
1375 // Should the Matcher clone shifts on addressing modes, expecting them to
1376 // be subsumed into complex addressing expressions or compute them into
1377 // registers? True for Intel but false for most RISCs
1378 const bool Matcher::clone_shift_expressions = true;
1379
1380 bool Matcher::narrow_oop_use_complex_address() {
1381 ShouldNotCallThis();
1382 return true;
1383 }
1384
1385
1386 // Is it better to copy float constants, or load them directly from memory?
1387 // Intel can load a float constant from a direct address, requiring no
1388 // extra registers. Most RISCs will have to materialize an address into a
1389 // register first, so they would do better to copy the constant from stack.
1390 const bool Matcher::rematerialize_float_constants = true;
1391
1392 // If CPU can load and store mis-aligned doubles directly then no fixup is
1393 // needed. Else we split the double into 2 integer pieces and move it
1394 // piece-by-piece. Only happens when passing doubles into C code as the
1395 // Java calling convention forces doubles to be aligned.
1396 const bool Matcher::misaligned_doubles_ok = true;
1397
1398
1399 void Matcher::pd_implicit_null_fixup(MachNode *node, uint idx) {
1400 // Get the memory operand from the node
1401 uint numopnds = node->num_opnds(); // Virtual call for number of operands
1402 uint skipped = node->oper_input_base(); // Sum of leaves skipped so far
1403 assert( idx >= skipped, "idx too low in pd_implicit_null_fixup" );
1404 uint opcnt = 1; // First operand
1405 uint num_edges = node->_opnds[1]->num_edges(); // leaves for first operand
|