Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/sources/formale Sprachen/Java/Openjdk/src/hotspot/cpu/s390/ (Sun/Oracle ^©) Datei vom 13.11.2022 mit Größe 8 kB

Quelle abstractInterpreter_s390.cpp Sprache: C

/*
* Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2016 SAP SE. 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 "interpreter/interpreter.hpp"
#include "oops/constMethod.hpp"
#include "oops/klass.inline.hpp"
#include "oops/method.hpp"
#include "runtime/frame.inline.hpp"
#include "utilities/debug.hpp"
#include "utilities/macros.hpp"

int AbstractInterpreter::BasicType_as_index(BasicType type) {
  int i = 0;
  switch (type) {
    case T_BOOLEAN: i = 0; break;
    case T_CHAR   : i = 1; break;
    case T_BYTE   : i = 2; break;
    case T_SHORT  : i = 3; break;
    case T_INT    : i = 4; break;
    case T_LONG   : i = 5; break;
    case T_VOID   : i = 6; break;
    case T_FLOAT  : i = 7; break;
    case T_DOUBLE : i = 8; break;
    case T_OBJECT : i = 9; break;
    case T_ARRAY  : i = 9; break;
    default       : ShouldNotReachHere();
  }
  assert(0 <= i && i < AbstractInterpreter::number_of_result_handlers, "index out of bounds");
  return i;
}

// How much stack a method top interpreter activation needs in words.
int AbstractInterpreter::size_top_interpreter_activation(Method* method) {

  // We have to size the following 2 frames:
  //
  //   [TOP_IJAVA_FRAME_ABI]
  //   [ENTRY_FRAME]
  //
  // This expands to (see frame_s390.hpp):
  //
  //   [TOP_IJAVA_FRAME_ABI]
  //   [operand stack]                 > stack
  //   [monitors]      (optional)      > monitors
  //   [IJAVA_STATE]                   > interpreter_state
  //   [PARENT_IJAVA_FRAME_ABI]
  //   [callee's locals w/o arguments] \ locals
  //   [outgoing arguments]            /
  //   [ENTRY_FRAME_LOCALS]

  int locals = method->max_locals() * BytesPerWord;
  int interpreter_state = frame::z_ijava_state_size;

  int stack = method->max_stack() * BytesPerWord;
  int monitors = method->is_synchronized() ? frame::interpreter_frame_monitor_size_in_bytes() : 0;

  int total_bytes =
    frame::z_top_ijava_frame_abi_size +
    stack +
    monitors +
    interpreter_state +
    frame::z_parent_ijava_frame_abi_size +
    locals +
    frame::z_entry_frame_locals_size;

  return (total_bytes/BytesPerWord);
}

// Returns number of stackElementWords needed for the interpreter frame with the
// given sections.
// This overestimates the stack by one slot in case of alignments.
int AbstractInterpreter::size_activation(int max_stack,
                                         int temps,
                                         int extra_args,
                                         int monitors,
                                         int callee_params,
                                         int callee_locals,
                                         bool is_top_frame) {
  // Note: This calculation must exactly parallel the frame setup
  // in AbstractInterpreterGenerator::generate_method_entry.

  assert((Interpreter::stackElementSize == frame::alignment_in_bytes), "must align frame size");
  const int abi_scratch = is_top_frame ? (frame::z_top_ijava_frame_abi_size    / Interpreter::stackElementSize) :
                                         (frame::z_parent_ijava_frame_abi_size / Interpreter::stackElementSize);

  const int size =
    max_stack                                                 +
    (callee_locals - callee_params)                           + // Already counted in max_stack().
    monitors * frame::interpreter_frame_monitor_size()        +
    abi_scratch                                               +
    frame::z_ijava_state_size / Interpreter::stackElementSize;

  // Fixed size of an interpreter frame.
  return size;
}

// Fills a sceletal interpreter frame generated during deoptimizations.
//
// Parameters:
//
// interpreter_frame != NULL:
//   set up the method, locals, and monitors.
//   The frame interpreter_frame, if not NULL, is guaranteed to be the
//   right size, as determined by a previous call to this method.
//   It is also guaranteed to be walkable even though it is in a skeletal state
//
// is_top_frame == true:
//   We're processing the *oldest* interpreter frame!
//
// pop_frame_extra_args:
//   If this is != 0 we are returning to a deoptimized frame by popping
//   off the callee frame. We want to re-execute the call that called the
//   callee interpreted, but since the return to the interpreter would pop
//   the arguments off advance the esp by dummy popframe_extra_args slots.
//   Popping off those will establish the stack layout as it was before the call.
//

void AbstractInterpreter::layout_activation(Method* method,
                                            int tempcount,
                                            int popframe_extra_args,
                                            int moncount,
                                            int caller_actual_parameters,
                                            int callee_param_count,
                                            int callee_locals_count,
                                            frame* caller,
                                            frame* interpreter_frame,
                                            bool is_top_frame,
                                            bool is_bottom_frame) {
  // TOP_IJAVA_FRAME:
  //
  //    0 [TOP_IJAVA_FRAME_ABI]         -+
  //   16 [operand stack]                | size
  //      [monitors]      (optional)     |
  //      [IJAVA_STATE]                 -+
  //      Note: own locals are located in the caller frame.
  //
  // PARENT_IJAVA_FRAME:
  //
  //    0 [PARENT_IJAVA_FRAME_ABI]                    -+
  //      [callee's locals w/o arguments]              |
  //      [outgoing arguments]                         | size
  //      [used part of operand stack w/o arguments]   |
  //      [monitors]      (optional)                   |
  //      [IJAVA_STATE]                               -+
  //

  // Now we know our caller, calc the exact frame layout and size
  // z_ijava_state->locals - i*BytesPerWord points to i-th Java local (i starts at 0).
  intptr_t* locals_base = (caller->is_interpreted_frame())
    ? (caller->interpreter_frame_tos_address() + caller_actual_parameters - 1)
    : (caller->sp()                            + method->max_locals()     - 1 +
       frame::z_parent_ijava_frame_abi_size / Interpreter::stackElementSize);

  intptr_t* monitor_base = (intptr_t*)((address)interpreter_frame->fp() - frame::z_ijava_state_size);
  intptr_t* monitor      = monitor_base - (moncount * frame::interpreter_frame_monitor_size());
  intptr_t* operand_stack_base = monitor;
  intptr_t* tos          = operand_stack_base - tempcount - popframe_extra_args;
  intptr_t* top_frame_sp =
    operand_stack_base - method->max_stack() - frame::z_top_ijava_frame_abi_size / Interpreter::stackElementSize;
  intptr_t* sender_sp;
  if (caller->is_interpreted_frame()) {
    sender_sp = caller->interpreter_frame_top_frame_sp();
  } else if (caller->is_compiled_frame()) {
    sender_sp = caller->fp() - caller->cb()->frame_size();
    // The bottom frame's sender_sp is its caller's unextended_sp.
    // It was already set when its skeleton was pushed (see push_skeleton_frames()).
    // Note: the unextended_sp is required by nmethod::orig_pc_addr().
    assert(is_bottom_frame && (sender_sp == caller->unextended_sp()),
           "must initialize sender_sp of bottom skeleton frame when pushing it");
  } else {
    assert(caller->is_entry_frame(), "is there a new frame type??");
    sender_sp = caller->sp(); // Call_stub only uses it's fp.
  }

  interpreter_frame->interpreter_frame_set_method(method);
  interpreter_frame->interpreter_frame_set_mirror(method->method_holder()->java_mirror());
  interpreter_frame->interpreter_frame_set_locals(locals_base);
  interpreter_frame->interpreter_frame_set_monitor_end((BasicObjectLock *)monitor);
  *interpreter_frame->interpreter_frame_cache_addr() = method->constants()->cache();
  interpreter_frame->interpreter_frame_set_tos_address(tos);
  interpreter_frame->interpreter_frame_set_sender_sp(sender_sp);
  interpreter_frame->interpreter_frame_set_top_frame_sp(top_frame_sp);
}

quality95%

¤ Dauer der Verarbeitung: 0.11 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.