jdk8-mips64-public/hotspot: comparison src/cpu/sparc/vm/sparc.ad

-:3068270ba476
+:2b8e28fdf503
 } else {
 assert(!UseInlineCaches, "expect vtable calls only if not using ICs");
 int entry_offset = InstanceKlass::vtable_start_offset() + vtable_index*vtableEntry::size();
 int v_off = entry_offset*wordSize + vtableEntry::method_offset_in_bytes();
 int klass_load_size;
-if (UseCompressedKlassPointers) {
+if (UseCompressedClassPointers) {
 assert(Universe::heap() != NULL, "java heap should be initialized");
 klass_load_size = MacroAssembler::instr_size_for_decode_klass_not_null() + 1*BytesPerInstWord;
 } else {
 klass_load_size = 1*BytesPerInstWord;
 }
 //=============================================================================
 #ifndef PRODUCT
 void MachUEPNode::format( PhaseRegAlloc *ra_, outputStream *st ) const {
 st->print_cr("\nUEP:");
 #ifdef    _LP64
-if (UseCompressedKlassPointers) {
+if (UseCompressedClassPointers) {
 assert(Universe::heap() != NULL, "java heap should be initialized");
 st->print_cr("\tLDUW   [R_O0 + oopDesc::klass_offset_in_bytes],R_G5\t! Inline cache check - compressed klass");
-st->print_cr("\tSET    Universe::narrow_klass_base,R_G6_heap_base");
+if (Universe::narrow_klass_base() != 0) {
-if (Universe::narrow_klass_shift() != 0) {
+st->print_cr("\tSET    Universe::narrow_klass_base,R_G6_heap_base");
-st->print_cr("\tSLL    R_G5,3,R_G5");
+if (Universe::narrow_klass_shift() != 0) {
+st->print_cr("\tSLL    R_G5,Universe::narrow_klass_shift,R_G5");
+}
+st->print_cr("\tADD    R_G5,R_G6_heap_base,R_G5");
+st->print_cr("\tSET    Universe::narrow_ptrs_base,R_G6_heap_base");
+} else {
+st->print_cr("\tSLL    R_G5,Universe::narrow_klass_shift,R_G5");
 }
-st->print_cr("\tADD    R_G5,R_G6_heap_base,R_G5");
-st->print_cr("\tSET    Universe::narrow_ptrs_base,R_G6_heap_base");
 } else {
 st->print_cr("\tLDX    [R_O0 + oopDesc::klass_offset_in_bytes],R_G5\t! Inline cache check");
 }
 st->print_cr("\tCMP    R_G5,R_G3" );
 st->print   ("\tTne    xcc,R_G0+ST_RESERVED_FOR_USER_0+2");
 return false;
 }
 bool Matcher::narrow_klass_use_complex_address() {
 NOT_LP64(ShouldNotCallThis());
-assert(UseCompressedKlassPointers, "only for compressed klass code");
+assert(UseCompressedClassPointers, "only for compressed klass code");
 return false;
 }
 // Is it better to copy float constants, or load them directly from memory?
 // Intel can load a float constant from a direct address, requiring no
 }
 const RegMask Matcher::method_handle_invoke_SP_save_mask() {
 return L7_REGP_mask();
 }
+const RegMask Matcher::mathExactI_result_proj_mask() {
+return G1_REGI_mask();
+}
+const RegMask Matcher::mathExactL_result_proj_mask() {
+return G1_REGL_mask();
+}
+const RegMask Matcher::mathExactI_flags_proj_mask() {
+return INT_FLAGS_mask();
+}
 %}
 // The intptr_t operand types, defined by textual substitution.
 // get receiver klass (receiver already checked for non-null)
 // If we end up going thru a c2i adapter interpreter expects method in G5
 int off = __ offset();
 __ load_klass(O0, G3_scratch);
 int klass_load_size;
-if (UseCompressedKlassPointers) {
+if (UseCompressedClassPointers) {
 assert(Universe::heap() != NULL, "java heap should be initialized");
 klass_load_size = MacroAssembler::instr_size_for_decode_klass_not_null() + 1*BytesPerInstWord;
 } else {
 klass_load_size = 1*BytesPerInstWord;
 }
 not_equal(0x9);
 less(0x3);
 greater_equal(0xB);
 less_equal(0x2);
 greater(0xA);
+overflow(0x7);
+no_overflow(0xF);
 %}
 %}
 // Comparison Op, unsigned
 operand cmpOpU() %{
 match(Bool);
+predicate(n->as_Bool()->_test._test != BoolTest::overflow &&
+n->as_Bool()->_test._test != BoolTest::no_overflow);
 format %{ "u" %}
 interface(COND_INTER) %{
 equal(0x1);
 not_equal(0x9);
 less(0x5);
 greater_equal(0xD);
 less_equal(0x4);
 greater(0xC);
+overflow(0x7);
+no_overflow(0xF);
 %}
 %}
 // Comparison Op, pointer (same as unsigned)
 operand cmpOpP() %{
 match(Bool);
+predicate(n->as_Bool()->_test._test != BoolTest::overflow &&
+n->as_Bool()->_test._test != BoolTest::no_overflow);
 format %{ "p" %}
 interface(COND_INTER) %{
 equal(0x1);
 not_equal(0x9);
 less(0x5);
 greater_equal(0xD);
 less_equal(0x4);
 greater(0xC);
+overflow(0x7);
+no_overflow(0xF);
 %}
 %}
 // Comparison Op, branch-register encoding
 operand cmpOp_reg() %{
 match(Bool);
+predicate(n->as_Bool()->_test._test != BoolTest::overflow &&
+n->as_Bool()->_test._test != BoolTest::no_overflow);
 format %{ "" %}
 interface(COND_INTER) %{
 equal        (0x1);
 not_equal    (0x5);
 less         (0x3);
 greater_equal(0x7);
 less_equal   (0x2);
 greater      (0x6);
+overflow(0x7); // not supported
+no_overflow(0xF); // not supported
 %}
 %}
 // Comparison Code, floating, unordered same as less
 operand cmpOpF() %{
 match(Bool);
+predicate(n->as_Bool()->_test._test != BoolTest::overflow &&
+n->as_Bool()->_test._test != BoolTest::no_overflow);
 format %{ "fl" %}
 interface(COND_INTER) %{
 equal(0x9);
 not_equal(0x1);
 less(0x3);
 greater_equal(0xB);
 less_equal(0xE);
 greater(0x6);
+overflow(0x7); // not supported
+no_overflow(0xF); // not supported
 %}
 %}
 // Used by long compare
 operand cmpOp_commute() %{
 match(Bool);
+predicate(n->as_Bool()->_test._test != BoolTest::overflow &&
+n->as_Bool()->_test._test != BoolTest::no_overflow);
 format %{ "" %}
 interface(COND_INTER) %{
 equal(0x1);
 not_equal(0x9);
 less(0xA);
 greater_equal(0x2);
 less_equal(0xB);
 greater(0x3);
+overflow(0x7);
+no_overflow(0xF);
 %}
 %}
 //----------OPERAND CLASSES----------------------------------------------------
 // Operand Classes are groups of operands that are used to simplify

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/cpu/sparc/vm/sparc.ad

src/cpu/sparc/vm/sparc.ad