8871 // Call runtime without safepoint - same as CallLeaf
8872 instruct CallLeafNoFPDirect(method meth) %{
8873 match(CallLeafNoFP);
8874 effect(USE meth);
8875 ins_cost(CALL_COST);
8876 format %{ "CALL,runtime leaf nofp" %}
8877 // TODO: need save_last_PC here?
8878 ins_encode( SetInstMark, Java_To_Runtime( meth ),
8879 call_epilog, ClearInstMark );
8880 ins_pipe(simple_call);
8881 %}
8882
8883 // Tail Call; Jump from runtime stub to Java code.
8884 // Also known as an 'interprocedural jump'.
8885 // Target of jump will eventually return to caller.
8886 // TailJump below removes the return address.
8887 instruct TailCalljmpInd(IPRegP jump_target, inline_cache_regP method_ptr) %{
8888 match(TailCall jump_target method_ptr);
8889
8890 ins_cost(CALL_COST);
8891 format %{ "MOV Rexception_pc, LR\n\t"
8892 "jump $jump_target \t! $method_ptr holds method" %}
8893 ins_encode %{
8894 __ mov(Rexception_pc, LR); // this is used only to call
8895 // StubRoutines::forward_exception_entry()
8896 // which expects PC of exception in
8897 // R5. FIXME?
8898 __ jump($jump_target$$Register);
8899 %}
8900 ins_pipe(tail_call);
8901 %}
8902
8903
8904 // Return Instruction
8905 instruct Ret() %{
8906 match(Return);
8907
8908 format %{ "ret LR" %}
8909
8910 ins_encode %{
8911 __ ret(LR);
8912 %}
8913
8914 ins_pipe(br);
8915 %}
8916
8917
8922 // "restore" before this instruction (in Epilogue), we need to materialize it
8923 // in %i0.
8924 instruct tailjmpInd(IPRegP jump_target, RExceptionRegP ex_oop) %{
8925 match( TailJump jump_target ex_oop );
8926 ins_cost(CALL_COST);
8927 format %{ "MOV Rexception_pc, LR\n\t"
8928 "jump $jump_target \t! $ex_oop holds exc. oop" %}
8929 ins_encode %{
8930 __ mov(Rexception_pc, LR);
8931 __ jump($jump_target$$Register);
8932 %}
8933 ins_pipe(tail_call);
8934 %}
8935
8936 // Forward exception.
8937 instruct ForwardExceptionjmp()
8938 %{
8939 match(ForwardException);
8940 ins_cost(CALL_COST);
8941
8942 format %{ "b forward_exception_stub" %}
8943 ins_encode %{
8944 // OK to trash Rtemp, because Rtemp is used by stub
8945 __ jump(StubRoutines::forward_exception_entry(), relocInfo::runtime_call_type, Rtemp);
8946 %}
8947 ins_pipe(tail_call);
8948 %}
8949
8950 // Create exception oop: created by stack-crawling runtime code.
8951 // Created exception is now available to this handler, and is setup
8952 // just prior to jumping to this handler. No code emitted.
8953 instruct CreateException( RExceptionRegP ex_oop )
8954 %{
8955 match(Set ex_oop (CreateEx));
8956 ins_cost(0);
8957
8958 size(0);
8959 // use the following format syntax
8960 format %{ "! exception oop is in Rexception_obj; no code emitted" %}
8961 ins_encode();
8962 ins_pipe(empty);
8963 %}
|
8871 // Call runtime without safepoint - same as CallLeaf
8872 instruct CallLeafNoFPDirect(method meth) %{
8873 match(CallLeafNoFP);
8874 effect(USE meth);
8875 ins_cost(CALL_COST);
8876 format %{ "CALL,runtime leaf nofp" %}
8877 // TODO: need save_last_PC here?
8878 ins_encode( SetInstMark, Java_To_Runtime( meth ),
8879 call_epilog, ClearInstMark );
8880 ins_pipe(simple_call);
8881 %}
8882
8883 // Tail Call; Jump from runtime stub to Java code.
8884 // Also known as an 'interprocedural jump'.
8885 // Target of jump will eventually return to caller.
8886 // TailJump below removes the return address.
8887 instruct TailCalljmpInd(IPRegP jump_target, inline_cache_regP method_ptr) %{
8888 match(TailCall jump_target method_ptr);
8889
8890 ins_cost(CALL_COST);
8891 format %{ "jump $jump_target \t! $method_ptr holds method" %}
8892 ins_encode %{
8893 __ jump($jump_target$$Register);
8894 %}
8895 ins_pipe(tail_call);
8896 %}
8897
8898
8899 // Return Instruction
8900 instruct Ret() %{
8901 match(Return);
8902
8903 format %{ "ret LR" %}
8904
8905 ins_encode %{
8906 __ ret(LR);
8907 %}
8908
8909 ins_pipe(br);
8910 %}
8911
8912
8917 // "restore" before this instruction (in Epilogue), we need to materialize it
8918 // in %i0.
8919 instruct tailjmpInd(IPRegP jump_target, RExceptionRegP ex_oop) %{
8920 match( TailJump jump_target ex_oop );
8921 ins_cost(CALL_COST);
8922 format %{ "MOV Rexception_pc, LR\n\t"
8923 "jump $jump_target \t! $ex_oop holds exc. oop" %}
8924 ins_encode %{
8925 __ mov(Rexception_pc, LR);
8926 __ jump($jump_target$$Register);
8927 %}
8928 ins_pipe(tail_call);
8929 %}
8930
8931 // Forward exception.
8932 instruct ForwardExceptionjmp()
8933 %{
8934 match(ForwardException);
8935 ins_cost(CALL_COST);
8936
8937 format %{ "MOV Rexception_pc, LR\n\t"
8938 "b forward_exception_entry" %}
8939 ins_encode %{
8940 __ mov(Rexception_pc, LR);
8941 // OK to trash Rtemp, because Rtemp is used by stub
8942 __ jump(StubRoutines::forward_exception_entry(), relocInfo::runtime_call_type, Rtemp);
8943 %}
8944 ins_pipe(tail_call);
8945 %}
8946
8947 // Create exception oop: created by stack-crawling runtime code.
8948 // Created exception is now available to this handler, and is setup
8949 // just prior to jumping to this handler. No code emitted.
8950 instruct CreateException( RExceptionRegP ex_oop )
8951 %{
8952 match(Set ex_oop (CreateEx));
8953 ins_cost(0);
8954
8955 size(0);
8956 // use the following format syntax
8957 format %{ "! exception oop is in Rexception_obj; no code emitted" %}
8958 ins_encode();
8959 ins_pipe(empty);
8960 %}
|