< prev index next >

src/hotspot/share/c1/c1_LIR.cpp

Print this page

 778       assert(opUp->_val->is_valid(), "used");          do_input(opUp->_val);     do_temp(opUp->_val);
 779       assert(opUp->_result->is_valid(), "used");       do_output(opUp->_result);
 780       assert(opUp->_info == NULL, "no info for LIR_OpUpdateCRC32");
 781 
 782       break;
 783     }
 784 
 785 
 786 // LIR_OpLock
 787     case lir_lock:
 788     case lir_unlock: {
 789       assert(op->as_OpLock() != NULL, "must be");
 790       LIR_OpLock* opLock = (LIR_OpLock*)op;
 791 
 792       if (opLock->_info)                          do_info(opLock->_info);
 793 
 794       // TODO: check if these operands really have to be temp
 795       // (or if input is sufficient). This may have influence on the oop map!
 796       assert(opLock->_lock->is_valid(), "used");  do_temp(opLock->_lock);
 797       assert(opLock->_hdr->is_valid(),  "used");  do_temp(opLock->_hdr);
 798       assert(opLock->_obj->is_valid(),  "used");  do_temp(opLock->_obj);
 799 
 800       if (opLock->_scratch->is_valid())           do_temp(opLock->_scratch);
 801       assert(opLock->_result->is_illegal(), "unused");
 802 
 803       do_stub(opLock->_stub);
 804 
 805       break;
 806     }
 807 
 808 
 809 // LIR_OpDelay
 810     case lir_delay_slot: {
 811       assert(op->as_OpDelay() != NULL, "must be");
 812       LIR_OpDelay* opDelay = (LIR_OpDelay*)op;
 813 
 814       visit(opDelay->delay_op());
 815       break;
 816     }
 817 
 818 // LIR_OpTypeCheck

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

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

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

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

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

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

 778       assert(opUp->_val->is_valid(), "used");          do_input(opUp->_val);     do_temp(opUp->_val);
 779       assert(opUp->_result->is_valid(), "used");       do_output(opUp->_result);
 780       assert(opUp->_info == NULL, "no info for LIR_OpUpdateCRC32");
 781 
 782       break;
 783     }
 784 
 785 
 786 // LIR_OpLock
 787     case lir_lock:
 788     case lir_unlock: {
 789       assert(op->as_OpLock() != NULL, "must be");
 790       LIR_OpLock* opLock = (LIR_OpLock*)op;
 791 
 792       if (opLock->_info)                          do_info(opLock->_info);
 793 
 794       // TODO: check if these operands really have to be temp
 795       // (or if input is sufficient). This may have influence on the oop map!
 796       assert(opLock->_lock->is_valid(), "used");  do_temp(opLock->_lock);
 797       assert(opLock->_hdr->is_valid(),  "used");  do_temp(opLock->_hdr);
 798       assert(opLock->_obj->is_valid(),  "used");  do_input(opLock->_obj); do_temp(opLock->_obj);
 799 
 800       if (opLock->_scratch->is_valid())           do_temp(opLock->_scratch);
 801       assert(opLock->_result->is_illegal(), "unused");
 802 
 803       do_stub(opLock->_stub);
 804 
 805       break;
 806     }
 807 
 808 
 809 // LIR_OpDelay
 810     case lir_delay_slot: {
 811       assert(op->as_OpDelay() != NULL, "must be");
 812       LIR_OpDelay* opDelay = (LIR_OpDelay*)op;
 813 
 814       visit(opDelay->delay_op());
 815       break;
 816     }
 817 
 818 // LIR_OpTypeCheck

 870       if (opAllocArray->_info)                        do_info(opAllocArray->_info);
 871       if (opAllocArray->_klass->is_valid())           do_input(opAllocArray->_klass); do_temp(opAllocArray->_klass);
 872       if (opAllocArray->_len->is_valid())             do_input(opAllocArray->_len);   do_temp(opAllocArray->_len);
 873       if (opAllocArray->_tmp1->is_valid())            do_temp(opAllocArray->_tmp1);
 874       if (opAllocArray->_tmp2->is_valid())            do_temp(opAllocArray->_tmp2);
 875       if (opAllocArray->_tmp3->is_valid())            do_temp(opAllocArray->_tmp3);
 876       if (opAllocArray->_tmp4->is_valid())            do_temp(opAllocArray->_tmp4);
 877       if (opAllocArray->_result->is_valid())          do_output(opAllocArray->_result);
 878                                                       do_stub(opAllocArray->_stub);
 879       break;
 880     }
 881 
 882 // LIR_OpLoadKlass
 883     case lir_load_klass:
 884     {
 885       LIR_OpLoadKlass* opLoadKlass = op->as_OpLoadKlass();
 886       assert(opLoadKlass != NULL, "must be");
 887 
 888       do_input(opLoadKlass->_obj);
 889       do_output(opLoadKlass->_result);
 890       do_stub(opLoadKlass->_stub);
 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   masm->append_code_stub(stub());
1072 }
1073 
1074 #ifdef ASSERT
1075 void LIR_OpAssert::emit_code(LIR_Assembler* masm) {
1076   masm->emit_assert(this);
1077 }
1078 #endif
1079 
1080 void LIR_OpDelay::emit_code(LIR_Assembler* masm) {
1081   masm->emit_delay(this);
1082 }
1083 
1084 void LIR_OpProfileCall::emit_code(LIR_Assembler* masm) {
1085   masm->emit_profile_call(this);
1086 }
1087 
1088 void LIR_OpProfileType::emit_code(LIR_Assembler* masm) {
1089   masm->emit_profile_type(this);
1090 }
1091 

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