< prev index next >

src/hotspot/share/c1/c1_LIR.cpp

Print this page

 863     }
 864 
 865 
 866 // LIR_OpAllocArray;
 867     case lir_alloc_array: {
 868       assert(op->as_OpAllocArray() != NULL, "must be");
 869       LIR_OpAllocArray* opAllocArray = (LIR_OpAllocArray*)op;
 870 
 871       if (opAllocArray->_info)                        do_info(opAllocArray->_info);
 872       if (opAllocArray->_klass->is_valid())           do_input(opAllocArray->_klass); do_temp(opAllocArray->_klass);
 873       if (opAllocArray->_len->is_valid())             do_input(opAllocArray->_len);   do_temp(opAllocArray->_len);
 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                                                       do_stub(opAllocArray->_stub);
 880       break;
 881     }
 882 














 883 // LIR_OpProfileCall:
 884     case lir_profile_call: {
 885       assert(op->as_OpProfileCall() != NULL, "must be");
 886       LIR_OpProfileCall* opProfileCall = (LIR_OpProfileCall*)op;
 887 
 888       if (opProfileCall->_recv->is_valid())              do_temp(opProfileCall->_recv);
 889       assert(opProfileCall->_mdo->is_valid(), "used");   do_temp(opProfileCall->_mdo);
 890       assert(opProfileCall->_tmp1->is_valid(), "used");  do_temp(opProfileCall->_tmp1);
 891       break;
 892     }
 893 
 894 // LIR_OpProfileType:
 895     case lir_profile_type: {
 896       assert(op->as_OpProfileType() != NULL, "must be");
 897       LIR_OpProfileType* opProfileType = (LIR_OpProfileType*)op;
 898 
 899       do_input(opProfileType->_mdp); do_temp(opProfileType->_mdp);
 900       do_input(opProfileType->_obj);
 901       do_temp(opProfileType->_tmp);
 902       break;

1032   if (stub()) {
1033     masm->append_code_stub(stub());
1034   }
1035 }
1036 
1037 void LIR_OpCompareAndSwap::emit_code(LIR_Assembler* masm) {
1038   masm->emit_compare_and_swap(this);
1039 }
1040 
1041 void LIR_Op3::emit_code(LIR_Assembler* masm) {
1042   masm->emit_op3(this);
1043 }
1044 
1045 void LIR_OpLock::emit_code(LIR_Assembler* masm) {
1046   masm->emit_lock(this);
1047   if (stub()) {
1048     masm->append_code_stub(stub());
1049   }
1050 }
1051 







1052 #ifdef ASSERT
1053 void LIR_OpAssert::emit_code(LIR_Assembler* masm) {
1054   masm->emit_assert(this);
1055 }
1056 #endif
1057 
1058 void LIR_OpDelay::emit_code(LIR_Assembler* masm) {
1059   masm->emit_delay(this);
1060 }
1061 
1062 void LIR_OpProfileCall::emit_code(LIR_Assembler* masm) {
1063   masm->emit_profile_call(this);
1064 }
1065 
1066 void LIR_OpProfileType::emit_code(LIR_Assembler* masm) {
1067   masm->emit_profile_type(this);
1068 }
1069 
1070 // LIR_List
1071 LIR_List::LIR_List(Compilation* compilation, BlockBegin* block)

1956 
1957 // LIR_Op3
1958 void LIR_Op3::print_instr(outputStream* out) const {
1959   in_opr1()->print(out);    out->print(" ");
1960   in_opr2()->print(out);    out->print(" ");
1961   in_opr3()->print(out);    out->print(" ");
1962   result_opr()->print(out);
1963 }
1964 
1965 
1966 void LIR_OpLock::print_instr(outputStream* out) const {
1967   hdr_opr()->print(out);   out->print(" ");
1968   obj_opr()->print(out);   out->print(" ");
1969   lock_opr()->print(out);  out->print(" ");
1970   if (_scratch->is_valid()) {
1971     _scratch->print(out);  out->print(" ");
1972   }
1973   out->print("[lbl:" INTPTR_FORMAT "]", p2i(stub()->entry()));
1974 }
1975 








1976 #ifdef ASSERT
1977 void LIR_OpAssert::print_instr(outputStream* out) const {
1978   print_condition(out, condition()); out->print(" ");
1979   in_opr1()->print(out);             out->print(" ");
1980   in_opr2()->print(out);             out->print(", \"");
1981   out->print("%s", msg());          out->print("\"");
1982 }
1983 #endif
1984 
1985 
1986 void LIR_OpDelay::print_instr(outputStream* out) const {
1987   _op->print_on(out);
1988 }
1989 
1990 
1991 // LIR_OpProfileCall
1992 void LIR_OpProfileCall::print_instr(outputStream* out) const {
1993   profiled_method()->name()->print_symbol_on(out);
1994   out->print(".");
1995   profiled_method()->holder()->name()->print_symbol_on(out);

 863     }
 864 
 865 
 866 // LIR_OpAllocArray;
 867     case lir_alloc_array: {
 868       assert(op->as_OpAllocArray() != NULL, "must be");
 869       LIR_OpAllocArray* opAllocArray = (LIR_OpAllocArray*)op;
 870 
 871       if (opAllocArray->_info)                        do_info(opAllocArray->_info);
 872       if (opAllocArray->_klass->is_valid())           do_input(opAllocArray->_klass); do_temp(opAllocArray->_klass);
 873       if (opAllocArray->_len->is_valid())             do_input(opAllocArray->_len);   do_temp(opAllocArray->_len);
 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                                                       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;
 912 
 913       do_input(opProfileType->_mdp); do_temp(opProfileType->_mdp);
 914       do_input(opProfileType->_obj);
 915       do_temp(opProfileType->_tmp);
 916       break;

1046   if (stub()) {
1047     masm->append_code_stub(stub());
1048   }
1049 }
1050 
1051 void LIR_OpCompareAndSwap::emit_code(LIR_Assembler* masm) {
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_OpLock::emit_code(LIR_Assembler* masm) {
1060   masm->emit_lock(this);
1061   if (stub()) {
1062     masm->append_code_stub(stub());
1063   }
1064 }
1065 
1066 void LIR_OpLoadKlass::emit_code(LIR_Assembler* masm) {
1067   masm->emit_load_klass(this);
1068   if (stub()) {
1069     masm->append_code_stub(stub());
1070   }
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 
1091 // LIR_List
1092 LIR_List::LIR_List(Compilation* compilation, BlockBegin* block)

1977 
1978 // LIR_Op3
1979 void LIR_Op3::print_instr(outputStream* out) const {
1980   in_opr1()->print(out);    out->print(" ");
1981   in_opr2()->print(out);    out->print(" ");
1982   in_opr3()->print(out);    out->print(" ");
1983   result_opr()->print(out);
1984 }
1985 
1986 
1987 void LIR_OpLock::print_instr(outputStream* out) const {
1988   hdr_opr()->print(out);   out->print(" ");
1989   obj_opr()->print(out);   out->print(" ");
1990   lock_opr()->print(out);  out->print(" ");
1991   if (_scratch->is_valid()) {
1992     _scratch->print(out);  out->print(" ");
1993   }
1994   out->print("[lbl:" INTPTR_FORMAT "]", p2i(stub()->entry()));
1995 }
1996 
1997 void LIR_OpLoadKlass::print_instr(outputStream* out) const {
1998   obj()->print(out);        out->print(" ");
1999   result_opr()->print(out); out->print(" ");
2000   if (stub()) {
2001     out->print("[lbl:" INTPTR_FORMAT "]", p2i(stub()->entry()));
2002   }
2003 }
2004 
2005 #ifdef ASSERT
2006 void LIR_OpAssert::print_instr(outputStream* out) const {
2007   print_condition(out, condition()); out->print(" ");
2008   in_opr1()->print(out);             out->print(" ");
2009   in_opr2()->print(out);             out->print(", \"");
2010   out->print("%s", msg());          out->print("\"");
2011 }
2012 #endif
2013 
2014 
2015 void LIR_OpDelay::print_instr(outputStream* out) const {
2016   _op->print_on(out);
2017 }
2018 
2019 
2020 // LIR_OpProfileCall
2021 void LIR_OpProfileCall::print_instr(outputStream* out) const {
2022   profiled_method()->name()->print_symbol_on(out);
2023   out->print(".");
2024   profiled_method()->holder()->name()->print_symbol_on(out);
< prev index next >