< prev index next >

src/hotspot/share/c1/c1_LIR.cpp

Print this page

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

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

1041   }
1042 }
1043 
1044 void LIR_OpCompareAndSwap::emit_code(LIR_Assembler* masm) {
1045   masm->emit_compare_and_swap(this);
1046 }
1047 
1048 void LIR_Op3::emit_code(LIR_Assembler* masm) {
1049   masm->emit_op3(this);
1050 }
1051 
1052 void LIR_OpLock::emit_code(LIR_Assembler* masm) {
1053   masm->emit_lock(this);
1054   if (stub()) {
1055     masm->append_code_stub(stub());
1056   }
1057 }
1058 
1059 void LIR_OpLoadKlass::emit_code(LIR_Assembler* masm) {
1060   masm->emit_load_klass(this);

1061 }
1062 
1063 #ifdef ASSERT
1064 void LIR_OpAssert::emit_code(LIR_Assembler* masm) {
1065   masm->emit_assert(this);
1066 }
1067 #endif
1068 
1069 void LIR_OpDelay::emit_code(LIR_Assembler* masm) {
1070   masm->emit_delay(this);
1071 }
1072 
1073 void LIR_OpProfileCall::emit_code(LIR_Assembler* masm) {
1074   masm->emit_profile_call(this);
1075 }
1076 
1077 void LIR_OpProfileType::emit_code(LIR_Assembler* masm) {
1078   masm->emit_profile_type(this);
1079 }
1080 

1961   in_opr1()->print(out);    out->print(" ");
1962   in_opr2()->print(out);    out->print(" ");
1963   in_opr3()->print(out);    out->print(" ");
1964   result_opr()->print(out);
1965 }
1966 
1967 
1968 void LIR_OpLock::print_instr(outputStream* out) const {
1969   hdr_opr()->print(out);   out->print(" ");
1970   obj_opr()->print(out);   out->print(" ");
1971   lock_opr()->print(out);  out->print(" ");
1972   if (_scratch->is_valid()) {
1973     _scratch->print(out);  out->print(" ");
1974   }
1975   out->print("[lbl:" INTPTR_FORMAT "]", p2i(stub()->entry()));
1976 }
1977 
1978 void LIR_OpLoadKlass::print_instr(outputStream* out) const {
1979   obj()->print(out);        out->print(" ");
1980   result_opr()->print(out); out->print(" ");

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

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

1042   }
1043 }
1044 
1045 void LIR_OpCompareAndSwap::emit_code(LIR_Assembler* masm) {
1046   masm->emit_compare_and_swap(this);
1047 }
1048 
1049 void LIR_Op3::emit_code(LIR_Assembler* masm) {
1050   masm->emit_op3(this);
1051 }
1052 
1053 void LIR_OpLock::emit_code(LIR_Assembler* masm) {
1054   masm->emit_lock(this);
1055   if (stub()) {
1056     masm->append_code_stub(stub());
1057   }
1058 }
1059 
1060 void LIR_OpLoadKlass::emit_code(LIR_Assembler* masm) {
1061   masm->emit_load_klass(this);
1062   masm->append_code_stub(stub());
1063 }
1064 
1065 #ifdef ASSERT
1066 void LIR_OpAssert::emit_code(LIR_Assembler* masm) {
1067   masm->emit_assert(this);
1068 }
1069 #endif
1070 
1071 void LIR_OpDelay::emit_code(LIR_Assembler* masm) {
1072   masm->emit_delay(this);
1073 }
1074 
1075 void LIR_OpProfileCall::emit_code(LIR_Assembler* masm) {
1076   masm->emit_profile_call(this);
1077 }
1078 
1079 void LIR_OpProfileType::emit_code(LIR_Assembler* masm) {
1080   masm->emit_profile_type(this);
1081 }
1082 

1963   in_opr1()->print(out);    out->print(" ");
1964   in_opr2()->print(out);    out->print(" ");
1965   in_opr3()->print(out);    out->print(" ");
1966   result_opr()->print(out);
1967 }
1968 
1969 
1970 void LIR_OpLock::print_instr(outputStream* out) const {
1971   hdr_opr()->print(out);   out->print(" ");
1972   obj_opr()->print(out);   out->print(" ");
1973   lock_opr()->print(out);  out->print(" ");
1974   if (_scratch->is_valid()) {
1975     _scratch->print(out);  out->print(" ");
1976   }
1977   out->print("[lbl:" INTPTR_FORMAT "]", p2i(stub()->entry()));
1978 }
1979 
1980 void LIR_OpLoadKlass::print_instr(outputStream* out) const {
1981   obj()->print(out);        out->print(" ");
1982   result_opr()->print(out); out->print(" ");
1983   out->print("[lbl:" INTPTR_FORMAT "]", p2i(stub()->entry()));
1984 }
1985 
1986 #ifdef ASSERT
1987 void LIR_OpAssert::print_instr(outputStream* out) const {
1988   print_condition(out, condition()); out->print(" ");
1989   in_opr1()->print(out);             out->print(" ");
1990   in_opr2()->print(out);             out->print(", \"");
1991   out->print("%s", msg());          out->print("\"");
1992 }
1993 #endif
1994 
1995 
1996 void LIR_OpDelay::print_instr(outputStream* out) const {
1997   _op->print_on(out);
1998 }
1999 
2000 
2001 // LIR_OpProfileCall
2002 void LIR_OpProfileCall::print_instr(outputStream* out) const {
2003   profiled_method()->name()->print_symbol_on(out);
< prev index next >