< prev index next >

src/hotspot/share/c1/c1_LIR.cpp

Print this page

 911       if (opAllocArray->_info)                        do_info(opAllocArray->_info);
 912       if (opAllocArray->_klass->is_valid())           do_input(opAllocArray->_klass); do_temp(opAllocArray->_klass);
 913       if (opAllocArray->_len->is_valid())             do_input(opAllocArray->_len);   do_temp(opAllocArray->_len);
 914       if (opAllocArray->_tmp1->is_valid())            do_temp(opAllocArray->_tmp1);
 915       if (opAllocArray->_tmp2->is_valid())            do_temp(opAllocArray->_tmp2);
 916       if (opAllocArray->_tmp3->is_valid())            do_temp(opAllocArray->_tmp3);
 917       if (opAllocArray->_tmp4->is_valid())            do_temp(opAllocArray->_tmp4);
 918       if (opAllocArray->_result->is_valid())          do_output(opAllocArray->_result);
 919                                                       do_stub(opAllocArray->_stub);
 920       break;
 921     }
 922 
 923 // LIR_OpLoadKlass
 924     case lir_load_klass:
 925     {
 926       LIR_OpLoadKlass* opLoadKlass = op->as_OpLoadKlass();
 927       assert(opLoadKlass != NULL, "must be");
 928 
 929       do_input(opLoadKlass->_obj);
 930       do_output(opLoadKlass->_result);

 931       if (opLoadKlass->_info) do_info(opLoadKlass->_info);
 932       break;
 933     }
 934 
 935 
 936 // LIR_OpProfileCall:
 937     case lir_profile_call: {
 938       assert(op->as_OpProfileCall() != NULL, "must be");
 939       LIR_OpProfileCall* opProfileCall = (LIR_OpProfileCall*)op;
 940 
 941       if (opProfileCall->_recv->is_valid())              do_temp(opProfileCall->_recv);
 942       assert(opProfileCall->_mdo->is_valid(), "used");   do_temp(opProfileCall->_mdo);
 943       assert(opProfileCall->_tmp1->is_valid(), "used");  do_temp(opProfileCall->_tmp1);
 944       break;
 945     }
 946 
 947 // LIR_OpProfileType:
 948     case lir_profile_type: {
 949       assert(op->as_OpProfileType() != NULL, "must be");
 950       LIR_OpProfileType* opProfileType = (LIR_OpProfileType*)op;

1093 
1094 void LIR_Op3::emit_code(LIR_Assembler* masm) {
1095   masm->emit_op3(this);
1096 }
1097 
1098 #ifdef RISCV
1099 void LIR_Op4::emit_code(LIR_Assembler* masm) {
1100   masm->emit_op4(this);
1101 }
1102 #endif
1103 
1104 void LIR_OpLock::emit_code(LIR_Assembler* masm) {
1105   masm->emit_lock(this);
1106   if (stub()) {
1107     masm->append_code_stub(stub());
1108   }
1109 }
1110 
1111 void LIR_OpLoadKlass::emit_code(LIR_Assembler* masm) {
1112   masm->emit_load_klass(this);



1113 }
1114 
1115 #ifdef ASSERT
1116 void LIR_OpAssert::emit_code(LIR_Assembler* masm) {
1117   masm->emit_assert(this);
1118 }
1119 #endif
1120 
1121 void LIR_OpDelay::emit_code(LIR_Assembler* masm) {
1122   masm->emit_delay(this);
1123 }
1124 
1125 void LIR_OpProfileCall::emit_code(LIR_Assembler* masm) {
1126   masm->emit_profile_call(this);
1127 }
1128 
1129 void LIR_OpProfileType::emit_code(LIR_Assembler* masm) {
1130   masm->emit_profile_type(this);
1131 }
1132 

2077   in_opr2()->print(out);             out->print(" ");
2078   in_opr3()->print(out);             out->print(" ");
2079   in_opr4()->print(out);             out->print(" ");
2080   result_opr()->print(out);
2081 }
2082 #endif
2083 
2084 void LIR_OpLock::print_instr(outputStream* out) const {
2085   hdr_opr()->print(out);   out->print(" ");
2086   obj_opr()->print(out);   out->print(" ");
2087   lock_opr()->print(out);  out->print(" ");
2088   if (_scratch->is_valid()) {
2089     _scratch->print(out);  out->print(" ");
2090   }
2091   out->print("[lbl:" INTPTR_FORMAT "]", p2i(stub()->entry()));
2092 }
2093 
2094 void LIR_OpLoadKlass::print_instr(outputStream* out) const {
2095   obj()->print(out);        out->print(" ");
2096   result_opr()->print(out); out->print(" ");



2097 }
2098 
2099 #ifdef ASSERT
2100 void LIR_OpAssert::print_instr(outputStream* out) const {
2101   print_condition(out, condition()); out->print(" ");
2102   in_opr1()->print(out);             out->print(" ");
2103   in_opr2()->print(out);             out->print(", \"");
2104   out->print("%s", msg());          out->print("\"");
2105 }
2106 #endif
2107 
2108 
2109 void LIR_OpDelay::print_instr(outputStream* out) const {
2110   _op->print_on(out);
2111 }
2112 
2113 
2114 // LIR_OpProfileCall
2115 void LIR_OpProfileCall::print_instr(outputStream* out) const {
2116   profiled_method()->name()->print_symbol_on(out);

 911       if (opAllocArray->_info)                        do_info(opAllocArray->_info);
 912       if (opAllocArray->_klass->is_valid())           do_input(opAllocArray->_klass); do_temp(opAllocArray->_klass);
 913       if (opAllocArray->_len->is_valid())             do_input(opAllocArray->_len);   do_temp(opAllocArray->_len);
 914       if (opAllocArray->_tmp1->is_valid())            do_temp(opAllocArray->_tmp1);
 915       if (opAllocArray->_tmp2->is_valid())            do_temp(opAllocArray->_tmp2);
 916       if (opAllocArray->_tmp3->is_valid())            do_temp(opAllocArray->_tmp3);
 917       if (opAllocArray->_tmp4->is_valid())            do_temp(opAllocArray->_tmp4);
 918       if (opAllocArray->_result->is_valid())          do_output(opAllocArray->_result);
 919                                                       do_stub(opAllocArray->_stub);
 920       break;
 921     }
 922 
 923 // LIR_OpLoadKlass
 924     case lir_load_klass:
 925     {
 926       LIR_OpLoadKlass* opLoadKlass = op->as_OpLoadKlass();
 927       assert(opLoadKlass != NULL, "must be");
 928 
 929       do_input(opLoadKlass->_obj);
 930       do_output(opLoadKlass->_result);
 931       if (opLoadKlass->_stub) do_stub(opLoadKlass->_stub);
 932       if (opLoadKlass->_info) do_info(opLoadKlass->_info);
 933       break;
 934     }
 935 
 936 
 937 // LIR_OpProfileCall:
 938     case lir_profile_call: {
 939       assert(op->as_OpProfileCall() != NULL, "must be");
 940       LIR_OpProfileCall* opProfileCall = (LIR_OpProfileCall*)op;
 941 
 942       if (opProfileCall->_recv->is_valid())              do_temp(opProfileCall->_recv);
 943       assert(opProfileCall->_mdo->is_valid(), "used");   do_temp(opProfileCall->_mdo);
 944       assert(opProfileCall->_tmp1->is_valid(), "used");  do_temp(opProfileCall->_tmp1);
 945       break;
 946     }
 947 
 948 // LIR_OpProfileType:
 949     case lir_profile_type: {
 950       assert(op->as_OpProfileType() != NULL, "must be");
 951       LIR_OpProfileType* opProfileType = (LIR_OpProfileType*)op;

1094 
1095 void LIR_Op3::emit_code(LIR_Assembler* masm) {
1096   masm->emit_op3(this);
1097 }
1098 
1099 #ifdef RISCV
1100 void LIR_Op4::emit_code(LIR_Assembler* masm) {
1101   masm->emit_op4(this);
1102 }
1103 #endif
1104 
1105 void LIR_OpLock::emit_code(LIR_Assembler* masm) {
1106   masm->emit_lock(this);
1107   if (stub()) {
1108     masm->append_code_stub(stub());
1109   }
1110 }
1111 
1112 void LIR_OpLoadKlass::emit_code(LIR_Assembler* masm) {
1113   masm->emit_load_klass(this);
1114   if (stub()) {
1115     masm->append_code_stub(stub());
1116   }
1117 }
1118 
1119 #ifdef ASSERT
1120 void LIR_OpAssert::emit_code(LIR_Assembler* masm) {
1121   masm->emit_assert(this);
1122 }
1123 #endif
1124 
1125 void LIR_OpDelay::emit_code(LIR_Assembler* masm) {
1126   masm->emit_delay(this);
1127 }
1128 
1129 void LIR_OpProfileCall::emit_code(LIR_Assembler* masm) {
1130   masm->emit_profile_call(this);
1131 }
1132 
1133 void LIR_OpProfileType::emit_code(LIR_Assembler* masm) {
1134   masm->emit_profile_type(this);
1135 }
1136 

2081   in_opr2()->print(out);             out->print(" ");
2082   in_opr3()->print(out);             out->print(" ");
2083   in_opr4()->print(out);             out->print(" ");
2084   result_opr()->print(out);
2085 }
2086 #endif
2087 
2088 void LIR_OpLock::print_instr(outputStream* out) const {
2089   hdr_opr()->print(out);   out->print(" ");
2090   obj_opr()->print(out);   out->print(" ");
2091   lock_opr()->print(out);  out->print(" ");
2092   if (_scratch->is_valid()) {
2093     _scratch->print(out);  out->print(" ");
2094   }
2095   out->print("[lbl:" INTPTR_FORMAT "]", p2i(stub()->entry()));
2096 }
2097 
2098 void LIR_OpLoadKlass::print_instr(outputStream* out) const {
2099   obj()->print(out);        out->print(" ");
2100   result_opr()->print(out); out->print(" ");
2101   if (stub()) {
2102     out->print("[lbl:" INTPTR_FORMAT "]", p2i(stub()->entry()));
2103   }
2104 }
2105 
2106 #ifdef ASSERT
2107 void LIR_OpAssert::print_instr(outputStream* out) const {
2108   print_condition(out, condition()); out->print(" ");
2109   in_opr1()->print(out);             out->print(" ");
2110   in_opr2()->print(out);             out->print(", \"");
2111   out->print("%s", msg());          out->print("\"");
2112 }
2113 #endif
2114 
2115 
2116 void LIR_OpDelay::print_instr(outputStream* out) const {
2117   _op->print_on(out);
2118 }
2119 
2120 
2121 // LIR_OpProfileCall
2122 void LIR_OpProfileCall::print_instr(outputStream* out) const {
2123   profiled_method()->name()->print_symbol_on(out);
< prev index next >