jdk8-mips64-public/hotspot: src/cpu/mips/vm/runtime_mips

     1 /*

     2  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.

     3  * Copyright (c) 2015, 2016, Loongson Technology. All rights reserved.

     4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     5  *

     6  * This code is free software; you can redistribute it and/or modify it

     7  * under the terms of the GNU General Public License version 2 only, as

     8  * published by the Free Software Foundation.

     9  *

    10  * This code is distributed in the hope that it will be useful, but WITHOUT

    11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    13  * version 2 for more details (a copy is included in the LICENSE file that

    14  * accompanied this code).

    15  *

    16  * You should have received a copy of the GNU General Public License version

    17  * 2 along with this work; if not, write to the Free Software Foundation,

    18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    19  *

    20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    21  * or visit www.oracle.com if you need additional information or have any

    22  * questions.

    23  *

    24  */

    26 #include "precompiled.hpp"

    27 #ifdef COMPILER2

    28 #include "asm/macroAssembler.hpp"

    29 #include "asm/macroAssembler.inline.hpp"

    30 #include "classfile/systemDictionary.hpp"

    31 #include "code/vmreg.hpp"

    32 #include "interpreter/interpreter.hpp"

    33 #include "opto/runtime.hpp"

    34 #include "runtime/interfaceSupport.hpp"

    35 #include "runtime/sharedRuntime.hpp"

    36 #include "runtime/stubRoutines.hpp"

    37 #include "runtime/vframeArray.hpp"

    38 #include "utilities/globalDefinitions.hpp"

    39 #include "vmreg_mips.inline.hpp"

    40 #endif

    42 #define __ masm->

    44 //-------------- generate_exception_blob -----------

    45 // creates _exception_blob.

    46 // The exception blob is jumped to from a compiled method.

    47 // (see emit_exception_handler in sparc.ad file)

    48 //

    49 // Given an exception pc at a call we call into the runtime for the

    50 // handler in this method. This handler might merely restore state

    51 // (i.e. callee save registers) unwind the frame and jump to the

    52 // exception handler for the nmethod if there is no Java level handler

    53 // for the nmethod.

    54 //

    55 // This code is entered with a jump, and left with a jump.

    56 //

    57 // Arguments:

    58 //   V0: exception oop

    59 //   V1: exception pc

    60 //

    61 // Results:

    62 //   A0: exception oop

    63 //   A1: exception pc in caller or ???

    64 //   jumps to: exception handler of caller

    65 //

    66 // Note: the exception pc MUST be at a call (precise debug information)

    67 //

    68 // 2012/9/14 Jin: [stubGenerator_mips.cpp] generate_forward_exception()

    69 //                    |- V0, V1 are created

    70 //                    |- T9 <= SharedRuntime::exception_handler_for_return_address

    71 //                    `- jr T9

    72 //                         `- the caller's exception_handler

    73 //                               `- jr OptoRuntime::exception_blob

    74 //                                      `- here

    75 //

    76 void OptoRuntime::generate_exception_blob() {

    77   // Capture info about frame layout

    78   enum layout {

    79     fp_off,

    80     return_off,                 // slot for return address

    81     framesize

    82   };

    84   // allocate space for the code

    85   ResourceMark rm;

    86   // setup code generation tools

    87   CodeBuffer   buffer("exception_blob", 5120, 5120);

    88   MacroAssembler* masm = new MacroAssembler(&buffer);

    90 //  OopMapSet *oop_maps = new OopMapSet();

    92   address start = __ pc();

    94   __ daddiu(SP, SP, -1 * framesize * wordSize);   // Prolog!

    96   /* 2012/9.27 Jin: this frame will be treated as the original caller method.

    97    * So, the return pc should be filled with the original exception pc.

    98    *   ref: X86's implementation

    99    */

   100   __ sd(V1, SP, return_off  *wordSize);	// return address

   101   __ sd(FP, SP, fp_off  *wordSize);	// EBP

   103   // Save callee saved registers.  None for UseSSE=0,

   104   // floats-only for UseSSE=1, and doubles for UseSSE=2.

   106   __ daddiu(FP, SP, fp_off * wordSize);

   108   // Store exception in Thread object. We cannot pass any arguments to the

   109   // handle_exception call, since we do not want to make any assumption

   110   // about the size of the frame where the exception happened in.

   111   Register thread = TREG;

   113 #ifndef OPT_THREAD

   114   __ get_thread(thread);

   115 #endif

   117   __ sd(V0, Address(thread, JavaThread::exception_oop_offset()));

   118   __ sd(V1, Address(thread, JavaThread::exception_pc_offset()));

   120   // This call does all the hard work.  It checks if an exception handler

   121   // exists in the method.

   122   // If so, it returns the handler address.

   123   // If not, it prepares for stack-unwinding, restoring the callee-save

   124   // registers of the frame being removed.

   125   __ set_last_Java_frame(thread, NOREG, NOREG, NULL);

   127   __ move(AT, -(StackAlignmentInBytes));

   128   __ andr(SP, SP, AT);   // Fix stack alignment as required by ABI

   130   __ relocate(relocInfo::internal_pc_type);

   132   {

   133     long save_pc = (long)__ pc() +  24 + NativeCall::return_address_offset;

   134     __ li48(AT, save_pc);

   135   }

   136   __ sd(AT, thread, in_bytes(JavaThread::last_Java_pc_offset()));

   138   __ move(A0, thread);

   139   __ li48(T9, (long)OptoRuntime::handle_exception_C);

   140   __ jalr(T9);

   141   __ delayed()->nop();

   143   // Set an oopmap for the call site

   144   OopMapSet *oop_maps = new OopMapSet();

   145   OopMap* map =  new OopMap( framesize, 0 );

   147   oop_maps->add_gc_map( __ offset(), map);

   149 #ifndef OPT_THREAD

   150   __ get_thread(thread);

   151 #endif

   152   __ reset_last_Java_frame(thread, true, true);

   154   // Pop self-frame.

   155   __ leave();     // Epilog!

   157   // rax,: exception handler for given <exception oop/exception pc>

   159   // We have a handler in rax, (could be deopt blob)

   160   // rdx - throwing pc, deopt blob will need it.

   161   /* FIXME: rdx? */

   163   // rcx contains handler address

   164   __ move(T9, V0);

   166 #ifndef OPT_THREAD

   167   __ get_thread(thread);

   168 #endif

   169   // Get the exception

   170   __ ld(A0, Address(thread, JavaThread::exception_oop_offset()));

   171   // Get the exception pc in case we are deoptimized

   172   __ ld(A1, Address(thread, JavaThread::exception_pc_offset()));

   173 #ifdef ASSERT

   174   __ sd(R0, Address(thread, JavaThread::exception_handler_pc_offset()));

   175   __ sd(R0, Address(thread, JavaThread::exception_pc_offset()));

   176 #endif

   177   // Clear the exception oop so GC no longer processes it as a root.

   178   __ sd(R0, Address(thread, JavaThread::exception_oop_offset()));

   180   /* 2014/5/12 Jin: Fix seg fault when running:

   181    *    Eclipse + Plugin + Debug As

   182    *  This is the only condition where C2 calls SharedRuntime::generate_deopt_blob()

   183    *

   184    *  Ref:  http://10.2.5.21:8000/projects/java/wiki/Jgj-log-2014-5-12_

   185    */

   186   __ move(V0, A0);

   187   __ move(V1, A1);

   189   // rax,: exception oop

   190   // rcx: exception handler

   191   // rdx: exception pc

   192   __ jr(T9);

   193   __ delayed()->nop();

   195   // make sure all code is generated

   196   masm->flush();

   198   _exception_blob = ExceptionBlob::create(&buffer, oop_maps, framesize);

   199 }

src/cpu/mips/vm/runtime_mips_64.cpp@d885f8d65c58