hotspot/src/cpu/sparc/vm/c1_Runtime1_sparc.cpp
author bobv
Tue, 03 Aug 2010 08:13:38 -0400
changeset 6176 4d9030fe341f
parent 5702 201c5cde25bb
child 6453 970dc585ab63
permissions -rw-r--r--
6953477: Increase portability and flexibility of building Hotspot Summary: A collection of portability improvements including shared code support for PPC, ARM platforms, software floating point, cross compilation support and improvements in error crash detail. Reviewed-by: phh, never, coleenp, dholmes
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5046
diff changeset
     2
 * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5046
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5046
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5046
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
489c9b5090e2 Initial load
duke
parents:
diff changeset
    25
#include "incls/_precompiled.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    26
#include "incls/_c1_Runtime1_sparc.cpp.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    27
489c9b5090e2 Initial load
duke
parents:
diff changeset
    28
// Implementation of StubAssembler
489c9b5090e2 Initial load
duke
parents:
diff changeset
    29
489c9b5090e2 Initial load
duke
parents:
diff changeset
    30
int StubAssembler::call_RT(Register oop_result1, Register oop_result2, address entry_point, int number_of_arguments) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
  // for sparc changing the number of arguments doesn't change
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
  // anything about the frame size so we'll always lie and claim that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
  // we are only passing 1 argument.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
  set_num_rt_args(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
  assert_not_delayed();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
  // bang stack before going to runtime
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
  set(-os::vm_page_size() + STACK_BIAS, G3_scratch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
  st(G0, SP, G3_scratch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
  // debugging support
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
  assert(number_of_arguments >= 0   , "cannot have negative number of arguments");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
  set_last_Java_frame(SP, noreg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
  if (VerifyThread)  mov(G2_thread, O0); // about to be smashed; pass early
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
  save_thread(L7_thread_cache);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
  // do the call
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
  call(entry_point, relocInfo::runtime_call_type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
  if (!VerifyThread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
    delayed()->mov(G2_thread, O0);  // pass thread as first argument
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
    delayed()->nop();             // (thread already passed)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
  int call_offset = offset();  // offset of return address
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
  restore_thread(L7_thread_cache);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
  reset_last_Java_frame();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
  // check for pending exceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
  { Label L;
2571
d602ad6538bd 6822110: Add AddressLiteral class on SPARC
twisti
parents: 2256
diff changeset
    60
    Address exception_addr(G2_thread, Thread::pending_exception_offset());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
    ld_ptr(exception_addr, Gtemp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
    br_null(Gtemp, false, pt, L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
    delayed()->nop();
2571
d602ad6538bd 6822110: Add AddressLiteral class on SPARC
twisti
parents: 2256
diff changeset
    64
    Address vm_result_addr(G2_thread, JavaThread::vm_result_offset());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
    st_ptr(G0, vm_result_addr);
2571
d602ad6538bd 6822110: Add AddressLiteral class on SPARC
twisti
parents: 2256
diff changeset
    66
    Address vm_result_addr_2(G2_thread, JavaThread::vm_result_2_offset());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
    st_ptr(G0, vm_result_addr_2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
    if (frame_size() == no_frame_size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
      // we use O7 linkage so that forward_exception_entry has the issuing PC
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
      call(StubRoutines::forward_exception_entry(), relocInfo::runtime_call_type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
      delayed()->restore();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
    } else if (_stub_id == Runtime1::forward_exception_id) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
      should_not_reach_here();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
    } else {
2571
d602ad6538bd 6822110: Add AddressLiteral class on SPARC
twisti
parents: 2256
diff changeset
    76
      AddressLiteral exc(Runtime1::entry_for(Runtime1::forward_exception_id));
d602ad6538bd 6822110: Add AddressLiteral class on SPARC
twisti
parents: 2256
diff changeset
    77
      jump_to(exc, G4);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
      delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
    bind(L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  // get oop result if there is one and reset the value in the thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
  if (oop_result1->is_valid()) {                    // get oop result if there is one and reset it in the thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
    get_vm_result  (oop_result1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
    // be a little paranoid and clear the result
2571
d602ad6538bd 6822110: Add AddressLiteral class on SPARC
twisti
parents: 2256
diff changeset
    88
    Address vm_result_addr(G2_thread, JavaThread::vm_result_offset());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
    st_ptr(G0, vm_result_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
  if (oop_result2->is_valid()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
    get_vm_result_2(oop_result2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
    // be a little paranoid and clear the result
2571
d602ad6538bd 6822110: Add AddressLiteral class on SPARC
twisti
parents: 2256
diff changeset
    96
    Address vm_result_addr_2(G2_thread, JavaThread::vm_result_2_offset());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
    st_ptr(G0, vm_result_addr_2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  return call_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
int StubAssembler::call_RT(Register oop_result1, Register oop_result2, address entry, Register arg1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  // O0 is reserved for the thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  mov(arg1, O1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  return call_RT(oop_result1, oop_result2, entry, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
int StubAssembler::call_RT(Register oop_result1, Register oop_result2, address entry, Register arg1, Register arg2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
  // O0 is reserved for the thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  mov(arg1, O1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
  mov(arg2, O2); assert(arg2 != O1, "smashed argument");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  return call_RT(oop_result1, oop_result2, entry, 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
int StubAssembler::call_RT(Register oop_result1, Register oop_result2, address entry, Register arg1, Register arg2, Register arg3) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  // O0 is reserved for the thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  mov(arg1, O1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  mov(arg2, O2); assert(arg2 != O1,               "smashed argument");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  mov(arg3, O3); assert(arg3 != O1 && arg3 != O2, "smashed argument");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  return call_RT(oop_result1, oop_result2, entry, 3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
// Implementation of Runtime1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
#define __ sasm->
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
static int cpu_reg_save_offsets[FrameMap::nof_cpu_regs];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
static int fpu_reg_save_offsets[FrameMap::nof_fpu_regs];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
static int reg_save_size_in_words;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
static int frame_size_in_bytes = -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
static OopMap* generate_oop_map(StubAssembler* sasm, bool save_fpu_registers) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  assert(frame_size_in_bytes == __ total_frame_size_in_bytes(reg_save_size_in_words),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
         " mismatch in calculation");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  sasm->set_frame_size(frame_size_in_bytes / BytesPerWord);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
  int frame_size_in_slots = frame_size_in_bytes / sizeof(jint);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  OopMap* oop_map = new OopMap(frame_size_in_slots, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  int i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  for (i = 0; i < FrameMap::nof_cpu_regs; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
    Register r = as_Register(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
    if (r == G1 || r == G3 || r == G4 || r == G5) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
      int sp_offset = cpu_reg_save_offsets[i];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
      oop_map->set_callee_saved(VMRegImpl::stack2reg(sp_offset),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
                                r->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  if (save_fpu_registers) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
    for (i = 0; i < FrameMap::nof_fpu_regs; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
      FloatRegister r = as_FloatRegister(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
      int sp_offset = fpu_reg_save_offsets[i];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
      oop_map->set_callee_saved(VMRegImpl::stack2reg(sp_offset),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
                                r->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  return oop_map;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
static OopMap* save_live_registers(StubAssembler* sasm, bool save_fpu_registers = true) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
  assert(frame_size_in_bytes == __ total_frame_size_in_bytes(reg_save_size_in_words),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
         " mismatch in calculation");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
  __ save_frame_c1(frame_size_in_bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
  sasm->set_frame_size(frame_size_in_bytes / BytesPerWord);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  // Record volatile registers as callee-save values in an OopMap so their save locations will be
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  // propagated to the caller frame's RegisterMap during StackFrameStream construction (needed for
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  // deoptimization; see compiledVFrame::create_stack_value).  The caller's I, L and O registers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  // are saved in register windows - I's and L's in the caller's frame and O's in the stub frame
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
  // (as the stub's I's) when the runtime routine called by the stub creates its frame.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  // OopMap frame sizes are in c2 stack slot sizes (sizeof(jint))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  int i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  for (i = 0; i < FrameMap::nof_cpu_regs; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
    Register r = as_Register(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
    if (r == G1 || r == G3 || r == G4 || r == G5) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
      int sp_offset = cpu_reg_save_offsets[i];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
      __ st_ptr(r, SP, (sp_offset * BytesPerWord) + STACK_BIAS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  if (save_fpu_registers) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
    for (i = 0; i < FrameMap::nof_fpu_regs; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
      FloatRegister r = as_FloatRegister(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
      int sp_offset = fpu_reg_save_offsets[i];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
      __ stf(FloatRegisterImpl::S, r, SP, (sp_offset * BytesPerWord) + STACK_BIAS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
  return generate_oop_map(sasm, save_fpu_registers);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
static void restore_live_registers(StubAssembler* sasm, bool restore_fpu_registers = true) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  for (int i = 0; i < FrameMap::nof_cpu_regs; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
    Register r = as_Register(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
    if (r == G1 || r == G3 || r == G4 || r == G5) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
      __ ld_ptr(SP, (cpu_reg_save_offsets[i] * BytesPerWord) + STACK_BIAS, r);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  if (restore_fpu_registers) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
    for (int i = 0; i < FrameMap::nof_fpu_regs; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
      FloatRegister r = as_FloatRegister(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
      __ ldf(FloatRegisterImpl::S, SP, (fpu_reg_save_offsets[i] * BytesPerWord) + STACK_BIAS, r);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
void Runtime1::initialize_pd() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
  // compute word offsets from SP at which live (non-windowed) registers are captured by stub routines
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
  // A stub routine will have a frame that is at least large enough to hold
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
  // a register window save area (obviously) and the volatile g registers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
  // and floating registers. A user of save_live_registers can have a frame
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
  // that has more scratch area in it (although typically they will use L-regs).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
  // in that case the frame will look like this (stack growing down)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
  // FP -> |             |
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
  //       | scratch mem |
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
  //       |   "      "  |
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
  //       --------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
  //       | float regs  |
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  //       |   "    "    |
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
  //       ---------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
  //       | G regs      |
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
  //       | "  "        |
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
  //       ---------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
  //       | abi reg.    |
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  //       | window save |
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
  //       | area        |
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
  // SP -> ---------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  int i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
  int sp_offset = round_to(frame::register_save_words, 2); //  start doubleword aligned
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
  // only G int registers are saved explicitly; others are found in register windows
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
  for (i = 0; i < FrameMap::nof_cpu_regs; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
    Register r = as_Register(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
    if (r == G1 || r == G3 || r == G4 || r == G5) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
      cpu_reg_save_offsets[i] = sp_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
      sp_offset++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
  // all float registers are saved explicitly
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
  assert(FrameMap::nof_fpu_regs == 32, "double registers not handled here");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
  for (i = 0; i < FrameMap::nof_fpu_regs; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
    fpu_reg_save_offsets[i] = sp_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
    sp_offset++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
  reg_save_size_in_words = sp_offset - frame::memory_parameter_word_sp_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
  // this should match assembler::total_frame_size_in_bytes, which
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
  // isn't callable from this context.  It's checked by an assert when
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
  // it's used though.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  frame_size_in_bytes = align_size_up(sp_offset * wordSize, 8);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
OopMapSet* Runtime1::generate_exception_throw(StubAssembler* sasm, address target, bool has_argument) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
  // make a frame and preserve the caller's caller-save registers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
  OopMap* oop_map = save_live_registers(sasm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
  int call_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
  if (!has_argument) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
    call_offset = __ call_RT(noreg, noreg, target);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
    call_offset = __ call_RT(noreg, noreg, target, G4);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
  OopMapSet* oop_maps = new OopMapSet();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
  oop_maps->add_gc_map(call_offset, oop_map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
  __ should_not_reach_here();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
  return oop_maps;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
OopMapSet* Runtime1::generate_stub_call(StubAssembler* sasm, Register result, address target,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
                                        Register arg1, Register arg2, Register arg3) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
  // make a frame and preserve the caller's caller-save registers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
  OopMap* oop_map = save_live_registers(sasm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
  int call_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
  if (arg1 == noreg) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
    call_offset = __ call_RT(result, noreg, target);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
  } else if (arg2 == noreg) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
    call_offset = __ call_RT(result, noreg, target, arg1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
  } else if (arg3 == noreg) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
    call_offset = __ call_RT(result, noreg, target, arg1, arg2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
    call_offset = __ call_RT(result, noreg, target, arg1, arg2, arg3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  OopMapSet* oop_maps = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  oop_maps = new OopMapSet();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
  oop_maps->add_gc_map(call_offset, oop_map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
  restore_live_registers(sasm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
  __ ret();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
  __ delayed()->restore();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
  return oop_maps;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
OopMapSet* Runtime1::generate_patching(StubAssembler* sasm, address target) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
  // make a frame and preserve the caller's caller-save registers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
  OopMap* oop_map = save_live_registers(sasm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
  // call the runtime patching routine, returns non-zero if nmethod got deopted.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
  int call_offset = __ call_RT(noreg, noreg, target);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  OopMapSet* oop_maps = new OopMapSet();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
  oop_maps->add_gc_map(call_offset, oop_map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
  // re-execute the patched instruction or, if the nmethod was deoptmized, return to the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
  // deoptimization handler entry that will cause re-execution of the current bytecode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  DeoptimizationBlob* deopt_blob = SharedRuntime::deopt_blob();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
  assert(deopt_blob != NULL, "deoptimization blob must have been created");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
  Label no_deopt;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
  __ tst(O0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
  __ brx(Assembler::equal, false, Assembler::pt, no_deopt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  __ delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
  // return to the deoptimization handler entry for unpacking and rexecute
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
  // if we simply returned the we'd deopt as if any call we patched had just
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
  // returned.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
  restore_live_registers(sasm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
  __ restore();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
  __ br(Assembler::always, false, Assembler::pt, deopt_blob->unpack_with_reexecution(), relocInfo::runtime_call_type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
  __ delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
  __ bind(no_deopt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
  restore_live_registers(sasm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  __ ret();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
  __ delayed()->restore();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
  return oop_maps;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
OopMapSet* Runtime1::generate_code_for(StubID id, StubAssembler* sasm) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
  OopMapSet* oop_maps = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
  // for better readability
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
  const bool must_gc_arguments = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
  const bool dont_gc_arguments = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
  // stub code & info for the different stubs
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
  switch (id) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
    case forward_exception_id:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
        // we're handling an exception in the context of a compiled
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
        // frame.  The registers have been saved in the standard
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
        // places.  Perform an exception lookup in the caller and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
        // dispatch to the handler if found.  Otherwise unwind and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
        // dispatch to the callers exception handler.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
        oop_maps = new OopMapSet();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
        OopMap* oop_map = generate_oop_map(sasm, true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
        // transfer the pending exception to the exception_oop
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
        __ ld_ptr(G2_thread, in_bytes(JavaThread::pending_exception_offset()), Oexception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
        __ ld_ptr(Oexception, 0, G0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
        __ st_ptr(G0, G2_thread, in_bytes(JavaThread::pending_exception_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
        __ add(I7, frame::pc_return_offset, Oissuing_pc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
        generate_handle_exception(sasm, oop_maps, oop_map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
        __ should_not_reach_here();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
    case new_instance_id:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
    case fast_new_instance_id:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
    case fast_new_instance_init_check_id:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
        Register G5_klass = G5; // Incoming
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
        Register O0_obj   = O0; // Outgoing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
        if (id == new_instance_id) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
          __ set_info("new_instance", dont_gc_arguments);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
        } else if (id == fast_new_instance_id) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
          __ set_info("fast new_instance", dont_gc_arguments);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
          assert(id == fast_new_instance_init_check_id, "bad StubID");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
          __ set_info("fast new_instance init check", dont_gc_arguments);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
        if ((id == fast_new_instance_id || id == fast_new_instance_init_check_id) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
            UseTLAB && FastTLABRefill) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
          Label slow_path;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
          Register G1_obj_size = G1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
          Register G3_t1 = G3;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
          Register G4_t2 = G4;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
          assert_different_registers(G5_klass, G1_obj_size, G3_t1, G4_t2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
          // Push a frame since we may do dtrace notification for the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
          // allocation which requires calling out and we don't want
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
          // to stomp the real return address.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
          __ save_frame(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
          if (id == fast_new_instance_init_check_id) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
            // make sure the klass is initialized
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
            __ ld(G5_klass, instanceKlass::init_state_offset_in_bytes() + sizeof(oopDesc), G3_t1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
            __ cmp(G3_t1, instanceKlass::fully_initialized);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
            __ br(Assembler::notEqual, false, Assembler::pn, slow_path);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
            __ delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
          // assert object can be fast path allocated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
          {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
            Label ok, not_ok;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
          __ ld(G5_klass, Klass::layout_helper_offset_in_bytes() + sizeof(oopDesc), G1_obj_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
          __ cmp(G1_obj_size, 0);  // make sure it's an instance (LH > 0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
          __ br(Assembler::lessEqual, false, Assembler::pn, not_ok);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
          __ delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
          __ btst(Klass::_lh_instance_slow_path_bit, G1_obj_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
          __ br(Assembler::zero, false, Assembler::pn, ok);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
          __ delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
          __ bind(not_ok);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
          __ stop("assert(can be fast path allocated)");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
          __ should_not_reach_here();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
          __ bind(ok);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
#endif // ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
          // if we got here then the TLAB allocation failed, so try
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
          // refilling the TLAB or allocating directly from eden.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
          Label retry_tlab, try_eden;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
          __ tlab_refill(retry_tlab, try_eden, slow_path); // preserves G5_klass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
          __ bind(retry_tlab);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
          // get the instance size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
          __ ld(G5_klass, klassOopDesc::header_size() * HeapWordSize + Klass::layout_helper_offset_in_bytes(), G1_obj_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
          __ tlab_allocate(O0_obj, G1_obj_size, 0, G3_t1, slow_path);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
          __ initialize_object(O0_obj, G5_klass, G1_obj_size, 0, G3_t1, G4_t2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
          __ verify_oop(O0_obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
          __ mov(O0, I0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
          __ ret();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
          __ delayed()->restore();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
          __ bind(try_eden);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
          // get the instance size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
          __ ld(G5_klass, klassOopDesc::header_size() * HeapWordSize + Klass::layout_helper_offset_in_bytes(), G1_obj_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
          __ eden_allocate(O0_obj, G1_obj_size, 0, G3_t1, G4_t2, slow_path);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
          __ initialize_object(O0_obj, G5_klass, G1_obj_size, 0, G3_t1, G4_t2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
          __ verify_oop(O0_obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
          __ mov(O0, I0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
          __ ret();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
          __ delayed()->restore();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
          __ bind(slow_path);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
          // pop this frame so generate_stub_call can push it's own
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
          __ restore();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
        oop_maps = generate_stub_call(sasm, I0, CAST_FROM_FN_PTR(address, new_instance), G5_klass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
        // I0->O0: new instance
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
#ifdef TIERED
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
    case counter_overflow_id:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
        // G4 contains bci
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
      oop_maps = generate_stub_call(sasm, noreg, CAST_FROM_FN_PTR(address, counter_overflow), G4);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
#endif // TIERED
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
    case new_type_array_id:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
    case new_object_array_id:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
        Register G5_klass = G5; // Incoming
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
        Register G4_length = G4; // Incoming
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
        Register O0_obj   = O0; // Outgoing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
2571
d602ad6538bd 6822110: Add AddressLiteral class on SPARC
twisti
parents: 2256
diff changeset
   482
        Address klass_lh(G5_klass, ((klassOopDesc::header_size() * HeapWordSize)
d602ad6538bd 6822110: Add AddressLiteral class on SPARC
twisti
parents: 2256
diff changeset
   483
                                    + Klass::layout_helper_offset_in_bytes()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
        assert(Klass::_lh_header_size_shift % BitsPerByte == 0, "bytewise");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
        assert(Klass::_lh_header_size_mask == 0xFF, "bytewise");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
        // Use this offset to pick out an individual byte of the layout_helper:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
        const int klass_lh_header_size_offset = ((BytesPerInt - 1)  // 3 - 2 selects byte {0,1,0,0}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
                                                 - Klass::_lh_header_size_shift / BitsPerByte);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
        if (id == new_type_array_id) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
          __ set_info("new_type_array", dont_gc_arguments);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
          __ set_info("new_object_array", dont_gc_arguments);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
        // assert object type is really an array of the proper kind
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
        {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
          Label ok;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
          Register G3_t1 = G3;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
          __ ld(klass_lh, G3_t1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
          __ sra(G3_t1, Klass::_lh_array_tag_shift, G3_t1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
          int tag = ((id == new_type_array_id)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
                     ? Klass::_lh_array_tag_type_value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
                     : Klass::_lh_array_tag_obj_value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
          __ cmp(G3_t1, tag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
          __ brx(Assembler::equal, false, Assembler::pt, ok);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
          __ delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
          __ stop("assert(is an array klass)");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
          __ should_not_reach_here();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
          __ bind(ok);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
#endif // ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
        if (UseTLAB && FastTLABRefill) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
          Label slow_path;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
          Register G1_arr_size = G1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
          Register G3_t1 = G3;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
          Register O1_t2 = O1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
          assert_different_registers(G5_klass, G4_length, G1_arr_size, G3_t1, O1_t2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
          // check that array length is small enough for fast path
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
          __ set(C1_MacroAssembler::max_array_allocation_length, G3_t1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
          __ cmp(G4_length, G3_t1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
          __ br(Assembler::greaterUnsigned, false, Assembler::pn, slow_path);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
          __ delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
          // if we got here then the TLAB allocation failed, so try
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
          // refilling the TLAB or allocating directly from eden.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
          Label retry_tlab, try_eden;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
          __ tlab_refill(retry_tlab, try_eden, slow_path); // preserves G4_length and G5_klass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
          __ bind(retry_tlab);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
          // get the allocation size: (length << (layout_helper & 0x1F)) + header_size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
          __ ld(klass_lh, G3_t1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
          __ sll(G4_length, G3_t1, G1_arr_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
          __ srl(G3_t1, Klass::_lh_header_size_shift, G3_t1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
          __ and3(G3_t1, Klass::_lh_header_size_mask, G3_t1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
          __ add(G1_arr_size, G3_t1, G1_arr_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
          __ add(G1_arr_size, MinObjAlignmentInBytesMask, G1_arr_size);  // align up
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
          __ and3(G1_arr_size, ~MinObjAlignmentInBytesMask, G1_arr_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
          __ tlab_allocate(O0_obj, G1_arr_size, 0, G3_t1, slow_path);  // preserves G1_arr_size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
          __ initialize_header(O0_obj, G5_klass, G4_length, G3_t1, O1_t2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
          __ ldub(klass_lh, G3_t1, klass_lh_header_size_offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
          __ sub(G1_arr_size, G3_t1, O1_t2);  // body length
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
          __ add(O0_obj, G3_t1, G3_t1);       // body start
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
          __ initialize_body(G3_t1, O1_t2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
          __ verify_oop(O0_obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
          __ retl();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
          __ delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
          __ bind(try_eden);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
          // get the allocation size: (length << (layout_helper & 0x1F)) + header_size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
          __ ld(klass_lh, G3_t1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
          __ sll(G4_length, G3_t1, G1_arr_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
          __ srl(G3_t1, Klass::_lh_header_size_shift, G3_t1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
          __ and3(G3_t1, Klass::_lh_header_size_mask, G3_t1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
          __ add(G1_arr_size, G3_t1, G1_arr_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
          __ add(G1_arr_size, MinObjAlignmentInBytesMask, G1_arr_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
          __ and3(G1_arr_size, ~MinObjAlignmentInBytesMask, G1_arr_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
          __ eden_allocate(O0_obj, G1_arr_size, 0, G3_t1, O1_t2, slow_path);  // preserves G1_arr_size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
          __ initialize_header(O0_obj, G5_klass, G4_length, G3_t1, O1_t2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
          __ ldub(klass_lh, G3_t1, klass_lh_header_size_offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
          __ sub(G1_arr_size, G3_t1, O1_t2);  // body length
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
          __ add(O0_obj, G3_t1, G3_t1);       // body start
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
          __ initialize_body(G3_t1, O1_t2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
          __ verify_oop(O0_obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
          __ retl();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
          __ delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
          __ bind(slow_path);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
        if (id == new_type_array_id) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
          oop_maps = generate_stub_call(sasm, I0, CAST_FROM_FN_PTR(address, new_type_array), G5_klass, G4_length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
          oop_maps = generate_stub_call(sasm, I0, CAST_FROM_FN_PTR(address, new_object_array), G5_klass, G4_length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
        // I0 -> O0: new array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
    case new_multi_array_id:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
      { // O0: klass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
        // O1: rank
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
        // O2: address of 1st dimension
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
        __ set_info("new_multi_array", dont_gc_arguments);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
        oop_maps = generate_stub_call(sasm, I0, CAST_FROM_FN_PTR(address, new_multi_array), I0, I1, I2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
        // I0 -> O0: new multi array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
    case register_finalizer_id:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
        __ set_info("register_finalizer", dont_gc_arguments);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
        // load the klass and check the has finalizer flag
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
        Label register_finalizer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
        Register t = O1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
        __ ld_ptr(O0, oopDesc::klass_offset_in_bytes(), t);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
        __ ld(t, Klass::access_flags_offset_in_bytes() + sizeof(oopDesc), t);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
        __ set(JVM_ACC_HAS_FINALIZER, G3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
        __ andcc(G3, t, G0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
        __ br(Assembler::notZero, false, Assembler::pt, register_finalizer);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
        __ delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
        // do a leaf return
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
        __ retl();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
        __ delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
        __ bind(register_finalizer);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
        OopMap* oop_map = save_live_registers(sasm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
        int call_offset = __ call_RT(noreg, noreg,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
                                     CAST_FROM_FN_PTR(address, SharedRuntime::register_finalizer), I0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
        oop_maps = new OopMapSet();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
        oop_maps->add_gc_map(call_offset, oop_map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
        // Now restore all the live registers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
        restore_live_registers(sasm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
        __ ret();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
        __ delayed()->restore();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
    case throw_range_check_failed_id:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
      { __ set_info("range_check_failed", dont_gc_arguments); // arguments will be discarded
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
        // G4: index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
        oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_range_check_exception), true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
    case throw_index_exception_id:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
      { __ set_info("index_range_check_failed", dont_gc_arguments); // arguments will be discarded
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
        // G4: index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
        oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_index_exception), true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
    case throw_div0_exception_id:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
      { __ set_info("throw_div0_exception", dont_gc_arguments);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
        oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_div0_exception), false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
    case throw_null_pointer_exception_id:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
      { __ set_info("throw_null_pointer_exception", dont_gc_arguments);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
        oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_null_pointer_exception), false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
    case handle_exception_id:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
        __ set_info("handle_exception", dont_gc_arguments);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
        // make a frame and preserve the caller's caller-save registers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
        oop_maps = new OopMapSet();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
        OopMap* oop_map = save_live_registers(sasm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
        __ mov(Oexception->after_save(),  Oexception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
        __ mov(Oissuing_pc->after_save(), Oissuing_pc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
        generate_handle_exception(sasm, oop_maps, oop_map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
    case unwind_exception_id:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
        // O0: exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
        // I7: address of call to this method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
        __ set_info("unwind_exception", dont_gc_arguments);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
        __ mov(Oexception, Oexception->after_save());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
        __ add(I7, frame::pc_return_offset, Oissuing_pc->after_save());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
        __ call_VM_leaf(L7_thread_cache, CAST_FROM_FN_PTR(address, SharedRuntime::exception_handler_for_return_address),
5046
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 2571
diff changeset
   680
                        G2_thread, Oissuing_pc->after_save());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
        __ verify_not_null_oop(Oexception->after_save());
5687
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 5046
diff changeset
   682
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 5046
diff changeset
   683
        // Restore SP from L7 if the exception PC is a MethodHandle call site.
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 5046
diff changeset
   684
        __ mov(O0, G5);  // Save the target address.
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 5046
diff changeset
   685
        __ lduw(Address(G2_thread, JavaThread::is_method_handle_return_offset()), L0);
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 5046
diff changeset
   686
        __ tst(L0);  // Condition codes are preserved over the restore.
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 5046
diff changeset
   687
        __ restore();
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 5046
diff changeset
   688
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 5046
diff changeset
   689
        __ jmp(G5, 0);
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 5046
diff changeset
   690
        __ delayed()->movcc(Assembler::notZero, false, Assembler::icc, L7_mh_SP_save, SP);  // Restore SP if required.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
    case throw_array_store_exception_id:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
        __ set_info("throw_array_store_exception", dont_gc_arguments);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
        oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_array_store_exception), false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
    case throw_class_cast_exception_id:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
        // G4: object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
        __ set_info("throw_class_cast_exception", dont_gc_arguments);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
        oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_class_cast_exception), true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
    case throw_incompatible_class_change_error_id:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
        __ set_info("throw_incompatible_class_cast_exception", dont_gc_arguments);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
        oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_incompatible_class_change_error), false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
    case slow_subtype_check_id:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
      { // Support for uint StubRoutine::partial_subtype_check( Klass sub, Klass super );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
        // Arguments :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
        //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
        //      ret  : G3
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
        //      sub  : G3, argument, destroyed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
        //      super: G1, argument, not changed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
        //      raddr: O7, blown by call
2256
82d4e10b7c6b 6813212: factor duplicated assembly code for general subclass check (for 6655638)
jrose
parents: 1374
diff changeset
   724
        Label miss;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
        __ save_frame(0);               // Blow no registers!
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
2256
82d4e10b7c6b 6813212: factor duplicated assembly code for general subclass check (for 6655638)
jrose
parents: 1374
diff changeset
   728
        __ check_klass_subtype_slow_path(G3, G1, L0, L1, L2, L4, NULL, &miss);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
        __ mov(1, G3);
2256
82d4e10b7c6b 6813212: factor duplicated assembly code for general subclass check (for 6655638)
jrose
parents: 1374
diff changeset
   731
        __ ret();                       // Result in G5 is 'true'
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
        __ delayed()->restore();        // free copy or add can go here
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
        __ bind(miss);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
        __ mov(0, G3);
2256
82d4e10b7c6b 6813212: factor duplicated assembly code for general subclass check (for 6655638)
jrose
parents: 1374
diff changeset
   736
        __ ret();                       // Result in G5 is 'false'
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
        __ delayed()->restore();        // free copy or add can go here
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
    case monitorenter_nofpu_id:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
    case monitorenter_id:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
      { // G4: object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
        // G5: lock address
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
        __ set_info("monitorenter", dont_gc_arguments);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
        int save_fpu_registers = (id == monitorenter_id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
        // make a frame and preserve the caller's caller-save registers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
        OopMap* oop_map = save_live_registers(sasm, save_fpu_registers);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
        int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, monitorenter), G4, G5);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
        oop_maps = new OopMapSet();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
        oop_maps->add_gc_map(call_offset, oop_map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
        restore_live_registers(sasm, save_fpu_registers);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
        __ ret();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
        __ delayed()->restore();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
    case monitorexit_nofpu_id:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
    case monitorexit_id:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
      { // G4: lock address
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
        // note: really a leaf routine but must setup last java sp
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
        //       => use call_RT for now (speed can be improved by
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
        //       doing last java sp setup manually)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
        __ set_info("monitorexit", dont_gc_arguments);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
        int save_fpu_registers = (id == monitorexit_id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
        // make a frame and preserve the caller's caller-save registers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
        OopMap* oop_map = save_live_registers(sasm, save_fpu_registers);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
        int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, monitorexit), G4);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
        oop_maps = new OopMapSet();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
        oop_maps->add_gc_map(call_offset, oop_map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
        restore_live_registers(sasm, save_fpu_registers);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
        __ ret();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
        __ delayed()->restore();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
    case access_field_patching_id:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
      { __ set_info("access_field_patching", dont_gc_arguments);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
        oop_maps = generate_patching(sasm, CAST_FROM_FN_PTR(address, access_field_patching));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
    case load_klass_patching_id:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
      { __ set_info("load_klass_patching", dont_gc_arguments);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
        oop_maps = generate_patching(sasm, CAST_FROM_FN_PTR(address, move_klass_patching));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
    case jvmti_exception_throw_id:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
      { // Oexception : exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
        __ set_info("jvmti_exception_throw", dont_gc_arguments);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
        oop_maps = generate_stub_call(sasm, noreg, CAST_FROM_FN_PTR(address, Runtime1::post_jvmti_exception_throw), I0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
    case dtrace_object_alloc_id:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
      { // O0: object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
        __ set_info("dtrace_object_alloc", dont_gc_arguments);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
        // we can't gc here so skip the oopmap but make sure that all
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
        // the live registers get saved.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
        save_live_registers(sasm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
        __ save_thread(L7_thread_cache);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
        __ call(CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_object_alloc),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
                relocInfo::runtime_call_type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
        __ delayed()->mov(I0, O0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
        __ restore_thread(L7_thread_cache);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
        restore_live_registers(sasm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
        __ ret();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
        __ delayed()->restore();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   823
#ifndef SERIALGC
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   824
    case g1_pre_barrier_slow_id:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   825
      { // G4: previous value of memory
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   826
        BarrierSet* bs = Universe::heap()->barrier_set();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   827
        if (bs->kind() != BarrierSet::G1SATBCTLogging) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   828
          __ save_frame(0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   829
          __ set((int)id, O1);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   830
          __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, unimplemented_entry), I0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   831
          __ should_not_reach_here();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   832
          break;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   833
        }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   834
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   835
        __ set_info("g1_pre_barrier_slow_id", dont_gc_arguments);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   836
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   837
        Register pre_val = G4;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   838
        Register tmp  = G1_scratch;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   839
        Register tmp2 = G3_scratch;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   840
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   841
        Label refill, restart;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   842
        bool with_frame = false; // I don't know if we can do with-frame.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   843
        int satb_q_index_byte_offset =
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   844
          in_bytes(JavaThread::satb_mark_queue_offset() +
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   845
                   PtrQueue::byte_offset_of_index());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   846
        int satb_q_buf_byte_offset =
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   847
          in_bytes(JavaThread::satb_mark_queue_offset() +
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   848
                   PtrQueue::byte_offset_of_buf());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   849
        __ bind(restart);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   850
        __ ld_ptr(G2_thread, satb_q_index_byte_offset, tmp);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   851
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   852
        __ br_on_reg_cond(Assembler::rc_z, /*annul*/false,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   853
                          Assembler::pn, tmp, refill);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   854
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   855
        // If the branch is taken, no harm in executing this in the delay slot.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   856
        __ delayed()->ld_ptr(G2_thread, satb_q_buf_byte_offset, tmp2);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   857
        __ sub(tmp, oopSize, tmp);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   858
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   859
        __ st_ptr(pre_val, tmp2, tmp);  // [_buf + index] := <address_of_card>
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   860
        // Use return-from-leaf
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   861
        __ retl();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   862
        __ delayed()->st_ptr(tmp, G2_thread, satb_q_index_byte_offset);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   863
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   864
        __ bind(refill);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   865
        __ save_frame(0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   866
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   867
        __ mov(pre_val, L0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   868
        __ mov(tmp,     L1);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   869
        __ mov(tmp2,    L2);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   870
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   871
        __ call_VM_leaf(L7_thread_cache,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   872
                        CAST_FROM_FN_PTR(address,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   873
                                         SATBMarkQueueSet::handle_zero_index_for_thread),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   874
                                         G2_thread);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   875
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   876
        __ mov(L0, pre_val);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   877
        __ mov(L1, tmp);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   878
        __ mov(L2, tmp2);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   879
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   880
        __ br(Assembler::always, /*annul*/false, Assembler::pt, restart);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   881
        __ delayed()->restore();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   882
      }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   883
      break;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   884
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   885
    case g1_post_barrier_slow_id:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   886
      {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   887
        BarrierSet* bs = Universe::heap()->barrier_set();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   888
        if (bs->kind() != BarrierSet::G1SATBCTLogging) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   889
          __ save_frame(0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   890
          __ set((int)id, O1);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   891
          __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, unimplemented_entry), I0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   892
          __ should_not_reach_here();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   893
          break;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   894
        }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   895
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   896
        __ set_info("g1_post_barrier_slow_id", dont_gc_arguments);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   897
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   898
        Register addr = G4;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   899
        Register cardtable = G5;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   900
        Register tmp  = G1_scratch;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   901
        Register tmp2 = G3_scratch;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   902
        jbyte* byte_map_base = ((CardTableModRefBS*)bs)->byte_map_base;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   903
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   904
        Label not_already_dirty, restart, refill;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   905
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   906
#ifdef _LP64
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   907
        __ srlx(addr, CardTableModRefBS::card_shift, addr);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   908
#else
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   909
        __ srl(addr, CardTableModRefBS::card_shift, addr);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   910
#endif
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   911
2571
d602ad6538bd 6822110: Add AddressLiteral class on SPARC
twisti
parents: 2256
diff changeset
   912
        AddressLiteral rs(byte_map_base);
d602ad6538bd 6822110: Add AddressLiteral class on SPARC
twisti
parents: 2256
diff changeset
   913
        __ set(rs, cardtable);         // cardtable := <card table base>
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   914
        __ ldub(addr, cardtable, tmp); // tmp := [addr + cardtable]
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   915
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   916
        __ br_on_reg_cond(Assembler::rc_nz, /*annul*/false, Assembler::pt,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   917
                          tmp, not_already_dirty);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   918
        // Get cardtable + tmp into a reg by itself -- useful in the take-the-branch
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   919
        // case, harmless if not.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   920
        __ delayed()->add(addr, cardtable, tmp2);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   921
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   922
        // We didn't take the branch, so we're already dirty: return.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   923
        // Use return-from-leaf
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   924
        __ retl();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   925
        __ delayed()->nop();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   926
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   927
        // Not dirty.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   928
        __ bind(not_already_dirty);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   929
        // First, dirty it.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   930
        __ stb(G0, tmp2, 0);  // [cardPtr] := 0  (i.e., dirty).
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   931
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   932
        Register tmp3 = cardtable;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   933
        Register tmp4 = tmp;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   934
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   935
        // these registers are now dead
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   936
        addr = cardtable = tmp = noreg;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   937
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   938
        int dirty_card_q_index_byte_offset =
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   939
          in_bytes(JavaThread::dirty_card_queue_offset() +
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   940
                   PtrQueue::byte_offset_of_index());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   941
        int dirty_card_q_buf_byte_offset =
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   942
          in_bytes(JavaThread::dirty_card_queue_offset() +
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   943
                   PtrQueue::byte_offset_of_buf());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   944
        __ bind(restart);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   945
        __ ld_ptr(G2_thread, dirty_card_q_index_byte_offset, tmp3);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   946
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   947
        __ br_on_reg_cond(Assembler::rc_z, /*annul*/false, Assembler::pn,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   948
                          tmp3, refill);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   949
        // If the branch is taken, no harm in executing this in the delay slot.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   950
        __ delayed()->ld_ptr(G2_thread, dirty_card_q_buf_byte_offset, tmp4);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   951
        __ sub(tmp3, oopSize, tmp3);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   952
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   953
        __ st_ptr(tmp2, tmp4, tmp3);  // [_buf + index] := <address_of_card>
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   954
        // Use return-from-leaf
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   955
        __ retl();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   956
        __ delayed()->st_ptr(tmp3, G2_thread, dirty_card_q_index_byte_offset);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   957
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   958
        __ bind(refill);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   959
        __ save_frame(0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   960
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   961
        __ mov(tmp2, L0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   962
        __ mov(tmp3, L1);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   963
        __ mov(tmp4, L2);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   964
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   965
        __ call_VM_leaf(L7_thread_cache,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   966
                        CAST_FROM_FN_PTR(address,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   967
                                         DirtyCardQueueSet::handle_zero_index_for_thread),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   968
                                         G2_thread);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   969
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   970
        __ mov(L0, tmp2);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   971
        __ mov(L1, tmp3);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   972
        __ mov(L2, tmp4);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   973
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   974
        __ br(Assembler::always, /*annul*/false, Assembler::pt, restart);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   975
        __ delayed()->restore();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   976
      }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   977
      break;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   978
#endif // !SERIALGC
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   979
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
    default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   981
      { __ set_info("unimplemented entry", dont_gc_arguments);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   982
        __ save_frame(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
        __ set((int)id, O1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
        __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, unimplemented_entry), O1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
        __ should_not_reach_here();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
  return oop_maps;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
void Runtime1::generate_handle_exception(StubAssembler* sasm, OopMapSet* oop_maps, OopMap* oop_map, bool) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
  Label no_deopt;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
  __ verify_not_null_oop(Oexception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
  // save the exception and issuing pc in the thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
  __ st_ptr(Oexception, G2_thread, in_bytes(JavaThread::exception_oop_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
  __ st_ptr(Oissuing_pc, G2_thread, in_bytes(JavaThread::exception_pc_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
  // save the real return address and use the throwing pc as the return address to lookup (has bci & oop map)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
  __ mov(I7, L0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
  __ mov(Oissuing_pc, I7);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
  __ sub(I7, frame::pc_return_offset, I7);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
  int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, exception_handler_for_pc));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
  // Note: if nmethod has been deoptimized then regardless of
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
  // whether it had a handler or not we will deoptimize
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
  // by entering the deopt blob with a pending exception.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
5046
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 2571
diff changeset
  1012
#ifdef ASSERT
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 2571
diff changeset
  1013
  Label done;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
  __ tst(O0);
5046
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 2571
diff changeset
  1015
  __ br(Assembler::notZero, false, Assembler::pn, done);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
  __ delayed()->nop();
5046
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 2571
diff changeset
  1017
  __ stop("should have found address");
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 2571
diff changeset
  1018
  __ bind(done);
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 2571
diff changeset
  1019
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1020
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1021
  // restore the registers that were saved at the beginning and jump to the exception handler.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1022
  restore_live_registers(sasm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1024
  __ jmp(O0, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
  __ delayed()->restore();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
  oop_maps->add_gc_map(call_offset, oop_map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
#undef __
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
#define __ masm->
6176
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5702
diff changeset
  1034
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5702
diff changeset
  1035
const char *Runtime1::pd_name_for_address(address entry) {
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5702
diff changeset
  1036
  return "<unknown function>";
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5702
diff changeset
  1037
}