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

src/cpu/mips/vm/cppInterpreter_mips.cpp@2d8a650513c2 (annotated)

src/cpu/mips/vm/cppInterpreter_mips.cpp

Fri, 29 Apr 2016 00:06:10 +0800

author: aoqi
date: Fri, 29 Apr 2016 00:06:10 +0800
changeset 1: 2d8a650513c2
permissions: -rw-r--r--

Added MIPS 64-bit port.

 /*
  * Copyright (c) 2007, 2013, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2015, 2016, Loongson Technology. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  *
  */
 #include "precompiled.hpp"
 #include "asm/macroAssembler.hpp"
 #include "interpreter/bytecodeHistogram.hpp"
 #include "interpreter/cppInterpreter.hpp"
 #include "interpreter/interpreter.hpp"
 #include "interpreter/interpreterGenerator.hpp"
 #include "interpreter/interpreterRuntime.hpp"
 #include "oops/arrayOop.hpp"
 #include "oops/methodData.hpp"
 #include "oops/method.hpp"
 #include "oops/oop.inline.hpp"
 #include "prims/jvmtiExport.hpp"
 #include "prims/jvmtiThreadState.hpp"
 #include "runtime/arguments.hpp"
 #include "runtime/deoptimization.hpp"
 #include "runtime/frame.inline.hpp"
 #include "runtime/interfaceSupport.hpp"
 #include "runtime/sharedRuntime.hpp"
 #include "runtime/stubRoutines.hpp"
 #include "runtime/synchronizer.hpp"
 #include "runtime/timer.hpp"
 #include "runtime/vframeArray.hpp"
 #include "utilities/debug.hpp"
 #ifdef SHARK
 #include "shark/shark_globals.hpp"
 #endif
 #ifdef CC_INTERP
 // Routine exists to make tracebacks look decent in debugger
 // while "shadow" interpreter frames are on stack. It is also
 // used to distinguish interpreter frames.
 extern "C" void RecursiveInterpreterActivation(interpreterState istate) {
   ShouldNotReachHere();
 }
 bool CppInterpreter::contains(address pc) {
   Unimplemented();
 }
 #define STATE(field_name) Lstate, in_bytes(byte_offset_of(BytecodeInterpreter, field_name))
 #define __ _masm->
 Label frame_manager_entry;
 Label fast_accessor_slow_entry_path;  // fast accessor methods need to be able to jmp to unsynchronized
                                       // c++ interpreter entry point this holds that entry point label.
 static address unctrap_frame_manager_entry  = NULL;
 static address interpreter_return_address  = NULL;
 static address deopt_frame_manager_return_atos  = NULL;
 static address deopt_frame_manager_return_btos  = NULL;
 static address deopt_frame_manager_return_itos  = NULL;
 static address deopt_frame_manager_return_ltos  = NULL;
 static address deopt_frame_manager_return_ftos  = NULL;
 static address deopt_frame_manager_return_dtos  = NULL;
 static address deopt_frame_manager_return_vtos  = NULL;
 const Register prevState = G1_scratch;
 void InterpreterGenerator::save_native_result(void) {
   Unimplemented();
 }
 void InterpreterGenerator::restore_native_result(void) {
   Unimplemented();
 }
 // A result handler converts/unboxes a native call result into
 // a java interpreter/compiler result. The current frame is an
 // interpreter frame. The activation frame unwind code must be
 // consistent with that of TemplateTable::_return(...). In the
 // case of native methods, the caller's SP was not modified.
 address CppInterpreterGenerator::generate_result_handler_for(BasicType type) {
   Unimplemented();
 }
 address CppInterpreterGenerator::generate_tosca_to_stack_converter(BasicType type) {
   Unimplemented();
 }
 address CppInterpreterGenerator::generate_stack_to_stack_converter(BasicType type) {
   Unimplemented();
 }
 address CppInterpreterGenerator::generate_stack_to_native_abi_converter(BasicType type) {
   Unimplemented();
 }
 address CppInterpreter::return_entry(TosState state, int length) {
   Unimplemented();
 }
 address CppInterpreter::deopt_entry(TosState state, int length) {
   Unimplemented();
 }
 void InterpreterGenerator::generate_counter_incr(Label* overflow, Label* profile_method, Label* profile_method_continue) {
   Unimplemented();
 }
 address InterpreterGenerator::generate_empty_entry(void) {
   Unimplemented();
 }
 address InterpreterGenerator::generate_accessor_entry(void) {
   Unimplemented();
 }
 address InterpreterGenerator::generate_native_entry(bool synchronized) {
   Unimplemented();
 }
 void CppInterpreterGenerator::generate_compute_interpreter_state(const Register state,
                                                               const Register prev_state,
                                                               bool native) {
   Unimplemented();
 }
 void InterpreterGenerator::lock_method(void) {
   Unimplemented();
 }
 void CppInterpreterGenerator::generate_deopt_handling() {
   Unimplemented();
 }
 void CppInterpreterGenerator::generate_more_monitors() {
   Unimplemented();
 }
 static address interpreter_frame_manager = NULL;
 void CppInterpreterGenerator::adjust_callers_stack(Register args) {
   Unimplemented();
 }
 address InterpreterGenerator::generate_normal_entry(bool synchronized) {
   Unimplemented();
 }
 InterpreterGenerator::InterpreterGenerator(StubQueue* code)
  : CppInterpreterGenerator(code) {
   Unimplemented();
 }
 static int size_activation_helper(int callee_extra_locals, int max_stack, int monitor_size) {
   Unimplemented();
 }
 int AbstractInterpreter::size_top_interpreter_activation(methodOop method) {
   Unimplemented();
 }
 void BytecodeInterpreter::layout_interpreterState(interpreterState to_fill,
                                            frame* caller,
                                            frame* current,
                                            methodOop method,
                                            intptr_t* locals,
                                            intptr_t* stack,
                                            intptr_t* stack_base,
                                            intptr_t* monitor_base,
                                            intptr_t* frame_bottom,
                                            bool is_top_frame
                                            )
 {
   Unimplemented();
 }
 void BytecodeInterpreter::pd_layout_interpreterState(interpreterState istate, address last_Java_pc, intptr_t* last_Java_fp) {
   Unimplemented();
 }
 int AbstractInterpreter::layout_activation(methodOop method,
                                            int tempcount, // Number of slots on java expression stack in use
                                            int popframe_extra_args,
                                            int moncount,  // Number of active monitors
                                            int callee_param_size,
                                            int callee_locals_size,
                                            frame* caller,
                                            frame* interpreter_frame,
                                            bool is_top_frame) {
   Unimplemented();
 }
 #endif // CC_INTERP

Mercurial > jdk8-mips64-public > hotspot / annotate

src/cpu/mips/vm/cppInterpreter_mips.cpp@2d8a650513c2 (annotated)

src/cpu/mips/vm/cppInterpreter_mips.cpp