< prev index next >

src/hotspot/share/c1/c1_LIR.cpp

Print this page

 871       if (opAllocArray->_len->is_valid())   {         do_input(opAllocArray->_len);
 872                                                       do_temp(opAllocArray->_len);
 873                                             }
 874       if (opAllocArray->_tmp1->is_valid())            do_temp(opAllocArray->_tmp1);
 875       if (opAllocArray->_tmp2->is_valid())            do_temp(opAllocArray->_tmp2);
 876       if (opAllocArray->_tmp3->is_valid())            do_temp(opAllocArray->_tmp3);
 877       if (opAllocArray->_tmp4->is_valid())            do_temp(opAllocArray->_tmp4);
 878       if (opAllocArray->_result->is_valid())          do_output(opAllocArray->_result);
 879       if (opAllocArray->_stub != nullptr)             do_stub(opAllocArray->_stub);
 880       break;
 881     }
 882 
 883 // LIR_OpLoadKlass
 884     case lir_load_klass:
 885     {
 886       LIR_OpLoadKlass* opLoadKlass = op->as_OpLoadKlass();
 887       assert(opLoadKlass != NULL, "must be");
 888 
 889       do_input(opLoadKlass->_obj);
 890       do_output(opLoadKlass->_result);

 891       if (opLoadKlass->_info) do_info(opLoadKlass->_info);
 892       break;
 893     }
 894 
 895 
 896 // LIR_OpProfileCall:
 897     case lir_profile_call: {
 898       assert(op->as_OpProfileCall() != NULL, "must be");
 899       LIR_OpProfileCall* opProfileCall = (LIR_OpProfileCall*)op;
 900 
 901       if (opProfileCall->_recv->is_valid())              do_temp(opProfileCall->_recv);
 902       assert(opProfileCall->_mdo->is_valid(), "used");   do_temp(opProfileCall->_mdo);
 903       assert(opProfileCall->_tmp1->is_valid(), "used");  do_temp(opProfileCall->_tmp1);
 904       break;
 905     }
 906 
 907 // LIR_OpProfileType:
 908     case lir_profile_type: {
 909       assert(op->as_OpProfileType() != NULL, "must be");
 910       LIR_OpProfileType* opProfileType = (LIR_OpProfileType*)op;

1051   masm->emit_compare_and_swap(this);
1052 }
1053 
1054 void LIR_Op3::emit_code(LIR_Assembler* masm) {
1055   masm->emit_op3(this);
1056 }
1057 
1058 void LIR_Op4::emit_code(LIR_Assembler* masm) {
1059   masm->emit_op4(this);
1060 }
1061 
1062 void LIR_OpLock::emit_code(LIR_Assembler* masm) {
1063   masm->emit_lock(this);
1064   if (stub()) {
1065     masm->append_code_stub(stub());
1066   }
1067 }
1068 
1069 void LIR_OpLoadKlass::emit_code(LIR_Assembler* masm) {
1070   masm->emit_load_klass(this);



1071 }
1072 
1073 #ifdef ASSERT
1074 void LIR_OpAssert::emit_code(LIR_Assembler* masm) {
1075   masm->emit_assert(this);
1076 }
1077 #endif
1078 
1079 void LIR_OpDelay::emit_code(LIR_Assembler* masm) {
1080   masm->emit_delay(this);
1081 }
1082 
1083 void LIR_OpProfileCall::emit_code(LIR_Assembler* masm) {
1084   masm->emit_profile_call(this);
1085 }
1086 
1087 void LIR_OpProfileType::emit_code(LIR_Assembler* masm) {
1088   masm->emit_profile_type(this);
1089 }
1090 

2019   in_opr1()->print(out);             out->print(" ");
2020   in_opr2()->print(out);             out->print(" ");
2021   in_opr3()->print(out);             out->print(" ");
2022   in_opr4()->print(out);             out->print(" ");
2023   result_opr()->print(out);
2024 }
2025 
2026 void LIR_OpLock::print_instr(outputStream* out) const {
2027   hdr_opr()->print(out);   out->print(" ");
2028   obj_opr()->print(out);   out->print(" ");
2029   lock_opr()->print(out);  out->print(" ");
2030   if (_scratch->is_valid()) {
2031     _scratch->print(out);  out->print(" ");
2032   }
2033   out->print("[lbl:" INTPTR_FORMAT "]", p2i(stub()->entry()));
2034 }
2035 
2036 void LIR_OpLoadKlass::print_instr(outputStream* out) const {
2037   obj()->print(out);        out->print(" ");
2038   result_opr()->print(out); out->print(" ");



2039 }
2040 
2041 #ifdef ASSERT
2042 void LIR_OpAssert::print_instr(outputStream* out) const {
2043   print_condition(out, condition()); out->print(" ");
2044   in_opr1()->print(out);             out->print(" ");
2045   in_opr2()->print(out);             out->print(", \"");
2046   out->print("%s", msg());          out->print("\"");
2047 }
2048 #endif
2049 
2050 
2051 void LIR_OpDelay::print_instr(outputStream* out) const {
2052   _op->print_on(out);
2053 }
2054 
2055 
2056 // LIR_OpProfileCall
2057 void LIR_OpProfileCall::print_instr(outputStream* out) const {
2058   profiled_method()->name()->print_symbol_on(out);

 871       if (opAllocArray->_len->is_valid())   {         do_input(opAllocArray->_len);
 872                                                       do_temp(opAllocArray->_len);
 873                                             }
 874       if (opAllocArray->_tmp1->is_valid())            do_temp(opAllocArray->_tmp1);
 875       if (opAllocArray->_tmp2->is_valid())            do_temp(opAllocArray->_tmp2);
 876       if (opAllocArray->_tmp3->is_valid())            do_temp(opAllocArray->_tmp3);
 877       if (opAllocArray->_tmp4->is_valid())            do_temp(opAllocArray->_tmp4);
 878       if (opAllocArray->_result->is_valid())          do_output(opAllocArray->_result);
 879       if (opAllocArray->_stub != nullptr)             do_stub(opAllocArray->_stub);
 880       break;
 881     }
 882 
 883 // LIR_OpLoadKlass
 884     case lir_load_klass:
 885     {
 886       LIR_OpLoadKlass* opLoadKlass = op->as_OpLoadKlass();
 887       assert(opLoadKlass != NULL, "must be");
 888 
 889       do_input(opLoadKlass->_obj);
 890       do_output(opLoadKlass->_result);
 891       if (opLoadKlass->_stub) do_stub(opLoadKlass->_stub);
 892       if (opLoadKlass->_info) do_info(opLoadKlass->_info);
 893       break;
 894     }
 895 
 896 
 897 // LIR_OpProfileCall:
 898     case lir_profile_call: {
 899       assert(op->as_OpProfileCall() != NULL, "must be");
 900       LIR_OpProfileCall* opProfileCall = (LIR_OpProfileCall*)op;
 901 
 902       if (opProfileCall->_recv->is_valid())              do_temp(opProfileCall->_recv);
 903       assert(opProfileCall->_mdo->is_valid(), "used");   do_temp(opProfileCall->_mdo);
 904       assert(opProfileCall->_tmp1->is_valid(), "used");  do_temp(opProfileCall->_tmp1);
 905       break;
 906     }
 907 
 908 // LIR_OpProfileType:
 909     case lir_profile_type: {
 910       assert(op->as_OpProfileType() != NULL, "must be");
 911       LIR_OpProfileType* opProfileType = (LIR_OpProfileType*)op;

1052   masm->emit_compare_and_swap(this);
1053 }
1054 
1055 void LIR_Op3::emit_code(LIR_Assembler* masm) {
1056   masm->emit_op3(this);
1057 }
1058 
1059 void LIR_Op4::emit_code(LIR_Assembler* masm) {
1060   masm->emit_op4(this);
1061 }
1062 
1063 void LIR_OpLock::emit_code(LIR_Assembler* masm) {
1064   masm->emit_lock(this);
1065   if (stub()) {
1066     masm->append_code_stub(stub());
1067   }
1068 }
1069 
1070 void LIR_OpLoadKlass::emit_code(LIR_Assembler* masm) {
1071   masm->emit_load_klass(this);
1072   if (stub()) {
1073     masm->append_code_stub(stub());
1074   }
1075 }
1076 
1077 #ifdef ASSERT
1078 void LIR_OpAssert::emit_code(LIR_Assembler* masm) {
1079   masm->emit_assert(this);
1080 }
1081 #endif
1082 
1083 void LIR_OpDelay::emit_code(LIR_Assembler* masm) {
1084   masm->emit_delay(this);
1085 }
1086 
1087 void LIR_OpProfileCall::emit_code(LIR_Assembler* masm) {
1088   masm->emit_profile_call(this);
1089 }
1090 
1091 void LIR_OpProfileType::emit_code(LIR_Assembler* masm) {
1092   masm->emit_profile_type(this);
1093 }
1094 

2023   in_opr1()->print(out);             out->print(" ");
2024   in_opr2()->print(out);             out->print(" ");
2025   in_opr3()->print(out);             out->print(" ");
2026   in_opr4()->print(out);             out->print(" ");
2027   result_opr()->print(out);
2028 }
2029 
2030 void LIR_OpLock::print_instr(outputStream* out) const {
2031   hdr_opr()->print(out);   out->print(" ");
2032   obj_opr()->print(out);   out->print(" ");
2033   lock_opr()->print(out);  out->print(" ");
2034   if (_scratch->is_valid()) {
2035     _scratch->print(out);  out->print(" ");
2036   }
2037   out->print("[lbl:" INTPTR_FORMAT "]", p2i(stub()->entry()));
2038 }
2039 
2040 void LIR_OpLoadKlass::print_instr(outputStream* out) const {
2041   obj()->print(out);        out->print(" ");
2042   result_opr()->print(out); out->print(" ");
2043   if (stub()) {
2044     out->print("[lbl:" INTPTR_FORMAT "]", p2i(stub()->entry()));
2045   }
2046 }
2047 
2048 #ifdef ASSERT
2049 void LIR_OpAssert::print_instr(outputStream* out) const {
2050   print_condition(out, condition()); out->print(" ");
2051   in_opr1()->print(out);             out->print(" ");
2052   in_opr2()->print(out);             out->print(", \"");
2053   out->print("%s", msg());          out->print("\"");
2054 }
2055 #endif
2056 
2057 
2058 void LIR_OpDelay::print_instr(outputStream* out) const {
2059   _op->print_on(out);
2060 }
2061 
2062 
2063 // LIR_OpProfileCall
2064 void LIR_OpProfileCall::print_instr(outputStream* out) const {
2065   profiled_method()->name()->print_symbol_on(out);
< prev index next >