hotspot/src/cpu/x86/vm/sharedRuntime_x86_64.cpp
author twisti
Tue, 01 Feb 2011 03:38:44 -0800
changeset 8315 1503f9d7681f
parent 8076 96d498ec7ae1
child 8872 36680c58660e
permissions -rw-r--r--
7009309: JSR 292: compiler/6991596/Test6991596.java crashes on fastdebug JDK7/b122 Reviewed-by: kvn, never
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
8315
1503f9d7681f 7009309: JSR 292: compiler/6991596/Test6991596.java crashes on fastdebug JDK7/b122
twisti
parents: 8076
diff changeset
     2
 * Copyright (c) 2003, 2011, 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: 5419
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5419
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: 5419
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
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    26
#include "asm/assembler.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    27
#include "assembler_x86.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    28
#include "code/debugInfoRec.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    29
#include "code/icBuffer.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    30
#include "code/vtableStubs.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    31
#include "interpreter/interpreter.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    32
#include "oops/compiledICHolderOop.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    33
#include "prims/jvmtiRedefineClassesTrace.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    34
#include "runtime/sharedRuntime.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    35
#include "runtime/vframeArray.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    36
#include "vmreg_x86.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    37
#ifdef COMPILER1
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    38
#include "c1/c1_Runtime1.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    39
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    40
#ifdef COMPILER2
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    41
#include "opto/runtime.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    42
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
DeoptimizationBlob *SharedRuntime::_deopt_blob;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
#ifdef COMPILER2
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
UncommonTrapBlob   *SharedRuntime::_uncommon_trap_blob;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
ExceptionBlob      *OptoRuntime::_exception_blob;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
#endif // COMPILER2
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
SafepointBlob      *SharedRuntime::_polling_page_safepoint_handler_blob;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
SafepointBlob      *SharedRuntime::_polling_page_return_handler_blob;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
RuntimeStub*       SharedRuntime::_wrong_method_blob;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
RuntimeStub*       SharedRuntime::_ic_miss_blob;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
RuntimeStub*       SharedRuntime::_resolve_opt_virtual_call_blob;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
RuntimeStub*       SharedRuntime::_resolve_virtual_call_blob;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
RuntimeStub*       SharedRuntime::_resolve_static_call_blob;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
1900
68ea5d5fab8b 6792301: StackAlignmentInBytes not honored for compiled native methods
xlu
parents: 1896
diff changeset
    58
const int StackAlignmentInSlots = StackAlignmentInBytes / VMRegImpl::stack_slot_size;
68ea5d5fab8b 6792301: StackAlignmentInBytes not honored for compiled native methods
xlu
parents: 1896
diff changeset
    59
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
#define __ masm->
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
class SimpleRuntimeFrame {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
  public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
  // Most of the runtime stubs have this simple frame layout.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
  // This class exists to make the layout shared in one place.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
  // Offsets are for compiler stack slots, which are jints.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
  enum layout {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
    // The frame sender code expects that rbp will be in the "natural" place and
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
    // will override any oopMap setting for it. We must therefore force the layout
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
    // so that it agrees with the frame sender code.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
    rbp_off = frame::arg_reg_save_area_bytes/BytesPerInt,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
    rbp_off2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
    return_off, return_off2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
    framesize
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
class RegisterSaver {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  // Capture info about frame layout.  Layout offsets are in jint
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  // units because compiler frame slots are jints.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
#define DEF_XMM_OFFS(regnum) xmm ## regnum ## _off = xmm_off + (regnum)*16/BytesPerInt, xmm ## regnum ## H_off
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
  enum layout {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
    fpu_state_off = frame::arg_reg_save_area_bytes/BytesPerInt, // fxsave save area
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
    xmm_off       = fpu_state_off + 160/BytesPerInt,            // offset in fxsave save area
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
    DEF_XMM_OFFS(0),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
    DEF_XMM_OFFS(1),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
    DEF_XMM_OFFS(2),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
    DEF_XMM_OFFS(3),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
    DEF_XMM_OFFS(4),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
    DEF_XMM_OFFS(5),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
    DEF_XMM_OFFS(6),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
    DEF_XMM_OFFS(7),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
    DEF_XMM_OFFS(8),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
    DEF_XMM_OFFS(9),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
    DEF_XMM_OFFS(10),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
    DEF_XMM_OFFS(11),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
    DEF_XMM_OFFS(12),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
    DEF_XMM_OFFS(13),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
    DEF_XMM_OFFS(14),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
    DEF_XMM_OFFS(15),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
    fpu_state_end = fpu_state_off + ((FPUStateSizeInWords-1)*wordSize / BytesPerInt),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
    fpu_stateH_end,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
    r15_off, r15H_off,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
    r14_off, r14H_off,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
    r13_off, r13H_off,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
    r12_off, r12H_off,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
    r11_off, r11H_off,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
    r10_off, r10H_off,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
    r9_off,  r9H_off,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
    r8_off,  r8H_off,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
    rdi_off, rdiH_off,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
    rsi_off, rsiH_off,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
    ignore_off, ignoreH_off,  // extra copy of rbp
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
    rsp_off, rspH_off,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
    rbx_off, rbxH_off,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
    rdx_off, rdxH_off,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
    rcx_off, rcxH_off,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
    rax_off, raxH_off,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
    // 16-byte stack alignment fill word: see MacroAssembler::push/pop_IU_state
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
    align_off, alignH_off,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
    flags_off, flagsH_off,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
    // The frame sender code expects that rbp will be in the "natural" place and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
    // will override any oopMap setting for it. We must therefore force the layout
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
    // so that it agrees with the frame sender code.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
    rbp_off, rbpH_off,        // copy of rbp we will restore
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
    return_off, returnH_off,  // slot for return address
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
    reg_save_size             // size in compiler stack slots
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  static OopMap* save_live_registers(MacroAssembler* masm, int additional_frame_words, int* total_frame_words);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
  static void restore_live_registers(MacroAssembler* masm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  // Offsets into the register save area
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  // Used by deoptimization when it is managing result register
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  // values on its own
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  static int rax_offset_in_bytes(void)    { return BytesPerInt * rax_off; }
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   141
  static int rdx_offset_in_bytes(void)    { return BytesPerInt * rdx_off; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  static int rbx_offset_in_bytes(void)    { return BytesPerInt * rbx_off; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
  static int xmm0_offset_in_bytes(void)   { return BytesPerInt * xmm0_off; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  static int return_offset_in_bytes(void) { return BytesPerInt * return_off; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  // During deoptimization only the result registers need to be restored,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  // all the other values have already been extracted.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  static void restore_result_registers(MacroAssembler* masm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
OopMap* RegisterSaver::save_live_registers(MacroAssembler* masm, int additional_frame_words, int* total_frame_words) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  // Always make the frame size 16-byte aligned
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  int frame_size_in_bytes = round_to(additional_frame_words*wordSize +
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
                                     reg_save_size*BytesPerInt, 16);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  // OopMap frame size is in compiler stack slots (jint's) not bytes or words
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  int frame_size_in_slots = frame_size_in_bytes / BytesPerInt;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  // The caller will allocate additional_frame_words
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  int additional_frame_slots = additional_frame_words*wordSize / BytesPerInt;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  // CodeBlob frame size is in words.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  int frame_size_in_words = frame_size_in_bytes / wordSize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  *total_frame_words = frame_size_in_words;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
  // Save registers, fpu state, and flags.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  // We assume caller has already pushed the return address onto the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
  // stack, so rsp is 8-byte aligned here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
  // We push rpb twice in this sequence because we want the real rbp
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
  // to be under the return like a normal enter.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
  __ enter();          // rsp becomes 16-byte aligned here
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  __ push_CPU_state(); // Push a multiple of 16 bytes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  if (frame::arg_reg_save_area_bytes != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
    // Allocate argument register save area
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   174
    __ subptr(rsp, frame::arg_reg_save_area_bytes);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  // Set an oopmap for the call site.  This oopmap will map all
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  // oop-registers and debug-info registers as callee-saved.  This
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  // will allow deoptimization at this safepoint to find all possible
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  // debug-info recordings, as well as let GC find all oops.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  OopMapSet *oop_maps = new OopMapSet();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
  OopMap* map = new OopMap(frame_size_in_slots, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
  map->set_callee_saved(VMRegImpl::stack2reg( rax_off  + additional_frame_slots), rax->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
  map->set_callee_saved(VMRegImpl::stack2reg( rcx_off  + additional_frame_slots), rcx->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
  map->set_callee_saved(VMRegImpl::stack2reg( rdx_off  + additional_frame_slots), rdx->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  map->set_callee_saved(VMRegImpl::stack2reg( rbx_off  + additional_frame_slots), rbx->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
  // rbp location is known implicitly by the frame sender code, needs no oopmap
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
  // and the location where rbp was saved by is ignored
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  map->set_callee_saved(VMRegImpl::stack2reg( rsi_off  + additional_frame_slots), rsi->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  map->set_callee_saved(VMRegImpl::stack2reg( rdi_off  + additional_frame_slots), rdi->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  map->set_callee_saved(VMRegImpl::stack2reg( r8_off   + additional_frame_slots), r8->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  map->set_callee_saved(VMRegImpl::stack2reg( r9_off   + additional_frame_slots), r9->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  map->set_callee_saved(VMRegImpl::stack2reg( r10_off  + additional_frame_slots), r10->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
  map->set_callee_saved(VMRegImpl::stack2reg( r11_off  + additional_frame_slots), r11->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
  map->set_callee_saved(VMRegImpl::stack2reg( r12_off  + additional_frame_slots), r12->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
  map->set_callee_saved(VMRegImpl::stack2reg( r13_off  + additional_frame_slots), r13->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  map->set_callee_saved(VMRegImpl::stack2reg( r14_off  + additional_frame_slots), r14->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  map->set_callee_saved(VMRegImpl::stack2reg( r15_off  + additional_frame_slots), r15->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
  map->set_callee_saved(VMRegImpl::stack2reg(xmm0_off  + additional_frame_slots), xmm0->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
  map->set_callee_saved(VMRegImpl::stack2reg(xmm1_off  + additional_frame_slots), xmm1->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
  map->set_callee_saved(VMRegImpl::stack2reg(xmm2_off  + additional_frame_slots), xmm2->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
  map->set_callee_saved(VMRegImpl::stack2reg(xmm3_off  + additional_frame_slots), xmm3->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  map->set_callee_saved(VMRegImpl::stack2reg(xmm4_off  + additional_frame_slots), xmm4->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
  map->set_callee_saved(VMRegImpl::stack2reg(xmm5_off  + additional_frame_slots), xmm5->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  map->set_callee_saved(VMRegImpl::stack2reg(xmm6_off  + additional_frame_slots), xmm6->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
  map->set_callee_saved(VMRegImpl::stack2reg(xmm7_off  + additional_frame_slots), xmm7->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
  map->set_callee_saved(VMRegImpl::stack2reg(xmm8_off  + additional_frame_slots), xmm8->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
  map->set_callee_saved(VMRegImpl::stack2reg(xmm9_off  + additional_frame_slots), xmm9->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
  map->set_callee_saved(VMRegImpl::stack2reg(xmm10_off + additional_frame_slots), xmm10->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
  map->set_callee_saved(VMRegImpl::stack2reg(xmm11_off + additional_frame_slots), xmm11->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
  map->set_callee_saved(VMRegImpl::stack2reg(xmm12_off + additional_frame_slots), xmm12->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
  map->set_callee_saved(VMRegImpl::stack2reg(xmm13_off + additional_frame_slots), xmm13->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
  map->set_callee_saved(VMRegImpl::stack2reg(xmm14_off + additional_frame_slots), xmm14->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
  map->set_callee_saved(VMRegImpl::stack2reg(xmm15_off + additional_frame_slots), xmm15->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
  // %%% These should all be a waste but we'll keep things as they were for now
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
  if (true) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
    map->set_callee_saved(VMRegImpl::stack2reg( raxH_off  + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
                          rax->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
    map->set_callee_saved(VMRegImpl::stack2reg( rcxH_off  + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
                          rcx->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
    map->set_callee_saved(VMRegImpl::stack2reg( rdxH_off  + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
                          rdx->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
    map->set_callee_saved(VMRegImpl::stack2reg( rbxH_off  + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
                          rbx->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
    // rbp location is known implicitly by the frame sender code, needs no oopmap
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
    map->set_callee_saved(VMRegImpl::stack2reg( rsiH_off  + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
                          rsi->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
    map->set_callee_saved(VMRegImpl::stack2reg( rdiH_off  + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
                          rdi->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
    map->set_callee_saved(VMRegImpl::stack2reg( r8H_off   + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
                          r8->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
    map->set_callee_saved(VMRegImpl::stack2reg( r9H_off   + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
                          r9->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
    map->set_callee_saved(VMRegImpl::stack2reg( r10H_off  + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
                          r10->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
    map->set_callee_saved(VMRegImpl::stack2reg( r11H_off  + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
                          r11->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
    map->set_callee_saved(VMRegImpl::stack2reg( r12H_off  + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
                          r12->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
    map->set_callee_saved(VMRegImpl::stack2reg( r13H_off  + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
                          r13->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
    map->set_callee_saved(VMRegImpl::stack2reg( r14H_off  + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
                          r14->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
    map->set_callee_saved(VMRegImpl::stack2reg( r15H_off  + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
                          r15->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
    map->set_callee_saved(VMRegImpl::stack2reg(xmm0H_off  + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
                          xmm0->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
    map->set_callee_saved(VMRegImpl::stack2reg(xmm1H_off  + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
                          xmm1->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
    map->set_callee_saved(VMRegImpl::stack2reg(xmm2H_off  + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
                          xmm2->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
    map->set_callee_saved(VMRegImpl::stack2reg(xmm3H_off  + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
                          xmm3->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
    map->set_callee_saved(VMRegImpl::stack2reg(xmm4H_off  + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
                          xmm4->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
    map->set_callee_saved(VMRegImpl::stack2reg(xmm5H_off  + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
                          xmm5->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
    map->set_callee_saved(VMRegImpl::stack2reg(xmm6H_off  + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
                          xmm6->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
    map->set_callee_saved(VMRegImpl::stack2reg(xmm7H_off  + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
                          xmm7->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
    map->set_callee_saved(VMRegImpl::stack2reg(xmm8H_off  + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
                          xmm8->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
    map->set_callee_saved(VMRegImpl::stack2reg(xmm9H_off  + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
                          xmm9->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
    map->set_callee_saved(VMRegImpl::stack2reg(xmm10H_off + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
                          xmm10->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
    map->set_callee_saved(VMRegImpl::stack2reg(xmm11H_off + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
                          xmm11->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
    map->set_callee_saved(VMRegImpl::stack2reg(xmm12H_off + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
                          xmm12->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
    map->set_callee_saved(VMRegImpl::stack2reg(xmm13H_off + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
                          xmm13->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
    map->set_callee_saved(VMRegImpl::stack2reg(xmm14H_off + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
                          xmm14->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
    map->set_callee_saved(VMRegImpl::stack2reg(xmm15H_off + additional_frame_slots),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
                          xmm15->as_VMReg()->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
  return map;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
void RegisterSaver::restore_live_registers(MacroAssembler* masm) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
  if (frame::arg_reg_save_area_bytes != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
    // Pop arg register save area
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   288
    __ addptr(rsp, frame::arg_reg_save_area_bytes);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
  // Recover CPU state
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
  __ pop_CPU_state();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
  // Get the rbp described implicitly by the calling convention (no oopMap)
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   293
  __ pop(rbp);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
void RegisterSaver::restore_result_registers(MacroAssembler* masm) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
  // Just restore result register. Only used by deoptimization. By
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  // now any callee save register that needs to be restored to a c2
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
  // caller of the deoptee has been extracted into the vframeArray
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
  // and will be stuffed into the c2i adapter we create for later
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
  // restoration so only result registers need to be restored here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
  // Restore fp result register
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
  __ movdbl(xmm0, Address(rsp, xmm0_offset_in_bytes()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
  // Restore integer result register
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   307
  __ movptr(rax, Address(rsp, rax_offset_in_bytes()));
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   308
  __ movptr(rdx, Address(rsp, rdx_offset_in_bytes()));
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   309
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
  // Pop all of the register save are off the stack except the return address
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   311
  __ addptr(rsp, return_offset_in_bytes());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
// The java_calling_convention describes stack locations as ideal slots on
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
// a frame with no abi restrictions. Since we must observe abi restrictions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
// (like the placement of the register window) the slots must be biased by
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
// the following value.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
static int reg2offset_in(VMReg r) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
  // Account for saved rbp and return address
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
  // This should really be in_preserve_stack_slots
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  return (r->reg2stack() + 4) * VMRegImpl::stack_slot_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
static int reg2offset_out(VMReg r) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
  return (r->reg2stack() + SharedRuntime::out_preserve_stack_slots()) * VMRegImpl::stack_slot_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
// ---------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
// Read the array of BasicTypes from a signature, and compute where the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
// arguments should go.  Values in the VMRegPair regs array refer to 4-byte
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
// quantities.  Values less than VMRegImpl::stack0 are registers, those above
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
// refer to 4-byte stack slots.  All stack slots are based off of the stack pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
// as framesizes are fixed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
// VMRegImpl::stack0 refers to the first slot 0(sp).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
// and VMRegImpl::stack0+1 refers to the memory word 4-byes higher.  Register
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
// up to RegisterImpl::number_of_registers) are the 64-bit
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
// integer registers.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
// Note: the INPUTS in sig_bt are in units of Java argument words, which are
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
// either 32-bit or 64-bit depending on the build.  The OUTPUTS are in 32-bit
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
// units regardless of build. Of course for i486 there is no 64 bit build
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
// The Java calling convention is a "shifted" version of the C ABI.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
// By skipping the first C ABI register we can call non-static jni methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
// with small numbers of arguments without having to shuffle the arguments
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
// at all. Since we control the java ABI we ought to at least get some
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
// advantage out of it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
int SharedRuntime::java_calling_convention(const BasicType *sig_bt,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
                                           VMRegPair *regs,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
                                           int total_args_passed,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
                                           int is_outgoing) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
  // Create the mapping between argument positions and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
  // registers.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
  static const Register INT_ArgReg[Argument::n_int_register_parameters_j] = {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
    j_rarg0, j_rarg1, j_rarg2, j_rarg3, j_rarg4, j_rarg5
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
  static const XMMRegister FP_ArgReg[Argument::n_float_register_parameters_j] = {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
    j_farg0, j_farg1, j_farg2, j_farg3,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
    j_farg4, j_farg5, j_farg6, j_farg7
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
  uint int_args = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
  uint fp_args = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
  uint stk_args = 0; // inc by 2 each time
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
  for (int i = 0; i < total_args_passed; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
    switch (sig_bt[i]) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
    case T_BOOLEAN:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
    case T_CHAR:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
    case T_BYTE:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
    case T_SHORT:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
    case T_INT:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
      if (int_args < Argument::n_int_register_parameters_j) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
        regs[i].set1(INT_ArgReg[int_args++]->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
        regs[i].set1(VMRegImpl::stack2reg(stk_args));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
        stk_args += 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
    case T_VOID:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
      // halves of T_LONG or T_DOUBLE
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
      assert(i != 0 && (sig_bt[i - 1] == T_LONG || sig_bt[i - 1] == T_DOUBLE), "expecting half");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
      regs[i].set_bad();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
    case T_LONG:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
      assert(sig_bt[i + 1] == T_VOID, "expecting half");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
      // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
    case T_OBJECT:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
    case T_ARRAY:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
    case T_ADDRESS:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
      if (int_args < Argument::n_int_register_parameters_j) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
        regs[i].set2(INT_ArgReg[int_args++]->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
        regs[i].set2(VMRegImpl::stack2reg(stk_args));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
        stk_args += 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
    case T_FLOAT:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
      if (fp_args < Argument::n_float_register_parameters_j) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
        regs[i].set1(FP_ArgReg[fp_args++]->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
        regs[i].set1(VMRegImpl::stack2reg(stk_args));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
        stk_args += 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
    case T_DOUBLE:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
      assert(sig_bt[i + 1] == T_VOID, "expecting half");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
      if (fp_args < Argument::n_float_register_parameters_j) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
        regs[i].set2(FP_ArgReg[fp_args++]->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
        regs[i].set2(VMRegImpl::stack2reg(stk_args));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
        stk_args += 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
    default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
      ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
  return round_to(stk_args, 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
// Patch the callers callsite with entry to compiled code if it exists.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
static void patch_callers_callsite(MacroAssembler *masm) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
  Label L;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
  __ verify_oop(rbx);
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   431
  __ cmpptr(Address(rbx, in_bytes(methodOopDesc::code_offset())), (int32_t)NULL_WORD);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
  __ jcc(Assembler::equal, L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
  // Save the current stack pointer
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   435
  __ mov(r13, rsp);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
  // Schedule the branch target address early.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
  // Call into the VM to patch the caller, then jump to compiled callee
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
  // rax isn't live so capture return address while we easily can
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   439
  __ movptr(rax, Address(rsp, 0));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
  // align stack so push_CPU_state doesn't fault
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   442
  __ andptr(rsp, -(StackAlignmentInBytes));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
  __ push_CPU_state();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
  __ verify_oop(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  // VM needs caller's callsite
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
  // VM needs target method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
  // This needs to be a long call since we will relocate this adapter to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
  // the codeBuffer and it may not reach
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
  // Allocate argument register save area
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
  if (frame::arg_reg_save_area_bytes != 0) {
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   454
    __ subptr(rsp, frame::arg_reg_save_area_bytes);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
  }
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   456
  __ mov(c_rarg0, rbx);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   457
  __ mov(c_rarg1, rax);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
  __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, SharedRuntime::fixup_callers_callsite)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
  // De-allocate argument register save area
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
  if (frame::arg_reg_save_area_bytes != 0) {
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   462
    __ addptr(rsp, frame::arg_reg_save_area_bytes);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
  __ pop_CPU_state();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
  // restore sp
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   467
  __ mov(rsp, r13);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
  __ bind(L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
static void gen_c2i_adapter(MacroAssembler *masm,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
                            int total_args_passed,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
                            int comp_args_on_stack,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
                            const BasicType *sig_bt,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
                            const VMRegPair *regs,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
                            Label& skip_fixup) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
  // Before we get into the guts of the C2I adapter, see if we should be here
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
  // at all.  We've come from compiled code and are attempting to jump to the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
  // interpreter, which means the caller made a static call to get here
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
  // (vcalls always get a compiled target if there is one).  Check for a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
  // compiled target.  If there is one, we need to patch the caller's call.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
  patch_callers_callsite(masm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
  __ bind(skip_fixup);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
  // Since all args are passed on the stack, total_args_passed *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
  // Interpreter::stackElementSize is the space we need. Plus 1 because
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
  // we also account for the return address location since
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
  // we store it first rather than hold it in rax across all the shuffling
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
5419
f2e8cc8c12ea 6943304: remove tagged stack interpreter
twisti
parents: 5252
diff changeset
   492
  int extraspace = (total_args_passed * Interpreter::stackElementSize) + wordSize;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
  // stack is aligned, keep it that way
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
  extraspace = round_to(extraspace, 2*wordSize);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
  // Get return address
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   498
  __ pop(rax);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
  // set senderSP value
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   501
  __ mov(r13, rsp);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   502
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   503
  __ subptr(rsp, extraspace);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
  // Store the return address in the expected location
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   506
  __ movptr(Address(rsp, 0), rax);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
  // Now write the args into the outgoing interpreter space
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
  for (int i = 0; i < total_args_passed; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
    if (sig_bt[i] == T_VOID) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
      assert(i > 0 && (sig_bt[i-1] == T_LONG || sig_bt[i-1] == T_DOUBLE), "missing half");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
      continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
    // offset to start parameters
5419
f2e8cc8c12ea 6943304: remove tagged stack interpreter
twisti
parents: 5252
diff changeset
   516
    int st_off   = (total_args_passed - i) * Interpreter::stackElementSize;
f2e8cc8c12ea 6943304: remove tagged stack interpreter
twisti
parents: 5252
diff changeset
   517
    int next_off = st_off - Interpreter::stackElementSize;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
    // Say 4 args:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
    // i   st_off
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
    // 0   32 T_LONG
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
    // 1   24 T_VOID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
    // 2   16 T_OBJECT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
    // 3    8 T_BOOL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
    // -    0 return address
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
    // However to make thing extra confusing. Because we can fit a long/double in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
    // a single slot on a 64 bt vm and it would be silly to break them up, the interpreter
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
    // leaves one slot empty and only stores to a single slot. In this case the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
    // slot that is occupied is the T_VOID slot. See I said it was confusing.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
    VMReg r_1 = regs[i].first();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
    VMReg r_2 = regs[i].second();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
    if (!r_1->is_valid()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
      assert(!r_2->is_valid(), "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
      continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
    if (r_1->is_stack()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
      // memory to memory use rax
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
      int ld_off = r_1->reg2stack() * VMRegImpl::stack_slot_size + extraspace;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
      if (!r_2->is_valid()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
        // sign extend??
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
        __ movl(rax, Address(rsp, ld_off));
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   544
        __ movptr(Address(rsp, st_off), rax);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
        __ movq(rax, Address(rsp, ld_off));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
        // Two VMREgs|OptoRegs can be T_OBJECT, T_ADDRESS, T_DOUBLE, T_LONG
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
        // T_DOUBLE and T_LONG use two slots in the interpreter
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
        if ( sig_bt[i] == T_LONG || sig_bt[i] == T_DOUBLE) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
          // ld_off == LSW, ld_off+wordSize == MSW
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
          // st_off == MSW, next_off == LSW
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
          __ movq(Address(rsp, next_off), rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
          // Overwrite the unused slot with known junk
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
          __ mov64(rax, CONST64(0xdeadffffdeadaaaa));
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   559
          __ movptr(Address(rsp, st_off), rax);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
#endif /* ASSERT */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
          __ movq(Address(rsp, st_off), rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
    } else if (r_1->is_Register()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
      Register r = r_1->as_Register();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
      if (!r_2->is_valid()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
        // must be only an int (or less ) so move only 32bits to slot
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
        // why not sign extend??
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
        __ movl(Address(rsp, st_off), r);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
        // Two VMREgs|OptoRegs can be T_OBJECT, T_ADDRESS, T_DOUBLE, T_LONG
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
        // T_DOUBLE and T_LONG use two slots in the interpreter
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
        if ( sig_bt[i] == T_LONG || sig_bt[i] == T_DOUBLE) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
          // long/double in gpr
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
          // Overwrite the unused slot with known junk
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
          __ mov64(rax, CONST64(0xdeadffffdeadaaab));
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   579
          __ movptr(Address(rsp, st_off), rax);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
#endif /* ASSERT */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
          __ movq(Address(rsp, next_off), r);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
        } else {
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   583
          __ movptr(Address(rsp, st_off), r);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
      assert(r_1->is_XMMRegister(), "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
      if (!r_2->is_valid()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
        // only a float use just part of the slot
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
        __ movflt(Address(rsp, st_off), r_1->as_XMMRegister());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
        // Overwrite the unused slot with known junk
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
        __ mov64(rax, CONST64(0xdeadffffdeadaaac));
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   595
        __ movptr(Address(rsp, st_off), rax);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
#endif /* ASSERT */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
        __ movdbl(Address(rsp, next_off), r_1->as_XMMRegister());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
  // Schedule the branch target address early.
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   603
  __ movptr(rcx, Address(rbx, in_bytes(methodOopDesc::interpreter_entry_offset())));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
  __ jmp(rcx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
static void gen_i2c_adapter(MacroAssembler *masm,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
                            int total_args_passed,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
                            int comp_args_on_stack,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
                            const BasicType *sig_bt,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
                            const VMRegPair *regs) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
  // Note: r13 contains the senderSP on entry. We must preserve it since
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
  // we may do a i2c -> c2i transition if we lose a race where compiled
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
  // code goes non-entrant while we get args ready.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
  // In addition we use r13 to locate all the interpreter args as
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
  // we must align the stack to 16 bytes on an i2c entry else we
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
  // lose alignment we expect in all compiled code and register
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
  // save code can segv when fxsave instructions find improperly
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
  // aligned stack pointer.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
8315
1503f9d7681f 7009309: JSR 292: compiler/6991596/Test6991596.java crashes on fastdebug JDK7/b122
twisti
parents: 8076
diff changeset
   622
  // Pick up the return address
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   623
  __ movptr(rax, Address(rsp, 0));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
4564
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3265
diff changeset
   625
  // Must preserve original SP for loading incoming arguments because
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3265
diff changeset
   626
  // we need to align the outgoing SP for compiled code.
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3265
diff changeset
   627
  __ movptr(r11, rsp);
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3265
diff changeset
   628
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
  // Cut-out for having no stack args.  Since up to 2 int/oop args are passed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
  // in registers, we will occasionally have no stack args.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
  int comp_words_on_stack = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
  if (comp_args_on_stack) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
    // Sig words on the stack are greater-than VMRegImpl::stack0.  Those in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
    // registers are below.  By subtracting stack0, we either get a negative
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
    // number (all values in registers) or the maximum stack slot accessed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
    // Convert 4-byte c2 stack slots to words.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
    comp_words_on_stack = round_to(comp_args_on_stack*VMRegImpl::stack_slot_size, wordSize)>>LogBytesPerWord;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
    // Round up to miminum stack alignment, in wordSize
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
    comp_words_on_stack = round_to(comp_words_on_stack, 2);
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   641
    __ subptr(rsp, comp_words_on_stack * wordSize);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
  // Ensure compiled code always sees stack at proper alignment
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   646
  __ andptr(rsp, -16);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
  // push the return address and misalign the stack that youngest frame always sees
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
  // as far as the placement of the call instruction
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   650
  __ push(rax);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
4564
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3265
diff changeset
   652
  // Put saved SP in another register
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3265
diff changeset
   653
  const Register saved_sp = rax;
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3265
diff changeset
   654
  __ movptr(saved_sp, r11);
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3265
diff changeset
   655
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
  // Will jump to the compiled code just as if compiled code was doing it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
  // Pre-load the register-jump target early, to schedule it better.
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   658
  __ movptr(r11, Address(rbx, in_bytes(methodOopDesc::from_compiled_offset())));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
  // Now generate the shuffle code.  Pick up all register args and move the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
  // rest through the floating point stack top.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
  for (int i = 0; i < total_args_passed; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
    if (sig_bt[i] == T_VOID) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
      // Longs and doubles are passed in native word order, but misaligned
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
      // in the 32-bit build.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
      assert(i > 0 && (sig_bt[i-1] == T_LONG || sig_bt[i-1] == T_DOUBLE), "missing half");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
      continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
    // Pick up 0, 1 or 2 words from SP+offset.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
    assert(!regs[i].second()->is_valid() || regs[i].first()->next() == regs[i].second(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
            "scrambled load targets?");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
    // Load in argument order going down.
5419
f2e8cc8c12ea 6943304: remove tagged stack interpreter
twisti
parents: 5252
diff changeset
   675
    int ld_off = (total_args_passed - i)*Interpreter::stackElementSize;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
    // Point to interpreter value (vs. tag)
5419
f2e8cc8c12ea 6943304: remove tagged stack interpreter
twisti
parents: 5252
diff changeset
   677
    int next_off = ld_off - Interpreter::stackElementSize;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
    VMReg r_1 = regs[i].first();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
    VMReg r_2 = regs[i].second();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
    if (!r_1->is_valid()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
      assert(!r_2->is_valid(), "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
      continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
    if (r_1->is_stack()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
      // Convert stack slot to an SP offset (+ wordSize to account for return address )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
      int st_off = regs[i].first()->reg2stack()*VMRegImpl::stack_slot_size + wordSize;
4564
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3265
diff changeset
   690
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3265
diff changeset
   691
      // We can use r13 as a temp here because compiled code doesn't need r13 as an input
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3265
diff changeset
   692
      // and if we end up going thru a c2i because of a miss a reasonable value of r13
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3265
diff changeset
   693
      // will be generated.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
      if (!r_2->is_valid()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
        // sign extend???
4564
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3265
diff changeset
   696
        __ movl(r13, Address(saved_sp, ld_off));
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3265
diff changeset
   697
        __ movptr(Address(rsp, st_off), r13);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
        //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
        // We are using two optoregs. This can be either T_OBJECT, T_ADDRESS, T_LONG, or T_DOUBLE
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
        // the interpreter allocates two slots but only uses one for thr T_LONG or T_DOUBLE case
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
        // So we must adjust where to pick up the data to match the interpreter.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
        //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
        // Interpreter local[n] == MSW, local[n+1] == LSW however locals
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
        // are accessed as negative so LSW is at LOW address
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
        // ld_off is MSW so get LSW
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
        const int offset = (sig_bt[i]==T_LONG||sig_bt[i]==T_DOUBLE)?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
                           next_off : ld_off;
4564
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3265
diff changeset
   710
        __ movq(r13, Address(saved_sp, offset));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
        // st_off is LSW (i.e. reg.first())
4564
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3265
diff changeset
   712
        __ movq(Address(rsp, st_off), r13);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
    } else if (r_1->is_Register()) {  // Register argument
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
      Register r = r_1->as_Register();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
      assert(r != rax, "must be different");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
      if (r_2->is_valid()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
        //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
        // We are using two VMRegs. This can be either T_OBJECT, T_ADDRESS, T_LONG, or T_DOUBLE
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
        // the interpreter allocates two slots but only uses one for thr T_LONG or T_DOUBLE case
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
        // So we must adjust where to pick up the data to match the interpreter.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
        const int offset = (sig_bt[i]==T_LONG||sig_bt[i]==T_DOUBLE)?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
                           next_off : ld_off;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
        // this can be a misaligned move
4564
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3265
diff changeset
   727
        __ movq(r, Address(saved_sp, offset));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
        // sign extend and use a full word?
4564
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3265
diff changeset
   730
        __ movl(r, Address(saved_sp, ld_off));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
      if (!r_2->is_valid()) {
4564
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3265
diff changeset
   734
        __ movflt(r_1->as_XMMRegister(), Address(saved_sp, ld_off));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
      } else {
4564
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3265
diff changeset
   736
        __ movdbl(r_1->as_XMMRegister(), Address(saved_sp, next_off));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
  // 6243940 We might end up in handle_wrong_method if
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
  // the callee is deoptimized as we race thru here. If that
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
  // happens we don't want to take a safepoint because the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
  // caller frame will look interpreted and arguments are now
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
  // "compiled" so it is much better to make this transition
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
  // invisible to the stack walking code. Unfortunately if
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
  // we try and find the callee by normal means a safepoint
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
  // is possible. So we stash the desired callee in the thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
  // and the vm will find there should this case occur.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   751
  __ movptr(Address(r15_thread, JavaThread::callee_target_offset()), rbx);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
  // put methodOop where a c2i would expect should we end up there
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
  // only needed becaus eof c2 resolve stubs return methodOop as a result in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
  // rax
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   756
  __ mov(rax, rbx);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
  __ jmp(r11);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
// ---------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
AdapterHandlerEntry* SharedRuntime::generate_i2c2i_adapters(MacroAssembler *masm,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
                                                            int total_args_passed,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
                                                            int comp_args_on_stack,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
                                                            const BasicType *sig_bt,
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4564
diff changeset
   765
                                                            const VMRegPair *regs,
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4564
diff changeset
   766
                                                            AdapterFingerPrint* fingerprint) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
  address i2c_entry = __ pc();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
  gen_i2c_adapter(masm, total_args_passed, comp_args_on_stack, sig_bt, regs);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
  // -------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
  // Generate a C2I adapter.  On entry we know rbx holds the methodOop during calls
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
  // to the interpreter.  The args start out packed in the compiled layout.  They
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
  // need to be unpacked into the interpreter layout.  This will almost always
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
  // require some stack space.  We grow the current (compiled) stack, then repack
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
  // the args.  We  finally end in a jump to the generic interpreter entry point.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
  // On exit from the interpreter, the interpreter will restore our SP (lest the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
  // compiled code, which relys solely on SP and not RBP, get sick).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
  address c2i_unverified_entry = __ pc();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
  Label skip_fixup;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
  Label ok;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
  Register holder = rax;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
  Register receiver = j_rarg0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
  Register temp = rbx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
    __ verify_oop(holder);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   790
    __ load_klass(temp, receiver);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
    __ verify_oop(temp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   793
    __ cmpptr(temp, Address(holder, compiledICHolderOopDesc::holder_klass_offset()));
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   794
    __ movptr(rbx, Address(holder, compiledICHolderOopDesc::holder_method_offset()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
    __ jcc(Assembler::equal, ok);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
    __ jump(RuntimeAddress(SharedRuntime::get_ic_miss_stub()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
    __ bind(ok);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
    // Method might have been compiled since the call site was patched to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
    // interpreted if that is the case treat it as a miss so we can get
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
    // the call site corrected.
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   802
    __ cmpptr(Address(rbx, in_bytes(methodOopDesc::code_offset())), (int32_t)NULL_WORD);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
    __ jcc(Assembler::equal, skip_fixup);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
    __ jump(RuntimeAddress(SharedRuntime::get_ic_miss_stub()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
  address c2i_entry = __ pc();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
  gen_c2i_adapter(masm, total_args_passed, comp_args_on_stack, sig_bt, regs, skip_fixup);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
  __ flush();
4735
3d4e4ec0df67 6911204: generated adapters with large signatures can fill up the code cache
never
parents: 4564
diff changeset
   812
  return AdapterHandlerLibrary::new_entry(fingerprint, i2c_entry, c2i_entry, c2i_unverified_entry);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
int SharedRuntime::c_calling_convention(const BasicType *sig_bt,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
                                         VMRegPair *regs,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
                                         int total_args_passed) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
// We return the amount of VMRegImpl stack slots we need to reserve for all
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
// the arguments NOT counting out_preserve_stack_slots.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
// NOTE: These arrays will have to change when c1 is ported
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
#ifdef _WIN64
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
    static const Register INT_ArgReg[Argument::n_int_register_parameters_c] = {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
      c_rarg0, c_rarg1, c_rarg2, c_rarg3
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
    };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
    static const XMMRegister FP_ArgReg[Argument::n_float_register_parameters_c] = {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
      c_farg0, c_farg1, c_farg2, c_farg3
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
    };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
    static const Register INT_ArgReg[Argument::n_int_register_parameters_c] = {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
      c_rarg0, c_rarg1, c_rarg2, c_rarg3, c_rarg4, c_rarg5
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
    };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
    static const XMMRegister FP_ArgReg[Argument::n_float_register_parameters_c] = {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
      c_farg0, c_farg1, c_farg2, c_farg3,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
      c_farg4, c_farg5, c_farg6, c_farg7
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
    };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
#endif // _WIN64
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
    uint int_args = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
    uint fp_args = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
    uint stk_args = 0; // inc by 2 each time
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
    for (int i = 0; i < total_args_passed; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
      switch (sig_bt[i]) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
      case T_BOOLEAN:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
      case T_CHAR:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
      case T_BYTE:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
      case T_SHORT:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
      case T_INT:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
        if (int_args < Argument::n_int_register_parameters_c) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
          regs[i].set1(INT_ArgReg[int_args++]->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
#ifdef _WIN64
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
          fp_args++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
          // Allocate slots for callee to stuff register args the stack.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
          stk_args += 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
          regs[i].set1(VMRegImpl::stack2reg(stk_args));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
          stk_args += 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
      case T_LONG:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
        assert(sig_bt[i + 1] == T_VOID, "expecting half");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
        // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
      case T_OBJECT:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
      case T_ARRAY:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
      case T_ADDRESS:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
        if (int_args < Argument::n_int_register_parameters_c) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
          regs[i].set2(INT_ArgReg[int_args++]->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
#ifdef _WIN64
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
          fp_args++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
          stk_args += 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
          regs[i].set2(VMRegImpl::stack2reg(stk_args));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
          stk_args += 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
      case T_FLOAT:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
        if (fp_args < Argument::n_float_register_parameters_c) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
          regs[i].set1(FP_ArgReg[fp_args++]->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
#ifdef _WIN64
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
          int_args++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
          // Allocate slots for callee to stuff register args the stack.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
          stk_args += 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   887
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   889
          regs[i].set1(VMRegImpl::stack2reg(stk_args));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
          stk_args += 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
      case T_DOUBLE:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
        assert(sig_bt[i + 1] == T_VOID, "expecting half");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   895
        if (fp_args < Argument::n_float_register_parameters_c) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
          regs[i].set2(FP_ArgReg[fp_args++]->as_VMReg());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
#ifdef _WIN64
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
          int_args++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
          // Allocate slots for callee to stuff register args the stack.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
          stk_args += 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
          regs[i].set2(VMRegImpl::stack2reg(stk_args));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
          stk_args += 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
      case T_VOID: // Halves of longs and doubles
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
        assert(i != 0 && (sig_bt[i - 1] == T_LONG || sig_bt[i - 1] == T_DOUBLE), "expecting half");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
        regs[i].set_bad();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
      default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
        ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   916
#ifdef _WIN64
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
  // windows abi requires that we always allocate enough stack space
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
  // for 4 64bit registers to be stored down.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   919
  if (stk_args < 8) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   920
    stk_args = 8;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   921
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
#endif // _WIN64
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
  return stk_args;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
// On 64 bit we will store integer like items to the stack as
489c9b5090e2 Initial load
duke
parents:
diff changeset
   928
// 64 bits items (sparc abi) even though java would only store
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
// 32bits for a parameter. On 32bit it will simply be 32 bits
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
// So this routine will do 32->32 on 32bit and 32->64 on 64bit
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
static void move32_64(MacroAssembler* masm, VMRegPair src, VMRegPair dst) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   932
  if (src.first()->is_stack()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   933
    if (dst.first()->is_stack()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
      // stack to stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
   935
      __ movslq(rax, Address(rbp, reg2offset_in(src.first())));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   936
      __ movq(Address(rsp, reg2offset_out(dst.first())), rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   937
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   938
      // stack to reg
489c9b5090e2 Initial load
duke
parents:
diff changeset
   939
      __ movslq(dst.first()->as_Register(), Address(rbp, reg2offset_in(src.first())));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   940
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   941
  } else if (dst.first()->is_stack()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   942
    // reg to stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
   943
    // Do we really have to sign extend???
489c9b5090e2 Initial load
duke
parents:
diff changeset
   944
    // __ movslq(src.first()->as_Register(), src.first()->as_Register());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   945
    __ movq(Address(rsp, reg2offset_out(dst.first())), src.first()->as_Register());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   946
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   947
    // Do we really have to sign extend???
489c9b5090e2 Initial load
duke
parents:
diff changeset
   948
    // __ movslq(dst.first()->as_Register(), src.first()->as_Register());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   949
    if (dst.first() != src.first()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   950
      __ movq(dst.first()->as_Register(), src.first()->as_Register());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   951
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   952
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   953
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   954
489c9b5090e2 Initial load
duke
parents:
diff changeset
   955
489c9b5090e2 Initial load
duke
parents:
diff changeset
   956
// An oop arg. Must pass a handle not the oop itself
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
static void object_move(MacroAssembler* masm,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   958
                        OopMap* map,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   959
                        int oop_handle_offset,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   960
                        int framesize_in_slots,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   961
                        VMRegPair src,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   962
                        VMRegPair dst,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
                        bool is_receiver,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   964
                        int* receiver_offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
  // must pass a handle. First figure out the location we use as a handle
489c9b5090e2 Initial load
duke
parents:
diff changeset
   967
489c9b5090e2 Initial load
duke
parents:
diff changeset
   968
  Register rHandle = dst.first()->is_stack() ? rax : dst.first()->as_Register();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   969
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
  // See if oop is NULL if it is we need no handle
489c9b5090e2 Initial load
duke
parents:
diff changeset
   971
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
  if (src.first()->is_stack()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   973
489c9b5090e2 Initial load
duke
parents:
diff changeset
   974
    // Oop is already on the stack as an argument
489c9b5090e2 Initial load
duke
parents:
diff changeset
   975
    int offset_in_older_frame = src.first()->reg2stack() + SharedRuntime::out_preserve_stack_slots();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   976
    map->set_oop(VMRegImpl::stack2reg(offset_in_older_frame + framesize_in_slots));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
    if (is_receiver) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
      *receiver_offset = (offset_in_older_frame + framesize_in_slots) * VMRegImpl::stack_slot_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   981
    __ cmpptr(Address(rbp, reg2offset_in(src.first())), (int32_t)NULL_WORD);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   982
    __ lea(rHandle, Address(rbp, reg2offset_in(src.first())));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
    // conditionally move a NULL
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
   984
    __ cmovptr(Assembler::equal, rHandle, Address(rbp, reg2offset_in(src.first())));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
    // Oop is in an a register we must store it to the space we reserve
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
    // on the stack for oop_handles and pass a handle if oop is non-NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
    const Register rOop = src.first()->as_Register();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
    int oop_slot;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
    if (rOop == j_rarg0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
      oop_slot = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
    else if (rOop == j_rarg1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
      oop_slot = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
    else if (rOop == j_rarg2)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
      oop_slot = 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
    else if (rOop == j_rarg3)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
      oop_slot = 3;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
    else if (rOop == j_rarg4)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
      oop_slot = 4;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
    else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
      assert(rOop == j_rarg5, "wrong register");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
      oop_slot = 5;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
    oop_slot = oop_slot * VMRegImpl::slots_per_word + oop_handle_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
    int offset = oop_slot*VMRegImpl::stack_slot_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
    map->set_oop(VMRegImpl::stack2reg(oop_slot));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
    // Store oop in handle area, may be NULL
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1012
    __ movptr(Address(rsp, offset), rOop);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1013
    if (is_receiver) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
      *receiver_offset = offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1015
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1017
    __ cmpptr(rOop, (int32_t)NULL_WORD);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1018
    __ lea(rHandle, Address(rsp, offset));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1019
    // conditionally move a NULL from the handle area where it was just stored
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1020
    __ cmovptr(Assembler::equal, rHandle, Address(rsp, offset));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1021
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1022
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
  // If arg is on the stack then place it otherwise it is already in correct reg.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1024
  if (dst.first()->is_stack()) {
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1025
    __ movptr(Address(rsp, reg2offset_out(dst.first())), rHandle);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
// A float arg may have to do float reg int reg conversion
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
static void float_move(MacroAssembler* masm, VMRegPair src, VMRegPair dst) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
  assert(!src.second()->is_valid() && !dst.second()->is_valid(), "bad float_move");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
  // The calling conventions assures us that each VMregpair is either
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
  // all really one physical register or adjacent stack slots.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
  // This greatly simplifies the cases here compared to sparc.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
  if (src.first()->is_stack()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
    if (dst.first()->is_stack()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
      __ movl(rax, Address(rbp, reg2offset_in(src.first())));
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1040
      __ movptr(Address(rsp, reg2offset_out(dst.first())), rax);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1042
      // stack to reg
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1043
      assert(dst.first()->is_XMMRegister(), "only expect xmm registers as parameters");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1044
      __ movflt(dst.first()->as_XMMRegister(), Address(rbp, reg2offset_in(src.first())));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1045
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1046
  } else if (dst.first()->is_stack()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1047
    // reg to stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1048
    assert(src.first()->is_XMMRegister(), "only expect xmm registers as parameters");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1049
    __ movflt(Address(rsp, reg2offset_out(dst.first())), src.first()->as_XMMRegister());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1050
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1051
    // reg to reg
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1052
    // In theory these overlap but the ordering is such that this is likely a nop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1053
    if ( src.first() != dst.first()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1054
      __ movdbl(dst.first()->as_XMMRegister(),  src.first()->as_XMMRegister());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1055
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1056
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1057
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1058
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
// A long move
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
static void long_move(MacroAssembler* masm, VMRegPair src, VMRegPair dst) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1062
  // The calling conventions assures us that each VMregpair is either
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
  // all really one physical register or adjacent stack slots.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
  // This greatly simplifies the cases here compared to sparc.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1065
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
  if (src.is_single_phys_reg() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1067
    if (dst.is_single_phys_reg()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1068
      if (dst.first() != src.first()) {
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1069
        __ mov(dst.first()->as_Register(), src.first()->as_Register());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1070
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1071
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1072
      assert(dst.is_single_reg(), "not a stack pair");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1073
      __ movq(Address(rsp, reg2offset_out(dst.first())), src.first()->as_Register());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1074
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
  } else if (dst.is_single_phys_reg()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1076
    assert(src.is_single_reg(),  "not a stack pair");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1077
    __ movq(dst.first()->as_Register(), Address(rbp, reg2offset_out(src.first())));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1078
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
    assert(src.is_single_reg() && dst.is_single_reg(), "not stack pairs");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1080
    __ movq(rax, Address(rbp, reg2offset_in(src.first())));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1081
    __ movq(Address(rsp, reg2offset_out(dst.first())), rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1082
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1083
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1084
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1085
// A double move
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1086
static void double_move(MacroAssembler* masm, VMRegPair src, VMRegPair dst) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1087
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
  // The calling conventions assures us that each VMregpair is either
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1089
  // all really one physical register or adjacent stack slots.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1090
  // This greatly simplifies the cases here compared to sparc.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1091
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1092
  if (src.is_single_phys_reg() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1093
    if (dst.is_single_phys_reg()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
      // In theory these overlap but the ordering is such that this is likely a nop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1095
      if ( src.first() != dst.first()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1096
        __ movdbl(dst.first()->as_XMMRegister(), src.first()->as_XMMRegister());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1097
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1098
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1099
      assert(dst.is_single_reg(), "not a stack pair");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1100
      __ movdbl(Address(rsp, reg2offset_out(dst.first())), src.first()->as_XMMRegister());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1101
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1102
  } else if (dst.is_single_phys_reg()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1103
    assert(src.is_single_reg(),  "not a stack pair");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1104
    __ movdbl(dst.first()->as_XMMRegister(), Address(rbp, reg2offset_out(src.first())));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1105
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1106
    assert(src.is_single_reg() && dst.is_single_reg(), "not stack pairs");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1107
    __ movq(rax, Address(rbp, reg2offset_in(src.first())));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1108
    __ movq(Address(rsp, reg2offset_out(dst.first())), rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1109
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1110
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1111
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1112
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1113
void SharedRuntime::save_native_result(MacroAssembler *masm, BasicType ret_type, int frame_slots) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1114
  // We always ignore the frame_slots arg and just use the space just below frame pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1115
  // which by this time is free to use
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1116
  switch (ret_type) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1117
  case T_FLOAT:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1118
    __ movflt(Address(rbp, -wordSize), xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1119
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1120
  case T_DOUBLE:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1121
    __ movdbl(Address(rbp, -wordSize), xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1122
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1123
  case T_VOID:  break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1124
  default: {
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1125
    __ movptr(Address(rbp, -wordSize), rax);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1126
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1127
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1128
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1129
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1130
void SharedRuntime::restore_native_result(MacroAssembler *masm, BasicType ret_type, int frame_slots) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1131
  // We always ignore the frame_slots arg and just use the space just below frame pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1132
  // which by this time is free to use
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1133
  switch (ret_type) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1134
  case T_FLOAT:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1135
    __ movflt(xmm0, Address(rbp, -wordSize));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1136
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1137
  case T_DOUBLE:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1138
    __ movdbl(xmm0, Address(rbp, -wordSize));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1139
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1140
  case T_VOID:  break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1141
  default: {
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1142
    __ movptr(rax, Address(rbp, -wordSize));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1143
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1144
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1145
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1146
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1147
static void save_args(MacroAssembler *masm, int arg_count, int first_arg, VMRegPair *args) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1148
    for ( int i = first_arg ; i < arg_count ; i++ ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1149
      if (args[i].first()->is_Register()) {
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1150
        __ push(args[i].first()->as_Register());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1151
      } else if (args[i].first()->is_XMMRegister()) {
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1152
        __ subptr(rsp, 2*wordSize);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1153
        __ movdbl(Address(rsp, 0), args[i].first()->as_XMMRegister());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1154
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1155
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1156
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1157
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1158
static void restore_args(MacroAssembler *masm, int arg_count, int first_arg, VMRegPair *args) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1159
    for ( int i = arg_count - 1 ; i >= first_arg ; i-- ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1160
      if (args[i].first()->is_Register()) {
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1161
        __ pop(args[i].first()->as_Register());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1162
      } else if (args[i].first()->is_XMMRegister()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1163
        __ movdbl(args[i].first()->as_XMMRegister(), Address(rsp, 0));
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1164
        __ addptr(rsp, 2*wordSize);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1165
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1166
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1167
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1168
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1169
// ---------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1170
// Generate a native wrapper for a given method.  The method takes arguments
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1171
// in the Java compiled code convention, marshals them to the native
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1172
// convention (handlizes oops, etc), transitions to native, makes the call,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1173
// returns to java state (possibly blocking), unhandlizes any result and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1174
// returns.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1175
nmethod *SharedRuntime::generate_native_wrapper(MacroAssembler *masm,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1176
                                                methodHandle method,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1177
                                                int total_in_args,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1178
                                                int comp_args_on_stack,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1179
                                                BasicType *in_sig_bt,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1180
                                                VMRegPair *in_regs,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1181
                                                BasicType ret_type) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1182
  // Native nmethod wrappers never take possesion of the oop arguments.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1183
  // So the caller will gc the arguments. The only thing we need an
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1184
  // oopMap for is if the call is static
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1185
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1186
  // An OopMap for lock (and class if static)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1187
  OopMapSet *oop_maps = new OopMapSet();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1188
  intptr_t start = (intptr_t)__ pc();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1189
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1190
  // We have received a description of where all the java arg are located
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1191
  // on entry to the wrapper. We need to convert these args to where
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1192
  // the jni function will expect them. To figure out where they go
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1193
  // we convert the java signature to a C signature by inserting
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1194
  // the hidden arguments as arg[0] and possibly arg[1] (static method)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1195
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1196
  int total_c_args = total_in_args + 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1197
  if (method->is_static()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1198
    total_c_args++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1199
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1200
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1201
  BasicType* out_sig_bt = NEW_RESOURCE_ARRAY(BasicType, total_c_args);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1202
  VMRegPair* out_regs   = NEW_RESOURCE_ARRAY(VMRegPair,   total_c_args);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1203
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1204
  int argc = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1205
  out_sig_bt[argc++] = T_ADDRESS;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1206
  if (method->is_static()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1207
    out_sig_bt[argc++] = T_OBJECT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1208
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1209
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1210
  for (int i = 0; i < total_in_args ; i++ ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1211
    out_sig_bt[argc++] = in_sig_bt[i];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1212
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1213
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1214
  // Now figure out where the args must be stored and how much stack space
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1215
  // they require.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1216
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1217
  int out_arg_slots;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1218
  out_arg_slots = c_calling_convention(out_sig_bt, out_regs, total_c_args);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1219
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1220
  // Compute framesize for the wrapper.  We need to handlize all oops in
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1221
  // incoming registers
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1222
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1223
  // Calculate the total number of stack slots we will need.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1224
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1225
  // First count the abi requirement plus all of the outgoing args
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1226
  int stack_slots = SharedRuntime::out_preserve_stack_slots() + out_arg_slots;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1227
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1228
  // Now the space for the inbound oop handle area
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1229
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1230
  int oop_handle_offset = stack_slots;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1231
  stack_slots += 6*VMRegImpl::slots_per_word;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1232
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1233
  // Now any space we need for handlizing a klass if static method
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1234
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1235
  int oop_temp_slot_offset = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1236
  int klass_slot_offset = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1237
  int klass_offset = -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1238
  int lock_slot_offset = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1239
  bool is_static = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1240
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1241
  if (method->is_static()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1242
    klass_slot_offset = stack_slots;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1243
    stack_slots += VMRegImpl::slots_per_word;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1244
    klass_offset = klass_slot_offset * VMRegImpl::stack_slot_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1245
    is_static = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1246
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1247
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1248
  // Plus a lock if needed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1249
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1250
  if (method->is_synchronized()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1251
    lock_slot_offset = stack_slots;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1252
    stack_slots += VMRegImpl::slots_per_word;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1253
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1254
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1255
  // Now a place (+2) to save return values or temp during shuffling
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1256
  // + 4 for return address (which we own) and saved rbp
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1257
  stack_slots += 6;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1258
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1259
  // Ok The space we have allocated will look like:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1260
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1261
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1262
  // FP-> |                     |
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1263
  //      |---------------------|
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1264
  //      | 2 slots for moves   |
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1265
  //      |---------------------|
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1266
  //      | lock box (if sync)  |
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1267
  //      |---------------------| <- lock_slot_offset
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1268
  //      | klass (if static)   |
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1269
  //      |---------------------| <- klass_slot_offset
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1270
  //      | oopHandle area      |
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1271
  //      |---------------------| <- oop_handle_offset (6 java arg registers)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1272
  //      | outbound memory     |
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1273
  //      | based arguments     |
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1274
  //      |                     |
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1275
  //      |---------------------|
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1276
  //      |                     |
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1277
  // SP-> | out_preserved_slots |
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1278
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1279
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1280
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1281
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1282
  // Now compute actual number of stack words we need rounding to make
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1283
  // stack properly aligned.
1900
68ea5d5fab8b 6792301: StackAlignmentInBytes not honored for compiled native methods
xlu
parents: 1896
diff changeset
  1284
  stack_slots = round_to(stack_slots, StackAlignmentInSlots);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1285
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1286
  int stack_size = stack_slots * VMRegImpl::stack_slot_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1287
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1288
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1289
  // First thing make an ic check to see if we should even be here
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1290
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1291
  // We are free to use all registers as temps without saving them and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1292
  // restoring them except rbp. rbp is the only callee save register
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1293
  // as far as the interpreter and the compiler(s) are concerned.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1294
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1295
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1296
  const Register ic_reg = rax;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1297
  const Register receiver = j_rarg0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1298
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1299
  Label ok;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1300
  Label exception_pending;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1301
3265
d57651294166 6859338: amd64 native unverified entry point pushes values before implicit null check
never
parents: 2349
diff changeset
  1302
  assert_different_registers(ic_reg, receiver, rscratch1);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1303
  __ verify_oop(receiver);
3265
d57651294166 6859338: amd64 native unverified entry point pushes values before implicit null check
never
parents: 2349
diff changeset
  1304
  __ load_klass(rscratch1, receiver);
d57651294166 6859338: amd64 native unverified entry point pushes values before implicit null check
never
parents: 2349
diff changeset
  1305
  __ cmpq(ic_reg, rscratch1);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1306
  __ jcc(Assembler::equal, ok);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1307
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1308
  __ jump(RuntimeAddress(SharedRuntime::get_ic_miss_stub()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1309
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  1310
  __ bind(ok);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  1311
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1312
  // Verified entry point must be aligned
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1313
  __ align(8);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1314
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1315
  int vep_offset = ((intptr_t)__ pc()) - start;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1316
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1317
  // The instruction at the verified entry point must be 5 bytes or longer
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1318
  // because it can be patched on the fly by make_non_entrant. The stack bang
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1319
  // instruction fits that requirement.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1320
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1321
  // Generate stack overflow check
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1322
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1323
  if (UseStackBanging) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1324
    __ bang_stack_with_offset(StackShadowPages*os::vm_page_size());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1325
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1326
    // need a 5 byte instruction to allow MT safe patching to non-entrant
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1327
    __ fat_nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1328
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1329
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1330
  // Generate a new frame for the wrapper.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1331
  __ enter();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1332
  // -2 because return address is already present and so is saved rbp
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1333
  __ subptr(rsp, stack_size - 2*wordSize);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1334
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1335
    // Frame is now completed as far as size and linkage.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1336
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1337
    int frame_complete = ((intptr_t)__ pc()) - start;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1338
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1339
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1340
    {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1341
      Label L;
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1342
      __ mov(rax, rsp);
2131
98f9cef66a34 6810672: Comment typos
twisti
parents: 1900
diff changeset
  1343
      __ andptr(rax, -16); // must be 16 byte boundary (see amd64 ABI)
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1344
      __ cmpptr(rax, rsp);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1345
      __ jcc(Assembler::equal, L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1346
      __ stop("improperly aligned stack");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1347
      __ bind(L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1348
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1349
#endif /* ASSERT */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1350
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1351
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1352
  // We use r14 as the oop handle for the receiver/klass
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1353
  // It is callee save so it survives the call to native
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1354
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1355
  const Register oop_handle_reg = r14;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1356
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1357
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1358
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1359
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1360
  // We immediately shuffle the arguments so that any vm call we have to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1361
  // make from here on out (sync slow path, jvmti, etc.) we will have
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1362
  // captured the oops from our caller and have a valid oopMap for
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1363
  // them.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1364
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1365
  // -----------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1366
  // The Grand Shuffle
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1367
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1368
  // The Java calling convention is either equal (linux) or denser (win64) than the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1369
  // c calling convention. However the because of the jni_env argument the c calling
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1370
  // convention always has at least one more (and two for static) arguments than Java.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1371
  // Therefore if we move the args from java -> c backwards then we will never have
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1372
  // a register->register conflict and we don't have to build a dependency graph
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1373
  // and figure out how to break any cycles.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1374
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1375
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1376
  // Record esp-based slot for receiver on stack for non-static methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1377
  int receiver_offset = -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1378
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1379
  // This is a trick. We double the stack slots so we can claim
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1380
  // the oops in the caller's frame. Since we are sure to have
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1381
  // more args than the caller doubling is enough to make
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1382
  // sure we can capture all the incoming oop args from the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1383
  // caller.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1384
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1385
  OopMap* map = new OopMap(stack_slots * 2, 0 /* arg_slots*/);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1386
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1387
  // Mark location of rbp (someday)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1388
  // map->set_callee_saved(VMRegImpl::stack2reg( stack_slots - 2), stack_slots * 2, 0, vmreg(rbp));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1389
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1390
  // Use eax, ebx as temporaries during any memory-memory moves we have to do
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1391
  // All inbound args are referenced based on rbp and all outbound args via rsp.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1392
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1393
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1394
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1395
  bool reg_destroyed[RegisterImpl::number_of_registers];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1396
  bool freg_destroyed[XMMRegisterImpl::number_of_registers];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1397
  for ( int r = 0 ; r < RegisterImpl::number_of_registers ; r++ ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1398
    reg_destroyed[r] = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1399
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1400
  for ( int f = 0 ; f < XMMRegisterImpl::number_of_registers ; f++ ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1401
    freg_destroyed[f] = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1402
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1403
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1404
#endif /* ASSERT */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1405
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1406
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1407
  int c_arg = total_c_args - 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1408
  for ( int i = total_in_args - 1; i >= 0 ; i--, c_arg-- ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1409
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1410
    if (in_regs[i].first()->is_Register()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1411
      assert(!reg_destroyed[in_regs[i].first()->as_Register()->encoding()], "destroyed reg!");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1412
    } else if (in_regs[i].first()->is_XMMRegister()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1413
      assert(!freg_destroyed[in_regs[i].first()->as_XMMRegister()->encoding()], "destroyed reg!");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1414
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1415
    if (out_regs[c_arg].first()->is_Register()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1416
      reg_destroyed[out_regs[c_arg].first()->as_Register()->encoding()] = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1417
    } else if (out_regs[c_arg].first()->is_XMMRegister()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1418
      freg_destroyed[out_regs[c_arg].first()->as_XMMRegister()->encoding()] = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1419
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1420
#endif /* ASSERT */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1421
    switch (in_sig_bt[i]) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1422
      case T_ARRAY:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1423
      case T_OBJECT:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1424
        object_move(masm, map, oop_handle_offset, stack_slots, in_regs[i], out_regs[c_arg],
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1425
                    ((i == 0) && (!is_static)),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1426
                    &receiver_offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1427
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1428
      case T_VOID:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1429
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1430
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1431
      case T_FLOAT:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1432
        float_move(masm, in_regs[i], out_regs[c_arg]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1433
          break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1434
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1435
      case T_DOUBLE:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1436
        assert( i + 1 < total_in_args &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1437
                in_sig_bt[i + 1] == T_VOID &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1438
                out_sig_bt[c_arg+1] == T_VOID, "bad arg list");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1439
        double_move(masm, in_regs[i], out_regs[c_arg]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1440
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1441
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1442
      case T_LONG :
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1443
        long_move(masm, in_regs[i], out_regs[c_arg]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1444
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1445
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1446
      case T_ADDRESS: assert(false, "found T_ADDRESS in java args");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1447
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1448
      default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1449
        move32_64(masm, in_regs[i], out_regs[c_arg]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1450
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1451
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1452
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1453
  // point c_arg at the first arg that is already loaded in case we
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1454
  // need to spill before we call out
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1455
  c_arg++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1456
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1457
  // Pre-load a static method's oop into r14.  Used both by locking code and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1458
  // the normal JNI call code.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1459
  if (method->is_static()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1460
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1461
    //  load oop into a register
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1462
    __ movoop(oop_handle_reg, JNIHandles::make_local(Klass::cast(method->method_holder())->java_mirror()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1463
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1464
    // Now handlize the static class mirror it's known not-null.
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1465
    __ movptr(Address(rsp, klass_offset), oop_handle_reg);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1466
    map->set_oop(VMRegImpl::stack2reg(klass_slot_offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1467
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1468
    // Now get the handle
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1469
    __ lea(oop_handle_reg, Address(rsp, klass_offset));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1470
    // store the klass handle as second argument
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1471
    __ movptr(c_rarg1, oop_handle_reg);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1472
    // and protect the arg if we must spill
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1473
    c_arg--;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1474
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1475
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1476
  // Change state to native (we save the return address in the thread, since it might not
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1477
  // be pushed on the stack when we do a a stack traversal). It is enough that the pc()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1478
  // points into the right code segment. It does not have to be the correct return pc.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1479
  // We use the same pc/oopMap repeatedly when we call out
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1480
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1481
  intptr_t the_pc = (intptr_t) __ pc();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1482
  oop_maps->add_gc_map(the_pc - start, map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1483
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1484
  __ set_last_Java_frame(rsp, noreg, (address)the_pc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1485
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1486
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1487
  // We have all of the arguments setup at this point. We must not touch any register
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1488
  // argument registers at this point (what if we save/restore them there are no oop?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1489
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1490
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1491
    SkipIfEqual skip(masm, &DTraceMethodProbes, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1492
    // protect the args we've loaded
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1493
    save_args(masm, total_c_args, c_arg, out_regs);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1494
    __ movoop(c_rarg1, JNIHandles::make_local(method()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1495
    __ call_VM_leaf(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1496
      CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_method_entry),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1497
      r15_thread, c_rarg1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1498
    restore_args(masm, total_c_args, c_arg, out_regs);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1499
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1500
2136
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1066
diff changeset
  1501
  // RedefineClasses() tracing support for obsolete method entry
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1066
diff changeset
  1502
  if (RC_TRACE_IN_RANGE(0x00001000, 0x00002000)) {
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1066
diff changeset
  1503
    // protect the args we've loaded
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1066
diff changeset
  1504
    save_args(masm, total_c_args, c_arg, out_regs);
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1066
diff changeset
  1505
    __ movoop(c_rarg1, JNIHandles::make_local(method()));
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1066
diff changeset
  1506
    __ call_VM_leaf(
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1066
diff changeset
  1507
      CAST_FROM_FN_PTR(address, SharedRuntime::rc_trace_method_entry),
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1066
diff changeset
  1508
      r15_thread, c_rarg1);
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1066
diff changeset
  1509
    restore_args(masm, total_c_args, c_arg, out_regs);
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1066
diff changeset
  1510
  }
c55428da3cec 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined
dcubed
parents: 1066
diff changeset
  1511
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1512
  // Lock a synchronized method
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1513
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1514
  // Register definitions used by locking and unlocking
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1515
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1516
  const Register swap_reg = rax;  // Must use rax for cmpxchg instruction
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1517
  const Register obj_reg  = rbx;  // Will contain the oop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1518
  const Register lock_reg = r13;  // Address of compiler lock object (BasicLock)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1519
  const Register old_hdr  = r13;  // value of old header at unlock time
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1520
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1521
  Label slow_path_lock;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1522
  Label lock_done;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1523
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1524
  if (method->is_synchronized()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1525
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1526
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1527
    const int mark_word_offset = BasicLock::displaced_header_offset_in_bytes();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1528
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1529
    // Get the handle (the 2nd argument)
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1530
    __ mov(oop_handle_reg, c_rarg1);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1531
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1532
    // Get address of the box
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1533
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1534
    __ lea(lock_reg, Address(rsp, lock_slot_offset * VMRegImpl::stack_slot_size));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1535
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1536
    // Load the oop from the handle
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1537
    __ movptr(obj_reg, Address(oop_handle_reg, 0));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1538
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1539
    if (UseBiasedLocking) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1540
      __ biased_locking_enter(lock_reg, obj_reg, swap_reg, rscratch1, false, lock_done, &slow_path_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1541
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1542
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1543
    // Load immediate 1 into swap_reg %rax
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1544
    __ movl(swap_reg, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1545
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1546
    // Load (object->mark() | 1) into swap_reg %rax
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1547
    __ orptr(swap_reg, Address(obj_reg, 0));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1548
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1549
    // Save (object->mark() | 1) into BasicLock's displaced header
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1550
    __ movptr(Address(lock_reg, mark_word_offset), swap_reg);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1551
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1552
    if (os::is_MP()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1553
      __ lock();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1554
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1555
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1556
    // src -> dest iff dest == rax else rax <- dest
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1557
    __ cmpxchgptr(lock_reg, Address(obj_reg, 0));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1558
    __ jcc(Assembler::equal, lock_done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1559
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1560
    // Hmm should this move to the slow path code area???
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1561
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1562
    // Test if the oopMark is an obvious stack pointer, i.e.,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1563
    //  1) (mark & 3) == 0, and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1564
    //  2) rsp <= mark < mark + os::pagesize()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1565
    // These 3 tests can be done by evaluating the following
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1566
    // expression: ((mark - rsp) & (3 - os::vm_page_size())),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1567
    // assuming both stack pointer and pagesize have their
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1568
    // least significant 2 bits clear.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1569
    // NOTE: the oopMark is in swap_reg %rax as the result of cmpxchg
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1570
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1571
    __ subptr(swap_reg, rsp);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1572
    __ andptr(swap_reg, 3 - os::vm_page_size());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1573
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1574
    // Save the test result, for recursive case, the result is zero
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1575
    __ movptr(Address(lock_reg, mark_word_offset), swap_reg);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1576
    __ jcc(Assembler::notEqual, slow_path_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1577
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1578
    // Slow path will re-enter here
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1579
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1580
    __ bind(lock_done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1581
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1582
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1583
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1584
  // Finally just about ready to make the JNI call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1585
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1586
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1587
  // get JNIEnv* which is first argument to native
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1588
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1589
  __ lea(c_rarg0, Address(r15_thread, in_bytes(JavaThread::jni_environment_offset())));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1590
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1591
  // Now set thread in native
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1592
  __ movl(Address(r15_thread, JavaThread::thread_state_offset()), _thread_in_native);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1593
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1594
  __ call(RuntimeAddress(method->native_function()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1595
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1596
    // Either restore the MXCSR register after returning from the JNI Call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1597
    // or verify that it wasn't changed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1598
    if (RestoreMXCSROnJNICalls) {
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1599
      __ ldmxcsr(ExternalAddress(StubRoutines::x86::mxcsr_std()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1600
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1601
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1602
    else if (CheckJNICalls ) {
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1603
      __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, StubRoutines::x86::verify_mxcsr_entry())));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1604
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1605
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1606
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1607
  // Unpack native results.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1608
  switch (ret_type) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1609
  case T_BOOLEAN: __ c2bool(rax);            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1610
  case T_CHAR   : __ movzwl(rax, rax);      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1611
  case T_BYTE   : __ sign_extend_byte (rax); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1612
  case T_SHORT  : __ sign_extend_short(rax); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1613
  case T_INT    : /* nothing to do */        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1614
  case T_DOUBLE :
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1615
  case T_FLOAT  :
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1616
    // Result is in xmm0 we'll save as needed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1617
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1618
  case T_ARRAY:                 // Really a handle
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1619
  case T_OBJECT:                // Really a handle
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1620
      break; // can't de-handlize until after safepoint check
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1621
  case T_VOID: break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1622
  case T_LONG: break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1623
  default       : ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1624
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1625
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1626
  // Switch thread to "native transition" state before reading the synchronization state.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1627
  // This additional state is necessary because reading and testing the synchronization
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1628
  // state is not atomic w.r.t. GC, as this scenario demonstrates:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1629
  //     Java thread A, in _thread_in_native state, loads _not_synchronized and is preempted.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1630
  //     VM thread changes sync state to synchronizing and suspends threads for GC.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1631
  //     Thread A is resumed to finish this native method, but doesn't block here since it
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1632
  //     didn't see any synchronization is progress, and escapes.
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1633
  __ movl(Address(r15_thread, JavaThread::thread_state_offset()), _thread_in_native_trans);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1634
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1635
  if(os::is_MP()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1636
    if (UseMembar) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1637
      // Force this write out before the read below
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1638
      __ membar(Assembler::Membar_mask_bits(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1639
           Assembler::LoadLoad | Assembler::LoadStore |
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1640
           Assembler::StoreLoad | Assembler::StoreStore));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1641
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1642
      // Write serialization page so VM thread can do a pseudo remote membar.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1643
      // We use the current thread pointer to calculate a thread specific
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1644
      // offset to write to within the page. This minimizes bus traffic
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1645
      // due to cache line collision.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1646
      __ serialize_memory(r15_thread, rcx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1647
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1648
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1649
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1650
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1651
  // check for safepoint operation in progress and/or pending suspend requests
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1652
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1653
    Label Continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1654
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1655
    __ cmp32(ExternalAddress((address)SafepointSynchronize::address_of_state()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1656
             SafepointSynchronize::_not_synchronized);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1657
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1658
    Label L;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1659
    __ jcc(Assembler::notEqual, L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1660
    __ cmpl(Address(r15_thread, JavaThread::suspend_flags_offset()), 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1661
    __ jcc(Assembler::equal, Continue);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1662
    __ bind(L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1663
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1664
    // Don't use call_VM as it will see a possible pending exception and forward it
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1665
    // and never return here preventing us from clearing _last_native_pc down below.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1666
    // Also can't use call_VM_leaf either as it will check to see if rsi & rdi are
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1667
    // preserved and correspond to the bcp/locals pointers. So we do a runtime call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1668
    // by hand.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1669
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1670
    save_native_result(masm, ret_type, stack_slots);
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1671
    __ mov(c_rarg0, r15_thread);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1672
    __ mov(r12, rsp); // remember sp
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1673
    __ subptr(rsp, frame::arg_reg_save_area_bytes); // windows
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1674
    __ andptr(rsp, -16); // align stack as required by ABI
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1675
    __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, JavaThread::check_special_condition_for_native_trans)));
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1676
    __ mov(rsp, r12); // restore sp
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  1677
    __ reinit_heapbase();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1678
    // Restore any method result value
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1679
    restore_native_result(masm, ret_type, stack_slots);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1680
    __ bind(Continue);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1681
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1682
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1683
  // change thread state
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1684
  __ movl(Address(r15_thread, JavaThread::thread_state_offset()), _thread_in_Java);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1685
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1686
  Label reguard;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1687
  Label reguard_done;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1688
  __ cmpl(Address(r15_thread, JavaThread::stack_guard_state_offset()), JavaThread::stack_guard_yellow_disabled);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1689
  __ jcc(Assembler::equal, reguard);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1690
  __ bind(reguard_done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1691
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1692
  // native result if any is live
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1693
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1694
  // Unlock
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1695
  Label unlock_done;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1696
  Label slow_path_unlock;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1697
  if (method->is_synchronized()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1698
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1699
    // Get locked oop from the handle we passed to jni
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1700
    __ movptr(obj_reg, Address(oop_handle_reg, 0));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1701
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1702
    Label done;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1703
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1704
    if (UseBiasedLocking) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1705
      __ biased_locking_exit(obj_reg, old_hdr, done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1706
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1707
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1708
    // Simple recursive lock?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1709
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1710
    __ cmpptr(Address(rsp, lock_slot_offset * VMRegImpl::stack_slot_size), (int32_t)NULL_WORD);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1711
    __ jcc(Assembler::equal, done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1712
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1713
    // Must save rax if if it is live now because cmpxchg must use it
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1714
    if (ret_type != T_FLOAT && ret_type != T_DOUBLE && ret_type != T_VOID) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1715
      save_native_result(masm, ret_type, stack_slots);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1716
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1717
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1718
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1719
    // get address of the stack lock
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1720
    __ lea(rax, Address(rsp, lock_slot_offset * VMRegImpl::stack_slot_size));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1721
    //  get old displaced header
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1722
    __ movptr(old_hdr, Address(rax, 0));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1723
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1724
    // Atomic swap old header if oop still contains the stack lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1725
    if (os::is_MP()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1726
      __ lock();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1727
    }
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1728
    __ cmpxchgptr(old_hdr, Address(obj_reg, 0));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1729
    __ jcc(Assembler::notEqual, slow_path_unlock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1730
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1731
    // slow path re-enters here
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1732
    __ bind(unlock_done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1733
    if (ret_type != T_FLOAT && ret_type != T_DOUBLE && ret_type != T_VOID) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1734
      restore_native_result(masm, ret_type, stack_slots);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1735
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1736
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1737
    __ bind(done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1738
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1739
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1740
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1741
    SkipIfEqual skip(masm, &DTraceMethodProbes, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1742
    save_native_result(masm, ret_type, stack_slots);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1743
    __ movoop(c_rarg1, JNIHandles::make_local(method()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1744
    __ call_VM_leaf(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1745
         CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_method_exit),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1746
         r15_thread, c_rarg1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1747
    restore_native_result(masm, ret_type, stack_slots);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1748
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1749
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1750
  __ reset_last_Java_frame(false, true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1751
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1752
  // Unpack oop result
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1753
  if (ret_type == T_OBJECT || ret_type == T_ARRAY) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1754
      Label L;
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1755
      __ testptr(rax, rax);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1756
      __ jcc(Assembler::zero, L);
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1757
      __ movptr(rax, Address(rax, 0));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1758
      __ bind(L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1759
      __ verify_oop(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1760
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1761
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1762
  // reset handle block
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1763
  __ movptr(rcx, Address(r15_thread, JavaThread::active_handles_offset()));
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1764
  __ movptr(Address(rcx, JNIHandleBlock::top_offset_in_bytes()), (int32_t)NULL_WORD);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1765
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1766
  // pop our frame
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1767
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1768
  __ leave();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1769
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1770
  // Any exception pending?
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1771
  __ cmpptr(Address(r15_thread, in_bytes(Thread::pending_exception_offset())), (int32_t)NULL_WORD);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1772
  __ jcc(Assembler::notEqual, exception_pending);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1773
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1774
  // Return
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1775
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1776
  __ ret(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1777
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1778
  // Unexpected paths are out of line and go here
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1779
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1780
  // forward the exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1781
  __ bind(exception_pending);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1782
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1783
  // and forward the exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1784
  __ jump(RuntimeAddress(StubRoutines::forward_exception_entry()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1785
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1786
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1787
  // Slow path locking & unlocking
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1788
  if (method->is_synchronized()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1789
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1790
    // BEGIN Slow path lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1791
    __ bind(slow_path_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1792
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1793
    // has last_Java_frame setup. No exceptions so do vanilla call not call_VM
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1794
    // args are (oop obj, BasicLock* lock, JavaThread* thread)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1795
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1796
    // protect the args we've loaded
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1797
    save_args(masm, total_c_args, c_arg, out_regs);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1798
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1799
    __ mov(c_rarg0, obj_reg);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1800
    __ mov(c_rarg1, lock_reg);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1801
    __ mov(c_rarg2, r15_thread);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1802
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1803
    // Not a leaf but we have last_Java_frame setup as we want
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1804
    __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::complete_monitor_locking_C), 3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1805
    restore_args(masm, total_c_args, c_arg, out_regs);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1806
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1807
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1808
    { Label L;
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1809
    __ cmpptr(Address(r15_thread, in_bytes(Thread::pending_exception_offset())), (int32_t)NULL_WORD);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1810
    __ jcc(Assembler::equal, L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1811
    __ stop("no pending exception allowed on exit from monitorenter");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1812
    __ bind(L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1813
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1814
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1815
    __ jmp(lock_done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1816
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1817
    // END Slow path lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1818
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1819
    // BEGIN Slow path unlock
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1820
    __ bind(slow_path_unlock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1821
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1822
    // If we haven't already saved the native result we must save it now as xmm registers
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1823
    // are still exposed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1824
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1825
    if (ret_type == T_FLOAT || ret_type == T_DOUBLE ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1826
      save_native_result(masm, ret_type, stack_slots);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1827
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1828
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1829
    __ lea(c_rarg1, Address(rsp, lock_slot_offset * VMRegImpl::stack_slot_size));
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1830
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1831
    __ mov(c_rarg0, obj_reg);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1832
    __ mov(r12, rsp); // remember sp
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1833
    __ subptr(rsp, frame::arg_reg_save_area_bytes); // windows
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1834
    __ andptr(rsp, -16); // align stack as required by ABI
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1835
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1836
    // Save pending exception around call to VM (which contains an EXCEPTION_MARK)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1837
    // NOTE that obj_reg == rbx currently
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1838
    __ movptr(rbx, Address(r15_thread, in_bytes(Thread::pending_exception_offset())));
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1839
    __ movptr(Address(r15_thread, in_bytes(Thread::pending_exception_offset())), (int32_t)NULL_WORD);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1840
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1841
    __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, SharedRuntime::complete_monitor_unlocking_C)));
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1842
    __ mov(rsp, r12); // restore sp
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  1843
    __ reinit_heapbase();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1844
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1845
    {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1846
      Label L;
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1847
      __ cmpptr(Address(r15_thread, in_bytes(Thread::pending_exception_offset())), (int)NULL_WORD);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1848
      __ jcc(Assembler::equal, L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1849
      __ stop("no pending exception allowed on exit complete_monitor_unlocking_C");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1850
      __ bind(L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1851
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1852
#endif /* ASSERT */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1853
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1854
    __ movptr(Address(r15_thread, in_bytes(Thread::pending_exception_offset())), rbx);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1855
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1856
    if (ret_type == T_FLOAT || ret_type == T_DOUBLE ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1857
      restore_native_result(masm, ret_type, stack_slots);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1858
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1859
    __ jmp(unlock_done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1860
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1861
    // END Slow path unlock
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1862
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1863
  } // synchronized
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1864
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1865
  // SLOW PATH Reguard the stack if needed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1866
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1867
  __ bind(reguard);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1868
  save_native_result(masm, ret_type, stack_slots);
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1869
  __ mov(r12, rsp); // remember sp
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1870
  __ subptr(rsp, frame::arg_reg_save_area_bytes); // windows
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1871
  __ andptr(rsp, -16); // align stack as required by ABI
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1872
  __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, SharedRuntime::reguard_yellow_pages)));
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  1873
  __ mov(rsp, r12); // restore sp
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  1874
  __ reinit_heapbase();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1875
  restore_native_result(masm, ret_type, stack_slots);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1876
  // and continue
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1877
  __ jmp(reguard_done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1878
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1879
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1880
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1881
  __ flush();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1882
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1883
  nmethod *nm = nmethod::new_native_nmethod(method,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1884
                                            masm->code(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1885
                                            vep_offset,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1886
                                            frame_complete,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1887
                                            stack_slots / VMRegImpl::slots_per_word,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1888
                                            (is_static ? in_ByteSize(klass_offset) : in_ByteSize(receiver_offset)),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1889
                                            in_ByteSize(lock_slot_offset*VMRegImpl::stack_slot_size),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1890
                                            oop_maps);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1891
  return nm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1892
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1893
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1894
363
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1895
#ifdef HAVE_DTRACE_H
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1896
// ---------------------------------------------------------------------------
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1897
// Generate a dtrace nmethod for a given signature.  The method takes arguments
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1898
// in the Java compiled code convention, marshals them to the native
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1899
// abi and then leaves nops at the position you would expect to call a native
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1900
// function. When the probe is enabled the nops are replaced with a trap
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1901
// instruction that dtrace inserts and the trace will cause a notification
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1902
// to dtrace.
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1903
//
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1904
// The probes are only able to take primitive types and java/lang/String as
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1905
// arguments.  No other java types are allowed. Strings are converted to utf8
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1906
// strings so that from dtrace point of view java strings are converted to C
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1907
// strings. There is an arbitrary fixed limit on the total space that a method
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1908
// can use for converting the strings. (256 chars per string in the signature).
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1909
// So any java string larger then this is truncated.
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1910
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1911
static int  fp_offset[ConcreteRegisterImpl::number_of_registers] = { 0 };
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1912
static bool offsets_initialized = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1913
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1914
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1915
nmethod *SharedRuntime::generate_dtrace_nmethod(MacroAssembler *masm,
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1916
                                                methodHandle method) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1917
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1918
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1919
  // generate_dtrace_nmethod is guarded by a mutex so we are sure to
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1920
  // be single threaded in this method.
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1921
  assert(AdapterHandlerLibrary_lock->owned_by_self(), "must be");
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1922
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1923
  if (!offsets_initialized) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1924
    fp_offset[c_rarg0->as_VMReg()->value()] = -1 * wordSize;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1925
    fp_offset[c_rarg1->as_VMReg()->value()] = -2 * wordSize;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1926
    fp_offset[c_rarg2->as_VMReg()->value()] = -3 * wordSize;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1927
    fp_offset[c_rarg3->as_VMReg()->value()] = -4 * wordSize;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1928
    fp_offset[c_rarg4->as_VMReg()->value()] = -5 * wordSize;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1929
    fp_offset[c_rarg5->as_VMReg()->value()] = -6 * wordSize;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1930
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1931
    fp_offset[c_farg0->as_VMReg()->value()] = -7 * wordSize;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1932
    fp_offset[c_farg1->as_VMReg()->value()] = -8 * wordSize;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1933
    fp_offset[c_farg2->as_VMReg()->value()] = -9 * wordSize;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1934
    fp_offset[c_farg3->as_VMReg()->value()] = -10 * wordSize;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1935
    fp_offset[c_farg4->as_VMReg()->value()] = -11 * wordSize;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1936
    fp_offset[c_farg5->as_VMReg()->value()] = -12 * wordSize;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1937
    fp_offset[c_farg6->as_VMReg()->value()] = -13 * wordSize;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1938
    fp_offset[c_farg7->as_VMReg()->value()] = -14 * wordSize;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1939
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1940
    offsets_initialized = true;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1941
  }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1942
  // Fill in the signature array, for the calling-convention call.
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1943
  int total_args_passed = method->size_of_parameters();
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1944
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1945
  BasicType* in_sig_bt  = NEW_RESOURCE_ARRAY(BasicType, total_args_passed);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1946
  VMRegPair  *in_regs   = NEW_RESOURCE_ARRAY(VMRegPair, total_args_passed);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1947
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1948
  // The signature we are going to use for the trap that dtrace will see
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1949
  // java/lang/String is converted. We drop "this" and any other object
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1950
  // is converted to NULL.  (A one-slot java/lang/Long object reference
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1951
  // is converted to a two-slot long, which is why we double the allocation).
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1952
  BasicType* out_sig_bt = NEW_RESOURCE_ARRAY(BasicType, total_args_passed * 2);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1953
  VMRegPair* out_regs   = NEW_RESOURCE_ARRAY(VMRegPair, total_args_passed * 2);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1954
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1955
  int i=0;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1956
  int total_strings = 0;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1957
  int first_arg_to_pass = 0;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1958
  int total_c_args = 0;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1959
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1960
  // Skip the receiver as dtrace doesn't want to see it
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1961
  if( !method->is_static() ) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1962
    in_sig_bt[i++] = T_OBJECT;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1963
    first_arg_to_pass = 1;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1964
  }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1965
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1966
  // We need to convert the java args to where a native (non-jni) function
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1967
  // would expect them. To figure out where they go we convert the java
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1968
  // signature to a C signature.
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1969
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1970
  SignatureStream ss(method->signature());
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1971
  for ( ; !ss.at_return_type(); ss.next()) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1972
    BasicType bt = ss.type();
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1973
    in_sig_bt[i++] = bt;  // Collect remaining bits of signature
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1974
    out_sig_bt[total_c_args++] = bt;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1975
    if( bt == T_OBJECT) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
  1976
      Symbol* s = ss.as_symbol_or_null();   // symbol is created
363
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1977
      if (s == vmSymbols::java_lang_String()) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1978
        total_strings++;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1979
        out_sig_bt[total_c_args-1] = T_ADDRESS;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1980
      } else if (s == vmSymbols::java_lang_Boolean() ||
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1981
                 s == vmSymbols::java_lang_Character() ||
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1982
                 s == vmSymbols::java_lang_Byte() ||
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1983
                 s == vmSymbols::java_lang_Short() ||
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1984
                 s == vmSymbols::java_lang_Integer() ||
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1985
                 s == vmSymbols::java_lang_Float()) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1986
        out_sig_bt[total_c_args-1] = T_INT;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1987
      } else if (s == vmSymbols::java_lang_Long() ||
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1988
                 s == vmSymbols::java_lang_Double()) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1989
        out_sig_bt[total_c_args-1] = T_LONG;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1990
        out_sig_bt[total_c_args++] = T_VOID;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1991
      }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1992
    } else if ( bt == T_LONG || bt == T_DOUBLE ) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1993
      in_sig_bt[i++] = T_VOID;   // Longs & doubles take 2 Java slots
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1994
      // We convert double to long
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1995
      out_sig_bt[total_c_args-1] = T_LONG;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1996
      out_sig_bt[total_c_args++] = T_VOID;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1997
    } else if ( bt == T_FLOAT) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1998
      // We convert float to int
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  1999
      out_sig_bt[total_c_args-1] = T_INT;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2000
    }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2001
  }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2002
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2003
  assert(i==total_args_passed, "validly parsed signature");
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2004
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2005
  // Now get the compiled-Java layout as input arguments
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2006
  int comp_args_on_stack;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2007
  comp_args_on_stack = SharedRuntime::java_calling_convention(
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2008
      in_sig_bt, in_regs, total_args_passed, false);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2009
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2010
  // Now figure out where the args must be stored and how much stack space
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2011
  // they require (neglecting out_preserve_stack_slots but space for storing
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2012
  // the 1st six register arguments). It's weird see int_stk_helper.
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2013
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2014
  int out_arg_slots;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2015
  out_arg_slots = c_calling_convention(out_sig_bt, out_regs, total_c_args);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2016
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2017
  // Calculate the total number of stack slots we will need.
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2018
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2019
  // First count the abi requirement plus all of the outgoing args
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2020
  int stack_slots = SharedRuntime::out_preserve_stack_slots() + out_arg_slots;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2021
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2022
  // Now space for the string(s) we must convert
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2023
  int* string_locs   = NEW_RESOURCE_ARRAY(int, total_strings + 1);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2024
  for (i = 0; i < total_strings ; i++) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2025
    string_locs[i] = stack_slots;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2026
    stack_slots += max_dtrace_string_size / VMRegImpl::stack_slot_size;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2027
  }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2028
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2029
  // Plus the temps we might need to juggle register args
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2030
  // regs take two slots each
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2031
  stack_slots += (Argument::n_int_register_parameters_c +
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2032
                  Argument::n_float_register_parameters_c) * 2;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2033
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2034
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2035
  // + 4 for return address (which we own) and saved rbp,
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2036
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2037
  stack_slots += 4;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2038
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2039
  // Ok The space we have allocated will look like:
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2040
  //
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2041
  //
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2042
  // FP-> |                     |
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2043
  //      |---------------------|
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2044
  //      | string[n]           |
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2045
  //      |---------------------| <- string_locs[n]
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2046
  //      | string[n-1]         |
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2047
  //      |---------------------| <- string_locs[n-1]
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2048
  //      | ...                 |
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2049
  //      | ...                 |
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2050
  //      |---------------------| <- string_locs[1]
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2051
  //      | string[0]           |
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2052
  //      |---------------------| <- string_locs[0]
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2053
  //      | outbound memory     |
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2054
  //      | based arguments     |
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2055
  //      |                     |
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2056
  //      |---------------------|
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2057
  //      |                     |
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2058
  // SP-> | out_preserved_slots |
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2059
  //
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2060
  //
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2061
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2062
  // Now compute actual number of stack words we need rounding to make
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2063
  // stack properly aligned.
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2064
  stack_slots = round_to(stack_slots, 4 * VMRegImpl::slots_per_word);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2065
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2066
  int stack_size = stack_slots * VMRegImpl::stack_slot_size;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2067
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2068
  intptr_t start = (intptr_t)__ pc();
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2069
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2070
  // First thing make an ic check to see if we should even be here
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2071
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2072
  // We are free to use all registers as temps without saving them and
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2073
  // restoring them except rbp. rbp, is the only callee save register
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2074
  // as far as the interpreter and the compiler(s) are concerned.
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2075
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2076
  const Register ic_reg = rax;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2077
  const Register receiver = rcx;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2078
  Label hit;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2079
  Label exception_pending;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2080
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2081
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2082
  __ verify_oop(receiver);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2083
  __ cmpl(ic_reg, Address(receiver, oopDesc::klass_offset_in_bytes()));
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2084
  __ jcc(Assembler::equal, hit);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2085
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2086
  __ jump(RuntimeAddress(SharedRuntime::get_ic_miss_stub()));
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2087
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2088
  // verified entry must be aligned for code patching.
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2089
  // and the first 5 bytes must be in the same cache line
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2090
  // if we align at 8 then we will be sure 5 bytes are in the same line
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2091
  __ align(8);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2092
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2093
  __ bind(hit);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2094
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2095
  int vep_offset = ((intptr_t)__ pc()) - start;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2096
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2097
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2098
  // The instruction at the verified entry point must be 5 bytes or longer
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2099
  // because it can be patched on the fly by make_non_entrant. The stack bang
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2100
  // instruction fits that requirement.
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2101
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2102
  // Generate stack overflow check
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2103
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2104
  if (UseStackBanging) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2105
    if (stack_size <= StackShadowPages*os::vm_page_size()) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2106
      __ bang_stack_with_offset(StackShadowPages*os::vm_page_size());
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2107
    } else {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2108
      __ movl(rax, stack_size);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2109
      __ bang_stack_size(rax, rbx);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2110
    }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2111
  } else {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2112
    // need a 5 byte instruction to allow MT safe patching to non-entrant
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2113
    __ fat_nop();
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2114
  }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2115
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2116
  assert(((uintptr_t)__ pc() - start - vep_offset) >= 5,
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2117
         "valid size for make_non_entrant");
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2118
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2119
  // Generate a new frame for the wrapper.
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2120
  __ enter();
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2121
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2122
  // -4 because return address is already present and so is saved rbp,
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2123
  if (stack_size - 2*wordSize != 0) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2124
    __ subq(rsp, stack_size - 2*wordSize);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2125
  }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2126
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2127
  // Frame is now completed as far a size and linkage.
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2128
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2129
  int frame_complete = ((intptr_t)__ pc()) - start;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2130
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2131
  int c_arg, j_arg;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2132
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2133
  // State of input register args
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2134
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2135
  bool  live[ConcreteRegisterImpl::number_of_registers];
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2136
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2137
  live[j_rarg0->as_VMReg()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2138
  live[j_rarg1->as_VMReg()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2139
  live[j_rarg2->as_VMReg()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2140
  live[j_rarg3->as_VMReg()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2141
  live[j_rarg4->as_VMReg()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2142
  live[j_rarg5->as_VMReg()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2143
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2144
  live[j_farg0->as_VMReg()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2145
  live[j_farg1->as_VMReg()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2146
  live[j_farg2->as_VMReg()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2147
  live[j_farg3->as_VMReg()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2148
  live[j_farg4->as_VMReg()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2149
  live[j_farg5->as_VMReg()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2150
  live[j_farg6->as_VMReg()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2151
  live[j_farg7->as_VMReg()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2152
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2153
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2154
  bool rax_is_zero = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2155
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2156
  // All args (except strings) destined for the stack are moved first
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2157
  for (j_arg = first_arg_to_pass, c_arg = 0 ;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2158
       j_arg < total_args_passed ; j_arg++, c_arg++ ) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2159
    VMRegPair src = in_regs[j_arg];
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2160
    VMRegPair dst = out_regs[c_arg];
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2161
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2162
    // Get the real reg value or a dummy (rsp)
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2163
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2164
    int src_reg = src.first()->is_reg() ?
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2165
                  src.first()->value() :
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2166
                  rsp->as_VMReg()->value();
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2167
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2168
    bool useless =  in_sig_bt[j_arg] == T_ARRAY ||
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2169
                    (in_sig_bt[j_arg] == T_OBJECT &&
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2170
                     out_sig_bt[c_arg] != T_INT &&
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2171
                     out_sig_bt[c_arg] != T_ADDRESS &&
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2172
                     out_sig_bt[c_arg] != T_LONG);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2173
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2174
    live[src_reg] = !useless;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2175
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2176
    if (dst.first()->is_stack()) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2177
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2178
      // Even though a string arg in a register is still live after this loop
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2179
      // after the string conversion loop (next) it will be dead so we take
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2180
      // advantage of that now for simpler code to manage live.
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2181
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2182
      live[src_reg] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2183
      switch (in_sig_bt[j_arg]) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2184
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2185
        case T_ARRAY:
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2186
        case T_OBJECT:
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2187
          {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2188
            Address stack_dst(rsp, reg2offset_out(dst.first()));
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2189
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2190
            if (out_sig_bt[c_arg] == T_INT || out_sig_bt[c_arg] == T_LONG) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2191
              // need to unbox a one-word value
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2192
              Register in_reg = rax;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2193
              if ( src.first()->is_reg() ) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2194
                in_reg = src.first()->as_Register();
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2195
              } else {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2196
                __ movq(rax, Address(rbp, reg2offset_in(src.first())));
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2197
                rax_is_zero = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2198
              }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2199
              Label skipUnbox;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2200
              __ movptr(Address(rsp, reg2offset_out(dst.first())),
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2201
                        (int32_t)NULL_WORD);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2202
              __ testq(in_reg, in_reg);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2203
              __ jcc(Assembler::zero, skipUnbox);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2204
591
04d2e26e6d69 6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents: 363
diff changeset
  2205
              BasicType bt = out_sig_bt[c_arg];
04d2e26e6d69 6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents: 363
diff changeset
  2206
              int box_offset = java_lang_boxing_object::value_offset_in_bytes(bt);
363
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2207
              Address src1(in_reg, box_offset);
591
04d2e26e6d69 6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents: 363
diff changeset
  2208
              if ( bt == T_LONG ) {
363
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2209
                __ movq(in_reg,  src1);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2210
                __ movq(stack_dst, in_reg);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2211
                assert(out_sig_bt[c_arg+1] == T_VOID, "must be");
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2212
                ++c_arg; // skip over T_VOID to keep the loop indices in sync
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2213
              } else {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2214
                __ movl(in_reg,  src1);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2215
                __ movl(stack_dst, in_reg);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2216
              }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2217
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2218
              __ bind(skipUnbox);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2219
            } else if (out_sig_bt[c_arg] != T_ADDRESS) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2220
              // Convert the arg to NULL
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2221
              if (!rax_is_zero) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2222
                __ xorq(rax, rax);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2223
                rax_is_zero = true;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2224
              }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2225
              __ movq(stack_dst, rax);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2226
            }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2227
          }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2228
          break;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2229
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2230
        case T_VOID:
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2231
          break;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2232
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2233
        case T_FLOAT:
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2234
          // This does the right thing since we know it is destined for the
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2235
          // stack
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2236
          float_move(masm, src, dst);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2237
          break;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2238
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2239
        case T_DOUBLE:
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2240
          // This does the right thing since we know it is destined for the
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2241
          // stack
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2242
          double_move(masm, src, dst);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2243
          break;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2244
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2245
        case T_LONG :
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2246
          long_move(masm, src, dst);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2247
          break;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2248
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2249
        case T_ADDRESS: assert(false, "found T_ADDRESS in java args");
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2250
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2251
        default:
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2252
          move32_64(masm, src, dst);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2253
      }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2254
    }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2255
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2256
  }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2257
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2258
  // If we have any strings we must store any register based arg to the stack
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2259
  // This includes any still live xmm registers too.
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2260
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2261
  int sid = 0;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2262
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2263
  if (total_strings > 0 ) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2264
    for (j_arg = first_arg_to_pass, c_arg = 0 ;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2265
         j_arg < total_args_passed ; j_arg++, c_arg++ ) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2266
      VMRegPair src = in_regs[j_arg];
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2267
      VMRegPair dst = out_regs[c_arg];
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2268
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2269
      if (src.first()->is_reg()) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2270
        Address src_tmp(rbp, fp_offset[src.first()->value()]);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2271
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2272
        // string oops were left untouched by the previous loop even if the
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2273
        // eventual (converted) arg is destined for the stack so park them
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2274
        // away now (except for first)
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2275
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2276
        if (out_sig_bt[c_arg] == T_ADDRESS) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2277
          Address utf8_addr = Address(
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2278
              rsp, string_locs[sid++] * VMRegImpl::stack_slot_size);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2279
          if (sid != 1) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2280
            // The first string arg won't be killed until after the utf8
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2281
            // conversion
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2282
            __ movq(utf8_addr, src.first()->as_Register());
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2283
          }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2284
        } else if (dst.first()->is_reg()) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2285
          if (in_sig_bt[j_arg] == T_FLOAT || in_sig_bt[j_arg] == T_DOUBLE) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2286
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2287
            // Convert the xmm register to an int and store it in the reserved
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2288
            // location for the eventual c register arg
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2289
            XMMRegister f = src.first()->as_XMMRegister();
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2290
            if (in_sig_bt[j_arg] == T_FLOAT) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2291
              __ movflt(src_tmp, f);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2292
            } else {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2293
              __ movdbl(src_tmp, f);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2294
            }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2295
          } else {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2296
            // If the arg is an oop type we don't support don't bother to store
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2297
            // it remember string was handled above.
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2298
            bool useless =  in_sig_bt[j_arg] == T_ARRAY ||
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2299
                            (in_sig_bt[j_arg] == T_OBJECT &&
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2300
                             out_sig_bt[c_arg] != T_INT &&
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2301
                             out_sig_bt[c_arg] != T_LONG);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2302
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2303
            if (!useless) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2304
              __ movq(src_tmp, src.first()->as_Register());
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2305
            }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2306
          }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2307
        }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2308
      }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2309
      if (in_sig_bt[j_arg] == T_OBJECT && out_sig_bt[c_arg] == T_LONG) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2310
        assert(out_sig_bt[c_arg+1] == T_VOID, "must be");
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2311
        ++c_arg; // skip over T_VOID to keep the loop indices in sync
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2312
      }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2313
    }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2314
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2315
    // Now that the volatile registers are safe, convert all the strings
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2316
    sid = 0;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2317
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2318
    for (j_arg = first_arg_to_pass, c_arg = 0 ;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2319
         j_arg < total_args_passed ; j_arg++, c_arg++ ) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2320
      if (out_sig_bt[c_arg] == T_ADDRESS) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2321
        // It's a string
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2322
        Address utf8_addr = Address(
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2323
            rsp, string_locs[sid++] * VMRegImpl::stack_slot_size);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2324
        // The first string we find might still be in the original java arg
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2325
        // register
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2326
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2327
        VMReg src = in_regs[j_arg].first();
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2328
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2329
        // We will need to eventually save the final argument to the trap
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2330
        // in the von-volatile location dedicated to src. This is the offset
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2331
        // from fp we will use.
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2332
        int src_off = src->is_reg() ?
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2333
            fp_offset[src->value()] : reg2offset_in(src);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2334
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2335
        // This is where the argument will eventually reside
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2336
        VMRegPair dst = out_regs[c_arg];
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2337
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2338
        if (src->is_reg()) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2339
          if (sid == 1) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2340
            __ movq(c_rarg0, src->as_Register());
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2341
          } else {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2342
            __ movq(c_rarg0, utf8_addr);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2343
          }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2344
        } else {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2345
          // arg is still in the original location
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2346
          __ movq(c_rarg0, Address(rbp, reg2offset_in(src)));
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2347
        }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2348
        Label done, convert;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2349
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2350
        // see if the oop is NULL
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2351
        __ testq(c_rarg0, c_rarg0);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2352
        __ jcc(Assembler::notEqual, convert);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2353
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2354
        if (dst.first()->is_reg()) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2355
          // Save the ptr to utf string in the origina src loc or the tmp
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2356
          // dedicated to it
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2357
          __ movq(Address(rbp, src_off), c_rarg0);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2358
        } else {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2359
          __ movq(Address(rsp, reg2offset_out(dst.first())), c_rarg0);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2360
        }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2361
        __ jmp(done);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2362
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2363
        __ bind(convert);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2364
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2365
        __ lea(c_rarg1, utf8_addr);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2366
        if (dst.first()->is_reg()) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2367
          __ movq(Address(rbp, src_off), c_rarg1);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2368
        } else {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2369
          __ movq(Address(rsp, reg2offset_out(dst.first())), c_rarg1);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2370
        }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2371
        // And do the conversion
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2372
        __ call(RuntimeAddress(
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2373
                CAST_FROM_FN_PTR(address, SharedRuntime::get_utf)));
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2374
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2375
        __ bind(done);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2376
      }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2377
      if (in_sig_bt[j_arg] == T_OBJECT && out_sig_bt[c_arg] == T_LONG) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2378
        assert(out_sig_bt[c_arg+1] == T_VOID, "must be");
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2379
        ++c_arg; // skip over T_VOID to keep the loop indices in sync
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2380
      }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2381
    }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2382
    // The get_utf call killed all the c_arg registers
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2383
    live[c_rarg0->as_VMReg()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2384
    live[c_rarg1->as_VMReg()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2385
    live[c_rarg2->as_VMReg()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2386
    live[c_rarg3->as_VMReg()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2387
    live[c_rarg4->as_VMReg()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2388
    live[c_rarg5->as_VMReg()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2389
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2390
    live[c_farg0->as_VMReg()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2391
    live[c_farg1->as_VMReg()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2392
    live[c_farg2->as_VMReg()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2393
    live[c_farg3->as_VMReg()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2394
    live[c_farg4->as_VMReg()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2395
    live[c_farg5->as_VMReg()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2396
    live[c_farg6->as_VMReg()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2397
    live[c_farg7->as_VMReg()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2398
  }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2399
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2400
  // Now we can finally move the register args to their desired locations
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2401
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2402
  rax_is_zero = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2403
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2404
  for (j_arg = first_arg_to_pass, c_arg = 0 ;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2405
       j_arg < total_args_passed ; j_arg++, c_arg++ ) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2406
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2407
    VMRegPair src = in_regs[j_arg];
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2408
    VMRegPair dst = out_regs[c_arg];
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2409
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2410
    // Only need to look for args destined for the interger registers (since we
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2411
    // convert float/double args to look like int/long outbound)
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2412
    if (dst.first()->is_reg()) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2413
      Register r =  dst.first()->as_Register();
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2414
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2415
      // Check if the java arg is unsupported and thereofre useless
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2416
      bool useless =  in_sig_bt[j_arg] == T_ARRAY ||
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2417
                      (in_sig_bt[j_arg] == T_OBJECT &&
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2418
                       out_sig_bt[c_arg] != T_INT &&
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2419
                       out_sig_bt[c_arg] != T_ADDRESS &&
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2420
                       out_sig_bt[c_arg] != T_LONG);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2421
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2422
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2423
      // If we're going to kill an existing arg save it first
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2424
      if (live[dst.first()->value()]) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2425
        // you can't kill yourself
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2426
        if (src.first() != dst.first()) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2427
          __ movq(Address(rbp, fp_offset[dst.first()->value()]), r);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2428
        }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2429
      }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2430
      if (src.first()->is_reg()) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2431
        if (live[src.first()->value()] ) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2432
          if (in_sig_bt[j_arg] == T_FLOAT) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2433
            __ movdl(r, src.first()->as_XMMRegister());
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2434
          } else if (in_sig_bt[j_arg] == T_DOUBLE) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2435
            __ movdq(r, src.first()->as_XMMRegister());
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2436
          } else if (r != src.first()->as_Register()) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2437
            if (!useless) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2438
              __ movq(r, src.first()->as_Register());
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2439
            }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2440
          }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2441
        } else {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2442
          // If the arg is an oop type we don't support don't bother to store
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2443
          // it
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2444
          if (!useless) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2445
            if (in_sig_bt[j_arg] == T_DOUBLE ||
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2446
                in_sig_bt[j_arg] == T_LONG  ||
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2447
                in_sig_bt[j_arg] == T_OBJECT ) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2448
              __ movq(r, Address(rbp, fp_offset[src.first()->value()]));
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2449
            } else {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2450
              __ movl(r, Address(rbp, fp_offset[src.first()->value()]));
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2451
            }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2452
          }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2453
        }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2454
        live[src.first()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2455
      } else if (!useless) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2456
        // full sized move even for int should be ok
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2457
        __ movq(r, Address(rbp, reg2offset_in(src.first())));
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2458
      }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2459
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2460
      // At this point r has the original java arg in the final location
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2461
      // (assuming it wasn't useless). If the java arg was an oop
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2462
      // we have a bit more to do
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2463
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2464
      if (in_sig_bt[j_arg] == T_ARRAY || in_sig_bt[j_arg] == T_OBJECT ) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2465
        if (out_sig_bt[c_arg] == T_INT || out_sig_bt[c_arg] == T_LONG) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2466
          // need to unbox a one-word value
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2467
          Label skip;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2468
          __ testq(r, r);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2469
          __ jcc(Assembler::equal, skip);
591
04d2e26e6d69 6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents: 363
diff changeset
  2470
          BasicType bt = out_sig_bt[c_arg];
04d2e26e6d69 6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents: 363
diff changeset
  2471
          int box_offset = java_lang_boxing_object::value_offset_in_bytes(bt);
363
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2472
          Address src1(r, box_offset);
591
04d2e26e6d69 6703888: Compressed Oops: use the 32-bits gap after klass in a object
kvn
parents: 363
diff changeset
  2473
          if ( bt == T_LONG ) {
363
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2474
            __ movq(r, src1);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2475
          } else {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2476
            __ movl(r, src1);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2477
          }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2478
          __ bind(skip);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2479
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2480
        } else if (out_sig_bt[c_arg] != T_ADDRESS) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2481
          // Convert the arg to NULL
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2482
          __ xorq(r, r);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2483
        }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2484
      }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2485
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2486
      // dst can longer be holding an input value
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2487
      live[dst.first()->value()] = false;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2488
    }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2489
    if (in_sig_bt[j_arg] == T_OBJECT && out_sig_bt[c_arg] == T_LONG) {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2490
      assert(out_sig_bt[c_arg+1] == T_VOID, "must be");
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2491
      ++c_arg; // skip over T_VOID to keep the loop indices in sync
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2492
    }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2493
  }
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2494
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2495
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2496
  // Ok now we are done. Need to place the nop that dtrace wants in order to
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2497
  // patch in the trap
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2498
  int patch_offset = ((intptr_t)__ pc()) - start;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2499
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2500
  __ nop();
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2501
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2502
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2503
  // Return
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2504
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2505
  __ leave();
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2506
  __ ret(0);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2507
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2508
  __ flush();
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2509
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2510
  nmethod *nm = nmethod::new_dtrace_nmethod(
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2511
      method, masm->code(), vep_offset, patch_offset, frame_complete,
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2512
      stack_slots / VMRegImpl::slots_per_word);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2513
  return nm;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2514
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2515
}
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2516
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2517
#endif // HAVE_DTRACE_H
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 360
diff changeset
  2518
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2519
// this function returns the adjust size (in number of words) to a c2i adapter
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2520
// activation for use during deoptimization
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2521
int Deoptimization::last_frame_adjust(int callee_parameters, int callee_locals ) {
5419
f2e8cc8c12ea 6943304: remove tagged stack interpreter
twisti
parents: 5252
diff changeset
  2522
  return (callee_locals - callee_parameters) * Interpreter::stackElementWords;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2523
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2524
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2525
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2526
uint SharedRuntime::out_preserve_stack_slots() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2527
  return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2528
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2529
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2530
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2531
//------------------------------generate_deopt_blob----------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2532
void SharedRuntime::generate_deopt_blob() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2533
  // Allocate space for the code
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2534
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2535
  // Setup code generation tools
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2536
  CodeBuffer buffer("deopt_blob", 2048, 1024);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2537
  MacroAssembler* masm = new MacroAssembler(&buffer);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2538
  int frame_size_in_words;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2539
  OopMap* map = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2540
  OopMapSet *oop_maps = new OopMapSet();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2541
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2542
  // -------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2543
  // This code enters when returning to a de-optimized nmethod.  A return
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2544
  // address has been pushed on the the stack, and return values are in
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2545
  // registers.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2546
  // If we are doing a normal deopt then we were called from the patched
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2547
  // nmethod from the point we returned to the nmethod. So the return
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2548
  // address on the stack is wrong by NativeCall::instruction_size
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2549
  // We will adjust the value so it looks like we have the original return
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2550
  // address on the stack (like when we eagerly deoptimized).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2551
  // In the case of an exception pending when deoptimizing, we enter
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2552
  // with a return address on the stack that points after the call we patched
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2553
  // into the exception handler. We have the following register state from,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2554
  // e.g., the forward exception stub (see stubGenerator_x86_64.cpp).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2555
  //    rax: exception oop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2556
  //    rbx: exception handler
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2557
  //    rdx: throwing pc
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2558
  // So in this case we simply jam rdx into the useless return address and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2559
  // the stack looks just like we want.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2560
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2561
  // At this point we need to de-opt.  We save the argument return
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2562
  // registers.  We call the first C routine, fetch_unroll_info().  This
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2563
  // routine captures the return values and returns a structure which
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2564
  // describes the current frame size and the sizes of all replacement frames.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2565
  // The current frame is compiled code and may contain many inlined
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2566
  // functions, each with their own JVM state.  We pop the current frame, then
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2567
  // push all the new frames.  Then we call the C routine unpack_frames() to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2568
  // populate these frames.  Finally unpack_frames() returns us the new target
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2569
  // address.  Notice that callee-save registers are BLOWN here; they have
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2570
  // already been captured in the vframeArray at the time the return PC was
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2571
  // patched.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2572
  address start = __ pc();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2573
  Label cont;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2574
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2575
  // Prolog for non exception case!
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2576
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2577
  // Save everything in sight.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2578
  map = RegisterSaver::save_live_registers(masm, 0, &frame_size_in_words);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2579
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2580
  // Normal deoptimization.  Save exec mode for unpack_frames.
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  2581
  __ movl(r14, Deoptimization::Unpack_deopt); // callee-saved
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2582
  __ jmp(cont);
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2583
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2584
  int reexecute_offset = __ pc() - start;
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2585
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2586
  // Reexecute case
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2587
  // return address is the pc describes what bci to do re-execute at
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2588
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2589
  // No need to update map as each call to save_live_registers will produce identical oopmap
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2590
  (void) RegisterSaver::save_live_registers(masm, 0, &frame_size_in_words);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2591
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2592
  __ movl(r14, Deoptimization::Unpack_reexecute); // callee-saved
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2593
  __ jmp(cont);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2594
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2595
  int exception_offset = __ pc() - start;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2596
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2597
  // Prolog for exception case
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2598
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2599
  // all registers are dead at this entry point, except for rax, and
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2600
  // rdx which contain the exception oop and exception pc
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2601
  // respectively.  Set them in TLS and fall thru to the
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2602
  // unpack_with_exception_in_tls entry point.
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2603
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2604
  __ movptr(Address(r15_thread, JavaThread::exception_pc_offset()), rdx);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2605
  __ movptr(Address(r15_thread, JavaThread::exception_oop_offset()), rax);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2606
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2607
  int exception_in_tls_offset = __ pc() - start;
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2608
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2609
  // new implementation because exception oop is now passed in JavaThread
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2610
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2611
  // Prolog for exception case
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2612
  // All registers must be preserved because they might be used by LinearScan
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2613
  // Exceptiop oop and throwing PC are passed in JavaThread
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2614
  // tos: stack at point of call to method that threw the exception (i.e. only
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2615
  // args are on the stack, no return address)
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2616
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2617
  // make room on stack for the return address
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2618
  // It will be patched later with the throwing pc. The correct value is not
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2619
  // available now because loading it from memory would destroy registers.
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2620
  __ push(0);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2621
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2622
  // Save everything in sight.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2623
  map = RegisterSaver::save_live_registers(masm, 0, &frame_size_in_words);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2624
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2625
  // Now it is safe to overwrite any register
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2626
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2627
  // Deopt during an exception.  Save exec mode for unpack_frames.
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  2628
  __ movl(r14, Deoptimization::Unpack_exception); // callee-saved
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2629
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2630
  // load throwing pc from JavaThread and patch it as the return address
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2631
  // of the current frame. Then clear the field in JavaThread
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2632
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2633
  __ movptr(rdx, Address(r15_thread, JavaThread::exception_pc_offset()));
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2634
  __ movptr(Address(rbp, wordSize), rdx);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2635
  __ movptr(Address(r15_thread, JavaThread::exception_pc_offset()), (int32_t)NULL_WORD);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2636
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2637
#ifdef ASSERT
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2638
  // verify that there is really an exception oop in JavaThread
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2639
  __ movptr(rax, Address(r15_thread, JavaThread::exception_oop_offset()));
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2640
  __ verify_oop(rax);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2641
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2642
  // verify that there is no pending exception
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2643
  Label no_pending_exception;
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2644
  __ movptr(rax, Address(r15_thread, Thread::pending_exception_offset()));
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2645
  __ testptr(rax, rax);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2646
  __ jcc(Assembler::zero, no_pending_exception);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2647
  __ stop("must not have pending exception here");
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2648
  __ bind(no_pending_exception);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2649
#endif
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2650
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2651
  __ bind(cont);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2652
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2653
  // Call C code.  Need thread and this frame, but NOT official VM entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2654
  // crud.  We cannot block on this call, no GC can happen.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2655
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2656
  // UnrollBlock* fetch_unroll_info(JavaThread* thread)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2657
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2658
  // fetch_unroll_info needs to call last_java_frame().
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2659
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2660
  __ set_last_Java_frame(noreg, noreg, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2661
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2662
  { Label L;
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2663
    __ cmpptr(Address(r15_thread,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2664
                    JavaThread::last_Java_fp_offset()),
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2665
            (int32_t)0);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2666
    __ jcc(Assembler::equal, L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2667
    __ stop("SharedRuntime::generate_deopt_blob: last_Java_fp not cleared");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2668
    __ bind(L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2669
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2670
#endif // ASSERT
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2671
  __ mov(c_rarg0, r15_thread);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2672
  __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, Deoptimization::fetch_unroll_info)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2673
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2674
  // Need to have an oopmap that tells fetch_unroll_info where to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2675
  // find any register it might need.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2676
  oop_maps->add_gc_map(__ pc() - start, map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2677
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2678
  __ reset_last_Java_frame(false, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2679
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2680
  // Load UnrollBlock* into rdi
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2681
  __ mov(rdi, rax);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2682
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2683
   Label noException;
2349
d438a6c62f88 6824463: deopt blob is testing wrong register on 64-bit x86
never
parents: 2154
diff changeset
  2684
  __ cmpl(r14, Deoptimization::Unpack_exception);   // Was exception pending?
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2685
  __ jcc(Assembler::notEqual, noException);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2686
  __ movptr(rax, Address(r15_thread, JavaThread::exception_oop_offset()));
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2687
  // QQQ this is useless it was NULL above
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2688
  __ movptr(rdx, Address(r15_thread, JavaThread::exception_pc_offset()));
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2689
  __ movptr(Address(r15_thread, JavaThread::exception_oop_offset()), (int32_t)NULL_WORD);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2690
  __ movptr(Address(r15_thread, JavaThread::exception_pc_offset()), (int32_t)NULL_WORD);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2691
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2692
  __ verify_oop(rax);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2693
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2694
  // Overwrite the result registers with the exception results.
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2695
  __ movptr(Address(rsp, RegisterSaver::rax_offset_in_bytes()), rax);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2696
  // I think this is useless
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2697
  __ movptr(Address(rsp, RegisterSaver::rdx_offset_in_bytes()), rdx);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2698
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2699
  __ bind(noException);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2700
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2701
  // Only register save data is on the stack.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2702
  // Now restore the result registers.  Everything else is either dead
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2703
  // or captured in the vframeArray.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2704
  RegisterSaver::restore_result_registers(masm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2705
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2706
  // All of the register save area has been popped of the stack. Only the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2707
  // return address remains.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2708
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2709
  // Pop all the frames we must move/replace.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2710
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2711
  // Frame picture (youngest to oldest)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2712
  // 1: self-frame (no frame link)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2713
  // 2: deopting frame  (no frame link)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2714
  // 3: caller of deopting frame (could be compiled/interpreted).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2715
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2716
  // Note: by leaving the return address of self-frame on the stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2717
  // and using the size of frame 2 to adjust the stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2718
  // when we are done the return to frame 3 will still be on the stack.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2719
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2720
  // Pop deoptimized frame
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2721
  __ movl(rcx, Address(rdi, Deoptimization::UnrollBlock::size_of_deoptimized_frame_offset_in_bytes()));
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2722
  __ addptr(rsp, rcx);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2723
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2724
  // rsp should be pointing at the return address to the caller (3)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2725
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2726
  // Stack bang to make sure there's enough room for these interpreter frames.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2727
  if (UseStackBanging) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2728
    __ movl(rbx, Address(rdi, Deoptimization::UnrollBlock::total_frame_sizes_offset_in_bytes()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2729
    __ bang_stack_size(rbx, rcx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2730
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2731
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2732
  // Load address of array of frame pcs into rcx
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2733
  __ movptr(rcx, Address(rdi, Deoptimization::UnrollBlock::frame_pcs_offset_in_bytes()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2734
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2735
  // Trash the old pc
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2736
  __ addptr(rsp, wordSize);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2737
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2738
  // Load address of array of frame sizes into rsi
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2739
  __ movptr(rsi, Address(rdi, Deoptimization::UnrollBlock::frame_sizes_offset_in_bytes()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2740
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2741
  // Load counter into rdx
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2742
  __ movl(rdx, Address(rdi, Deoptimization::UnrollBlock::number_of_frames_offset_in_bytes()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2743
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2744
  // Pick up the initial fp we should save
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2745
  __ movptr(rbp, Address(rdi, Deoptimization::UnrollBlock::initial_fp_offset_in_bytes()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2746
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2747
  // Now adjust the caller's stack to make up for the extra locals
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2748
  // but record the original sp so that we can save it in the skeletal interpreter
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2749
  // frame and the stack walking of interpreter_sender will get the unextended sp
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2750
  // value and not the "real" sp value.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2751
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2752
  const Register sender_sp = r8;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2753
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2754
  __ mov(sender_sp, rsp);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2755
  __ movl(rbx, Address(rdi,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2756
                       Deoptimization::UnrollBlock::
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2757
                       caller_adjustment_offset_in_bytes()));
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2758
  __ subptr(rsp, rbx);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2759
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2760
  // Push interpreter frames in a loop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2761
  Label loop;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2762
  __ bind(loop);
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2763
  __ movptr(rbx, Address(rsi, 0));      // Load frame size
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2764
#ifdef CC_INTERP
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2765
  __ subptr(rbx, 4*wordSize);           // we'll push pc and ebp by hand and
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2766
#ifdef ASSERT
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2767
  __ push(0xDEADDEAD);                  // Make a recognizable pattern
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2768
  __ push(0xDEADDEAD);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2769
#else /* ASSERT */
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2770
  __ subptr(rsp, 2*wordSize);           // skip the "static long no_param"
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2771
#endif /* ASSERT */
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2772
#else
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2773
  __ subptr(rbx, 2*wordSize);           // We'll push pc and ebp by hand
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2774
#endif // CC_INTERP
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2775
  __ pushptr(Address(rcx, 0));          // Save return address
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2776
  __ enter();                           // Save old & set new ebp
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2777
  __ subptr(rsp, rbx);                  // Prolog
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2778
#ifdef CC_INTERP
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2779
  __ movptr(Address(rbp,
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2780
                  -(sizeof(BytecodeInterpreter)) + in_bytes(byte_offset_of(BytecodeInterpreter, _sender_sp))),
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2781
            sender_sp); // Make it walkable
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2782
#else /* CC_INTERP */
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2783
  // This value is corrected by layout_activation_impl
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2784
  __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD );
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2785
  __ movptr(Address(rbp, frame::interpreter_frame_sender_sp_offset * wordSize), sender_sp); // Make it walkable
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2786
#endif /* CC_INTERP */
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2787
  __ mov(sender_sp, rsp);               // Pass sender_sp to next frame
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2788
  __ addptr(rsi, wordSize);             // Bump array pointer (sizes)
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2789
  __ addptr(rcx, wordSize);             // Bump array pointer (pcs)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2790
  __ decrementl(rdx);                   // Decrement counter
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2791
  __ jcc(Assembler::notZero, loop);
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2792
  __ pushptr(Address(rcx, 0));          // Save final return address
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2793
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2794
  // Re-push self-frame
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2795
  __ enter();                           // Save old & set new ebp
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2796
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2797
  // Allocate a full sized register save area.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2798
  // Return address and rbp are in place, so we allocate two less words.
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2799
  __ subptr(rsp, (frame_size_in_words - 2) * wordSize);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2800
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2801
  // Restore frame locals after moving the frame
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2802
  __ movdbl(Address(rsp, RegisterSaver::xmm0_offset_in_bytes()), xmm0);
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2803
  __ movptr(Address(rsp, RegisterSaver::rax_offset_in_bytes()), rax);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2804
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2805
  // Call C code.  Need thread but NOT official VM entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2806
  // crud.  We cannot block on this call, no GC can happen.  Call should
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2807
  // restore return values to their stack-slots with the new SP.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2808
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2809
  // void Deoptimization::unpack_frames(JavaThread* thread, int exec_mode)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2810
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2811
  // Use rbp because the frames look interpreted now
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2812
  __ set_last_Java_frame(noreg, rbp, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2813
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2814
  __ mov(c_rarg0, r15_thread);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  2815
  __ movl(c_rarg1, r14); // second arg: exec_mode
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2816
  __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, Deoptimization::unpack_frames)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2817
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2818
  // Set an oopmap for the call site
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2819
  oop_maps->add_gc_map(__ pc() - start,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2820
                       new OopMap( frame_size_in_words, 0 ));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2821
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2822
  __ reset_last_Java_frame(true, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2823
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2824
  // Collect return values
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2825
  __ movdbl(xmm0, Address(rsp, RegisterSaver::xmm0_offset_in_bytes()));
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2826
  __ movptr(rax, Address(rsp, RegisterSaver::rax_offset_in_bytes()));
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2827
  // I think this is useless (throwing pc?)
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2828
  __ movptr(rdx, Address(rsp, RegisterSaver::rdx_offset_in_bytes()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2829
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2830
  // Pop self-frame.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2831
  __ leave();                           // Epilog
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2832
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2833
  // Jump to interpreter
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2834
  __ ret(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2835
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2836
  // Make sure all code is generated
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2837
  masm->flush();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2838
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2839
  _deopt_blob = DeoptimizationBlob::create(&buffer, oop_maps, 0, exception_offset, reexecute_offset, frame_size_in_words);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2840
  _deopt_blob->set_unpack_with_exception_in_tls_offset(exception_in_tls_offset);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2841
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2842
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2843
#ifdef COMPILER2
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2844
//------------------------------generate_uncommon_trap_blob--------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2845
void SharedRuntime::generate_uncommon_trap_blob() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2846
  // Allocate space for the code
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2847
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2848
  // Setup code generation tools
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2849
  CodeBuffer buffer("uncommon_trap_blob", 2048, 1024);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2850
  MacroAssembler* masm = new MacroAssembler(&buffer);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2851
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2852
  assert(SimpleRuntimeFrame::framesize % 4 == 0, "sp not 16-byte aligned");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2853
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2854
  address start = __ pc();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2855
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2856
  // Push self-frame.  We get here with a return address on the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2857
  // stack, so rsp is 8-byte aligned until we allocate our frame.
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2858
  __ subptr(rsp, SimpleRuntimeFrame::return_off << LogBytesPerInt); // Epilog!
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2859
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2860
  // No callee saved registers. rbp is assumed implicitly saved
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2861
  __ movptr(Address(rsp, SimpleRuntimeFrame::rbp_off << LogBytesPerInt), rbp);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2862
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2863
  // compiler left unloaded_class_index in j_rarg0 move to where the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2864
  // runtime expects it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2865
  __ movl(c_rarg1, j_rarg0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2866
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2867
  __ set_last_Java_frame(noreg, noreg, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2868
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2869
  // Call C code.  Need thread but NOT official VM entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2870
  // crud.  We cannot block on this call, no GC can happen.  Call should
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2871
  // capture callee-saved registers as well as return values.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2872
  // Thread is in rdi already.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2873
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2874
  // UnrollBlock* uncommon_trap(JavaThread* thread, jint unloaded_class_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2875
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2876
  __ mov(c_rarg0, r15_thread);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2877
  __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, Deoptimization::uncommon_trap)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2878
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2879
  // Set an oopmap for the call site
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2880
  OopMapSet* oop_maps = new OopMapSet();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2881
  OopMap* map = new OopMap(SimpleRuntimeFrame::framesize, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2882
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2883
  // location of rbp is known implicitly by the frame sender code
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2884
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2885
  oop_maps->add_gc_map(__ pc() - start, map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2886
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2887
  __ reset_last_Java_frame(false, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2888
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2889
  // Load UnrollBlock* into rdi
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2890
  __ mov(rdi, rax);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2891
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2892
  // Pop all the frames we must move/replace.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2893
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2894
  // Frame picture (youngest to oldest)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2895
  // 1: self-frame (no frame link)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2896
  // 2: deopting frame  (no frame link)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2897
  // 3: caller of deopting frame (could be compiled/interpreted).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2898
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2899
  // Pop self-frame.  We have no frame, and must rely only on rax and rsp.
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2900
  __ addptr(rsp, (SimpleRuntimeFrame::framesize - 2) << LogBytesPerInt); // Epilog!
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2901
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2902
  // Pop deoptimized frame (int)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2903
  __ movl(rcx, Address(rdi,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2904
                       Deoptimization::UnrollBlock::
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2905
                       size_of_deoptimized_frame_offset_in_bytes()));
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2906
  __ addptr(rsp, rcx);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2907
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2908
  // rsp should be pointing at the return address to the caller (3)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2909
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2910
  // Stack bang to make sure there's enough room for these interpreter frames.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2911
  if (UseStackBanging) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2912
    __ movl(rbx, Address(rdi ,Deoptimization::UnrollBlock::total_frame_sizes_offset_in_bytes()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2913
    __ bang_stack_size(rbx, rcx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2914
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2915
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2916
  // Load address of array of frame pcs into rcx (address*)
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2917
  __ movptr(rcx,
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2918
            Address(rdi,
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2919
                    Deoptimization::UnrollBlock::frame_pcs_offset_in_bytes()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2920
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2921
  // Trash the return pc
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2922
  __ addptr(rsp, wordSize);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2923
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2924
  // Load address of array of frame sizes into rsi (intptr_t*)
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2925
  __ movptr(rsi, Address(rdi,
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2926
                         Deoptimization::UnrollBlock::
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2927
                         frame_sizes_offset_in_bytes()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2928
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2929
  // Counter
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2930
  __ movl(rdx, Address(rdi,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2931
                       Deoptimization::UnrollBlock::
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2932
                       number_of_frames_offset_in_bytes())); // (int)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2933
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2934
  // Pick up the initial fp we should save
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2935
  __ movptr(rbp,
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2936
            Address(rdi,
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2937
                    Deoptimization::UnrollBlock::initial_fp_offset_in_bytes()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2938
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2939
  // Now adjust the caller's stack to make up for the extra locals but
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2940
  // record the original sp so that we can save it in the skeletal
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2941
  // interpreter frame and the stack walking of interpreter_sender
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2942
  // will get the unextended sp value and not the "real" sp value.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2943
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2944
  const Register sender_sp = r8;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2945
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2946
  __ mov(sender_sp, rsp);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2947
  __ movl(rbx, Address(rdi,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2948
                       Deoptimization::UnrollBlock::
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2949
                       caller_adjustment_offset_in_bytes())); // (int)
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2950
  __ subptr(rsp, rbx);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2951
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2952
  // Push interpreter frames in a loop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2953
  Label loop;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2954
  __ bind(loop);
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2955
  __ movptr(rbx, Address(rsi, 0)); // Load frame size
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2956
  __ subptr(rbx, 2 * wordSize);    // We'll push pc and rbp by hand
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2957
  __ pushptr(Address(rcx, 0));     // Save return address
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2958
  __ enter();                      // Save old & set new rbp
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2959
  __ subptr(rsp, rbx);             // Prolog
1896
cce23a9ff495 6791168: Fix invalid code in bytecodeInterpreter that can cause gcc ICE
coleenp
parents: 1066
diff changeset
  2960
#ifdef CC_INTERP
cce23a9ff495 6791168: Fix invalid code in bytecodeInterpreter that can cause gcc ICE
coleenp
parents: 1066
diff changeset
  2961
  __ movptr(Address(rbp,
cce23a9ff495 6791168: Fix invalid code in bytecodeInterpreter that can cause gcc ICE
coleenp
parents: 1066
diff changeset
  2962
                  -(sizeof(BytecodeInterpreter)) + in_bytes(byte_offset_of(BytecodeInterpreter, _sender_sp))),
cce23a9ff495 6791168: Fix invalid code in bytecodeInterpreter that can cause gcc ICE
coleenp
parents: 1066
diff changeset
  2963
            sender_sp); // Make it walkable
cce23a9ff495 6791168: Fix invalid code in bytecodeInterpreter that can cause gcc ICE
coleenp
parents: 1066
diff changeset
  2964
#else // CC_INTERP
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2965
  __ movptr(Address(rbp, frame::interpreter_frame_sender_sp_offset * wordSize),
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2966
            sender_sp);            // Make it walkable
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2967
  // This value is corrected by layout_activation_impl
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2968
  __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD );
1896
cce23a9ff495 6791168: Fix invalid code in bytecodeInterpreter that can cause gcc ICE
coleenp
parents: 1066
diff changeset
  2969
#endif // CC_INTERP
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2970
  __ mov(sender_sp, rsp);          // Pass sender_sp to next frame
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2971
  __ addptr(rsi, wordSize);        // Bump array pointer (sizes)
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2972
  __ addptr(rcx, wordSize);        // Bump array pointer (pcs)
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2973
  __ decrementl(rdx);              // Decrement counter
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2974
  __ jcc(Assembler::notZero, loop);
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2975
  __ pushptr(Address(rcx, 0));     // Save final return address
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2976
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2977
  // Re-push self-frame
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2978
  __ enter();                 // Save old & set new rbp
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2979
  __ subptr(rsp, (SimpleRuntimeFrame::framesize - 4) << LogBytesPerInt);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2980
                              // Prolog
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2981
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2982
  // Use rbp because the frames look interpreted now
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2983
  __ set_last_Java_frame(noreg, rbp, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2984
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2985
  // Call C code.  Need thread but NOT official VM entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2986
  // crud.  We cannot block on this call, no GC can happen.  Call should
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2987
  // restore return values to their stack-slots with the new SP.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2988
  // Thread is in rdi already.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2989
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2990
  // BasicType unpack_frames(JavaThread* thread, int exec_mode);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2991
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  2992
  __ mov(c_rarg0, r15_thread);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2993
  __ movl(c_rarg1, Deoptimization::Unpack_uncommon_trap);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2994
  __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, Deoptimization::unpack_frames)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2995
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2996
  // Set an oopmap for the call site
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2997
  oop_maps->add_gc_map(__ pc() - start, new OopMap(SimpleRuntimeFrame::framesize, 0));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2998
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2999
  __ reset_last_Java_frame(true, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3000
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3001
  // Pop self-frame.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3002
  __ leave();                 // Epilog
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3003
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3004
  // Jump to interpreter
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3005
  __ ret(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3006
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3007
  // Make sure all code is generated
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3008
  masm->flush();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3009
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3010
  _uncommon_trap_blob =  UncommonTrapBlob::create(&buffer, oop_maps,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3011
                                                 SimpleRuntimeFrame::framesize >> 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3012
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3013
#endif // COMPILER2
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3014
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3015
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3016
//------------------------------generate_handler_blob------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3017
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3018
// Generate a special Compile2Runtime blob that saves all registers,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3019
// and setup oopmap.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3020
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3021
static SafepointBlob* generate_handler_blob(address call_ptr, bool cause_return) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3022
  assert(StubRoutines::forward_exception_entry() != NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3023
         "must be generated before");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3024
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3025
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3026
  OopMapSet *oop_maps = new OopMapSet();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3027
  OopMap* map;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3028
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3029
  // Allocate space for the code.  Setup code generation tools.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3030
  CodeBuffer buffer("handler_blob", 2048, 1024);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3031
  MacroAssembler* masm = new MacroAssembler(&buffer);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3032
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3033
  address start   = __ pc();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3034
  address call_pc = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3035
  int frame_size_in_words;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3036
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3037
  // Make room for return address (or push it again)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3038
  if (!cause_return) {
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  3039
    __ push(rbx);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3040
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3041
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3042
  // Save registers, fpu state, and flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3043
  map = RegisterSaver::save_live_registers(masm, 0, &frame_size_in_words);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3044
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3045
  // The following is basically a call_VM.  However, we need the precise
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3046
  // address of the call in order to generate an oopmap. Hence, we do all the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3047
  // work outselves.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3048
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3049
  __ set_last_Java_frame(noreg, noreg, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3050
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3051
  // The return address must always be correct so that frame constructor never
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3052
  // sees an invalid pc.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3053
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3054
  if (!cause_return) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3055
    // overwrite the dummy value we pushed on entry
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  3056
    __ movptr(c_rarg0, Address(r15_thread, JavaThread::saved_exception_pc_offset()));
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  3057
    __ movptr(Address(rbp, wordSize), c_rarg0);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3058
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3059
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3060
  // Do the call
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  3061
  __ mov(c_rarg0, r15_thread);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3062
  __ call(RuntimeAddress(call_ptr));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3063
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3064
  // Set an oopmap for the call site.  This oopmap will map all
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3065
  // oop-registers and debug-info registers as callee-saved.  This
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3066
  // will allow deoptimization at this safepoint to find all possible
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3067
  // debug-info recordings, as well as let GC find all oops.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3068
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3069
  oop_maps->add_gc_map( __ pc() - start, map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3070
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3071
  Label noException;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3072
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3073
  __ reset_last_Java_frame(false, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3074
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  3075
  __ cmpptr(Address(r15_thread, Thread::pending_exception_offset()), (int32_t)NULL_WORD);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3076
  __ jcc(Assembler::equal, noException);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3077
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3078
  // Exception pending
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3079
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3080
  RegisterSaver::restore_live_registers(masm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3081
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3082
  __ jump(RuntimeAddress(StubRoutines::forward_exception_entry()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3083
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3084
  // No exception case
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3085
  __ bind(noException);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3086
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3087
  // Normal exit, restore registers and exit.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3088
  RegisterSaver::restore_live_registers(masm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3089
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3090
  __ ret(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3091
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3092
  // Make sure all code is generated
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3093
  masm->flush();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3094
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3095
  // Fill-out other meta info
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3096
  return SafepointBlob::create(&buffer, oop_maps, frame_size_in_words);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3097
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3098
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3099
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3100
// generate_resolve_blob - call resolution (static/virtual/opt-virtual/ic-miss
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3101
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3102
// Generate a stub that calls into vm to find out the proper destination
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3103
// of a java call. All the argument registers are live at this point
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3104
// but since this is generic code we don't know what they are and the caller
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3105
// must do any gc of the args.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3106
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3107
static RuntimeStub* generate_resolve_blob(address destination, const char* name) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3108
  assert (StubRoutines::forward_exception_entry() != NULL, "must be generated before");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3109
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3110
  // allocate space for the code
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3111
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3112
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3113
  CodeBuffer buffer(name, 1000, 512);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3114
  MacroAssembler* masm                = new MacroAssembler(&buffer);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3115
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3116
  int frame_size_in_words;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3117
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3118
  OopMapSet *oop_maps = new OopMapSet();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3119
  OopMap* map = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3120
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3121
  int start = __ offset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3122
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3123
  map = RegisterSaver::save_live_registers(masm, 0, &frame_size_in_words);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3124
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3125
  int frame_complete = __ offset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3126
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3127
  __ set_last_Java_frame(noreg, noreg, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3128
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  3129
  __ mov(c_rarg0, r15_thread);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3130
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3131
  __ call(RuntimeAddress(destination));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3132
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3133
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3134
  // Set an oopmap for the call site.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3135
  // We need this not only for callee-saved registers, but also for volatile
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3136
  // registers that the compiler might be keeping live across a safepoint.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3137
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3138
  oop_maps->add_gc_map( __ offset() - start, map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3139
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3140
  // rax contains the address we are going to jump to assuming no exception got installed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3141
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3142
  // clear last_Java_sp
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3143
  __ reset_last_Java_frame(false, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3144
  // check for pending exceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3145
  Label pending;
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  3146
  __ cmpptr(Address(r15_thread, Thread::pending_exception_offset()), (int32_t)NULL_WORD);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3147
  __ jcc(Assembler::notEqual, pending);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3148
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3149
  // get the returned methodOop
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  3150
  __ movptr(rbx, Address(r15_thread, JavaThread::vm_result_offset()));
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  3151
  __ movptr(Address(rsp, RegisterSaver::rbx_offset_in_bytes()), rbx);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  3152
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  3153
  __ movptr(Address(rsp, RegisterSaver::rax_offset_in_bytes()), rax);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3154
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3155
  RegisterSaver::restore_live_registers(masm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3156
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3157
  // We are back the the original state on entry and ready to go.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3158
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3159
  __ jmp(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3160
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3161
  // Pending exception after the safepoint
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3162
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3163
  __ bind(pending);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3164
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3165
  RegisterSaver::restore_live_registers(masm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3166
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3167
  // exception pending => remove activation and forward to exception handler
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3168
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3169
  __ movptr(Address(r15_thread, JavaThread::vm_result_offset()), (int)NULL_WORD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3170
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  3171
  __ movptr(rax, Address(r15_thread, Thread::pending_exception_offset()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3172
  __ jump(RuntimeAddress(StubRoutines::forward_exception_entry()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3173
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3174
  // -------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3175
  // make sure all code is generated
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3176
  masm->flush();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3177
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3178
  // return the  blob
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3179
  // frame_size_words or bytes??
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3180
  return RuntimeStub::new_runtime_stub(name, &buffer, frame_complete, frame_size_in_words, oop_maps, true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3181
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3182
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3183
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3184
void SharedRuntime::generate_stubs() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3185
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3186
  _wrong_method_blob = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::handle_wrong_method),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3187
                                        "wrong_method_stub");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3188
  _ic_miss_blob =      generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::handle_wrong_method_ic_miss),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3189
                                        "ic_miss_stub");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3190
  _resolve_opt_virtual_call_blob = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::resolve_opt_virtual_call_C),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3191
                                        "resolve_opt_virtual_call");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3192
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3193
  _resolve_virtual_call_blob = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::resolve_virtual_call_C),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3194
                                        "resolve_virtual_call");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3195
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3196
  _resolve_static_call_blob = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::resolve_static_call_C),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3197
                                        "resolve_static_call");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3198
  _polling_page_safepoint_handler_blob =
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3199
    generate_handler_blob(CAST_FROM_FN_PTR(address,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3200
                   SafepointSynchronize::handle_polling_page_exception), false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3201
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3202
  _polling_page_return_handler_blob =
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3203
    generate_handler_blob(CAST_FROM_FN_PTR(address,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3204
                   SafepointSynchronize::handle_polling_page_exception), true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3205
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3206
  generate_deopt_blob();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3207
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3208
#ifdef COMPILER2
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3209
  generate_uncommon_trap_blob();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3210
#endif // COMPILER2
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3211
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3212
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3213
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3214
#ifdef COMPILER2
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3215
// This is here instead of runtime_x86_64.cpp because it uses SimpleRuntimeFrame
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3216
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3217
//------------------------------generate_exception_blob---------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3218
// creates exception blob at the end
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3219
// Using exception blob, this code is jumped from a compiled method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3220
// (see emit_exception_handler in x86_64.ad file)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3221
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3222
// Given an exception pc at a call we call into the runtime for the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3223
// handler in this method. This handler might merely restore state
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3224
// (i.e. callee save registers) unwind the frame and jump to the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3225
// exception handler for the nmethod if there is no Java level handler
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3226
// for the nmethod.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3227
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3228
// This code is entered with a jmp.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3229
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3230
// Arguments:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3231
//   rax: exception oop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3232
//   rdx: exception pc
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3233
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3234
// Results:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3235
//   rax: exception oop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3236
//   rdx: exception pc in caller or ???
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3237
//   destination: exception handler of caller
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3238
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3239
// Note: the exception pc MUST be at a call (precise debug information)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3240
//       Registers rax, rdx, rcx, rsi, rdi, r8-r11 are not callee saved.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3241
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3242
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3243
void OptoRuntime::generate_exception_blob() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3244
  assert(!OptoRuntime::is_callee_saved_register(RDX_num), "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3245
  assert(!OptoRuntime::is_callee_saved_register(RAX_num), "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3246
  assert(!OptoRuntime::is_callee_saved_register(RCX_num), "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3247
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3248
  assert(SimpleRuntimeFrame::framesize % 4 == 0, "sp not 16-byte aligned");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3249
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3250
  // Allocate space for the code
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3251
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3252
  // Setup code generation tools
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3253
  CodeBuffer buffer("exception_blob", 2048, 1024);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3254
  MacroAssembler* masm = new MacroAssembler(&buffer);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3255
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3256
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3257
  address start = __ pc();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3258
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3259
  // Exception pc is 'return address' for stack walker
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  3260
  __ push(rdx);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  3261
  __ subptr(rsp, SimpleRuntimeFrame::return_off << LogBytesPerInt); // Prolog
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3262
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3263
  // Save callee-saved registers.  See x86_64.ad.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3264
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3265
  // rbp is an implicitly saved callee saved register (i.e. the calling
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3266
  // convention will save restore it in prolog/epilog) Other than that
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3267
  // there are no callee save registers now that adapter frames are gone.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3268
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  3269
  __ movptr(Address(rsp, SimpleRuntimeFrame::rbp_off << LogBytesPerInt), rbp);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3270
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3271
  // Store exception in Thread object. We cannot pass any arguments to the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3272
  // handle_exception call, since we do not want to make any assumption
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3273
  // about the size of the frame where the exception happened in.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3274
  // c_rarg0 is either rdi (Linux) or rcx (Windows).
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  3275
  __ movptr(Address(r15_thread, JavaThread::exception_oop_offset()),rax);
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  3276
  __ movptr(Address(r15_thread, JavaThread::exception_pc_offset()), rdx);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3277
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3278
  // This call does all the hard work.  It checks if an exception handler
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3279
  // exists in the method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3280
  // If so, it returns the handler address.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3281
  // If not, it prepares for stack-unwinding, restoring the callee-save
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3282
  // registers of the frame being removed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3283
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3284
  // address OptoRuntime::handle_exception_C(JavaThread* thread)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3285
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3286
  __ set_last_Java_frame(noreg, noreg, NULL);
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  3287
  __ mov(c_rarg0, r15_thread);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3288
  __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, OptoRuntime::handle_exception_C)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3289
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3290
  // Set an oopmap for the call site.  This oopmap will only be used if we
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3291
  // are unwinding the stack.  Hence, all locations will be dead.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3292
  // Callee-saved registers will be the same as the frame above (i.e.,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3293
  // handle_exception_stub), since they were restored when we got the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3294
  // exception.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3295
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3296
  OopMapSet* oop_maps = new OopMapSet();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3297
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3298
  oop_maps->add_gc_map( __ pc()-start, new OopMap(SimpleRuntimeFrame::framesize, 0));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3299
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3300
  __ reset_last_Java_frame(false, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3301
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3302
  // Restore callee-saved registers
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3303
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3304
  // rbp is an implicitly saved callee saved register (i.e. the calling
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3305
  // convention will save restore it in prolog/epilog) Other than that
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3306
  // there are no callee save registers no that adapter frames are gone.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3307
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  3308
  __ movptr(rbp, Address(rsp, SimpleRuntimeFrame::rbp_off << LogBytesPerInt));
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  3309
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  3310
  __ addptr(rsp, SimpleRuntimeFrame::return_off << LogBytesPerInt); // Epilog
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  3311
  __ pop(rdx);                  // No need for exception pc anymore
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3312
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3313
  // rax: exception handler
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3314
5252
58f23871a5b6 6941529: SharedRuntime::raw_exception_handler_for_return_address must reset thread MethodHandle flag
twisti
parents: 4735
diff changeset
  3315
  // Restore SP from BP if the exception PC is a MethodHandle call site.
58f23871a5b6 6941529: SharedRuntime::raw_exception_handler_for_return_address must reset thread MethodHandle flag
twisti
parents: 4735
diff changeset
  3316
  __ cmpl(Address(r15_thread, JavaThread::is_method_handle_return_offset()), 0);
5690
796ff3814b23 6934104: JSR 292 needs to support SPARC C2
twisti
parents: 5419
diff changeset
  3317
  __ cmovptr(Assembler::notEqual, rsp, rbp_mh_SP_save);
4564
55dfb20908d0 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents: 3265
diff changeset
  3318
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3319
  // We have a handler in rax (could be deopt blob).
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  3320
  __ mov(r8, rax);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3321
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3322
  // Get the exception oop
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  3323
  __ movptr(rax, Address(r15_thread, JavaThread::exception_oop_offset()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3324
  // Get the exception pc in case we are deoptimized
1066
717c3345024f 5108146: Merge i486 and amd64 cpu directories
never
parents: 670
diff changeset
  3325
  __ movptr(rdx, Address(r15_thread, JavaThread::exception_pc_offset()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3326
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3327
  __ movptr(Address(r15_thread, JavaThread::exception_handler_pc_offset()), (int)NULL_WORD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3328
  __ movptr(Address(r15_thread, JavaThread::exception_pc_offset()), (int)NULL_WORD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3329
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3330
  // Clear the exception oop so GC no longer processes it as a root.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3331
  __ movptr(Address(r15_thread, JavaThread::exception_oop_offset()), (int)NULL_WORD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3332
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3333
  // rax: exception oop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3334
  // r8:  exception handler
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3335
  // rdx: exception pc
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3336
  // Jump to handler
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3337
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3338
  __ jmp(r8);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3339
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3340
  // Make sure all code is generated
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3341
  masm->flush();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3342
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3343
  // Set exception blob
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3344
  _exception_blob =  ExceptionBlob::create(&buffer, oop_maps, SimpleRuntimeFrame::framesize >> 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3345
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3346
#endif // COMPILER2